# packages

pkgId: 0d3eb585a6cc4c9265257ada8533afda20394afba9e6d8a6c7f61149f50caaad
name: python-Boruta
arch: src
version: 0.3
epoch: 0
release: 1
summary: Python Implementation of Boruta Feature Selection
url: https://github.com/danielhomola/boruta_py
rpm_license: BSD 3 clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dbe56093-8d13-4fac-8954-d932d200934b
location_href: 00010088-python-boruta/python-Boruta-0.3-1.src.rpm
checksum_type: sha256
description:
  This project hosts Python implementations of the [Boruta all-relevant feature selection method](https://m2.icm.edu.pl/boruta/).

  [Related blog post] (http://danielhomola.com/2015/05/08/borutapy-an-all-relevant-feature-selection-method/)



  * numpy
  * scipy
  * scikit-learn


  Download, import and do as you would with any other scikit-learn method:
  * fit(X, y)
  * transform(X)
  * fit_transform(X, y)



  Python implementations of the Boruta R package.

  This implementation tries to mimic the scikit-learn interface, so use fit,
  transform or fit_transform, to run the feature selection.

  For more, see the docs of these functions, and the examples below.

  Original code and method by: Miron B Kursa, https://m2.icm.edu.pl/boruta/

  Boruta is an all relevant feature selection method, while most other are
  minimal optimal; this means it tries to find all features carrying
  information usable for prediction, rather than finding a possibly compact
  subset of features on which some classifier has a minimal error.

  Why bother with all relevant feature selection?
  When you try to understand the phenomenon that made your data, you should
  care about all factors that contribute to it, not just the bluntest signs
  of it in context of your methodology (yes, minimal optimal set of features
  by definition depends on your classifier choice).




  It is the original R package recoded in Python with a few added extra features.
  Some improvements include:

  * Faster run times, thanks to scikit-learn

  * Scikit-learn like interface

  * Compatible with any ensemble method from scikit-learn

  * Automatic n_estimator selection

  * Ranking of features

  For more details, please check the top of the docstring.

  We highly recommend using pruned trees with a depth between 3-7.

  Also, after playing around a lot with the original code I identified a few areas
  where the core algorithm could be improved/altered to make it less strict and
  more applicable to biological data, where the Bonferroni correction might be
  overly harsh.

  __Percentile as threshold__
  The original method uses the maximum of the shadow features as a threshold in
  deciding which real feature is doing better than the shadow ones. This could be
  overly harsh.

  To control this, I added the perc parameter, which sets the
  percentile of the shadow features' importances, the algorithm uses as the
  threshold. The default of 100 which is equivalent to taking the maximum as the
  R version of Boruta does, but it could be relaxed. Note, since this is the
  percentile, it changes with the size of the dataset. With several thousands of
  features it isn't as stringent as with a few dozens at the end of a Boruta run.


  __Two step correction for multiple testing__
  The correction for multiple testing was relaxed by making it a two step
  process, rather than a harsh one step Bonferroni correction.

  We need to correct firstly because in each iteration we test a number of
  features against the null hypothesis (does a feature perform better than
  expected by random). For this the Bonferroni correction is used in the original
  code which is known to be too stringent in such scenarios (at least for
  biological data), and also the original code corrects for n features, even if
  we are in the 50th iteration where we only have k<<n features left. For this
  reason the first step of correction is the widely used Benjamini Hochberg FDR.

  Following that however we also need to account for the fact that we have been
  testing the same features over and over again in each iteration with the
  same test. For this scenario the Bonferroni is perfect, so it is applied by
  deviding the p-value threshold with the current iteration index.

  If this two step correction is not required, the two_step parameter has to be
  set to False, then (with perc=100) BorutaPy behaves exactly as the R version.



  __estimator__ : object
     > A supervised learning estimator, with a 'fit' method that returns the
     > feature_importances_ attribute. Important features must correspond to
     > high absolute values in the feature_importances_.

  __n_estimators__ : int or string, default = 1000
     > If int sets the number of estimators in the chosen ensemble method.
     > If 'auto' this is determined automatically based on the size of the
     > dataset. The other parameters of the used estimators need to be set
     > with initialisation.

  __perc__ : int, default = 100
     > Instead of the max we use the percentile defined by the user, to pick
     > our threshold for comparison between shadow and real features. The max
     > tend to be too stringent. This provides a finer control over this. The
     > lower perc is the more false positives will be picked as relevant but
     > also the less relevant features will be left out. The usual trade-off.
     > The default is essentially the vanilla Boruta corresponding to the max.

  __alpha__ : float, default = 0.05
     > Level at which the corrected p-values will get rejected in both correction
     steps.

  __two_step__ : Boolean, default = True
    > If you want to use the original implementation of Boruta with Bonferroni
    > correction only set this to False.

  __max_iter__ : int, default = 100
     > The number of maximum iterations to perform.

  __verbose__ : int, default=0
     > Controls verbosity of output.




  **n_features_** : int
     > The number of selected features.

  **support_** : array of shape [n_features]
     > The mask of selected features - only confirmed ones are True.

  **support_weak_** : array of shape [n_features]
    >  The mask of selected tentative features, which haven't gained enough
    >  support during the max_iter number of iterations..

  **ranking_** : array of shape [n_features]
    >  The feature ranking, such that ``ranking_[i]`` corresponds to the
    >  ranking position of the i-th feature. Selected (i.e., estimated
    >  best) features are assigned rank 1 and tentative features are assigned
    >  rank 2.




      import pandas as pd
      from sklearn.ensemble import RandomForestClassifier
      from boruta import BorutaPy

      
      
      X = pd.read_csv('examples/test_X.csv', index_col=0).values
      y = pd.read_csv('examples/test_y.csv', header=None, index_col=0).values
      y = y.ravel()

      
      
      rf = RandomForestClassifier(n_jobs=-1, class_weight='balanced', max_depth=5)

      
      feat_selector = BorutaPy(rf, n_estimators='auto', verbose=2, random_state=1)

      
      feat_selector.fit(X, y)

      
      feat_selector.support_

      
      feat_selector.ranking_

      
      X_filtered = feat_selector.transform(X)



  1. Kursa M., Rudnicki W., "Feature Selection with the Boruta Package" Journal of Statistical Software, Vol. 36, Issue 11, Sep 2010


pkgId: 5d6f8f5ab3fae405c5a750ca1b56cf03e0bb1bf4a2b5e959d7c312a87a48d855
name: python-BorutaShap
arch: src
version: 1.0.16
epoch: 0
release: 1
summary: A feature selection algorithm.
url: https://github.com/Ekeany/Boruta-Shap
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c04b6fc8-e0d7-4fdf-b117-2a0cf2bc6213
location_href: 00010800-python-borutashap/python-BorutaShap-1.0.16-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/255354538.svg)](https://zenodo.org/badge/latestdoi/255354538)
  <a href="https://badge.fury.io/py/BorutaShap"><img src="https://badge.fury.io/py/BorutaShap.svg" alt="PyPI version" height="18"></a>


  BorutaShap is a wrapper feature selection method which combines both the Boruta feature selection algorithm with shapley values. This combination has proven to out perform the original Permutation Importance method in both speed, and the quality of the feature subset produced. Not only does this algorithm provide a better subset of features, but it can also simultaneously provide the most accurate and consistent global feature rankings which can be used for model inference too. Unlike the orginal R package, which limits the user to a Random Forest model, BorutaShap allows the user to choose any Tree Based learner as the base model in the feature selection process.

  Despite BorutaShap's runtime improvments the SHAP TreeExplainer scales linearly with the number of observations making it's use cumbersome for large datasets. To combat this, BorutaShap includes a sampling procedure which uses the smallest possible subsample of the data availble at each iteration of the algorithm. It finds this sample by comparing the distributions produced by an isolation forest of the sample and the data using ks-test. From experiments, this procedure can reduce the run time up to 80% while still creating a valid approximation of the entire data set. Even with these improvments the user still might want a faster solution so BorutaShap has included an option to use the mean decrease in gini impurity. This importance measure is independent of the size dataset as it uses the tree's structure to compute a global feature ranking making it much faster than SHAP at larger datasets. Although this metric returns somewhat comparable feature subsets, it is not a reliable measure of global feature importance in spite of it's wide spread use. Thus, I would recommend to using the SHAP metric whenever possible.



  1. Start by creating new copies of all the features in the data set and name them shadow + feature_name, shuffle these newly added features to remove their correlations with the response variable.

  2. Run a classifier on the extended data with the random shadow features included. Then rank the features using a feature importance metric the original algorithm used permutation importance as it's metric of choice.

  3. Create a threshold using the maximum importance score from the shadow features. Then assign a hit to any feature that had exceeded this threshold.

  4. For every unassigned feature preform a two sided T-test of equality.

  5. Attributes which have an importance significantly lower than the threshold are deemed 'unimportant' and are removed them from process. Deem the attributes which have importance significantly higher than than the threshold as 'important'.

  6. Remove all shadow attributes and repeat the procedure until an importance has been assigned for each feature, or the algorithm has reached the previously set limit of runs.

  If the algorithm has reached its set limit of runs and an importance has not been assigned to each feature the user has two choices. Either increase the number of runs or use the tentative rough fix function which compares the median importance values between unassigned features and the maximum shadow feature to make the decision.





  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install foobar.

  ```bash
  pip install BorutaShap
  ```



  For more use cases such as alternative models, sampling or changing the importance metric please view the notebooks [here](https://github.com/Ekeany/Boruta-Shap/tree/master/Examples).


  ```python
  from BorutaShap import BorutaShap, load_data

  X, y = load_data(data_type='regression')
  X.head()
  ```
  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/BostonHead.PNG?raw=true" height="203" width="722">

  ```python

  Feature_Selector = BorutaShap(importance_measure='shap',
                                classification=False)

  '''
  Sample: Boolean
  	if true then a rowise sample of the data will be used to calculate the feature importance values

  sample_fraction: float
  	The sample fraction of the original data used in calculating the feature importance values only
          used if Sample==True.

  train_or_test: string
  	Decides whether the feature improtance should be calculated on out of sample data see the dicussion here.
          https://compstat-lmu.github.io/iml_methods_limitations/pfi-data.html#introduction-to-test-vs.training-data

  normalize: boolean
              if true the importance values will be normalized using the z-score formula

  verbose: Boolean
  	a flag indicator to print out all the rejected or accepted features.
  '''
  Feature_Selector.fit(X=X, y=y, n_trials=100, sample=False,
              	     train_or_test = 'test', normalize=True,
  		     verbose=True)
  ```

  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/BostonOutput.PNG?raw=true">

  ```python

  Feature_Selector.plot(which_features='all')
  ```
  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/Bostonplot.PNG?raw=true" height="530" width="699">

  ```python

  subset = Feature_Selector.Subset()
  ```

  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/bostonsubset.PNG?raw=true" height="194" width="465">




  ```python
  from BorutaShap import BorutaShap, load_data
  from xgboost import XGBClassifier

  X, y = load_data(data_type='classification')
  X.head()
  ```

  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/binaryhead.PNG?raw=true">

  ```python
  model = XGBClassifier()


  Feature_Selector = BorutaShap(model=model,
                                importance_measure='shap',
                                classification=True)

  Feature_Selector.fit(X=X, y=y, n_trials=100, sample=False,
              	     train_or_test = 'test', normalize=True,
  		     verbose=True)
  ```
  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/binaryoutput.PNG?raw=true">

  ```python

  Feature_Selector.plot(which_features='all')
  ```

  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/binaryplot.PNG?raw=true" height="565" width="671">

  ```python

  subset = Feature_Selector.Subset()
  ```
  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/binarysubset.PNG?raw=true">


  Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.


  If you wish to cite this work please click on the zenodo badge at the top of this READme file
  [MIT](https://choosealicense.com/licenses/mit/)


pkgId: 446aef46344bf16cb1820f5d5540401aee7d1cc336c55ad77e0e384a0d7c0e33
name: python-Bottleneck
arch: src
version: 1.3.6
epoch: 0
release: 1
summary: Fast NumPy array functions written in C
url: https://github.com/pydata/bottleneck
rpm_license: Simplified BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c5b6e4b0-8814-48e0-a46b-80e557e26b42
location_href: 00002839-python-Bottleneck/python-Bottleneck-1.3.6-1.src.rpm
checksum_type: sha256
description:
  Bottleneck comes with a benchmark suite::
      >>> bn.bench()
      Bottleneck performance benchmark
          Bottleneck 1.3.0.dev0+122.gb1615d7; Numpy 1.16.4
          Speed is NumPy time divided by Bottleneck time
          NaN means approx one-fifth NaNs; float64 used
                    no NaN     no NaN      NaN       no NaN      NaN
                     (100,)  (1000,1000)(1000,1000)(1000,1000)(1000,1000)
                     axis=0     axis=0     axis=0     axis=1     axis=1
      nansum         29.7        1.4        1.6        2.0        2.1
      nanmean        99.0        2.0        1.8        3.2        2.5
      nanstd        145.6        1.8        1.8        2.7        2.5
      nanvar        138.4        1.8        1.8        2.8        2.5
      nanmin         27.6        0.5        1.7        0.7        2.4
      nanmax         26.6        0.6        1.6        0.7        2.5
      median        120.6        1.3        4.9        1.1        5.7
      nanmedian     117.8        5.0        5.7        4.8        5.5
      ss             13.2        1.2        1.3        1.5        1.5
      nanargmin      66.8        5.5        4.8        3.5        7.1
      nanargmax      57.6        2.9        5.1        2.5        5.3
      anynan         10.2        0.3       52.3        0.8       41.6
      allnan         15.1      196.0      156.3      135.8      111.2
      rankdata       45.9        1.2        1.2        2.1        2.1
      nanrankdata    50.5        1.4        1.3        2.4        2.3
      partition       3.3        1.1        1.6        1.0        1.5
      argpartition    3.4        1.2        1.5        1.1        1.6
      replace         9.0        1.5        1.5        1.5        1.5
      push         1565.6        5.9        7.0       13.0       10.9
      move_sum     2159.3       31.1       83.6      186.9      182.5
      move_mean    6264.3       66.2      111.9      361.1      246.5
      move_std     8653.6       86.5      163.7      232.0      317.7
      move_var     8856.0       96.3      171.6      267.9      332.9
      move_min     1186.6       13.4       30.9       23.5       45.0
      move_max     1188.0       14.6       29.9       23.5       46.0
      move_argmin  2568.3       33.3       61.0       49.2       86.8
      move_argmax  2475.8       30.9       58.6       45.0       82.8
      move_median  2236.9      153.9      151.4      171.3      166.9
      move_rank     847.1        1.2        1.4        2.3        2.6
  You can also run a detailed benchmark for a single function using, for
  example, the command::
      >>> bn.bench_detailed("move_median", fraction_nan=0.3)
  Only arrays with data type (dtype) int32, int64, float32, and float64 are
  accelerated. All other dtypes result in calls to slower, unaccelerated
  functions. In the rare case of a byte-swapped input array (e.g. a big-endian
  array on a little-endian operating system) the function will not be
  accelerated regardless of dtype.


pkgId: c5bb7a10862468d6f78bfd84d7c4e3c0e52301e07b751064a2f23e2bae6011c4
name: python-Bottleneck-debuginfo
arch: x86_64
version: 1.3.7
epoch: 0
release: 1
summary: Debug information for package python-Bottleneck
url: https://github.com/pydata/bottleneck
rpm_license: Simplified BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-80e1893a-4ab3-49e8-a641-78b24cb9c99c
rpm_sourcerpm: python-Bottleneck-1.3.7-1.src.rpm
location_href: 00010033-python-bottleneck/python-Bottleneck-debuginfo-1.3.7-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-Bottleneck.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 6c1bbb955a436e1e824978c85b8996484d59fe347fe8d678812d6136ffeefdcc
name: python-Bottleneck-debugsource
arch: x86_64
version: 1.3.7
epoch: 0
release: 1
summary: Debug sources for package python-Bottleneck
url: https://github.com/pydata/bottleneck
rpm_license: Simplified BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-80e1893a-4ab3-49e8-a641-78b24cb9c99c
rpm_sourcerpm: python-Bottleneck-1.3.7-1.src.rpm
location_href: 00010033-python-bottleneck/python-Bottleneck-debugsource-1.3.7-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-Bottleneck.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: fa4f8a512fcd8226a21dbe4ec453b2fb8d5ad13328b8573e8a77f1e669581132
name: python-Brian2
arch: src
version: 2.5.1
epoch: 0
release: 1
summary: A clock-driven simulator for spiking neural networks
url: http://www.briansimulator.org/
rpm_license: CEA CNRS Inria Logiciel Libre License, version 2.1 (CeCILL-2.1)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cd760600-e3a7-46ec-83ad-dd4ba506d931
location_href: 00003156-python-brian2/python-Brian2-2.5.1-1.src.rpm
checksum_type: sha256
description:
  *A clock-driven simulator for spiking neural networks*
  Brian is a free, open source simulator for spiking neural networks. It is written in the Python programming language and is available on almost all platforms. We believe that a simulator should not only save the time of processors, but also the time of scientists. Brian is therefore designed to be easy to learn and use, highly flexible and easily extensible.
  Please report issues at the github issue tracker (https://github.com/brian-team/brian2/issues) or in the Brian forum (https://brian.discourse.group).
  Documentation for Brian2 can be found at http://brian2.readthedocs.org
  Brian2 is released under the terms of the `CeCILL 2.1 license <https://opensource.org/licenses/CECILL-2.1>`_.
  If you use Brian for your published research, we kindly ask you to cite our article:
  Stimberg, M, Brette, R, Goodman, DFM. “Brian 2, an Intuitive and Efficient Neural Simulator.” eLife 8 (2019): e47314. `doi: 10.7554/eLife.47314 <https://doi.org/10.7554/eLife.47314>`_.


pkgId: 117da6d0447aaefd9db797ee4c23e8a97bff7cc313a641591397d89d501a0999
name: python-Brian2-debuginfo
arch: x86_64
version: 2.5.1
epoch: 0
release: 1
summary: Debug information for package python-Brian2
url: http://www.briansimulator.org/
rpm_license: CEA CNRS Inria Logiciel Libre License, version 2.1 (CeCILL-2.1)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-cd760600-e3a7-46ec-83ad-dd4ba506d931
rpm_sourcerpm: python-Brian2-2.5.1-1.src.rpm
location_href: 00003156-python-brian2/python-Brian2-debuginfo-2.5.1-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-Brian2.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 1e41ee5e56972ca3af4f476bf5a11bc42643525f1330378e9b9fdf356e870866
name: python-Brian2-debugsource
arch: x86_64
version: 2.5.1
epoch: 0
release: 1
summary: Debug sources for package python-Brian2
url: http://www.briansimulator.org/
rpm_license: CEA CNRS Inria Logiciel Libre License, version 2.1 (CeCILL-2.1)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-cd760600-e3a7-46ec-83ad-dd4ba506d931
rpm_sourcerpm: python-Brian2-2.5.1-1.src.rpm
location_href: 00003156-python-brian2/python-Brian2-debugsource-2.5.1-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-Brian2.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: f442de3da71b6b0152af9cb71567063e690a14cc88b8fa1fec038f87929c0da6
name: python-Brotli-debuginfo
arch: x86_64
version: 1.0.9
epoch: 0
release: 1
summary: Debug information for package python-Brotli
url: https://github.com/google/brotli
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-089f1430-9a50-4de9-bbc5-43522de9511e
rpm_sourcerpm: python-Brotli-1.0.9-1.src.rpm
location_href: 00009295-python-brotli/python-Brotli-debuginfo-1.0.9-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-Brotli.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 18906d07e2ac01de74de483280e127aab2fea7412645e924c1c7c16ce9541cad
name: python-Brotli-debugsource
arch: x86_64
version: 1.0.9
epoch: 0
release: 1
summary: Debug sources for package python-Brotli
url: https://github.com/google/brotli
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-089f1430-9a50-4de9-bbc5-43522de9511e
rpm_sourcerpm: python-Brotli-1.0.9-1.src.rpm
location_href: 00009295-python-brotli/python-Brotli-debugsource-1.0.9-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-Brotli.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 7151dea21971ea22811236f9e6ebbad80c861167f22ed7b274bffe38c5902851
name: python-CairoSVG
arch: src
version: 2.6.0
epoch: 0
release: 1
summary: A Simple SVG Converter based on Cairo
url: https://courtbouillon.org/cairosvg
rpm_license: LGPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5b580f37-690f-49f4-a06c-6eda3da4e895
location_href: 00003172-python-cairosvg/python-CairoSVG-2.6.0-1.src.rpm
checksum_type: sha256
description:
  CairoSVG is an SVG converter based on Cairo. It can export SVG files to PDF,
  EPS, PS, and PNG files.

  * Free software: LGPL license
  * For Python 3.7+, tested on CPython and PyPy
  * Documentation: https://cairosvg.org/documentation/
  * Changelog: https://github.com/Kozea/CairoSVG/releases
  * Code, issues, tests: https://github.com/Kozea/CairoSVG
  * Code of conduct: https://www.courtbouillon.org/code-of-conduct
  * Professional support: https://www.courtbouillon.org
  * Donation: https://opencollective.com/courtbouillon

  CairoSVG has been created and developed by Kozea (https://kozea.fr).
  Professional support, maintenance and community management is provided by
  CourtBouillon (https://www.courtbouillon.org).

  Copyrights are retained by their contributors, no copyright assignment is
  required to contribute to CairoSVG. Unless explicitly stated otherwise, any
  contribution intentionally submitted for inclusion is licensed under the LGPL
  license, without any additional terms or conditions. For full
  authorship information, see the version control history.


pkgId: b38804cdf19fbfc975552725dd7987a1c81406346022628fc2c3d8c51a432f67
name: python-Cartopy
arch: src
version: 0.21.1
epoch: 0
release: 1
summary: A cartographic python library with Matplotlib support for visualisation
url: https://scitools.org.uk/cartopy/docs/latest/
rpm_license: LGPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9058b351-2e7c-4999-8313-1a0e782fa519
location_href: 00003184-python-cartopy/python-Cartopy-0.21.1-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center" style="margin:1em;">
    <a href="https://scitools.org.uk/cartopy/docs/latest/">
      <img src="https://scitools.org.uk/cartopy/docs/latest/_static/cartopy.png"
           alt="Cartopy"></a>
  </h1>

  <h4 align="center">
      Cartopy is a Python package designed to make drawing maps for
      data analysis and visualisation easy.
  </h4>

  <p align="center">
  <!-- https://shields.io/ is a good source of these -->
  <a href="https://anaconda.org/conda-forge/cartopy">
  <img src="https://img.shields.io/conda/dn/conda-forge/cartopy.svg"
   alt="conda-forge downloads" /></a>
  <a href="https://github.com/SciTools/cartopy/releases">
  <img src="https://img.shields.io/github/tag/SciTools/cartopy.svg"
   alt="Latest version" /></a>
  <a href="https://github.com/SciTools/cartopy/commits/main">
  <img src="https://img.shields.io/github/commits-since/SciTools/cartopy/latest.svg"
   alt="Commits since last release" /></a>
  <a href="https://github.com/SciTools/cartopy/graphs/contributors">
  <img src="https://img.shields.io/github/contributors/SciTools/cartopy.svg"
   alt="# contributors" /></a>
  <a href="https://travis-ci.org/SciTools/cartopy/branches">
  <img src="https://api.travis-ci.org/repositories/SciTools/cartopy.svg?branch=main"
   alt="Travis-CI" /></a>
  <a href="https://zenodo.org/badge/latestdoi/5282596">
  <img src="https://zenodo.org/badge/5282596.svg"
   alt="zenodo" /></a>
  <a href="https://gitter.im/SciTools/cartopy?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge">
  <img src="https://badges.gitter.im/SciTools/cartopy.svg" alt="Gitter Chat" /></a>
  </p>
  <br>



  <!--
  NOTE: toc auto-generated with https://github.com/jonschlinkert/markdown-toc
      $> markdown-toc -i --bullets='-' README.md

  NOTE: This entire README can be markdown linted with
      https://github.com/igorshubovych/markdownlint-cli
      $ echo '{"no-inline-html": false}' > .markdownrc
      $ markdownlint README.md
  -->

  <!-- toc -->

  - [Overview](#overview)
  - [Get in touch](#get-in-touch)
  - [License and copyright](#license-and-copyright)

  <!-- tocstop -->



  Cartopy is a Python package designed to make drawing maps for data
  analysis and visualisation easy.

  It features:

  - object oriented projection definitions
  - point, line, polygon and image transformations between projections
  - integration to expose advanced mapping in Matplotlib with a simple and
    intuitive interface
  - powerful vector data handling by integrating shapefile reading with Shapely
    capabilities

  Documentation can be found at <https://scitools.org.uk/cartopy/docs/latest/>.



  - Ask usage questions on
    [StackOverflow](https://stackoverflow.com/questions/tagged/cartopy).
  - For less well defined questions, ideas, general discussion or announcements
    of related projects use the
    [Google Group](https://groups.google.com/forum/#!forum/scitools-iris).
  - Report bugs, suggest features or view the source code on
    [GitHub](https://github.com/SciTools/cartopy).
  - To chat with developers and other users you can use the
    [Gitter Chat](https://gitter.im/SciTools/cartopy)




  Cartopy is developed collaboratively under the SciTools umberella.

  A full list of codecontributors ("Cartopy contributors") can be found at
  https://github.com/SciTools/cartopy/graphs/contributors.

  Code is just one of many ways of positively contributing to Cartopy, please see
  our [contributing guide](.github/CONTRIBUTING.md) for more details on how
  you can get involved.

  Cartopy is released under a LGPL license with a shared copyright model.
  See [COPYING](COPYING) and [COPYING.LESSER](COPYING.LESSER) for full terms.

  The [Met Office](https://metoffice.gov.uk) has made a significant
  contribution to the development, maintenance and support of this library.
  All Met Office contributions are copyright on behalf of the British Crown.


pkgId: e334d95fbb78c37be8c9cc6f851de811d5e5f237f398f73a98cfd51a21aba091
name: python-Cerberus
arch: src
version: 1.3.4
epoch: 0
release: 1
summary: Lightweight, extensible schema and data validation tool for Python dictionaries.
url: http://docs.python-cerberus.org
rpm_license: ISC
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-644b0ccd-38d5-4e77-abeb-b311c4468531
location_href: 00003196-python-cerberus/python-Cerberus-1.3.4-1.src.rpm
checksum_type: sha256
description:
  |build-status| |python-support| |black|
  Cerberus is a lightweight and extensible data validation library for Python.
      >>> v = Validator({'name': {'type': 'string'}})
      >>> v.validate({'name': 'john doe'})
      True


pkgId: 37b4a0852aa84eeee7e7783ad2462714a21f5d9b817f6cdd6ce320adac423ccf
name: python-Cerealizer
arch: src
version: 0.8.3
epoch: 0
release: 1
summary: A secure pickle-like module
url: http://www.lesfleursdunormal.fr/static/informatique/cerealizer/index_en.html
rpm_license: Python licence
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1ff5df17-fe65-4d1c-b980-c12d3c7d125f
location_href: 00003197-python-cerealizer/python-Cerealizer-0.8.3-1.src.rpm
checksum_type: sha256
description:
  A secure pickle-like module.
  It support basic types (int, string, unicode, tuple, list, dict, set,...),
  old and new-style classes (you need to register the class for security), object cycles,
  and it can be extended to support C-defined type.


pkgId: 4fde40a6b5f815881cb891e81591f8fcab5f0c08193f8fc644cf99633cb6cefc
name: python-Chameleon
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: Fast HTML/XML Template Compiler.
url: https://chameleon.readthedocs.io
rpm_license: BSD-like (http://repoze.org/license.html)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-26e9008c-1a98-4ef6-bfd9-cd2526af4854
location_href: 00003218-python-chameleon/python-Chameleon-4.0.0-1.src.rpm
checksum_type: sha256
description:
  Chameleon is an HTML/XML template engine for `Python
  <http://www.python.org>`_. It uses the *page templates* language.
  You can use it in any Python web application with just about any
  version of Python (2.7 and up, including 3.4+ and `pypy
  <http://pypy.org>`_).
  Visit the `documentation <https://chameleon.readthedocs.io/en/latest/>`_
  for more information.


pkgId: 772036c68f787c9517fe4c71ac946c955fdb6df89e48b9c0f70d50f9e8a56c9e
name: python-ChatterBot
arch: src
version: 1.0.8
epoch: 0
release: 1
summary: ChatterBot is a machine learning, conversational dialog engine.
url: https://github.com/gunthercox/ChatterBot
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0851c960-1ea1-454b-bfa8-359aec06ef16
location_href: 00012801-python-chatterbot/python-ChatterBot-1.0.8-1.src.rpm
checksum_type: sha256
description:
  ![ChatterBot: Machine learning in Python](https://i.imgur.com/b3SCmGT.png)



  ChatterBot is a machine-learning based conversational dialog engine build in
  Python which makes it possible to generate responses based on collections of
  known conversations. The language independent design of ChatterBot allows it
  to be trained to speak any language.

  [![Package Version](https://img.shields.io/pypi/v/chatterbot.svg)](https://pypi.python.org/pypi/chatterbot/)
  [![Python 3.6](https://img.shields.io/badge/python-3.6-blue.svg)](https://www.python.org/downloads/release/python-360/)
  [![Django 2.0](https://img.shields.io/badge/Django-2.0-blue.svg)](https://docs.djangoproject.com/en/2.1/releases/2.0/)
  [![Requirements Status](https://requires.io/github/gunthercox/ChatterBot/requirements.svg?branch=master)](https://requires.io/github/gunthercox/ChatterBot/requirements/?branch=master)
  [![Build Status](https://travis-ci.org/gunthercox/ChatterBot.svg?branch=master)](https://travis-ci.org/gunthercox/ChatterBot)
  [![Documentation Status](https://readthedocs.org/projects/chatterbot/badge/?version=stable)](http://chatterbot.readthedocs.io/en/stable/?badge=stable)
  [![Coverage Status](https://img.shields.io/coveralls/gunthercox/ChatterBot.svg)](https://coveralls.io/r/gunthercox/ChatterBot)
  [![Code Climate](https://codeclimate.com/github/gunthercox/ChatterBot/badges/gpa.svg)](https://codeclimate.com/github/gunthercox/ChatterBot)
  [![Join the chat at https://gitter.im/chatterbot/Lobby](https://badges.gitter.im/chatterbot/Lobby.svg)](https://gitter.im/chatterbot/Lobby?utm_source=badge&utm_medium=badge&utm_content=badge)

  An example of typical input would be something like this:

  > **user:** Good morning! How are you doing?
  > **bot:**  I am doing very well, thank you for asking.
  > **user:** You're welcome.
  > **bot:** Do you like hats?



  An untrained instance of ChatterBot starts off with no knowledge of how to communicate. Each time a user enters a statement, the library saves the text that they entered and the text that the statement was in response to. As ChatterBot receives more input the number of responses that it can reply and the accuracy of each response in relation to the input statement increase. The program selects the closest matching response by searching for the closest matching known statement that matches the input, it then returns the most likely response to that statement based on how frequently each response is issued by the people the bot communicates with.



  This package can be installed from [PyPi](https://pypi.python.org/pypi/ChatterBot) by running:

  ```
  pip install chatterbot
  ```



  ```
  from chatterbot import ChatBot
  from chatterbot.trainers import ChatterBotCorpusTrainer

  chatbot = ChatBot('Ron Obvious')


  trainer = ChatterBotCorpusTrainer(chatbot)


  trainer.train("chatterbot.corpus.english")


  chatbot.get_response("Hello, how are you today?")
  ```



  ChatterBot comes with a data utility module that can be used to train chat bots.
  At the moment there is training data for over a dozen languages in this module.
  Contributions of additional training data or training data
  in other languages would be greatly appreciated. Take a look at the data files
  in the [chatterbot-corpus](https://github.com/gunthercox/chatterbot-corpus)
  package if you are interested in contributing.

  ```
  from chatterbot.trainers import ChatterBotCorpusTrainer


  trainer = ChatterBotCorpusTrainer(chatbot)


  trainer.train("chatterbot.corpus.english")


  trainer.train("chatterbot.corpus.english.greetings")


  trainer.train("chatterbot.corpus.english.conversations")
  ```

  **Corpus contributions are welcome! Please make a pull request.**



  View the [documentation](https://chatterbot.readthedocs.io/)
  for ChatterBot on Read the Docs.

  To build the documentation yourself using [Sphinx](http://www.sphinx-doc.org/), run:

  ```
  sphinx-build -b html docs/ build/
  ```



  For examples, see the [examples](https://github.com/gunthercox/ChatterBot/tree/master/examples)
  directory in this project's git repository.

  There is also an example [Django project using ChatterBot](https://github.com/gunthercox/ChatterBot/tree/master/examples), as well as an example [Flask project using ChatterBot](https://github.com/chamkank/flask-chatterbot).



  See release notes for changes https://github.com/gunthercox/ChatterBot/releases



  1. [Create a fork](https://help.github.com/articles/fork-a-repo/) of
     the [main ChatterBot repository](https://github.com/gunthercox/ChatterBot) on GitHub.
  2. Make your changes in a branch named something different from `master`, e.g. create
     a new branch `my-pull-request`.
  3. [Create a pull request](https://help.github.com/articles/creating-a-pull-request/).
  4. Please follow the [Python style guide for PEP-8](https://www.python.org/dev/peps/pep-0008/).
  5. Use the projects [built-in automated testing](https://chatterbot.readthedocs.io/en/latest/testing.html).
     to help make sure that your contribution is free from errors.



  ChatterBot is licensed under the [BSD 3-clause license](https://opensource.org/licenses/BSD-3-Clause).


pkgId: 7f029fe86bddab9874849d7b1521c1213daab4ea6e7f45bf1c8c7a94a4d50051
name: python-Cheetah3
arch: src
version: 3.2.6.post1
epoch: 0
release: 1
summary: Cheetah is a template engine and code generation tool
url: https://cheetahtemplate.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-57abab0c-9ae1-4f01-8eca-4229bb727355
location_href: 00009835-python-cheetah3/python-Cheetah3-3.2.6.post1-1.src.rpm
checksum_type: sha256
description:
  For a high-level introduction to Cheetah please refer to the User's Guide
  at https://cheetahtemplate.org/users_guide/index.html


pkgId: cec1f51bea61b5719c64457dc8c55208b9af4c90e799a41247c28dc8098bcf3d
name: python-Cheetah3-debuginfo
arch: x86_64
version: 3.2.6.post1
epoch: 0
release: 1
summary: Debug information for package python-Cheetah3
url: https://cheetahtemplate.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-57abab0c-9ae1-4f01-8eca-4229bb727355
rpm_sourcerpm: python-Cheetah3-3.2.6.post1-1.src.rpm
location_href: 00009835-python-cheetah3/python-Cheetah3-debuginfo-3.2.6.post1-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-Cheetah3.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: cd86b4f56c50eacf5c712e49fb9fb55f1a89607ab434361d7a85cbfd6c46ceff
name: python-Cheetah3-debugsource
arch: x86_64
version: 3.2.6.post1
epoch: 0
release: 1
summary: Debug sources for package python-Cheetah3
url: https://cheetahtemplate.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-57abab0c-9ae1-4f01-8eca-4229bb727355
rpm_sourcerpm: python-Cheetah3-3.2.6.post1-1.src.rpm
location_href: 00009835-python-cheetah3/python-Cheetah3-debugsource-3.2.6.post1-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-Cheetah3.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 5f9054129ef03c9b6ffc2f4f8d52900d5aec3e0f27f211ebfbef8b8e094458ad
name: python-ClusterShell
arch: src
version: 1.9.1
epoch: 0
release: 1
summary: ClusterShell library and tools
url: https://clustershell.readthedocs.io/
rpm_license: LGPLv2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-37f30dee-2771-4532-b3f1-f584956aa78d
location_href: 00003257-python-clustershell/python-ClusterShell-1.9.1-1.src.rpm
checksum_type: sha256
description:
  ClusterShell provides clush, clubak and cluset/nodeset, convenient command-line
  tools that allow traditional shell scripts to benefit from some of the
  library's features:
  - **clush**: issue commands to cluster nodes and format output
  Example of use:
    $ clush -abL uname -r
    node[32-49,51-71,80,82-150,156-159]: 2.6.18-164.11.1.el5
    node[3-7,72-79]: 2.6.18-164.11.1.el5_lustre1.10.0.36
    node[2,151-155]: 2.6.31.6-145.fc11.2.x86_64
  See *man clush* for more details.
  - **clubak**: improved dshbak to gather and sort dsh-like outputs
  See *man clubak* for more details.
  - **nodeset** (or **cluset**): compute advanced nodeset/nodegroup operations
  Examples of use:
    $ echo node160 node161 node162 node163 | nodeset -f
    node[160-163]
    $ nodeset -f node[0-7,32-159] node[160-163]
    node[0-7,32-163]
    $ nodeset -e node[160-163]
    node160 node161 node162 node163
    $ nodeset -f node[32-159] -x node33
    node[32,34-159]
    $ nodeset -f node[32-159] -i node[0-7,20-21,32,156-159]
    node[32,156-159]
    $ nodeset -f node[33-159] --xor node[32-33,156-159]
    node[32,34-155]
    $ nodeset -l
    @oss
    @mds
    @io
    @compute
    $ nodeset -e @mds
    node6 node7
  See *man nodeset* (or *man cluset*) for more details.
  Please visit the ClusterShell website_.


pkgId: 2165dda372d2240ff66abb5556393b0d1fe6649d3849fc8f1ca7de539f30dbec
name: python-Collectfast
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: A Faster Collectstatic
url: https://github.com/antonagestam/collectfast/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4e91eb97-3cb0-46d9-9c43-3060c978f430
location_href: 00012072-python-collectfast/python-Collectfast-2.2.0-1.src.rpm
checksum_type: sha256
description:
  collectfast.strategies.boto3.Boto3Strategy|storages.backends.s3boto3.S3Boto3Storage
  collectfast.strategies.gcloud.GoogleCloudStrategy|storages.backends.gcloud.GoogleCloudStorage
  collectfast.strategies.filesystem.FileSystemStrategy|django.core.files.storage.FileSystemStorage
  Custom strategies can also be made for backends not listed above by
  implementing the `collectfast.strategies.Strategy` ABC.

  Collectfast overrides Django's builtin `collectstatic` command so just run
  `python manage.py collectstatic` as normal.
  You can disable Collectfast by using the `--disable-collectfast` option or by
  setting `COLLECTFAST_ENABLED = False` in your settings file.

  It's recommended to setup a dedicated cache backend for Collectfast. Every time
  Collectfast does not find a lookup for a file in the cache it will trigger a
  lookup to the storage backend, so it's recommended to have a fairly high
  `TIMEOUT` setting.
  Configure your dedicated cache with the `COLLECTFAST_CACHE` setting:
  ```python
  CACHES = {
      'default': {
          
      },
      'collectfast': {
          
      },
  }
  COLLECTFAST_CACHE = 'collectfast'
  ```
  If `COLLECTFAST_CACHE` isn't set, the `default` cache will be used.
  **Note:** Collectfast will never clean the cache of obsolete files. To clean
  out the entire cache, use `cache.clear()`. [See docs for Django's cache
  framework][django-cache].
  **Note:** We recommend you to set the `MAX_ENTRIES` setting if you have more
  than 300 static files, see [#47][issue-47].
  [django-cache]: https://docs.djangoproject.com/en/stable/topics/cache/
  [issue-47]: https://github.com/antonagestam/collectfast/issues/47

  The parallelization feature enables parallel file uploads using Python's
  `concurrent.futures` module. Enable it by setting the `COLLECTFAST_THREADS`
  setting.
  To enable parallel uploads, a dedicated cache backend must be setup and it must
  use a backend that is thread-safe, i.e. something other than Django's default
  LocMemCache.
  ```python
  COLLECTFAST_THREADS = 20
  ```

  By default, Collectfast will suppress any exceptions that happens when copying
  and let Django's `collectstatic` handle it. To debug those suppressed errors
  you can set `COLLECTFAST_DEBUG = True` in your Django settings file.

  Please feel free to contribute by using issues and pull requests. Discussion is
  open and welcome.

  The test suite is built to run against live S3 and GCloud buckets. You can
  disable live tests by setting `SKIP_LIVE_TESTS=true` or running `make
  test-skip-live`. To run live tests locally you need to provide API credentials
  to test against. Add the credentials to a file named `storage-credentials` in
  the root of the project directory:
  ```bash
  export AWS_ACCESS_KEY_ID='...'
  export AWS_SECRET_ACCESS_KEY='...'
  export GCLOUD_CREDENTIALS='{...}'  # Google Cloud credentials as JSON
  ```
  Install test dependencies and target Django version:
  ```bash
  python3 -m pip install -r test-requirements.txt
  python3 -m pip install django==2.2
  ```
  Run test suite:
  ```bash
  make test
  ```
  Code quality tools are broken out from test requirements because some of them
  only install on Python >= 3.7.
  ```bash
  python3 -m pip install -r lint-requirements.txt
  ```
  Run linters and static type check:
  ```bash
  make lint
  ```

  Collectfast is licensed under the MIT License, see LICENSE file for more
  information.


pkgId: ebce6e264692641cdb3a5b9f3c4b4f49426c40947fe38c9e26608708dd744688
name: python-Command
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Command runner with debug capabilities
url: http://github.com/helgi/python-command
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6511462f-7c8f-4ccf-b708-f13dcfd33bd4
location_href: 00011027-python-command/python-Command-0.1.0-1.src.rpm
checksum_type: sha256
description:
  Wrapper around subprocess.popen with on the fly debug / logging
  capabilities and timeout handling.
  Uses tempfiles for stdout/stderr to get past the 64kb subprocess.PIPE
  bug/limitation in python.
  Normal command run
      import command
      response = command.run(['ls'])
      print response.output
      print response.exit
  Print the output as it happens
      import command
      def debug(text):
          print text
      response = command.run(['ls'], debug=debug)
      print response.output
      print response.exit


pkgId: b09fa69e9cb25e0013ec635f368fb731b679c89174ab47743d0e640cfbc85804
name: python-ConcurrentLogHandler
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: Concurrent logging handler (drop-in replacement for RotatingFileHandler) Python 2.6+
url: http://launchpad.net/python-concurrent-log-handler
rpm_license: http://www.apache.org/licenses/LICENSE-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9a13c130-4593-4d90-824b-3a1ddb527200
location_href: 00003315-python-concurrentloghandler/python-ConcurrentLogHandler-0.9.1-1.src.rpm
checksum_type: sha256
description:
  This module provides an additional log handler for Python's standard logging
  package (PEP 282). This handler will write log events to log file which is
  rotated when the log file reaches a certain size.  Multiple processes can
  safely write to the same log file concurrently.


pkgId: 2c9e206e93db80e147a9cb7e464eb205070ff721cb8220b3a63f1a1873e3bccc
name: python-ConfigArgParse
arch: src
version: 1.5.3
epoch: 0
release: 1
url: https://github.com/bw2/ConfigArgParse
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-741c4c58-73ee-4d5b-aab2-d7635e82c9bd
location_href: 00003319-python-configargparse/python-ConfigArgParse-1.5.3-1.src.rpm
checksum_type: sha256
summary:
  A drop-in replacement for argparse that allows options to also be set via config files and/or environment variables.

description:
  Overview
  ~~~~~~~~
  Applications with more than a handful of user-settable options are best
  configured through a combination of command line args, config files,
  hard-coded defaults, and in some cases, environment variables.
  Python's command line parsing modules such as argparse have very limited
  support for config files and environment variables, so this module
  extends argparse to add these features.
  Available on PyPI: http://pypi.python.org/pypi/ConfigArgParse
  Features
  ~~~~~~~~
  -  command-line, config file, env var, and default settings can now be
     defined, documented, and parsed in one go using a single API (if a
     value is specified in more than one way then: command line >
     environment variables > config file values > defaults)
  -  config files can have .ini or .yaml style syntax (eg. key=value or
     key: value)
  -  user can provide a config file via a normal-looking command line arg
     (eg. -c path/to/config.txt) rather than the argparse-style @config.txt
  -  one or more default config file paths can be specified
     (eg. ['/etc/bla.conf', '~/.my_config'] )
  -  all argparse functionality is fully supported, so this module can
     serve as a drop-in replacement (verified by argparse unittests).
  -  env vars and config file keys & syntax are automatically documented
     in the -h help message
  -  new method :code:`print_values()` can report keys & values and where
     they were set (eg. command line, env var, config file, or default).
  -  lite-weight (no 3rd-party library dependencies except (optionally) PyYAML)
  -  extensible (:code:`ConfigFileParser` can be subclassed to define a new
     config file format)
  -  unittested by running the unittests that came with argparse but on
     configargparse, and using tox to test with Python 2.7 and Python 3+
  Example
  ~~~~~~~
  *config_test.py*:
  Script that defines 4 options and a positional arg and then parses and prints the values. Also,
  it prints out the help message as well as the string produced by :code:`format_values()` to show
  what they look like.
     import configargparse
     p = configargparse.ArgParser(default_config_files=['/etc/app/conf.d/*.conf', '~/.my_settings'])
     p.add('-c', '--my-config', required=True, is_config_file=True, help='config file path')
     p.add('--genome', required=True, help='path to genome file')  # this option can be set in a config file because it starts with '--'
     p.add('-v', help='verbose', action='store_true')
     p.add('-d', '--dbsnp', help='known variants .vcf', env_var='DBSNP_PATH')  # this option can be set in a config file because it starts with '--'
     p.add('vcf', nargs='+', help='variant file(s)')
     options = p.parse_args()
     print(options)
     print("----------")
     print(p.format_help())
     print("----------")
     print(p.format_values())    # useful for logging where different settings came from
  *config.txt:*
  Since the script above set the config file as required=True, lets create a config file to give it:
      
      genome = HCMV     # cytomegalovirus genome
      dbsnp = /data/dbsnp/variants.vcf
  *command line:*
  Now run the script and pass it the config file:
      DBSNP_PATH=/data/dbsnp/variants_v2.vcf python config_test.py --my-config config.txt f1.vcf f2.vcf
  *output:*
  Here is the result:


pkgId: 11a66b78ee4d821bb23e615c9eea78f31aa3a03aee136f2e996a1ff63fe71c55
name: python-CredSLayer
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: Extract credentials and other useful info from network captures
url: https://github.com/ShellCode33/CredSLayer
rpm_license: GPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8449849b-99dd-4278-856f-cc41201b2286
location_href: 00003353-python-credslayer/python-CredSLayer-0.1.3-1.src.rpm
checksum_type: sha256
description:
  ![alt python_version](https://img.shields.io/badge/python-3.5+-informational.svg?style=for-the-badge)
  ![alt tests_coverage](https://img.shields.io/badge/tests%20coverage-94%25-success.svg?style=for-the-badge)
  [![alt documentation](https://img.shields.io/badge/documentation-critical.svg?style=for-the-badge)](https://shellcode33.github.io/CredSLayer/)

  CredSLayer goal is to look for credentials and other useful stuff in network captures. Two modes are available, pcap scanning and active processing. The latest listens for packets on a chosen interface and dynamically extracts everything it can.

  This tool has been heavily inspired by [Pcredz](https://github.com/lgandx/PCredz) and [net-creds](https://github.com/DanMcInerney/net-creds) but is built with extensibility in mind.
  Pcredz and net-creds are great, but they are really hard to maintain and improve.
  Unlike these tools which are using regex and raw bytes parsing, CredSLayer takes advantage of Wireshark dissectors which have proven over time to be pretty accurate and reliable.
  It makes it really easy to add support for new protocols.


  This tool can be really helpful if you're doing IT security or if you want to scan your own network to see if anything critical is transmitted.

  ![alt credslayer_output_example](https://github.com/ShellCode33/CredSLayer/raw/master/docs/example.png)



  CredSLayer doesn't waste your time with invalid credentials, it makes sure credentials are valid.
  Yet if it's not able to tell whether they're valid or not, what has been found will be printed out anyway.

  Right now, CredSLayer supports the following protocols:
  * FTP
  * SMTP / IMAP / POP3
  * Telnet
  * HTTP
  * LDAP
  * SNMP
  * MySQL / PostgreSQL
  * NTLMSSP
  * Kerberos coming soon...

  It is also able to look for email addresses and credit card numbers.

  **Note:** To prevent false positives and performance issues, tshark (the Wireshark underlying engine) identifies protocols based on port numbers to know which dissector to use on which packets. A few protocols however have heuristic analysis to guess the protocol on different ports than the usual ones (such as HTTP). See the [limitation chapter](https://shellcode33.github.io/CredSLayer/getting-started/limitations.html) in the documentation. To address this issue, CredSLayer has a `--map` parameter, it enables you to map a (range of) port(s) to a specific protocol. This way you will be able to sniff credentials going to a specific service on a specific port you are aware of.



  You need `tshark` installed and Python >= 3.5. On some distribution tshark in shipped within the `wireshark` package.

  Then simply install using :

  ```
  $ pip install credslayer
  ```

  I recommend you use a [virtualenv](https://docs.python.org/3/library/venv.html) to prevent conflicts.



  ```
  $ credslayer -h
  usage: credslayer [-h] [-l INTERFACE] [-s {enable,disable}] [-f IP]
                       [-m PORT:PROTOCOL] [--debug]
                       [pcapfiles [pcapfiles ...]]

  Helps you find credentials and other interesting stuff in network captures

  positional arguments:
    pcapfiles             pcap files you want to analyse.

  optional arguments:
    -h, --help            show this help message and exit
    -l INTERFACE, --listen INTERFACE
                          start active processing on specified interface
    -s {enable,disable}, --string-inspection {enable,disable}
                          let you specify if you want to look for interesting
                          strings (email addresses, credit cards, ...) in
                          network captures. Pretty heavy on the CPU. Enabled by
                          default on pcap files, disabled on live captures.
    -f IP, --filter IP    only show packets involving the specified IP.
    -m PORT:PROTOCOL, --map PORT:PROTOCOL
                          map a port to a protocol
    --debug               put CredSLayer and pyshark in debug mode.
  ```



  Thanks to Wireshark dissectors, it's really easy to write new protocols support, you're welcome to contribute !

  Contributing doesn't necessarily mean writing code. You can simply contribute by opening new issues on Github if you spot any bug or if you would like to see something added to the tool.

  To learn how to create support for a new protocol, head over to the [documentation](https://shellcode33.github.io/CredSLayer/contribute/create-parser.html).



  * CredSLayer is based on [pyshark](https://github.com/KimiNewt/pyshark), a tshark Python wrapper

  * Wireshark for their [pcaps](https://wiki.wireshark.org/SampleCaptures)

  * [moloch](https://github.com/aol/moloch) for their [pcaps](https://github.com/aol/moloch/tree/master/tests/pcap)

  * [asecuritysite](https://asecuritysite.com) for their [pcaps](https://asecuritysite.com/forensics/pcap)


pkgId: 53d61bba8ae3fffaf0d2ff5338f6dc731dd6ab9071d6a402705d2ed25cb573b1
name: python-Cython
arch: src
version: 0.29.33
epoch: 0
release: 1
summary: The Cython compiler for writing C extensions for the Python language.
url: http://cython.org/
rpm_license: Apache
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-340c4be0-4944-4b8c-8104-c64b2760abd7
location_href: 00002845-python-Cython/python-Cython-0.29.33-1.src.rpm
checksum_type: sha256
description:
  The Cython language makes writing C extensions for the Python language as
  easy as Python itself.  Cython is a source code translator based on Pyrex_,
  but supports more cutting edge functionality and optimizations.

  The Cython language is a superset of the Python language (almost all Python
  code is also valid Cython code), but Cython additionally supports optional
  static typing to natively call C functions, operate with C++ classes and
  declare fast C types on variables and class attributes.  This allows the
  compiler to generate very efficient C code from Cython code.

  This makes Cython the ideal language for writing glue code for external
  C/C++ libraries, and for fast C modules that speed up the execution of
  Python code.

  Note that for one-time builds, e.g. for CI/testing, on platforms that are not
  covered by one of the wheel packages provided on PyPI *and* the pure Python wheel
  that we provide is not used, it is substantially faster than a full source build
  to install an uncompiled (slower) version of Cython with::

      pip install Cython --install-option="--no-cython-compile"

  .. _Pyrex: http://www.cosc.canterbury.ac.nz/greg.ewing/python/Pyrex/


pkgId: 9760de3043d068c1ecf2c996c956c09be59305e50eacc424927d4d379cfe157a
name: python-DAWG-Python
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: Pure-python reader for DAWGs (DAFSAs) created by dawgdic C++ library or DAWG Python extension.
url: https://github.com/kmike/DAWG-Python/
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3cfa7beb-b359-4f76-bd2b-7560b362aab8
location_href: 00011527-python-dawg-python/python-DAWG-Python-0.7.2-1.src.rpm
checksum_type: sha256
description:
  This pure-python package provides read-only access for files
  created by `dawgdic`_ C++ library and `DAWG`_ python package.
  This package is not capable of creating DAWGs. It works with DAWGs built by
  `dawgdic`_ C++ library or `DAWG`_ Python extension module. The main purpose
  of DAWG-Python is to provide an access to DAWGs without requiring compiled
  extensions. It is also quite fast under PyPy (see benchmarks).


pkgId: c69a1bfc7ef954f6f448c21251db2f0785933a14c547dc73ca23a71ed112b2df
name: python-DBUtils
arch: src
version: 3.0.2
epoch: 0
release: 1
summary: Database connections for multi-threaded environments.
url: https://webwareforpython.github.io/DBUtils/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1fc642e1-dfa5-48aa-b4ed-5c1cc5ef2b96
location_href: 00010377-python-dbutils/python-DBUtils-3.0.2-1.src.rpm
checksum_type: sha256
description:
  DBUtils is a suite of tools providing solid, persistent and pooled connections
  to a database that can be used in all kinds of multi-threaded environments.
  The suite supports DB-API 2 compliant database interfaces
  and the classic PyGreSQL interface.
  The current version 3.0.2 of DBUtils supports Python versions 3.6 to 3.10.
  **Please have a look at the [changelog](https://webwareforpython.github.io/DBUtils/changelog.html), because there were some breaking changes in version 2.0.**
  The DBUtils home page can be found at https://webwareforpython.github.io/DBUtils/


pkgId: 29ad09bf7fb459e1714bbe2ce0ac25fb32f08b68c5696cf5a253a7dda9eaba62
name: python-DateTimeRange
arch: src
version: 2.1.0
epoch: 0
release: 1
url: https://github.com/thombashi/DateTimeRange
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5c3d110b-1961-4bda-98fd-76e9c97eeec8
location_href: 00013040-python-datetimerange/python-DateTimeRange-2.1.0-1.src.rpm
checksum_type: sha256
summary:
  DateTimeRange is a Python library to handle a time range. e.g. check whether a time is within the time range, get the intersection of time ranges, truncate a time range, iterate through a time range, and so forth.

description:
  `DateTimeRange <https://github.com/thombashi/DateTimeRange>`__ is a Python library to handle a time range. e.g. check whether a time is within the time range, get the intersection of time ranges, truncate a time range, iterate through a time range, and so forth.


pkgId: e8bb1b283cad4cd0d47889548f3349838b4337654995fff9e87565c170841894
name: python-Deprecated
arch: src
version: 1.2.13
epoch: 0
release: 1
summary: Python @deprecated decorator to deprecate old python classes, functions or methods.
url: https://github.com/tantale/deprecated
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dbac2574-a8d9-4440-aadc-bdc6e911af22
location_href: 00009056-python-deprecated/python-Deprecated-1.2.13-1.src.rpm
checksum_type: sha256
description:
  Deprecated is Easy to Use
  `````````````````````````
  If you need to mark a function or a method as deprecated,
  you can use the ``@deprecated`` decorator:
  Save in a hello.py:
      from deprecated import deprecated
      @deprecated(version='1.2.1', reason="You should use another function")
      def some_old_function(x, y):
          return x + y
      class SomeClass(object):
          @deprecated(version='1.3.0', reason="This method is deprecated")
          def some_old_method(self, x, y):
              return x + y
      some_old_function(12, 34)
      obj = SomeClass()
      obj.some_old_method(5, 8)
  And Easy to Setup
  `````````````````
  And run it:
      $ pip install Deprecated
      $ python hello.py
      hello.py:15: DeprecationWarning: Call to deprecated function (or staticmethod) some_old_function.
      (You should use another function) -- Deprecated since version 1.2.0.
        some_old_function(12, 34)
      hello.py:17: DeprecationWarning: Call to deprecated method some_old_method.
      (This method is deprecated) -- Deprecated since version 1.3.0.
        obj.some_old_method(5, 8)
  You can document your code
  ``````````````````````````
  Have you ever wonder how to document that some functions, classes, methods, etc. are deprecated?
  This is now possible with the integrated Sphinx directives:
  For instance, in hello_sphinx.py:
      from deprecated.sphinx import deprecated
      from deprecated.sphinx import versionadded
      from deprecated.sphinx import versionchanged
      @versionadded(version='1.0', reason="This function is new")
      def function_one():
          '''This is the function one'''
      @versionchanged(version='1.0', reason="This function is modified")
      def function_two():
          '''This is the function two'''
      @deprecated(version='1.0', reason="This function will be removed soon")
      def function_three():
          '''This is the function three'''
      function_one()
      function_two()
      function_three()  # warns
      help(function_one)
      help(function_two)
      help(function_three)
  The result it immediate
  ```````````````````````
  Run it:
      $ python hello_sphinx.py
      hello_sphinx.py:23: DeprecationWarning: Call to deprecated function (or staticmethod) function_three.
      (This function will be removed soon) -- Deprecated since version 1.0.
        function_three()  # warns
      Help on function function_one in module __main__:
      function_one()
          This is the function one
             This function is new
      Help on function function_two in module __main__:
      function_two()
          This is the function two
             This function is modified
      Help on function function_three in module __main__:
      function_three()
          This is the function three
             This function will be removed soon
  Links
  `````
  * `Python package index (PyPi) <https://pypi.python.org/pypi/deprecated>`_
  * `GitHub website <https://github.com/tantale/deprecated>`_
  * `Read The Docs <https://readthedocs.org/projects/deprecated>`_
  * `EBook on Lulu.com <http://www.lulu.com/commerce/index.php?fBuyContent=21305117>`_
  * `StackOverFlow Q&A <https://stackoverflow.com/a/40301488/1513933>`_
  * `Development version
    <https://github.com/tantale/deprecated/zipball/master#egg=Deprecated-dev>`_


pkgId: 4650d83053a7c185abe0b9342bdcb9d6002254b6e5622656d60b4be38c50bc4e
name: python-DoubleMetaphone-debuginfo
arch: x86_64
version: 1.1
epoch: 0
release: 1
summary: Debug information for package python-DoubleMetaphone
url: https://pypi.org/project/DoubleMetaphone/
rpm_license: Artistic License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-dfd02cc1-bb82-45f7-9d2a-86b6f567d163
rpm_sourcerpm: python-DoubleMetaphone-1.1-1.src.rpm
location_href: 00010905-python-doublemetaphone/python-DoubleMetaphone-debuginfo-1.1-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-DoubleMetaphone.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: df7170e4aa86056ed7557621ec6a8c57eccb41f021c40efbb20c544e34cad8ce
name: python-DoubleMetaphone-debugsource
arch: x86_64
version: 1.1
epoch: 0
release: 1
summary: Debug sources for package python-DoubleMetaphone
url: https://pypi.org/project/DoubleMetaphone/
rpm_license: Artistic License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-dfd02cc1-bb82-45f7-9d2a-86b6f567d163
rpm_sourcerpm: python-DoubleMetaphone-1.1-1.src.rpm
location_href: 00010905-python-doublemetaphone/python-DoubleMetaphone-debugsource-1.1-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-DoubleMetaphone.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 83d70a951e9c8224a087a0881032df03543cfa0ee04758fd343fad535859a325
name: python-Dozer
arch: src
version: 0.8
epoch: 0
release: 1
summary: WSGI Middleware version of the CherryPy memory leak debugger
url: https://github.com/mgedmin/dozer
rpm_license: Public Domain
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a5c1ef4b-8089-4a7b-9b72-cc50bfda01a7
location_href: 00013564-python-dozer/python-Dozer-0.8-1.src.rpm
checksum_type: sha256
description:
  Dozer was originally a WSGI middleware version of Robert Brewer's
  `Dowser CherryPy tool <http://www.aminus.net/wiki/Dowser>`_ that
  displays information as collected by the gc module to assist in
  tracking down memory leaks.  It now also has middleware for profiling
  and for looking at logged messages.


pkgId: 125c921410d1585173884647e4f3664fccf8ef1d28ff645028a7c01de2b854a1
name: python-ECPy
arch: src
version: 1.2.5
epoch: 0
release: 1
summary: Pure Pyhton Elliptic Curve Library
url: https://github.com/cslashm/ECPy
rpm_license: Apache License - Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-96404c9b-0489-440a-8e00-8898b9c4e585
location_href: 00002846-python-ECPy/python-ECPy-1.2.5-1.src.rpm
checksum_type: sha256
description:
  ECPy (pronounced ekpy), is a pure python Elliptic Curve library
  providing ECDSA, EDDSA (Ed25519), ECSchnorr, Borromean signatures as well as Point
  operations.
  Full html documentation is available `here <https://cslashm.github.com/ECPy>`_.
  **ECDSA sample**
      from ecpy.curves     import Curve,Point
      from ecpy.keys       import ECPublicKey, ECPrivateKey
      from ecpy.ecdsa      import ECDSA
      cv   = Curve.get_curve('secp256k1')
      pu_key = ECPublicKey(Point(0x65d5b8bf9ab1801c9f168d4815994ad35f1dcb6ae6c7a1a303966b677b813b00,
                             0xe6b865e529b8ecbf71cf966e900477d49ced5846d7662dd2dd11ccd55c0aff7f,
                             cv))
      pv_key = ECPrivateKey(0xfb26a4e75eec75544c0f44e937dcf5ee6355c7176600b9688c667e5c283b43c5,
                        cv)
      signer = ECDSA()
      sig    = signer.sign(b'01234567890123456789012345678912',pv_key)
      assert(signer.verify(b'01234567890123456789012345678912',sig,pu_key))
  **Point sample**
      from ecpy.curves     import Curve,Point
      cv = Curve.get_curve('secp256k1')
      P  = Point(0x65d5b8bf9ab1801c9f168d4815994ad35f1dcb6ae6c7a1a303966b677b813b00,
                 0xe6b865e529b8ecbf71cf966e900477d49ced5846d7662dd2dd11ccd55c0aff7f,
                 cv)
      k  = 0xfb26a4e75eec75544c0f44e937dcf5ee6355c7176600b9688c667e5c283b43c5
      Q  = k*P
      R  = P+Q


pkgId: f921268c1e67786967c4bb8f66d9132b47fee49eec8321f88e0184ddaaab7e2a
name: python-ERAlchemy
arch: src
version: 1.2.10
epoch: 0
release: 1
summary: Simple entity relation (ER) diagrams generation
url: https://github.com/Alexis-benoist/eralchemy
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3fd6f025-1327-464b-80f0-87a4debaa133
location_href: 00003581-python-eralchemy/python-ERAlchemy-1.2.10-1.src.rpm
checksum_type: sha256
description:
  |Join the chat at https://gitter.im/Alexis-benoist/eralchemy|
  ERAlchemy generates Entity Relation (ER) diagram (like the one below)
  from databases or from SQLAlchemy models.


pkgId: 4fd4e2c02fd95ebff53852918b70c1c4797607f20698d4a4ae432686355c6636
name: python-EasyProcess
arch: src
version: 1.1
epoch: 0
release: 1
summary: Easy to use Python subprocess interface.
url: https://github.com/ponty/easyprocess
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-05d69d3b-65c3-4583-abdb-063375c8dab7
location_href: 00009695-python-easyprocess/python-EasyProcess-1.1-1.src.rpm
checksum_type: sha256
description:
  Easy to use Python subprocess interface.

  Documentation: https://github.com/ponty/easyprocess/tree/1.1


pkgId: ec32296c5746d229da598c5d930d0fcc89069abf3df625c6c3ce537e5a575e92
name: python-EbookLib
arch: src
version: 0.18
epoch: 0
release: 1
summary: Ebook library which can handle EPUB2/EPUB3 and Kindle format
url: https://github.com/aerkalov/ebooklib
rpm_license: GNU Affero General Public License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d2fab935-7ca7-4ab0-8cf0-e01f34c905f1
location_href: 00012253-python-ebooklib/python-EbookLib-0.18-1.src.rpm
checksum_type: sha256
description:
  EbookLib is a Python library for managing EPUB2/EPUB3 and Kindle files. It's capable of reading and writing EPUB files programmatically (Kindle support is under development).

  The API is designed to be as simple as possible, while at the same time making complex things possible too.  It has support for covers, table of contents, spine, guide, metadata and etc.

  EbookLib is used in `Booktype <https://github.com/sourcefabric/Booktype/>`_ from Sourcefabric, as well as `sprits-it! <https://github.com/the-happy-hippo/sprits-it>`_, `fanfiction2ebook <https://github.com/ltouroumov/fanfiction2ebook>`_, `viserlalune <https://github.com/vjousse/viserlalune>`_ and `Telemeta <https://github.com/Parisson/Telemeta>`_.

  Packages of EbookLib for GNU/Linux are available in `Debian <https://packages.debian.org/python-ebooklib>`_ and `Ubuntu <http://packages.ubuntu.com/python-ebooklib>`_.

  Sphinx documentation is generated from the templates in the docs/ directory and made available at http://ebooklib.readthedocs.io




  ```py
  import ebooklib
  from ebooklib import epub

  book = epub.read_epub('test.epub')

  for image in book.get_items_of_type(ebooklib.ITEM_IMAGE):
      print(image)
  ```



  ```py
  from ebooklib import epub

  book = epub.EpubBook()


  book.set_identifier("id123456")
  book.set_title("Sample book")
  book.set_language("en")

  book.add_author("Author Authorowski")
  book.add_author(
      "Danko Bananko",
      file_as="Gospodin Danko Bananko",
      role="ill",
      uid="coauthor",
  )


  c1 = epub.EpubHtml(title="Intro", file_name="chap_01.xhtml", lang="hr")
  c1.content = (
      "<h1>Intro heading</h1>"
      "<p>Zaba je skocila u baru.</p>"
      '<p><img alt="[ebook logo]" src="static/ebooklib.gif"/><br/></p>'
  )


  image_content = open("ebooklib.gif", "rb").read()
  img = epub.EpubImage(
      uid="image_1",
      file_name="static/ebooklib.gif",
      media_type="image/gif",
      content=image_content,
  )


  book.add_item(c1)

  book.add_item(img)


  book.toc = (
      epub.Link("chap_01.xhtml", "Introduction", "intro"),
      (epub.Section("Simple book"), (c1,)),
  )


  book.add_item(epub.EpubNcx())
  book.add_item(epub.EpubNav())


  style = "BODY {color: white;}"
  nav_css = epub.EpubItem(
      uid="style_nav",
      file_name="style/nav.css",
      media_type="text/css",
      content=style,
  )


  book.add_item(nav_css)


  book.spine = ["nav", c1]


  epub.write_epub("test.epub", book, {})
  ```



  EbookLib is licensed under the `AGPL license <LICENSE.txt>`_.



  Full list of authors is in `AUTHORS.txt <AUTHORS.txt>`_ file.


pkgId: a8796e22fd57eb6c1675dc3a1e14f05677464bb875dff0e984af8c6e47a418f8
name: python-ElasticMock
arch: src
version: 1.8.1
epoch: 0
release: 1
summary: Python Elasticsearch Mock for test purposes
url: https://github.com/vrcmarcos/elasticmock
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8ff3688e-c1a0-4f6d-914f-e65baf8986c5
location_href: 00013916-python-elasticmock/python-ElasticMock-1.8.1-1.src.rpm
checksum_type: sha256
description:
  Python Elasticsearch Mock for test purposes

  [![Build Status](https://travis-ci.org/vrcmarcos/elasticmock.svg?branch=master)](https://travis-ci.org/vrcmarcos/elasticmock) [![Coverage Status](https://coveralls.io/repos/github/vrcmarcos/elasticmock/badge.svg?branch=master)](https://coveralls.io/github/vrcmarcos/elasticmock?branch=master) [![PyPI version](https://badge.fury.io/py/ElasticMock.svg)](https://badge.fury.io/py/ElasticMock) [![GitHub license](https://img.shields.io/github/license/vrcmarcos/elasticmock)](https://github.com/vrcmarcos/elasticmock/blob/master/LICENSE) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ElasticMock) ![ElasticSearch Version](https://img.shields.io/badge/elasticsearch-1%20%7C%202%20%7C%205%20%7C%206%20%7C%207-blue)

  ![Libraries.io dependency status for latest release](https://img.shields.io/librariesio/release/pypi/elasticmock) [![Downloads](https://pepy.tech/badge/elasticmock/month)](https://pepy.tech/project/elasticmock/month)



  ```shell
  pip install ElasticMock
  ```



  To use ElasticMock, decorate your test method with **@elasticmock** decorator:

  ```python
  from unittest import TestCase

  from elasticmock import elasticmock


  class TestClass(TestCase):

      @elasticmock
      def test_should_return_something_from_elasticsearch(self):
          self.assertIsNotNone(some_function_that_uses_elasticsearch())
  ```



  You can also force the behaviour of the ElasticSearch instance by importing the `elasticmock.behaviour` module:

  ```python
  from unittest import TestCase

  from elasticmock import behaviour


  class TestClass(TestCase):

      ...

      def test_should_return_internal_server_error_when_simulate_server_error_is_true(self):
          behaviour.server_failure.enable()
          ...
          behaviour.server_failure.disable()
  ```

  You can also disable all behaviours by calling `behaviour.disable_all()` (Consider put this in your `def tearDown(self)` method)



  * `server_failure`: Will make all calls to ElasticSearch returns the following error message:
      ```python
      {
          'status_code': 500,
          'error': 'Internal Server Error'
      }
      ```



  Let's say you have a prod code snippet like this one:

  ```python
  import elasticsearch

  class FooService:

      def __init__(self):
          self.es = elasticsearch.Elasticsearch(hosts=[{'host': 'localhost', 'port': 9200}])

      def create(self, index, body):
          es_object = self.es.index(index, body)
          return es_object.get('_id')

      def read(self, index, id):
          es_object = self.es.get(index, id)
          return es_object.get('_source')

  ```

  Than you should be able to test this class by mocking ElasticSearch using the following test class:

  ```python
  from unittest import TestCase
  from elasticmock import elasticmock
  from foo.bar import FooService

  class FooServiceTest(TestCase):

      @elasticmock
      def should_create_and_read_object(self):
          
          index = 'test-index'
          expected_document = {
              'foo': 'bar'
          }

          
          service = FooService()

          
          id = service.create(index, expected_document)
          self.assertIsNotNone(id)

          
          document = service.read(index, id)
          self.assertEquals(expected_document, document)

  ```



  - The mocked **search** method returns **all available documents** indexed on the index with the requested document type.
  - The mocked **suggest** method returns the exactly suggestions dictionary passed as body serialized in Elasticsearch.suggest response. **Atention:** If the term is an *int*, the suggestion will be ```python term + 1```. If not, the suggestion will be formatted as ```python {0}_suggestion.format(term) ```.
  Example:
  	- **Suggestion Body**:
  	```python
      suggestion_body = {
          'suggestion-string': {
              'text': 'test_text',
              'term': {
                  'field': 'string'
              }
          },
          'suggestion-id': {
              'text': 1234567,
              'term': {
                  'field': 'id'
              }
          }
      }
      ```
      - **Suggestion Response**:
      ```python
      {
          'suggestion-string': [
              {
                  'text': 'test_text',
                  'length': 1,
                  'options': [
                      {
                          'text': 'test_text_suggestion',
                          'freq': 1,
                          'score': 1.0
                      }
                  ],
                  'offset': 0
              }
          ],
          'suggestion-id': [
              {
                  'text': 1234567,
                  'length': 1,
                  'options': [
                      {
                          'text': 1234568,
                          'freq': 1,
                          'score': 1.0
                      }
                  ],
                  'offset': 0
              }
          ],
      }
      ```



  ```bash
  python setup.py test
  ```




  - [Add support for Python 3.9](https://github.com/vrcmarcos/elasticmock/pull/72) (Thanks [@singingwolfboy](https://github.com/singingwolfboy))
  - [use unittest.mock instead of mock](https://github.com/vrcmarcos/elasticmock/pull/71) (Thanks [@singingwolfboy](https://github.com/singingwolfboy))
  - [Add must_not for bool search query](https://github.com/vrcmarcos/elasticmock/pull/70) (Thanks [@t-bittarn](https://github.com/t-bittarn))



  - [Add multi_match](https://github.com/vrcmarcos/elasticmock/pull/63) (Thanks [@carlosgalvez-tiendeo](https://github.com/carlosgalvez-tiendeo))
  - [Add mget](https://github.com/vrcmarcos/elasticmock/pull/64) (Thanks [@carlosgalvez-tiendeo](https://github.com/carlosgalvez-tiendeo))
  - [Add create, update, and delete to bulk API](https://github.com/vrcmarcos/elasticmock/pull/65) (Thanks [@fenimore](https://github.com/fenimore))
  - [Add Should to bool Query](https://github.com/vrcmarcos/elasticmock/pull/67) (Thanks [@fenimore](https://github.com/fenimore))
  - [Update Search API return result](https://github.com/vrcmarcos/elasticmock/pull/68) (Thanks [@fenimore](https://github.com/fenimore))


  - [Add shards skipped to search and count](https://github.com/vrcmarcos/elasticmock/pull/56) (Thanks [@philtweir](https://github.com/philtweir))
  - [Allow 'match_all' queries in FakeSearch](https://github.com/vrcmarcos/elasticmock/pull/54) (Thanks [@jankislinger](https://github.com/jankislinger))
  - [Query using nested attributes](https://github.com/vrcmarcos/elasticmock/pull/55) (Thanks [@jankislinger](https://github.com/jankislinger))
  - [New features: range, size, aggregations](https://github.com/vrcmarcos/elasticmock/pull/57) (Thanks [@jankislinger](https://github.com/jankislinger))
  - [Adding "should" and "minimum_should_match" to QueryType](https://github.com/vrcmarcos/elasticmock/pull/62) (Thanks [@lunarie16](https://github.com/lunarie16))


  - [Add must to query type](https://github.com/vrcmarcos/elasticmock/pull/47) (Thanks [@cuent](https://github.com/cuent))
  - [Add match all query type](https://github.com/vrcmarcos/elasticmock/pull/48) (Thanks [@cuent](https://github.com/cuent))


  - Fix Twine README.md


  - [Implements several basic search types](https://github.com/vrcmarcos/elasticmock/pull/42) (Thanks [@KyKoPho](https://github.com/KyKoPho))
  - [Allow ignoring of missing documents (404) for get and delete](https://github.com/vrcmarcos/elasticmock/pull/44) (Thanks [@joosterman](https://github.com/joosterman))


  - [Fix tests for es > 7](https://github.com/vrcmarcos/elasticmock/pull/38) (Thanks [@chesstrian](https://github.com/chesstrian))


  - [**FakeElasticSearch**: Mocked **indices** property](https://github.com/vrcmarcos/elasticmock/issues/22)
    - **FakeIndicesClient**: Mocked **create**, **exists**, **refresh** and **delete** methods
  - [**FakeElasticSearch**: Mocked **cluster** property](https://github.com/vrcmarcos/elasticmock/issues/8)
    - **FakeClusterClient**: Mocked **health** method



  - [Fix es.index regression issue](https://github.com/vrcmarcos/elasticmock/issues/34)
  - [Add 'Force Server Failure' feature as requested](https://github.com/vrcmarcos/elasticmock/issues/28)
  - Reformat code to be compliant with PEP8
  - Add support to Python 3.8



  - [Adding fix for updating existing doc using index](https://github.com/vrcmarcos/elasticmock/pull/32) (Thanks [@adityaghosh](https://github.com/adityaghosh))
  - [Added bulk method](https://github.com/vrcmarcos/elasticmock/pull/30) (Thanks [@charl-van-niekerk](https://github.com/charl-van-niekerk))
  - [Add default value to doc_type in index method as it is by default set to '\_doc'](https://github.com/vrcmarcos/elasticmock/pull/27) (Thanks [@mohantyashish109](https://github.com/mohantyashish109))
  - [Add support for Python 3.7](https://github.com/vrcmarcos/elasticmock/pull/25) (Thanks [@asherf](https://github.com/asherf))



  - [Fix installation issue](https://github.com/vrcmarcos/elasticmock/pull/20) (Thanks [@tdhopper](https://github.com/tdhopper))



  - [Fix 1.3.4 release](https://github.com/vrcmarcos/elasticmock/pull/19) (Thanks [@infinite-Joy](https://github.com/infinite-Joy))



  - [Added aggregations to response if requested](https://github.com/vrcmarcos/elasticmock/pull/15) (Thanks [@snakeye](https://github.com/snakeye))
  - [Implementing new methods for scrolling](https://github.com/vrcmarcos/elasticmock/pull/17) (Thanks [@tcatrain](https://github.com/tcatrain))



  - [Search: doc_type can be a list](https://github.com/vrcmarcos/elasticmock/pull/16) (Thanks [@garncarz](https://github.com/garncarz))
  - [Exclude tests package](https://github.com/vrcmarcos/elasticmock/pull/13) (Thanks [@jmlw](https://github.com/jmlw))
  - [Make the FakeElasticsearch __init__ signature match the one from Elasticsearch](https://github.com/vrcmarcos/elasticmock/pull/10) (Thanks [@xrmx](https://github.com/xrmx))
  - [Improve search and count](https://github.com/vrcmarcos/elasticmock/pull/7) (Thanks [@frivoire](https://github.com/frivoire))



  - **elasticmock**: Python 3 fixes (Thanks [@barseghyanartur](https://github.com/barseghyanartur))
  - **test**: Add information on testing (Thanks [@barseghyanartur](https://github.com/barseghyanartur))
  - **README.md**: Fixed typo (Thanks [@bowlofstew](https://github.com/bowlofstew))



  - **elasticmock**: Allow the same arguments to the mock that elasticsearch.Elasticsearch allows (Thanks [@mattbreeden](https://github.com/mattbreeden))


  - **FakeElasticSearch**: Mocked **count** method (Thanks [@TheoResources](https://github.com/TheoResources))


  - **FakeElasticSearch**: Mocked **suggest** method


  - **elasticmock**: Changing the cleanup older FakeElasticSearch's instances order
  - **FakeElasticSearch.index**: Changing the method signature to correctly overrides the Elasticsearch.index method


  - **FakeElasticSearch**: Mocked **delete** method


  - **setup.py**: Fixed GitHub link


  - **elasticmock**: Created **@elasticmock** decorator
  - **FakeElasticSearch**: Mocked **exists**, **get**, **get_source**, **index**, **info**, **search** and **ping** method


pkgId: 0105387bb6c5b2e3b4fb0ec24f896bbb78f76219341ddf77b8ee8d62543fc028
name: python-Events
arch: src
version: 0.4
epoch: 0
release: 1
summary: Bringing the elegance of C# EventHandler to Python
url: http://github.com/pyeve/events
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5dec7517-3d2c-4619-b7b6-8e3c59b16d77
location_href: 00003589-python-events/python-Events-0.4-1.src.rpm
checksum_type: sha256
description:
  The C# language provides a handy way to declare, subscribe to and fire events.
  Technically, an event is a "slot" where callback functions (event handlers) can
  be attached to - a process referred to as subscribing to an event. Here is
  a handy package that encapsulates the core to event subscription and event
  firing and feels like a "natural" part of the language.
      >>> def something_changed(reason):
      >>> from events import Events
      >>> events = Events()
      >>> events.on_change += something_changed
  Multiple callback functions can subscribe to the same event. When the event is
  fired, all attached event handlers are invoked in sequence. To fire the event,
  perform a call on the slot:
      >>> events.on_change('it had to happen')
      'something changed because it had to happen'
  By default, Events does not check if an event can be subscribed to and fired.
  You can predefine events by subclassing Events and listing them. Attempts to
  subscribe to or fire an undefined event will raise an EventsException.
      >>> class MyEvents(Events):
      >>> events = MyEvents()
      
      >>> events.on_change += something_changed
  You can also predefine events for a single Events instance by passing an
  iterator to the constructor.
      >>> events = Events(('on_this', 'on_that'))
      
      >>> events.on_change += something_changed


pkgId: b747eab2395a3e3542a5526c9e945fbebaa561a5a6db3799d461e3b3dea05957
name: python-ExifRead
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Read Exif metadata from tiff and jpeg files.
url: https://github.com/ianare/exif-py
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-480a5ee5-088c-4453-af82-82a999c26175
location_href: 00009657-python-exifread/python-ExifRead-3.0.0-1.src.rpm
checksum_type: sha256
description:
  The recommended process is to install the `PyPI package <https://pypi.python.org/pypi/ExifRead>`_,
  as it allows easily staying up to date::
      $ pip install exifread
  See the `pip documentation <https://pip.pypa.io/en/latest/user_guide.html>`_ for more info.
  EXIF.py is mature software and strives for stability.


pkgId: 9b2ad1cf67df049a77555f8c95ee52c72b6277d69aff49c8d2c02b9ff8ef63d1
name: python-Fabric3
arch: src
version: 1.14.post1
epoch: 0
release: 1
url: https://github.com/mathiasertl/fabric/
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-82394740-1093-43c1-8e89-1082e993e0d0
location_href: 00011144-python-fabric3/python-Fabric3-1.14.post1-1.src.rpm
checksum_type: sha256
summary:
  Fabric is a simple, Pythonic tool for remote execution and deployment (py2.7/py3.4+ compatible fork).

description:
  Fabric3 is a fork of `Fabric <http://fabfile.org>`_ to provide compatability
  with Python 3.4+. The port still works with Python 2.7.

  The goal is to stay 100% compatible with the original Fabric.  Any new releases
  of Fabric will also be released here.  Please file issues for any differences
  you find. Known differences are `documented on github
  <https://github.com/mathiasertl/fabric/>`.

  To find out what's new in this version of Fabric, please see `the changelog
  <http://fabfile.org/changelog.html>`_ of the original Fabric.

  For more information, please see the Fabric website or execute ``fab --help``.


pkgId: f8a8e0c15bb5f912c761d7ac14b35e434d250074ab2ea451fbaa9233d24a8baa
name: python-Faker
arch: src
version: 17.6.0
epoch: 0
release: 1
summary: Faker is a Python package that generates fake data for you.
url: https://github.com/joke2k/faker
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a6a90098-853f-4452-8c34-b9012e3be725
location_href: 00003599-python-faker/python-Faker-17.6.0-1.src.rpm
checksum_type: sha256
description:
      _|_|_|_|          _|
      _|        _|_|_|  _|  _|      _|_|    _|  _|_|
      _|_|_|  _|    _|  _|_|      _|_|_|_|  _|_|
      _|      _|    _|  _|  _|    _|        _|
      _|        _|_|_|  _|    _|    _|_|_|  _|


pkgId: c3d15df92758419676f45b3fbd3c025015e60d714871e4c1d9d02d650f64d8af
name: python-Flask
arch: src
version: 2.2.3
epoch: 0
release: 1
summary: A simple framework for building complex web applications.
url: https://palletsprojects.com/p/flask
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0e771557-e5e1-45d2-bf8b-7eeaccbff2a2
location_href: 00008918-python-flask/python-Flask-2.2.3-1.src.rpm
checksum_type: sha256
description:
  Flask is a lightweight `WSGI`_ web application framework. It is designed
  to make getting started quick and easy, with the ability to scale up to
  complex applications. It began as a simple wrapper around `Werkzeug`_
  and `Jinja`_ and has become one of the most popular Python web
  application frameworks.
  Flask offers suggestions, but doesn't enforce any dependencies or
  project layout. It is up to the developer to choose the tools and
  libraries they want to use. There are many extensions provided by the
  community that make adding new functionality easy.


pkgId: 0aacf74952a7d9e9cfa6fb6eb01aefb3bcbbe6c2e74276b23ee0bce5223c5390
name: python-Flask-Admin
arch: src
version: 1.6.1
epoch: 0
release: 1
summary: Simple and extensible admin interface framework for Flask
url: https://github.com/flask-admin/flask-admin/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-df767ce4-c9fe-426c-93e8-cf22b33ea75f
location_href: 00003644-python-flask-admin/python-Flask-Admin-1.6.1-1.src.rpm
checksum_type: sha256
description:
  The project was recently moved into its own organization. Please update your
  references to *git@github.com:flask-admin/flask-admin.git*.


pkgId: 0b8e13dbfa2c09d708aae93ab6a4af16b387ef410691b19f3d43488c1b0443de
name: python-Flask-AppBuilder
arch: src
version: 4.3.1
epoch: 0
release: 1
url: https://github.com/dpgaspar/flask-appbuilder/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e131a990-7f1f-4e19-9b4d-56501f382e11
location_href: 00009287-python-flask-appbuilder/python-Flask-AppBuilder-4.3.1-1.src.rpm
checksum_type: sha256
summary:
  Simple and rapid application development framework, built on top of Flask. includes detailed security, auto CRUD generation for your models, google charts and much more.

description:
  Simple and rapid application development framework, built on top of `Flask <http://flask.pocoo.org/>`_.
  includes detailed security, auto CRUD generation for your models, google charts and much more.
  Extensive configuration of all functionality, easily integrate with normal Flask/Jinja2 development.
  - Documentation: `Documentation <http://flask-appbuilder.readthedocs.org/en/latest/>`_
  - Mailing list: `Google group <https://groups.google.com/forum/#!forum/flask-appbuilder>`_
  - Chat: `Gitter <https://gitter.im/dpgaspar/Flask-AppBuilder>`_
  - Examples: `examples <https://github.com/dpgaspar/Flask-AppBuilder/tree/master/examples>`_
  Checkout installation video on `YouTube <http://youtu.be/xvum4vfwldg>`_
  Quick how to `Demo from the docs <http://flaskappbuilder.pythonanywhere.com/>`_ (login has guest/welcome).


pkgId: 00820fe44105b1349c24ce3d237c5206c15561a39d82111e087b28ee696b3eaa
name: python-Flask-Assets
arch: src
version: 2.0
epoch: 0
release: 1
summary: Asset management for Flask, to compress and merge CSS and Javascript files.
url: http://github.com/miracle2k/flask-assets
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6019a439-7e84-4e35-9bcc-929c6aba6c68
location_href: 00003645-python-flask-assets/python-Flask-Assets-2.0-1.src.rpm
checksum_type: sha256
description:
  Integrates the ``webassets`` library with Flask, adding support for
  merging, minifying and compiling CSS and Javascript files.


pkgId: 9378fd26a6cf0a6eab27edc9bd8aaa53f1008cabf226ac7a129d17a18721cf10
name: python-Flask-AutoIndex
arch: src
version: 0.6.6
epoch: 0
release: 1
summary: The mod_autoindex for Flask
url: https://flask-autoindex.readthedocs.io
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-767d8305-3d53-4eff-903d-e9d86db5bf33
location_href: 00003646-python-flask-autoindex/python-Flask-AutoIndex-0.6.6-1.src.rpm
checksum_type: sha256
description:
  Flask-AutoIndex generates an index page for your `Flask`_ application
  automatically. The result is similar to the one produced by the Apache
  module `mod_autoindex`_, but the look is more awesome!
  Links
  `````
  * `Documentation <https://flask-autoindex.readthedocs.io/>`_
  * `Code repository and issue tracker <https://github.com/general03/flask-autoindex>`_


pkgId: 49c74d2c0a1ffa2a9ba6ee4828469e9c8ad6d26edf45c19a1a144ac3ed0ead62
name: python-Flask-BabelEx
arch: src
version: 0.9.4
epoch: 0
release: 1
summary: Adds i18n/l10n support to Flask applications
url: http://github.com/mrjoes/flask-babelex
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-36b73c55-6279-48e0-8109-db82d46dd4b5
location_href: 00003648-python-flask-babelex/python-Flask-BabelEx-0.9.4-1.src.rpm
checksum_type: sha256
description:
  Adds i18n/l10n support to Flask applications with the help of the
  `Babel`_ library.
  This is fork of official Flask-Babel extension with following features:
  1. It is possible to use multiple language catalogs in one Flask application;
  2. Localization domains: your extension can package localization file(s) and use them
     if necessary;
  3. Does not reload localizations for each request.
  Links
  `````
  * `documentation <http://packages.python.org/Flask-BabelEx>`_
  * `development version
    <http://github.com/mrjoes/flask-babelex/zipball/master#egg=Flask-BabelEx-dev>`_
  * `original Flask-Babel extension <https://pypi.python.org/pypi/Flask-Babel>`_.


pkgId: 42e3b2e960cb660b80826dead863bea10295d391b127304d4d8f4c369965b7ba
name: python-Flask-BasicAuth
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: HTTP basic access authentication for Flask.
url: https://github.com/jpvanhal/flask-basicauth
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-94a78d5e-43ec-417a-af3d-1a32bcf712b4
location_href: 00010129-python-flask-basicauth/python-Flask-BasicAuth-0.2.0-1.src.rpm
checksum_type: sha256
description:
  |build status|_
  Flask-BasicAuth is a Flask extension that provides an easy way to protect
  certain views or your whole application with HTTP `basic access
  authentication`_.


pkgId: ed45adbaf18e2811e31dfd8a93124da34a46ff611d873bee9d674b56727f35c4
name: python-Flask-Bcrypt
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Brcrypt hashing for Flask.
url: https://github.com/maxcountryman/flask-bcrypt
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0f4c8bc1-d1a9-4d51-992b-9c233ff55416
location_href: 00009709-python-flask-bcrypt/python-Flask-Bcrypt-1.0.1-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://img.shields.io/github/workflow/status/maxcountryman/flask-bcrypt/Tests/master?label=tests)](https://github.com/maxcountryman/flask-bcrypt/actions)
  [![Version](https://img.shields.io/pypi/v/Flask-Bcrypt.svg)](https://pypi.python.org/pypi/Flask-Bcrypt)
  [![Supported Python Versions](https://img.shields.io/pypi/pyversions/Flask-Bcrypt.svg)](https://pypi.python.org/pypi/Flask-Bcrypt)



  Flask-Bcrypt is a Flask extension that provides bcrypt hashing utilities for
  your application.

  Due to the recent increased prevalence of powerful hardware, such as modern
  GPUs, hashes have become increasingly easy to crack. A proactive solution to
  this is to use a hash that was designed to be "de-optimized". Bcrypt is such
  a hashing facility; unlike hashing algorithms such as MD5 and SHA1, which are
  optimized for speed, bcrypt is intentionally structured to be slow.

  For sensitive data that must be protected, such as passwords, bcrypt is an
  advisable choice.



  Install the extension with one of the following commands:

      $ easy_install flask-bcrypt

  or alternatively if you have pip installed:

      $ pip install flask-bcrypt



  To use the extension simply import the class wrapper and pass the Flask app
  object back to here. Do so like this:

      from flask import Flask
      from flask_bcrypt import Bcrypt

      app = Flask(__name__)
      bcrypt = Bcrypt(app)

  Two primary hashing methods are now exposed by way of the bcrypt object. Use
  them like so:

      pw_hash = bcrypt.generate_password_hash('hunter2')
      bcrypt.check_password_hash(pw_hash, 'hunter2') # returns True



  The Sphinx-compiled documentation is available here: https://flask-bcrypt.readthedocs.io/


pkgId: e55a136541423eec65247c5ce3a77d6097b241b86e9e729b056e0c89cc68c5a2
name: python-Flask-Cognito
arch: src
version: 1.18
epoch: 0
release: 1
summary: Authenticate users to Cognito user pool via JWT.
url: https://github.com/jetbridge/flask_cognito
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e81cce7f-f4de-41f1-b65b-3a8e54c1ee3b
location_href: 00011237-python-flask-cognito/python-Flask-Cognito-1.18-1.src.rpm
checksum_type: sha256
description:
  Authenticate users based on AWS Cognito JWT.

  ```python3

  app.config.extend({
      'COGNITO_REGION': 'eu-central-1',
      'COGNITO_USERPOOL_ID': 'eu-central-1c3fea2',
      
      'COGNITO_APP_CLIENT_ID': 'abcdef123456',  # client ID you wish to verify user is authenticated against
      'COGNITO_CHECK_TOKEN_EXPIRATION': False,  # disable token expiration checking for testing purposes
      'COGNITO_JWT_HEADER_NAME': 'X-MyApp-Authorization',
      'COGNITO_JWT_HEADER_PREFIX': 'Bearer',
  })

  from flask_cognito import CognitoAuth
  cogauth = CognitoAuth(app)
  @cogauth.identity_handler
  def lookup_cognito_user(payload):
      """Look up user in our database from Cognito JWT payload."""
      return User.query.filter(User.cognito_username == payload['username']).one_or_none()
  ```

  ```python3
  from flask_cognito import cognito_auth_required, current_user, current_cognito_jwt
  @route('/api/private')
  @cognito_auth_required
  def api_private():
      
      
      return jsonify({
          'cognito_username': current_cognito_jwt['username'],   # from cognito pool
          'user_id': current_user.id,   # from your database
      })
  ```

  ```python3
  from flask_cognito import cognito_auth_required, current_user, current_cognito_jwt
  @route('/api/foo')
  @cognito_auth_required
  @cognito_group_permissions(['admin','developer'])
  def api_private():
      
      return jsonify({
          'foo': "bar"
      })
  ```

  * Uses [cognitojwt](https://github.com/borisrozumnuk/cognitojwt) at its core.
  * Based on [flask-jwt](https://github.com/mattupstate/flask-jwt/).


pkgId: 4418ac89561cd151b7bc281e957c3b74614dcc1f60c5e07357b741ab438774c4
name: python-Flask-Compress
arch: src
version: 1.13
epoch: 0
release: 1
summary: Compress responses in your Flask app with gzip, deflate or brotli.
url: https://github.com/colour-science/flask-compress
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8ead646e-efe9-4bb5-b2d6-816667176f3c
location_href: 00003651-python-flask-compress/python-Flask-Compress-1.13-1.src.rpm
checksum_type: sha256
description:
  [![Build](https://github.com/colour-science/flask-compress/actions/workflows/ci.yaml/badge.svg)](https://github.com/colour-science/flask-compress/actions/workflows/ci.yaml)
  [![Version](https://img.shields.io/pypi/v/flask-compress.svg)](https://pypi.python.org/pypi/Flask-Compress)
  [![Downloads](https://static.pepy.tech/badge/flask-compress)](https://pypi.python.org/pypi/Flask-Compress)

  Flask-Compress allows you to easily compress your [Flask](http://flask.pocoo.org/) application's responses with gzip, deflate or brotli. It originally started as a fork of [Flask-gzip](https://github.com/closeio/Flask-gzip).

  The preferred solution is to have a server (like [Nginx](http://wiki.nginx.org/Main)) automatically compress the static files for you. If you don't have that option Flask-Compress will solve the problem for you.




  Flask-Compress both adds the various headers required for a compressed response and compresses the response data.
  This makes serving compressed static files extremely easy.

  Internally, every time a request is made the extension will check if it matches one of the compressible MIME types
  and whether the client and the server use some common compression algorithm, and will automatically attach the
  appropriate headers.

  To determine the compression algorithm, the `Accept-Encoding` request header is inspected, respecting the
  quality factor as described in [MDN docs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Encoding).
  If no requested compression algorithm is supported by the server, we don't compress the response. If, on the other
  hand, multiple suitable algorithms are found and are requested with the same quality factor, we choose the first one
  defined in the `COMPRESS_ALGORITHM` option (see below).




  If you use pip then installation is simply:

  ```shell
  $ pip install --user flask-compress
  ```

  or, if you want the latest github version:

  ```shell
  $ pip install --user git+git://github.com/colour-science/flask-compress.git
  ```

  You can also install Flask-Compress via Easy Install:

  ```shell
  $ easy_install flask-compress
  ```






  Flask-Compress is incredibly simple to use. In order to start compressing your Flask application's assets, the first thing to do is let Flask-Compress know about your [`flask.Flask`](http://flask.pocoo.org/docs/latest/api/#flask.Flask) application object.

  ```python
  from flask import Flask
  from flask_compress import Compress

  app = Flask(__name__)
  Compress(app)
  ```

  In many cases, however, one cannot expect a Flask instance to be ready at import time, and a common pattern is to return a Flask instance from within a function only after other configuration details have been taken care of. In these cases, Flask-Compress provides a simple function, `flask_compress.Compress.init_app`, which takes your application as an argument.

  ```python
  from flask import Flask
  from flask_compress import Compress

  compress = Compress()

  def start_app():
      app = Flask(__name__)
      compress.init_app(app)
      return app
  ```

  In terms of automatically compressing your assets, passing your [`flask.Flask`](http://flask.pocoo.org/docs/latest/api/#flask.Flask) object to the `flask_compress.Compress` object is all that needs to be done.



  Compression is possible per view using the `@compress.compressed()` decorator. Make sure to disable global compression first.

  ```python
  from flask import Flask
  from flask_compress import Compress

  app = Flask(__name__)
  app.config["COMPRESS_REGISTER"] = False  # disable default compression of all eligible requests
  compress = Compress()
  compress.init_app(app)


  @app.route("/test")
  @compress.compressed()
  def view():
     pass
  ```



  Within your Flask application's settings you can provide the following settings to control the behavior of Flask-Compress. None of the settings are required.

  | Option | Description | Default |
  | ------ | ----------- | ------- |
  | `COMPRESS_MIMETYPES` | Set the list of mimetypes to compress here. | `[`<br>`'text/html',`<br>`'text/css',`<br>`'text/xml',`<br>`'application/json',`<br>`'application/javascript'`<br>`]` |
  | `COMPRESS_LEVEL` | Specifies the gzip compression level. | `6` |
  | `COMPRESS_BR_LEVEL` | Specifies the Brotli compression level. Ranges from 0 to 11. | `4` |
  | `COMPRESS_BR_MODE` | For Brotli, the compression mode. The options are 0, 1, or 2. These correspond to "generic", "text" (for UTF-8 input), and "font" (for WOFF 2.0). | `0` |
  | `COMPRESS_BR_WINDOW` | For Brotli, this specifies the base-2 logarithm of the sliding window size. Ranges from 10 to 24. | `22` |
  | `COMPRESS_BR_BLOCK` | For Brotli, this provides the base-2 logarithm of the maximum input block size. If zero is provided, value will be determined based on the quality. Ranges from 16 to 24. | `0` |
  | `COMPRESS_DEFLATE_LEVEL` | Specifies the deflate compression level. | `-1` |
  | `COMPRESS_MIN_SIZE` | Specifies the minimum file size threshold for compressing files. | `500` |
  | `COMPRESS_CACHE_KEY` | Specifies the cache key method for lookup/storage of response data. | `None` |
  | `COMPRESS_CACHE_BACKEND` | Specified the backend for storing the cached response data. | `None` |
  | `COMPRESS_REGISTER` | Specifies if compression should be automatically registered. | `True` |
  | `COMPRESS_ALGORITHM` | Supported compression algorithms. | `['br', 'gzip', 'deflate']` |
  | `COMPRESS_STREAMS` | Compress content streams. | `True` |


pkgId: 9a550f2ad66c8977305b65948e6050c7475a9f83ea2be812df87c73f760b8fd0
name: python-Flask-Cors
arch: src
version: 3.0.10
epoch: 0
release: 1
summary: A Flask extension adding a decorator for CORS support
url: https://github.com/corydolphin/flask-cors
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-01ab8cca-03c9-4e90-a5e0-df3fd25e3a1e
location_href: 00003652-python-flask-cors/python-Flask-Cors-3.0.10-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Latest Version| |Supported Python versions|
  |License|
  A Flask extension for handling Cross Origin Resource Sharing (CORS), making cross-origin AJAX possible.
  This package has a simple philosophy: when you want to enable CORS, you wish to enable it for all use cases on a domain.
  This means no mucking around with different allowed headers, methods, etc.
  By default, submission of cookies across domains is disabled due to the security implications.
  Please see the documentation for how to enable credential'ed requests, and please make sure you add some sort of `CSRF <http://en.wikipedia.org/wiki/Cross-site_request_forgery>`__ protection before doing so!


pkgId: 8354e020fdf36ac639360dd8b7288db184b602b03a145a91232794b18566e5d2
name: python-Flask-DebugToolbar
arch: src
version: 0.13.1
epoch: 0
release: 1
summary: A toolbar overlay for debugging Flask applications.
url: https://github.com/flask-debugtoolbar/flask-debugtoolbar
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d314829b-2c4f-4271-b121-422b56ec7571
location_href: 00011694-python-flask-debugtoolbar/python-Flask-DebugToolbar-0.13.1-1.src.rpm
checksum_type: sha256
description:
  This is a port of the excellent `django-debug-toolbar <https://github.com/django-debug-toolbar/django-debug-toolbar>`_
  for Flask applications.


pkgId: fb3c9711b7d14cbaf88a6ed26eeb27cd5f4809ceddecc4864a8f7b6d56bcb541
name: python-Flask-Executor
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: An easy to use Flask wrapper for concurrent.futures
url: https://github.com/dchevell/flask-executor
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f8b94f3b-9129-4e94-869d-19f511d809a4
location_href: 00011814-python-flask-executor/python-Flask-Executor-1.0.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/dchevell/flask-executor/actions/workflows/tests.yml/badge.svg)
  [![Coverage Status](https://coveralls.io/repos/github/dchevell/flask-executor/badge.svg)](https://coveralls.io/github/dchevell/flask-executor)
  [![PyPI Version](https://img.shields.io/pypi/v/Flask-Executor.svg)](https://pypi.python.org/pypi/Flask-Executor)
  [![GitHub license](https://img.shields.io/github/license/dchevell/flask-executor.svg)](https://github.com/dchevell/flask-executor/blob/master/LICENSE)
  Sometimes you need a simple task queue without the overhead of separate worker processes or powerful-but-complex libraries beyond your requirements. Flask-Executor is an easy to use wrapper for the `concurrent.futures` module that lets you initialise and configure executors via common Flask application patterns. It's a great way to get up and running fast with a lightweight in-process task queue.


pkgId: 86d4934e62be85c0894214fe770f9b468e6fd48683a1fb4f53909625056f1d8d
name: python-Flask-HTMLmin
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: Minify flask text/html mime type responses
url: https://github.com/hamidfzm/Flask-HTMLmin
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-caffc3a1-13d9-4dc5-8a1c-515a34510f78
location_href: 00003655-python-flask-htmlmin/python-Flask-HTMLmin-2.2.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/Flask-HTMLmin.svg)](https://badge.fury.io/py/Flask-HTMLmin)
  ![Supported Python Versions](https://img.shields.io/badge/python-3.6%20%7C%203.7%20%7C%203.8%20%7C%203.9-blue.svg)
  [![License](https://img.shields.io/badge/License-BSD%203--Clause-orange.svg)](LICENSE)
  ![tests](https://github.com/hamidfzm/Flask-HTMLmin/workflows/tests/badge.svg)
  [![codecov](https://codecov.io/gh/hamidfzm/Flask-HTMLmin/branch/master/graph/badge.svg)](https://codecov.io/gh/hamidfzm/Flask-HTMLmin)
  Minify flask `text/html` mime type responses.
  Just add `MINIFY_HTML = True` to your deployment config to minify HTML and text responses of your flask application.


pkgId: 11338767c2a22b9a3dfe625f5c18cbcee0643cac8f267a6e8d464adf6d7d45ac
name: python-Flask-HTTPAuth
arch: src
version: 4.7.0
epoch: 0
release: 1
summary: HTTP authentication for Flask routes
url: https://github.com/miguelgrinberg/flask-httpauth
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a4e9c623-ef87-42e6-8066-3d65241e51d8
location_href: 00003656-python-flask-httpauth/python-Flask-HTTPAuth-4.7.0-1.src.rpm
checksum_type: sha256
description:
  [![Build status](https://github.com/miguelgrinberg/Flask-HTTPAuth/workflows/build/badge.svg)](https://github.com/miguelgrinberg/Flask-HTTPAuth/actions) [![codecov](https://codecov.io/gh/miguelgrinberg/Flask-HTTPAuth/branch/master/graph/badge.svg?token=KeU2002DHo)](https://codecov.io/gh/miguelgrinberg/Flask-HTTPAuth)
  Simple extension that provides Basic and Digest HTTP authentication for Flask routes.


pkgId: 24187d74525c0389c5f048db4c262bca8f62a25c98dbd03c5744469cd1a79779
name: python-Flask-JSON
arch: src
version: 0.3.5
epoch: 0
release: 1
summary: Better JSON support for Flask
url: https://github.com/skozlovf/flask-json
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-09d384d5-60f2-4ad8-8c18-f023ae0712b3
location_href: 00011340-python-flask-json/python-Flask-JSON-0.3.5-1.src.rpm
checksum_type: sha256
description:
  Flask-JSON is a simple extension that adds better JSON support to Flask
  application.
  Features:
  * Works on python 2.6, 2.7, 3.3+ and Flask 0.10+.
  * More ways to generate JSON responses (comparing to plain Flask).
  * Extended JSON encoding support.


pkgId: 060fe1478e32109bd962ff23fc6b50eee7a5ad2a4ba86a0a3dde97c42814d505
name: python-Flask-JWT-Extended
arch: src
version: 4.4.4
epoch: 0
release: 1
summary: Extended JWT integration with Flask
url: https://github.com/vimalloc/flask-jwt-extended
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8b4dfbac-7783-4584-a2d7-3b1dc49d4d8c
location_href: 00009286-python-flask-jwt-extended/python-Flask-JWT-Extended-4.4.4-1.src.rpm
checksum_type: sha256
description:
  Flask-JWT-Extended not only adds support for using JSON Web Tokens (JWT) to Flask for protecting routes,
  but also many helpful (and **optional**) features built in to make working with JSON Web Tokens
  easier. These include:

  -   Adding custom claims to JSON Web Tokens
  -   Automatic user loading (`current_user`).
  -   Custom claims validation on received tokens
  -   [Refresh tokens](https://auth0.com/blog/refresh-tokens-what-are-they-and-when-to-use-them/)
  -   First class support for fresh tokens for making sensitive changes.
  -   Token revoking/blocklisting
  -   Storing tokens in cookies and CSRF protection



  [View the documentation online](https://flask-jwt-extended.readthedocs.io/en/stable/)



  [View the changes](https://flask-jwt-extended.readthedocs.io/en/stable/v4_upgrade_guide/)



  You can view the changelog [here](https://github.com/vimalloc/flask-jwt-extended/releases).
  This project follows [semantic versioning](https://semver.org/).



  Come chat with the community or ask questions at https://discord.gg/EJBsbFd



  Before making any changes, make sure to install the development requirements
  and setup the git hooks which will automatically lint and format your changes.

  ```bash
  pip install -r requirements.txt
  pre-commit install
  ```

  We require 100% code coverage in our unit tests. You can run the tests locally
  with `tox` which ensures that all tests pass, tests provide complete code coverage,
  documentation builds, and style guide are adhered to

  ```bash
  tox
  ```

  A subset of checks can also be ran by adding an argument to tox. The available
  arguments are:

  -   py37, py38, py39, py310, pypy3
      -   Run unit tests on the given python version
  -   mypy
      -   Run mypy type checking
  -   coverage
      -   Run a code coverage check
  -   docs
      -   Ensure documentation builds and there are no broken links
  -   style
      -   Ensure style guide is adhered to

  ```bash
  tox -e py38
  ```

  We also require features to be well documented. You can generate a local copy
  of the documentation by going to the `docs` directory and running:

  ```bash
  make clean && make html && open _build/html/index.html
  ```


pkgId: 34a1e6ee75b013e53474c51f870d1a010cae9540ec62062c47b3710dcbd4ec98
name: python-Flask-Jsonpify
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: A Flask extension adding a decorator for JSONP support
url: https://github.com/CoryDolphin/flask-jsonpify
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dfea20b0-2199-4fba-8e11-d48df5296417
location_href: 00012831-python-flask-jsonpify/python-Flask-Jsonpify-1.5.0-1.src.rpm
checksum_type: sha256
description:
  Flask-Jsonpify is an extension to Flask's core jsonify function,
  returning JSON-Padded responses when a callback is specified as
  request's arguments. It's usage and implementation is the same as
  flask.jsonify, differing only when a request has a ``callback``
  specified in the request arguments, in which case the response body is
  JSON-Padded, or JSONP, using the callback.
  To add JSONP support to all routes which previously used flask.jsonify,
  simply import jsonify from flask.ext.jsonpify instead of importing it
  from flask. The arguments and responses are fully compatible.
  Alternatively, import jsonpify from flask.ext.jsonpify to support JSONP
  in certain places.


pkgId: afb33fb8d96d590dc389d92f011beca978aff4cd9c05cbb42f98dadb036fc428
name: python-Flask-Limiter
arch: src
version: 3.3.0
epoch: 0
release: 1
summary: Rate limiting for flask applications
url: https://flask-limiter.readthedocs.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-45769a11-988e-41bf-8273-184a9907e228
location_href: 00010869-python-flask-limiter/python-Flask-Limiter-3.3.0-1.src.rpm
checksum_type: sha256
description:
  Sponsored by `Zuplo <https://zuplo.link/3NuX0co>`_ a fully-managed API Gateway for developers.
  Add `dynamic rate-limiting <https://zuplo.link/flask-dynamic-rate-limit>`_ authentication and more to any API in minutes.


pkgId: 6e6e90b37ca974b9695d05d331744d93352f75f54b4f410d8c5e94bfdfad2e4b
name: python-Flask-Login
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: User authentication and session management for Flask.
url: https://github.com/maxcountryman/flask-login
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d58fc13e-ac5b-4816-918c-ccdc5aceab60
location_href: 00003657-python-flask-login/python-Flask-Login-0.6.2-1.src.rpm
checksum_type: sha256
description:
  ![Tests](https://github.com/maxcountryman/flask-login/workflows/Tests/badge.svg)
  [![coverage](https://coveralls.io/repos/maxcountryman/flask-login/badge.svg?branch=main&service=github)](https://coveralls.io/github/maxcountryman/flask-login?branch=main)
  [![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](LICENSE)

  Flask-Login provides user session management for Flask. It handles the common
  tasks of logging in, logging out, and remembering your users' sessions over
  extended periods of time.

  Flask-Login is not bound to any particular database system or permissions
  model. The only requirement is that your user objects implement a few methods,
  and that you provide a callback to the extension capable of loading users from
  their ID.



  Install the extension with pip:

  ```sh
  $ pip install flask-login
  ```



  Once installed, the Flask-Login is easy to use. Let's walk through setting up
  a basic application. Also please note that this is a very basic guide: we will
  be taking shortcuts here that you should never take in a real application.

  To begin we'll set up a Flask app:

  ```python
  import flask

  app = flask.Flask(__name__)
  app.secret_key = 'super secret string'  # Change this!
  ```

  Flask-Login works via a login manager. To kick things off, we'll set up the
  login manager by instantiating it and telling it about our Flask app:

  ```python
  import flask_login

  login_manager = flask_login.LoginManager()

  login_manager.init_app(app)
  ```

  To keep things simple we're going to use a dictionary to represent a database
  of users. In a real application, this would be an actual persistence layer.
  However it's important to point out this is a feature of Flask-Login: it
  doesn't care how your data is stored so long as you tell it how to retrieve it!

  ```python

  users = {'foo@bar.tld': {'password': 'secret'}}
  ```

  We also need to tell Flask-Login how to load a user from a Flask request and
  from its session. To do this we need to define our user object, a
  `user_loader` callback, and a `request_loader` callback.

  ```python
  class User(flask_login.UserMixin):
      pass


  @login_manager.user_loader
  def user_loader(email):
      if email not in users:
          return

      user = User()
      user.id = email
      return user


  @login_manager.request_loader
  def request_loader(request):
      email = request.form.get('email')
      if email not in users:
          return

      user = User()
      user.id = email
      return user
  ```

  Now we're ready to define our views. We can start with a login view, which will
  populate the session with authentication bits. After that we can define a view
  that requires authentication.

  ```python
  @app.route('/login', methods=['GET', 'POST'])
  def login():
      if flask.request.method == 'GET':
          return '''
                 <form action='login' method='POST'>
                  <input type='text' name='email' id='email' placeholder='email'/>
                  <input type='password' name='password' id='password' placeholder='password'/>
                  <input type='submit' name='submit'/>
                 </form>
                 '''

      email = flask.request.form['email']
      if email in users and flask.request.form['password'] == users[email]['password']:
          user = User()
          user.id = email
          flask_login.login_user(user)
          return flask.redirect(flask.url_for('protected'))

      return 'Bad login'


  @app.route('/protected')
  @flask_login.login_required
  def protected():
      return 'Logged in as: ' + flask_login.current_user.id
  ```

  Finally we can define a view to clear the session and log users out:

  ```python
  @app.route('/logout')
  def logout():
      flask_login.logout_user()
      return 'Logged out'
  ```

  We now have a basic working application that makes use of session-based
  authentication. To round things off, we should provide a callback for login
  failures:

  ```python
  @login_manager.unauthorized_handler
  def unauthorized_handler():
      return 'Unauthorized', 401
  ```

  Documentation for Flask-Login is available on [ReadTheDocs](https://flask-login.readthedocs.io/en/latest/).
  For complete understanding of available configuration, please refer to the [source code](https://github.com/maxcountryman/flask-login).




  We welcome contributions! If you would like to hack on Flask-Login, please
  follow these steps:

  1. Fork this repository
  2. Make your changes
  3. Install the dev requirements with `pip install -r requirements/dev.txt`
  4. Submit a pull request after running `tox` (ensure it does not error!)

  Please give us adequate time to review your submission. Thanks!


pkgId: 02bdf6914347a01bb3333cc1358bb78478a01f691883b655560f71f702840527
name: python-Flask-Mail
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: Flask extension for sending email
url: https://github.com/rduplain/flask-mail
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dc649a93-3c2f-4183-8dc3-2ccee9bc7efd
location_href: 00003658-python-flask-mail/python-Flask-Mail-0.9.1-1.src.rpm
checksum_type: sha256
description:
  A Flask extension for sending email messages.
  Please refer to the online documentation for details.
  Links
  `````
  * `documentation <http://packages.python.org/Flask-Mail>`_


pkgId: 9d933cb2dbcc12f25a1da1e5aa8107995b176e4b002c1557a56520c2f8dceb19
name: python-Flask-Mako
arch: src
version: 0.4
epoch: 0
release: 1
summary: Mako templating support for Flask applications.
url: https://github.com/benselme/flask-mako
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-48c76a3d-0e06-4a68-9b50-42eb01c9a0d6
location_href: 00003659-python-flask-mako/python-Flask-Mako-0.4-1.src.rpm
checksum_type: sha256
description:
  This extension for the `Flask <http://flask.pocoo.org/>`_ micro web framework
  allows developers to use  `Mako Templates
  <http://http://www.makotemplates.org/>`_ instead of the default Jinja2
  templating engine.


pkgId: 2b5ea1da0a5004148023fd4320a2b4ca986d138c4afe489c0d6eb8b86acc7ae2
name: python-Flask-Migrate
arch: src
version: 4.0.4
epoch: 0
release: 1
summary: SQLAlchemy database migrations for Flask applications using Alembic.
url: https://github.com/miguelgrinberg/flask-migrate
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-78bb77f3-0780-4a1e-8ae9-51e5a34f09b1
location_href: 00003660-python-flask-migrate/python-Flask-Migrate-4.0.4-1.src.rpm
checksum_type: sha256
description:
  [![Build status](https://github.com/miguelgrinberg/flask-migrate/workflows/build/badge.svg)](https://github.com/miguelgrinberg/flask-migrate/actions)
  Flask-Migrate is an extension that handles SQLAlchemy database migrations for Flask applications using Alembic. The database operations are provided as command-line arguments under the `flask db` command.


pkgId: de785818f8fcf679d604bf1f45076ebb77fde9f12e5a9db0813491e5338ab7cc
name: python-Flask-Moment
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: Formatting of dates and times in Flask templates using moment.js.
url: https://github.com/miguelgrinberg/flask-moment
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-abe32824-0c64-4c02-8a96-356bb24a1a8a
location_href: 00014194-python-flask-moment/python-Flask-Moment-1.0.5-1.src.rpm
checksum_type: sha256
description:
  [![Build status](https://github.com/miguelgrinberg/flask-moment/workflows/build/badge.svg)](https://github.com/miguelgrinberg/flask-moment/actions) [![codecov](https://codecov.io/gh/miguelgrinberg/flask-moment/branch/main/graph/badge.svg)](https://codecov.io/gh/miguelgrinberg/flask-moment)
  This extension enhances Jinja2 templates with formatting of dates and times
  using [moment.js](https://momentjs.com/).


pkgId: f5358ff0eb3236f41777757d391d64392260b4248ab9b9b5b9b1e8e0977f7cf1
name: python-Flask-OAuth
arch: src
version: 0.12
epoch: 0
release: 1
summary: Adds OAuth support to Flask
url: http://github.com/mitsuhiko/flask-oauth
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-befe9a5b-60e6-4933-8534-fb8f90abbdf7
location_href: 00003662-python-flask-oauth/python-Flask-OAuth-0.12-1.src.rpm
checksum_type: sha256
description:
  Adds OAuth support to Flask.
  Links
  `````
  * `documentation <http://packages.python.org/Flask-OAuth>`_
  * `development version
    <http://github.com/mitsuhiko/flask-oauth/zipball/master#egg=Flask-OAuth-dev>`_


pkgId: 5bf711412360eb91e6f968dcb53d80086929ba2880268a01a0ec903684aceb06
name: python-Flask-OpenID
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: OpenID support for Flask
url: http://github.com/mitsuhiko/flask-openid/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-30f0b0be-72d8-4599-ac87-db5ae0559c44
location_href: 00003664-python-flask-openid/python-Flask-OpenID-1.3.0-1.src.rpm
checksum_type: sha256
description:
  Adds support for OpenID to flask applications.  Check out the
  example for more information.
  Documentation: http://packages.python.org/Flask-OpenID/


pkgId: 3d05ce2fb9a5c93d560a234d65a8d80c25e3da92ed1f86b5cb3598c7866e5daf
name: python-Flask-Paranoid
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Simple user session protection
url: https://github.com/miguelgrinberg/flask-paranoid
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f2154936-19df-4850-a8e8-3a45145ef31d
location_href: 00003665-python-flask-paranoid/python-Flask-Paranoid-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [![Build status](https://github.com/miguelgrinberg/flask-paranoid/workflows/build/badge.svg)](https://github.com/miguelgrinberg/flask-paranoid/actions) [![codecov](https://codecov.io/gh/miguelgrinberg/flask-paranoid/branch/main/graph/badge.svg)](https://codecov.io/gh/miguelgrinberg/flask-paranoid)
  Simple user session protection.


pkgId: a678bb91e36cde9eade0ec3eae789946ef786dd0e4a92a265fc554c646a29752
name: python-Flask-Plugins
arch: src
version: 1.6.1
epoch: 0
release: 1
summary: Create plugins for your Flask application
url: https://github.com/sh4nks/flask-plugins
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-91224ecb-0f71-4ec5-8cc9-7b1391cbb11a
location_href: 00009548-python-flask-plugins/python-Flask-Plugins-1.6.1-1.src.rpm
checksum_type: sha256
description:
  Flask-Plugins makes it possible, to create plugins for your
  application. In addition to the plugin system, it also provides a simple
  event system which can be used by plugins to extend your application without
  the need to modify your core code.
  And Easy to Setup
  `````````````````
  First of all, you have to install it:
      $ pip install flask-plugins
  and then you need to initialize it somewhere in your code.
      from flask_plugins import PluginManager
      plugin_manager = PluginManager(app)
  Want to use the factory pattern? No problem!
      from flask_plugins import PluginManager
      plugin_manager = PluginManager()
      plugin_manager.init_app(app)
  Resources
  `````````
  * `source <https://github.com/sh4nks/flask-plugins>`_
  * `docs <https://flask-plugins.readthedocs.org/en/latest>`_
  * `issues <https://github.com/sh4nks/flask-plugins/issues>`_


pkgId: 5de80a9337a72c03ed79892c36e50cec737eaa0324ea005679b207a12fe5cd2b
name: python-Flask-Principal
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Identity management for flask
url: http://packages.python.org/Flask-Principal/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-84206e5e-4530-45ca-82a4-08fc70ac5c24
location_href: 00003666-python-flask-principal/python-Flask-Principal-0.4.0-1.src.rpm
checksum_type: sha256
description:
  Identity management for Flask.
  Links
  `````
  * `documentation <http://packages.python.org/Flask-Principal/>`_
  * `source <https://github.com/mattupstate/flask-principal>`_
  * `development version
    <https://github.com/mattupstate/flask-principal/raw/master#egg=Flask-Principal-dev>`_


pkgId: 3074b07c7f34f25024c0be7d10bc93b5552fa41c27c705ad15b56b92134ead54
name: python-Flask-PyMongo
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: PyMongo support for Flask applications
url: http://flask-pymongo.readthedocs.org/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d9033d2b-eb57-44af-9b7d-8b2f8c604082
location_href: 00003667-python-flask-pymongo/python-Flask-PyMongo-2.3.0-1.src.rpm
checksum_type: sha256
description:
  MongoDB support for Flask applications.
  Flask-PyMongo is pip-installable:
      $ pip install Flask-PyMongo
  Documentation for Flask-PyMongo is available on `ReadTheDocs
  <http://flask-pymongo.readthedocs.io/en/latest/>`_.
  Source code is hosted on `GitHub <https://github.com/dcrosta/flask-pymongo>`_.
  Contributions are welcome!


pkgId: 96ab283233f20a56a62ad1fb7ee0d416cf0ecc347de9d7d7f8ed540bcc4fc439
name: python-Flask-RSTPages
arch: src
version: 0.3
epoch: 0
release: 1
summary: Adds support for reStructuredText to a Flask application
url: http://flask-rstpages.readthedocs.org/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1a99e866-3444-453f-9d8f-4885211be812
location_href: 00003669-python-flask-rstpages/python-Flask-RSTPages-0.3-1.src.rpm
checksum_type: sha256
description:
  Flask-RSTPages
  ~~~~~~~~~~~~~~

  Flask-RSTPages adds support for reStructuredText to your Flask application.
  See the docs for details: http://flask-rstpages.readthedocs.org/


pkgId: 4c83916ed680487d394c21a89afc1e91f6bff48d498890fd755fa4773aa3c65c
name: python-Flask-SSLify
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Force SSL on your Flask app.
url: https://github.com/kennethreitz/flask-sslify
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e4a290a9-78c2-41cd-a035-6943b46f1950
location_href: 00012886-python-flask-sslify/python-Flask-SSLify-0.1.5-1.src.rpm
checksum_type: sha256
description:
  This is a simple Flask extension that configures your Flask application to redirect
  all incoming requests to ``https``.
  Redirects only occur when ``app.debug`` is ``False``.


pkgId: 1b36d0132e82c93ac47684ebfd4282a197743617adbe81c7b8bee1c9d3688729
name: python-Flask-Script
arch: src
version: 2.0.6
epoch: 0
release: 1
summary: Scripting support for Flask
url: http://github.com/smurfix/flask-script
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f7b3c959-8164-4c73-93d8-44a408bea63c
location_href: 00003670-python-flask-script/python-Flask-Script-2.0.6-1.src.rpm
checksum_type: sha256
description:
  Flask support for writing external scripts.
  Links
  `````
  * `documentation <http://flask-script.readthedocs.org>`_


pkgId: bd60930f05cd3f353178badd7189a9aa50980bb32cf16473be6d7f0640bfea35
name: python-Flask-SeaSurf
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: An updated CSRF extension for Flask.
url: https://github.com/maxcountryman/flask-seasurf/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-17f702b1-eefd-4375-bcd6-f33e3f24ac2d
location_href: 00013274-python-flask-seasurf/python-Flask-SeaSurf-1.1.1-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://img.shields.io/github/workflow/status/maxcountryman/flask-seasurf/Tests/main?label=tests)](https://github.com/maxcountryman/flask-seasurf/actions)
  [![Version](https://img.shields.io/pypi/v/Flask-SeaSurf.svg)](https://pypi.python.org/pypi/Flask-SeaSurf)
  [![Supported Python Versions](https://img.shields.io/pypi/pyversions/Flask-SeaSurf.svg)](https://pypi.python.org/pypi/Flask-SeaSurf)



  SeaSurf is a Flask extension for preventing cross-site request forgery (CSRF).

  CSRF vulnerabilities have been found in large and popular sites such as
  YouTube. These attacks are problematic because the mechanism they use is
  relatively easy to exploit. This extension attempts to aid you in securing
  your application from such attacks.

  This extension is based on the excellent Django middleware.




  Install the extension with one of the following commands:

      $ easy_install flask-seasurf

  or alternatively if you have pip installed:

      $ pip install flask-seasurf




  Using SeaSurf is fairly straightforward. Begin by importing the extension and
  then passing your application object back to the extension, like this:

      from flask_seasurf import SeaSurf
      csrf = SeaSurf(app)




  The Sphinx-compiled documentation is available here: https://flask-seasurf.readthedocs.io/


pkgId: 8e4fbbb2610a8bf2eccc2ab78e9a4c4fe074a26d071cddd91cf8af075f7fbe1a
name: python-Flask-Session
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Adds server-side session support to your Flask application
url: https://github.com/fengsp/flask-session
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-740b780c-4d11-400c-ac42-f166f94b04d2
location_href: 00010693-python-flask-session/python-Flask-Session-0.4.0-1.src.rpm
checksum_type: sha256
description:
  Flask-Session is an extension for Flask that adds support for
  Server-side Session to your application.
  Links
  `````
  * `development version
    <https://github.com/fengsp/flask-session/zipball/master#egg=Flask-dev>`_


pkgId: 435f0b67b54dc992c224fbc50a723315e6db7f2ec5e472c3288f7b1335a88819
name: python-Flask-Silk
arch: src
version: 0.2
epoch: 0
release: 1
summary: Adds silk icons to your Flask application or blueprint, or extension.
url: http://github.com/sublee/flask-silk
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-904d6b94-e2de-404e-9380-f1c1d7ca7df5
location_href: 00003672-python-flask-silk/python-Flask-Silk-0.2-1.src.rpm
checksum_type: sha256
description:
  Adds `silk`_ icons to your Flask application or blueprint, or extension.
  Links
  `````
  * `documentation <http://packages.python.org/Flask-Silk>`_
  * `development version
    <http://github.com/sublee/flask-silk/zipball/master#egg=flask-silk-dev>`_


pkgId: 642d3b26f4e7e6cf1bf905507223abc219dcc4b89fb114e913a58f7dea676835
name: python-Flask-SocketIO
arch: src
version: 5.3.2
epoch: 0
release: 1
summary: Socket.IO integration for Flask applications
url: https://github.com/miguelgrinberg/flask-socketio
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3b54c2ae-31e8-4ea2-b6a0-ae67c515fe15
location_href: 00003673-python-flask-socketio/python-Flask-SocketIO-5.3.2-1.src.rpm
checksum_type: sha256
description:
  [![Build status](https://github.com/miguelgrinberg/flask-socketio/workflows/build/badge.svg)](https://github.com/miguelgrinberg/Flask-SocketIO/actions) [![codecov](https://codecov.io/gh/miguelgrinberg/flask-socketio/branch/main/graph/badge.svg)](https://codecov.io/gh/miguelgrinberg/flask-socketio)
  Socket.IO integration for Flask applications.


pkgId: 1568d51137d22f0646e40fb65036beae802535c87519bec5675d4fdc2312ad83
name: python-Flask-Sphinx-Themes
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: Sphinx themes for Flask and related projects.
url: https://github.com/pallets/flask-sphinx-themes
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a49ec0b2-3de0-48e6-a3eb-63a410a41236
location_href: 00003674-python-flask-sphinx-themes/python-Flask-Sphinx-Themes-1.0.2-1.src.rpm
checksum_type: sha256
description:
  This repository contains Sphinx themes for Flask and Flask related
  projects. To use this theme in your Sphinx documentation:
  1. Install the package using pip: ``pip install Flask-Sphinx-Themes``
  2. Add this to ``conf.py``:
         html_theme = 'flask'


pkgId: 3cb59c0b0d54f15f316d1ed0f000983527a4c0adbc9392b8e70fe901c74a8413
name: python-Flask-Testing
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Unit testing for Flask
url: https://github.com/jarus/flask-testing
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-108b36cf-b44f-420d-92ed-76918ff07fcc
location_href: 00010420-python-flask-testing/python-Flask-Testing-0.8.1-1.src.rpm
checksum_type: sha256
description:
  Flask unittest integration.
  Links
  `````
  * `documentation <http://packages.python.org/Flask-Testing>`
  * `development version <http://github.com/jarus/flask-testing/zipball/master#egg=Flask-Testing-dev>`


pkgId: 39d8749d82f3047c7ef0ee66d5587d562ee8778a9d74b6a98362504385367be3
name: python-Flask-XML-RPC
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Adds support for creating XML-RPC APIs to Flask
url: http://bitbucket.org/leafstorm/flask-xml-rpc/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3b113d5b-dbb3-4935-817c-4be0d1edbf5e
location_href: 00003679-python-flask-xml-rpc/python-Flask-XML-RPC-0.1.2-1.src.rpm
checksum_type: sha256
description:
  Flask-XML-RPC adds XML-RPC support to Flask. This way, you can provide simple
  APIs easily accessible from almost any programming language.
  Links
  `````
  * `documentation <http://packages.python.org/Flask-XML-RPC>`_
  * `development version
    <http://bitbucket.org/leafstorm/flask-xml-rpc/get/tip.gz#egg=Flask-XML-RPC-dev>`_


pkgId: e0f4e4beb3f6d2a4a245ea8c4b032a1145999ba5724a1ad254049c9ee0c397af
name: python-Flask-pyoidc
arch: src
version: 3.12.1
epoch: 0
release: 1
summary: Flask extension for OpenID Connect authentication.
url: https://github.com/zamzterz/flask-pyoidc
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-49820ea0-4356-4fcc-a90a-93d2de60e013
location_href: 00002751-python-Flask-pyoidc/python-Flask-pyoidc-3.12.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/flask-pyoidc.svg)](https://pypi.python.org/pypi/Flask-pyoidc)
  [![codecov.io](https://codecov.io/github/zamzterz/Flask-pyoidc/coverage.svg?branch=master)](https://codecov.io/github/its-dirg/Flask-pyoidc?branch=master)
  [![Build Status](https://travis-ci.org/zamzterz/Flask-pyoidc.svg?branch=master)](https://travis-ci.org/zamzterz/Flask-pyoidc)

  This Flask extension provides simple OpenID Connect authentication, backed by [pyoidc](https://github.com/rohe/pyoidc).

  ["Authorization Code Flow"](http://openid.net/specs/openid-connect-core-1_0.html#CodeFlowAuth),
  ["Implicit Flow"](https://openid.net/specs/openid-connect-core-1_0.html#ImplicitFlowAuth),
  ["Hybrid Flow"](https://openid.net/specs/openid-connect-core-1_0.html#HybridFlowAuth),
  ["Client Credentials Flow"](https://oauth.net/2/grant-types/client-credentials/) are supported.


  Read [the documentation](https://flask-pyoidc.readthedocs.io/) or have a look at the
  [example Flask app](example/app.py) for a full example of how to use this extension.

  Below is a basic example of how to get started:
  ```python
  app = Flask(__name__)
  app.config.update(
      OIDC_REDIRECT_URI = 'https://example.com/redirect_uri',
      SECRET_KEY = ...
  )


  client_metadata = ClientMetadata(
      client_id='client1',
      client_secret='secret1',
      post_logout_redirect_uris=['https://example.com/logout'])


  provider_config = ProviderConfiguration(issuer='<issuer URL of provider>',
                                          client_metadata=client_metadata)

  auth = OIDCAuthentication({'default': provider_config}, app)

  @app.route('/')
  @auth.oidc_auth('default') # endpoint will require login
  def index():
      user_session = UserSession(flask.session)
      return jsonify(access_token=user_session.access_token,
                     id_token=user_session.id_token,
                     userinfo=user_session.userinfo)
  ```


pkgId: 129d2ceb9615d979543f6a417f53332eca923865537b4a89a315f55fe6369f3d
name: python-Flask-uWSGI-WebSocket
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: High-performance WebSockets for your Flask apps powered by uWSGI.
url: https://github.com/zeekay/flask_uwsgi_websocket
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4ec473be-31c5-4275-bbf9-a7a0d0a7ec33
location_href: 00013906-python-flask-uwsgi-websocket/python-Flask-uWSGI-WebSocket-0.6.1-1.src.rpm
checksum_type: sha256
description:
  High-performance WebSockets for your Flask apps powered by `uWSGI
  <http://uwsgi-docs.readthedocs.org/en/latest/>`_. Low-level uWSGI WebSocket API
  access and flexible high-level abstractions for building complex WebSocket
  applications with Flask. Supports several different concurrency models
  including Gevent. Inspired by `Flask-Sockets
  <https://github.com/kennethreitz/flask-sockets>`_.
      from flask import Flask
      from flask_uwsgi_websocket import GeventWebSocket
      app = Flask(__name__)
      websocket = GeventWebSocket(app)
      @websocket.route('/echo')
      def echo(ws):
          while True:
              msg = ws.receive()
              ws.send(msg)
      if __name__ == '__main__':
          app.run(gevent=100)


pkgId: 0228d96ac2c38186cc7e0605a559e11eb63b8139ac4bf4033305a3e55218313b
name: python-FormEncode
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: HTML form validation, generation, and conversion package
url: http://formencode.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2a1c3aac-3c65-42ec-8e2b-2bc5d60e577d
location_href: 00003702-python-formencode/python-FormEncode-2.0.1-1.src.rpm
checksum_type: sha256
description:
  FormEncode validates and converts nested structures.

  It allows for a declarative form of defining the validation,
  and decoupled processes for filling and generating forms.

  The official repo is at GitHub: https://github.com/formencode/formencode


pkgId: b17db288ec04808d7172400f5fb3819cb59d0852728ead02aaa93af2a393293e
name: python-Frozen-Flask
arch: src
version: 0.18
epoch: 0
release: 1
summary: Freezes a Flask application into a set of static files.
url: https://github.com/Frozen-Flask/Frozen-Flask
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4fb673db-f030-4339-9dbe-36920ed3f314
location_href: 00003708-python-frozen-flask/python-Frozen-Flask-0.18-1.src.rpm
checksum_type: sha256
description:
  Freezes a Flask application into a set of static files. The result can be hosted
  without any server-side software other than a traditional web server.
  Links
  `````
  * `documentation <https://pythonhosted.org/Frozen-Flask/>`_
  * `development version
    <https://github.com/Frozen-Flask/Frozen-Flask/zipball/master#egg=Frozen-Flask-dev>`_


pkgId: 9e283563afacd349735d08e92b2d1a3cfce5c38f5b151098b92985b275c21129
name: python-GDAL
arch: src
version: 3.6.2
epoch: 0
release: 1
summary: GDAL: Geospatial Data Abstraction Library
url: http://www.gdal.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0fe2dc60-5663-43d6-8640-abc43ed74791
location_href: 00003732-python-gdal/python-GDAL-3.6.2-1.src.rpm
checksum_type: sha256
description:
  This Python package and extensions are a number of tools for programming and
  manipulating the GDAL_ Geospatial Data Abstraction Library.  Actually, it is
  two libraries -- GDAL for manipulating geospatial raster data and OGR for
  manipulating geospatial vector data -- but we'll refer to the entire package
  as the GDAL library for the purposes of this document.
  The GDAL project (primarily Even Rouault) maintains SWIG generated Python
  bindings for GDAL and OGR. Generally speaking the classes and methods mostly
  match those of the GDAL and OGR C++ classes. There is no Python specific
  reference documentation, but the `GDAL API Tutorial`_ includes Python examples.


pkgId: 4ff8c2a8fb880ab33a58546ea1cb8680eb4f213a56b52f3ed297cff8e95e6f44
name: python-HeapDict
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: a heap with decrease-key and increase-key operations
url: http://stutzbachenterprises.com/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-034a752c-d238-4c5d-acac-9015e77553de
location_href: 00003845-python-heapdict/python-HeapDict-1.0.1-1.src.rpm
checksum_type: sha256
description:
  heapdict implements the MutableMapping ABC, meaning it works pretty
  much like a regular Python dict.  It's designed to be used as a
  priority queue, where items are added and consumed as follows:
      hd = heapdict()
      hd[obj1] = priority1
      hd[obj2] = priority2
      
      (obj, priority) = hd.popitem()
  Compared to an ordinary dict, a heapdict has the following differences:
  popitem():
      Remove and return the (key, priority) pair with the lowest
      priority, instead of a random object.
  peekitem():
      Return the (key, priority) pair with the lowest priority, without
      removing it.
  Unlike the Python standard library's heapq module, the heapdict
  supports efficiently changing the priority of an existing object
  (often called "decrease-key" in textbooks).  Altering the priority is
  important for many algorithms such as Dijkstra's Algorithm and A*.


pkgId: 3f9162a01b14d01b019fa8553aa1ab84aa0e83e7c3a7572c16b8d3a3ae62b62c
name: python-HepMC3
arch: src
version: 3.2.5
epoch: 0
release: 1
summary: HepMC3 library and Python bindings for HepMC3
url: https://gitlab.cern.ch/hepmc/HepMC3
rpm_license: GPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8e95778a-c8aa-45b2-a044-7babf0addeb0
location_href: 00002852-python-HepMC3/python-HepMC3-3.2.5-1.src.rpm
checksum_type: sha256
description:
  Official python bindings for the HepMC3 library. Please visit https://hepmc.web.cern.ch/hepmc/ and  https://gitlab.cern.ch/hepmc/HepMC3 for more documentation


pkgId: 41fa2d1371a42baad66b00416d090d67a444fadc056ebd88c8ae17ae4c2ff619
name: python-IMAPClient
arch: src
version: 2.3.1
epoch: 0
release: 1
summary: Easy-to-use, Pythonic and complete IMAP client library
url: https://github.com/mjs/imapclient/
rpm_license: http://en.wikipedia.org/wiki/BSD_licenses
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cc1c8ae7-d28d-4f84-b125-f053caf997d5
location_href: 00010647-python-imapclient/python-IMAPClient-2.3.1-1.src.rpm
checksum_type: sha256
description:
  IMAPClient is an easy-to-use, Pythonic and complete IMAP client library.

  Features:
      * Arguments and return values are natural Python types.
      * IMAP server responses are fully parsed and readily usable.
      * IMAP unique message IDs (UIDs) are handled transparently.
      * Internationalised mailbox names are transparently handled.
      * Time zones are correctly handled.
      * Convenience methods are provided for commonly used functionality.
      * Exceptions are raised when errors occur.

  Python versions 2.7 and 3.4 through 3.9 are officially supported.

  IMAPClient includes comprehensive units tests and automated
  functional tests that can be run against a live IMAP server.


pkgId: a37699ae99c04d207a7bcccdebe2303c2c92d9a02a4098ce98d9fcc19b465f1b
name: python-IPy
arch: src
version: 1.01
epoch: 0
release: 1
summary: Class and tools for handling of IPv4 and IPv6 addresses and networks
url: https://github.com/autocracy/python-ipy
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-04d49a1f-16f0-4472-903d-99d5de98b7d5
location_href: 00011068-python-ipy/python-IPy-1.01-1.src.rpm
checksum_type: sha256
description:
  The IP class allows a comfortable parsing and handling for most
  notations in use for IPv4 and IPv6 addresses and networks. It was
  greatly inspired by RIPE's Perl module NET::IP's interface but
  doesn't share the implementation. It doesn't share non-CIDR netmasks,
  so funky stuff like a netmask of 0xffffff0f can't be done here. ::
      >>> from IPy import IP
      >>> ip = IP('127.0.0.0/30')
      >>> for x in ip:
      127.0.0.0
      127.0.0.1
      127.0.0.2
      127.0.0.3
      >>> ip2 = IP('0x7f000000/30')
      >>> ip == ip2
      1
      >>> ip.reverseNames()
      ['0.0.0.127.in-addr.arpa.', '1.0.0.127.in-addr.arpa.', '2.0.0.127.in-addr.arpa.', '3.0.0.127.in-addr.arpa.']
      >>> ip.reverseName()
      '0-3.0.0.127.in-addr.arpa.'
      >>> ip.iptype()
      'LOOPBACK'


pkgId: 1a643caa45f2859716df2550035e8c5fa9fafabef57c6e495c0ae3b2017e02b2
name: python-Inject
arch: src
version: 4.3.1
epoch: 0
release: 1
summary: Python dependency injection framework
url: https://github.com/ivankorobkov/python-inject
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5a4def77-3474-4013-8bd6-f684a1dddf66
location_href: 00003905-python-inject/python-Inject-4.3.1-1.src.rpm
checksum_type: sha256
description:
  Dependency injection the python way, the good way. Not a port of Guice or Spring.


  * Fast.
  * Thread-safe.
  * Simple to use.
  * Does not steal class constructors.
  * Does not try to manage your application object graph.
  * Transparently integrates into tests.
  * Supports Python 3.5+ (`v4.*`) and Python 2.7–3.5 (`v3.*`).
  * Supports type hinting in Python 3.5+.
  * Autoparams leveraging type annotations.



  | Python | Inject Version |
  |--------|----------------|
  | 3.6+   | 4.1+           |
  | 3.5    | 4.0            |
  | < 3.5  | 3.*            |



  Use pip to install the lastest version:

  ```bash
  pip install inject
  ```


  `@inject.autoparams` returns a decorator which automatically injects arguments into a function
  that uses type annotations. This is supported only in Python >= 3.5.

  ```python
  @inject.autoparams()
  def refresh_cache(cache: RedisCache, db: DbInterface):
      pass
  ```

  There is an option to specify which arguments we want to inject without attempts of
  injecting everything:

  ```python
  @inject.autoparams('cache', 'db')
  def sign_up(name, email, cache: RedisCache, db: DbInterface):
      pass
  ```


  ```python

  import inject



  def foo(bar):
      cache = inject.instance(Cache)
      cache.save('bar', bar)




  @inject.params(cache=Cache, user=CurrentUser)
  def baz(foo, cache=None, user=None):
      cache.save('foo', foo, user)



  baz('foo')


  baz('foo', my_cache)


  baz('foo', my_cache, user=current_user)



  @inject.param('cache', Cache)
  def bar(foo, cache=None):
      cache.save('foo', foo)



  class User(object):
      cache = inject.attr(Cache)

      def __init__(self, id):
          self.id = id

      def save(self):
          self.cache.save('users', self)

      @classmethod
      def load(cls, id):
          return cls.cache.load('users', id)



  def my_config(binder):
      binder.install(my_config2)  # Add bindings from another config.
      binder.bind(Cache, RedisCache('localhost:1234'))


  inject.configure(my_config)



  user = User(10)
  user.save()


  foo('Hello')
  bar('world')
  ```



  Django can load some modules multiple times which can lead to
  `InjectorException: Injector is already configured`. You can use `configure_once` which
  is guaranteed to run only once when the injector is absent:
  ```python
  import inject
  inject.configure_once(my_config)
  ```


  In tests use `inject.clear_and_configure(callable)` to create a new injector on setup,
  and optionally `inject.clear()` to clean up on tear down:
  ```python
  class MyTest(unittest.TestCase):
      def setUp(self):
          inject.clear_and_configure(lambda binder: binder
              .bind(Cache, Mock()) \
              .bind(Validator, TestValidator()))

      def tearDown(self):
          inject.clear()
  ```


  After configuration the injector is thread-safe and can be safely reused by multiple threads.


  **Instance** bindings always return the same instance:

  ```python
  redis = RedisCache(address='localhost:1234')
  def config(binder):
      binder.bind(Cache, redis)
  ```

  **Constructor** bindings create a singleton on injection:

  ```python
  def config(binder):
      
      binder.bind_to_constructor(Cache, lambda: RedisCache(address='localhost:1234'))
  ```

  **Provider** bindings call the provider on injection:

  ```python
  def get_my_thread_local_cache():
      pass

  def config(binder):
      
      binder.bind_to_provider(Cache, get_my_thread_local_cache)
  ```

  **Runtime** bindings automatically create singletons on injection, require no configuration.
  For example, only the `Config` class binding is present, other bindings are runtime:

  ```python
  class Config(object):
      pass

  class Cache(object):
      config = inject.attr(Config)

  class Db(object):
      config = inject.attr(Config)

  class User(object):
      cache = inject.attr(Cache)
      db = inject.attr(Db)

      @classmethod
      def load(cls, user_id):
          return cls.cache.load('users', user_id) or cls.db.load('users', user_id)

  inject.configure(lambda binder: binder.bind(Config, load_config_file()))
  user = User.load(10)
  ```

  Sometimes runtime binding leads to unexpected behaviour.  Say if you forget
  to bind an instance to a class, `inject` will try to implicitly instantiate it.

  If an instance is unintentionally created with default arguments it may lead to
  hard-to-debug bugs.  To disable runtime binding and make sure that only
  explicitly bound instances are injected, pass `bind_in_runtime=False`
  to `inject.configure`, `inject.configure_once` or `inject.clear_and_configure`.

  In this case `inject` immediately raises `InjectorException` when the code
  tries to get an unbound instance.


  It is possible to use any hashable object as a binding key. For example:

  ```python
  import inject

  inject.configure(lambda binder: \
      binder.bind('host', 'localhost') \
      binder.bind('port', 1234))
  ```


  I've used Guice and Spring in Java for a lot of years, and I don't like their scopes.
  `python-inject` by default creates objects as singletons. It does not need a prototype scope
  as in Spring or NO_SCOPE as in Guice because `python-inject` does not steal your class
  constructors. Create instances the way you like and then inject dependencies into them.

  Other scopes such as a request scope or a session scope are fragile, introduce high coupling,
  and are difficult to test. In `python-inject` write custom providers which can be thread-local,
  request-local, etc.

  For example, a thread-local current user provider:

  ```python
  import inject
  import threading


  class User(object):
      pass


  _LOCAL = threading.local()

  def get_current_user():
      return getattr(_LOCAL, 'user', None)

  def set_current_user(user):
      _LOCAL.user = user


  inject.configure(lambda binder: binder.bind_to_provider(User, get_current_user))


  @inject.params(user=User)
  def foo(user):
      pass
  ```


  * Project: https://github.com/ivankorobkov/python-inject


  Apache License 2.0


  * Ivan Korobkov [@ivankorobkov](https://github.com/ivankorobkov)
  * Jaime Wyant [@jaimewyant](https://github.com/jaimewyant)
  * Sebastian Buczyński [@Enforcer](https://github.com/Enforcer)
  * Oleksandr Fedorov [@Fedorof](https://github.com/Fedorof)
  * cselvaraj [@cselvaraj](https://github.com/cselvaraj)
  * 陆雨晴 [@SixExtreme](https://github.com/SixExtreme)
  * Andrew William Borba [@andrewborba10](https://github.com/andrewborba10)
  * jdmeyer3 [@jdmeyer3](https://github.com/jdmeyer3)
  * Alex Grover [@ajgrover](https://github.com/ajgrover)
  * Harro van der Kroft [@wisepotato](https://github.com/wisepotato)
  * Samiur Rahman [@samiur](https://github.com/samiur)
  * 45deg [@45deg](https://github.com/45deg)
  * Alexander Nicholas Costas [@ancostas](https://github.com/ancostas)
  * Dmitry Balabka [@dbalabka](https://github.com/dbalabka)


pkgId: ae3cf7cd16590a6bb66daf843498f2e737817fda556397ffd068a9cf13b6f0de
name: python-JPype1
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: A Python to Java bridge.
url: https://github.com/jpype-project/jpype
rpm_license: License :: OSI Approved :: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-88d867b3-1371-44e1-b6e7-e479cafc6eb0
location_href: 00009397-python-jpype1/python-JPype1-1.4.1-1.src.rpm
checksum_type: sha256
description:
  |implementation|  |pyversions|  |javaversions|  |jvm|  |platform|  |license|
  JPype is a Python module to provide full access to Java from
  within Python. It allows Python to make use of Java only libraries,
  exploring and visualization of Java structures, development and testing
  of Java libraries, scientific computing, and much more.  By gaining
  the best of both worlds using Python for rapid prototyping and Java
  for strong typed production code, JPype provides a powerful environment
  for engineering and code development.
  This is achieved not through re-implementing Python, as
  Jython has done, but rather through interfacing at the native
  level in both virtual machines. This shared memory based
  approach achieves decent computing performance, while providing the
  access to the entirety of CPython and Java libraries.
   <https://github.com/jpype-project/jpype>`_
   <https://github.com/jpype-project/jpype/issues>`_
   <https://github.com/jpype-project/jpype/discussions>`_
  The work on this project began on `Sourceforge <http://sourceforge.net/projects/jpype/>`__.
  LLNL-CODE- 812311
  SPDX-License-Identifier: Apache-2.0


pkgId: 1e406c53fafc2ec0a1df3fa49981e2d3fccbd0a77f87d84d4273095a1c1e148a
name: python-JPype1-debuginfo
arch: x86_64
version: 1.4.1
epoch: 0
release: 1
summary: Debug information for package python-JPype1
url: https://github.com/jpype-project/jpype
rpm_license: License :: OSI Approved :: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-88d867b3-1371-44e1-b6e7-e479cafc6eb0
rpm_sourcerpm: python-JPype1-1.4.1-1.src.rpm
location_href: 00009397-python-jpype1/python-JPype1-debuginfo-1.4.1-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-JPype1.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 9e1fb29480cba16886f6e691b9705840a02c9aefa75a03f6637d891af37f3f90
name: python-JPype1-debugsource
arch: x86_64
version: 1.4.1
epoch: 0
release: 1
summary: Debug sources for package python-JPype1
url: https://github.com/jpype-project/jpype
rpm_license: License :: OSI Approved :: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-88d867b3-1371-44e1-b6e7-e479cafc6eb0
rpm_sourcerpm: python-JPype1-1.4.1-1.src.rpm
location_href: 00009397-python-jpype1/python-JPype1-debugsource-1.4.1-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-JPype1.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 1179a975e08743b101090b59d6b47cb30c77996414fc2dc875d229e070eee558
name: python-Jinja2
arch: src
version: 3.1.2
epoch: 0
release: 1
summary: A very fast and expressive template engine.
url: https://palletsprojects.com/p/jinja/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-442873c6-fdd9-42ae-b516-bc4627461fd4
location_href: 00008896-python-jinja2/python-Jinja2-3.1.2-1.src.rpm
checksum_type: sha256
description:
  Jinja is a fast, expressive, extensible templating engine. Special
  placeholders in the template allow writing code similar to Python
  syntax. Then the template is passed data to render the final document.
  It includes:
  -   Template inheritance and inclusion.
  -   Define and import macros within templates.
  -   HTML templates can use autoescaping to prevent XSS from untrusted
      user input.
  -   A sandboxed environment can safely render untrusted templates.
  -   AsyncIO support for generating templates and calling async
      functions.
  -   I18N support with Babel.
  -   Templates are compiled to optimized Python code just-in-time and
      cached, or can be compiled ahead-of-time.
  -   Exceptions point to the correct line in templates to make debugging
      easier.
  -   Extensible filters, tests, functions, and even syntax.
  Jinja's philosophy is that while application logic belongs in Python if
  possible, it shouldn't make the template designer's job difficult by
  restricting functionality too much.


pkgId: e97dbc4fb991b306faecc9caf9987b93fe436d63a5abbe63d4b8c2986827f877
name: python-Js2Py
arch: src
version: 0.74
epoch: 0
release: 1
summary: JavaScript to Python Translator & JavaScript interpreter written in 100% pure Python.
url: https://github.com/PiotrDabkowski/Js2Py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ae783152-a6f2-42a9-b146-7f4ef7cf96b5
location_href: 00010805-python-js2py/python-Js2Py-0.74-1.src.rpm
checksum_type: sha256
description:
  Translates JavaScript to Python code. Js2Py is able to translate and execute virtually any JavaScript code.

  Js2Py is written in pure python and does not have any dependencies. Basically an implementation of JavaScript core in pure python.


      import js2py

      f = js2py.eval_js( "function $(name) {return name.length}" )

      f("Hello world")

      

  Now also supports ECMA 6 through js2py.eval_js6(js6_code)!

  More examples at: https://github.com/PiotrDabkowski/Js2Py


pkgId: d24a41a5f00ca7bfa8cf0018aceddc8f6332c44483722b8f4aad4a2d43524599
name: python-LEPL
arch: src
version: 5.1.3
epoch: 0
release: 1
summary: A Parser Library for Python 2.6+/3+: Recursive Descent; Full Backtracking
url: http://www.acooke.org/lepl/
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-104a85db-f7f5-4ab7-b0e9-ffd47318e780
location_href: 00013696-python-lepl/python-LEPL-5.1.3-1.src.rpm
checksum_type: sha256
description:
  * **Parsers are Python code**, defined in Python itself.  No separate
    grammar is necessary.
  * **Friendly syntax** using Python's operators allows grammars
    to be defined in a declarative style close to BNF.
  * Integrated, optional **lexer** simplifies handling whitespace.
  * Built-in **AST support** with support for iteration, traversal and
    re--writing.
  * Generic, pure-Python approach supports parsing a wide variety of data
    including **bytes** (Python 3+ only).
  * **Well documented** and easy to extend.
  * **Unlimited recursion depth**.  The underlying algorithm is
    recursive descent, which can exhaust the stack for complex grammars
    and large data sets.  LEPL avoids this problem by using Python
    generators as coroutines (aka "trampolining").
  * **Parser rewriting**.  The parser can itself be manipulated by
    Python code.  This gives unlimited opportunities for future
    expansion and optimisation.
  * Support for ambiguous grammars (**complete backtracking**).  A
    parser can return more than one result (aka **"parse forests"**).
  * Parsers can be made more **efficient** with automatic memoisation ("packrat
    parsing").
  * Memoisation can detect and control **left-recursive grammars**.  Together
    with LEPL's support for ambiguity this means that "any" grammar can be
    supported.
  * Trace and resource management, including **"deepest match" diagnostics**
    and the ability to limit backtracking.


pkgId: 9000950b8802bbb02d878c85aa618ac83c1a8614063643cfe7595b60438d2c7f
name: python-Lasagne
arch: src
version: 0.1
epoch: 0
release: 1
summary: A lightweight library to build and train neural networks in Theano
url: https://github.com/Lasagne/Lasagne
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5dc0a7b1-7fd0-489d-bc75-e2728d5deef3
location_href: 00004044-python-lasagne/python-Lasagne-0.1-1.src.rpm
checksum_type: sha256
description:
  Lasagne is a lightweight library to build and train neural networks in Theano.
  Its main features are:
  * Supports feed-forward networks such as Convolutional Neural Networks (CNNs),
    recurrent networks including Long Short-Term Memory (LSTM), and any
    combination thereof
  * Allows architectures of multiple inputs and multiple outputs, including
    auxiliary classifiers
  * Many optimization methods including Nesterov momentum, RMSprop and ADAM
  * Freely definable cost function and no need to derive gradients due to
    Theano's symbolic differentiation
  * Transparent support of CPUs and GPUs due to Theano's expression compiler
  Its design is governed by `six principles
  <http://lasagne.readthedocs.org/en/latest/user/development.html#philosophy>`_:
  * Simplicity: Be easy to use, easy to understand and easy to extend, to
    facilitate use in research
  * Transparency: Do not hide Theano behind abstractions, directly process and
    return Theano expressions or Python / numpy data types
  * Modularity: Allow all parts (layers, regularizers, optimizers, ...) to be
    used independently of Lasagne
  * Pragmatism: Make common use cases easy, do not overrate uncommon cases
  * Restraint: Do not obstruct users with features they decide not to use
  * Focus: "Do one thing and do it well"


pkgId: 256fcf4dd848987021bd869b47537b493e4248cc4f3783990ac65fcc11ddad7b
name: python-Lifetimes
arch: src
version: 0.11.3
epoch: 0
release: 1
summary: Measure customer lifetime value in Python
url: https://github.com/CamDavidsonPilon/lifetimes
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-df8d0c13-425b-4ffc-8b53-1ee2ae40c3bd
location_href: 00009710-python-lifetimes/python-Lifetimes-0.11.3-1.src.rpm
checksum_type: sha256
description:
  ![](http://i.imgur.com/7s3jqZM.png)


  [![PyPI version](https://badge.fury.io/py/Lifetimes.svg)](https://badge.fury.io/py/Lifetimes)
  [![Documentation Status](https://readthedocs.org/projects/lifetimes/badge/?version=latest)](http://lifetimes.readthedocs.io/en/latest/?badge=latest)
  [![Build Status](https://travis-ci.org/CamDavidsonPilon/lifetimes.svg?branch=master)](https://travis-ci.org/CamDavidsonPilon/lifetimes)
  [![Coverage Status](https://coveralls.io/repos/CamDavidsonPilon/lifetimes/badge.svg?branch=master)](https://coveralls.io/r/CamDavidsonPilon/lifetimes?branch=master)




  Lifetimes can be used to analyze your users based on a few assumption:

  1. Users interact with you when they are "alive".
  2. Users under study may "die" after some period of time.

  I've quoted "alive" and "die" as these are the most abstract terms: feel free to use your own definition of "alive" and "die" (they are used similarly to "birth" and "death" in survival analysis). Whenever we have individuals repeating occurrences, we can use Lifetimes to help understand user behaviour.



  If this is too abstract, consider these applications:

   - Predicting how often a visitor will return to your website. (Alive = visiting. Die = decided the website wasn't for them)
   - Understanding how frequently a patient may return to a hospital. (Alive = visiting. Die = maybe the patient moved to a new city, or became deceased.)
   - Predicting individuals who have churned from an app using only their usage history. (Alive = logins. Die = removed the app)
   - Predicting repeat purchases from a customer. (Alive = actively purchasing. Die = became disinterested with your product)
   - Predicting the lifetime value of your customers



  As emphasized by P. Fader and B. Hardie, understanding and acting on customer lifetime value (CLV) is the most important part of your business's sales efforts. [And (apparently) everyone is doing it wrong (Prof. Fader's Video Lecture)](https://www.youtube.com/watch?v=guj2gVEEx4s). *Lifetimes* is a Python library to calculate CLV for you.



  ```bash
  pip install lifetimes
  ```



  Please refer to the [Contributing Guide](https://github.com/CamDavidsonPilon/lifetimes/blob/master/CONTRIBUTING.md) before creating any *Pull Requests*. It will make life easier for everyone.


  [Official documentation](http://lifetimes.readthedocs.io/en/latest/)




  Please create an issue in the [lifetimes repository](https://github.com/CamDavidsonPilon/lifetimes).



  1. Probably, the seminal article of Non-Contractual CLV is [*Counting Your Customers: Who Are They and What Will They Do Next?*](https://www.jstor.org/stable/2631608?seq=1#page_scan_tab_contents), by David C. Schmittlein, Donald G. Morrison and Richard Colombo. Despite it being paid, it is worth the read. The relevant information will eventually end up in this library's documentation though.
  1. The other (more recent) paper is [*“Counting Your Customers” the Easy Way:
  An Alternative to the Pareto/NBD Model*](http://brucehardie.com/papers/018/fader_et_al_mksc_05.pdf), by Peter Fader, Bruce Hardie and Ka Lok Lee.



  1. [Roberto Medri](http://cdn.oreillystatic.com/en/assets/1/event/85/Case%20Study_%20What_s%20a%20Customer%20Worth_%20Presentation.pdf) did a nice presentation on CLV at Etsy.
  1. [Papers](http://mktg.uni-svishtov.bg/ivm/resources/Counting_Your_Customers.pdf), lots of [papers](http://brucehardie.com/notes/009/pareto_nbd_derivations_2005-11-05.pdf).
  1. R implementation is called [BTYD](http://cran.r-project.org/web/packages/BTYD/vignettes/BTYD-walkthrough.pdf) (*Buy 'Til You Die*).
  1. [Bruce Hardie's Website](http://brucehardie.com/), especially his notes, is full of useful and essential explanations, many of which are featured in this library.


pkgId: 00f1c0b4c645315eefa70d339faabd919604934b2d03605b6e02a523b7d9f242
name: python-LinkHeader
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: Parse and format link headers according to RFC 5988 "Web Linking"
url: http://bitbucket.org/asplake/link_header
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-129eebc1-7c52-44ef-a7ec-7ea29472aad9
location_href: 00004114-python-linkheader/python-LinkHeader-0.4.3-1.src.rpm
checksum_type: sha256
description:
  Parse and format link headers according to RFC 5988 "Web Linking".

  Usage (assuming a suitable headers object in the environment):

  	>>> headers['Link'] = str(LinkHeader([Link("http://example.com/foo", rel="self"),
  	...                                   Link("http://example.com", rel="up")]))
  	>>> headers['Link']
  	'<http://example.com/foo>; rel=self, <http://example.com>; rel=up'
  	>>> parse(headers['Link'])
  	LinkHeader([Link('http://example.com/foo', rel='self'), Link('http://example.com', rel='up')])

  Blank and missing values roundtrip correctly:

  	>>> format_link(parse('</s/1>; obs; if="core.s"; foo=""'))
  	'<</s/1>; obs; if=core.s; foo="">'

  Conversions to and from json-friendly list-based structures are also provided:

  	>>> parse(headers['Link']).to_py()
  	[['http://example.com/foo', [['rel', 'self']]], ['http://example.com', [['rel', 'up']]]]
  	>>> str(LinkHeader([['http://example.com/foo', [['rel', 'self']]],
  	...                 ['http://example.com', [['rel', 'up']]]]))
  	'<http://example.com/foo>; rel=self, <http://example.com>; rel=up'


pkgId: b2ab4edf11c32e9a07ab06a44d132448a78eac64cb95f22979c9dd852ab1ef66
name: python-Locales
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Module for multilingual solutions
url: https://github.com/vffuunnyy/Locales
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4fc7858b-5377-4ab8-9a0b-2212884cd034
location_href: 00012080-python-locales/python-Locales-0.0.2-1.src.rpm
checksum_type: sha256
description:
  Locales - module for multilingual projects





  Locales uses only standard library **json**. You need to write the translations in *json format*

  ```json
  {
    "languages": {
        "ru": "Р СѓСЃСЃРєРёР№", "eng": "English", "sp": "EspaГ±ol"
    },

    "messages": {
        "welcome": {
            "ru": "Р”РѕР±СЂРѕ РїРѕР¶Р°Р»РѕРІР°С‚СЊ!",
            "eng": "Welcome!"
        },
        "goodbye": {
            "ru": "РџРѕРєР°",
            "eng": "Goodbye",
            "sp": "AdiГіs"
        }
    }
  }
  ```
  Keys `languages` and `messages` required.

  To generate the same file use:
  ```python
  import Locales

  Locales().example()
  ```



  You can install Locales using pip

  ```sh
  $ pip install locales
  ```
  or download `Locales.py` and drop to folder with your project



  ```python
  import Locales

  loc = Locales("filename.json")
  loc.set_default_lang("eng")  # Set the language by default

  print(loc.get("welcome"))


  print(loc.get("welcome", "ru"))


  print(loc.get_all("goodbye")


  print(loc.get_by_name("English"))

  ```



  * **vffuunnyy** - *Initial work* - [@vffuunnyy](https://t.me/vffuunnyy)


pkgId: cf6bbd0370439a30e3672d1ef152fad07fb6be32498f745effb06d108e7e0e96
name: python-LumoPackage
arch: src
version: 2.2022.10.13
epoch: 0
release: 1
summary: Lumo example package
url: https://pypi.org/project/LumoPackage/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-639d5809-3caa-4a01-9064-f87c3e6209ac
location_href: 00012059-python-lumopackage/python-LumoPackage-2.2022.10.13-1.src.rpm
checksum_type: sha256
description:
  **Lumo Packages!**
  *Don't use this package in production!!*
  This is an auto-corralation package used in Lumatch system


pkgId: 539c6f6365ce8fb8df5f95e67e86053ab9e2a80de81e99c430077ab8d1d2f8bf
name: python-MDAnalysis
arch: src
version: 2.4.2
epoch: 0
release: 1
summary: An object-oriented toolkit to analyze molecular dynamics trajectories.
url: https://www.mdanalysis.org
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a4e7f226-2515-4218-86c6-82d45fc50332
location_href: 00002856-python-MDAnalysis/python-MDAnalysis-2.4.2-1.src.rpm
checksum_type: sha256
description:
     import MDAnalysis as mda
     
     u = mda.Universe('topol.tpr','traj.trr')
     
     ag = u.select_atoms('name OH')
     
     ag.positions
     ag.velocities
     ag.forces
     
     for ts in u.trajectory:
         print(ag.center_of_mass())

rpm_license:
  ========================================================================== Licenses of components of MDAnalysis ==========================================================================   GNU GENERAL PUBLIC LICENSE Version 2, June 1991  Copyright (C) 1989, 1991 Free Software Foundation, Inc. 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The licenses for most software are designed to take away your freedom to share and change it.  By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users.  This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it.  (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.)  You can apply it to your programs, too.  When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things.  To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it.  For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have.  You must make sure that they, too, receive or can get the source code.  And you must show them these terms so they know their rights.  We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software.  Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software.  If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations.  Finally, any free program is threatened constantly by software patents.  We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary.  To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all.  The precise terms and conditions for copying, distribution and modification follow.  GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION  0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License.  The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language.  (Hereinafter, translation is included without limitation in the term "modification".)  Each licensee is addressed as "you".  Activities other than copying, distribution and modification are not covered by this License; they are outside its scope.  The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does.  1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program.  You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.  2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:  a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change.  b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License.  c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License.  (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.)  These requirements apply to the modified work as a whole.  If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works.  But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.  Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program.  In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.  3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following:  a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,  b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,  c) Accompany it with the information you received as to the offer to distribute corresponding source code.  (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.)  The source code for a work means the preferred form of the work for making modifications to it.  For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable.  However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.  If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code.  4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License.  Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.  5. You are not required to accept this License, since you have not signed it.  However, nothing else grants you permission to modify or distribute the Program or its derivative works.  These actions are prohibited by law if you do not accept this License.  Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it.  6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions.  You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License.  7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all.  For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program.  If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances.  It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices.  Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.  This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.  8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded.  In such case, this License incorporates the limitation as if written in the body of this License.  9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation.  10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission.  For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this.  Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.  NO WARRANTY  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Programs  If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.  To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  <one line to give the program's name and a brief idea of what it does.> Copyright (C) <year>  <name of author>  This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA   Also add information on how to contact you by electronic and paper mail.  If the program is interactive, make it output a short notice like this when it starts in an interactive mode:  Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.  The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License.  Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program.  You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary.  Here is a sample; alter the names:  Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker.  <signature of Ty Coon>, 1 April 1989 Ty Coon, President of Vice  This General Public License does not permit incorporating your program into proprietary programs.  If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library.  If this is what you want to do, use the GNU Library General Public License instead of this License.   ==========================================================================  Gromacs xdrfile library for reading XTC/TRR trajectories - lib/formats/src/xdrfile.c - lib/formats/src/xdrfile_xtc.c - lib/formats/src/xdrfile_trr.c - lib/formats/include/xdrfile.h - lib/formats/include/xdrfile_xtc.h - lib/formats/include/xdrfile_trr.h  Copyright (c) 2009-2014, Erik Lindahl & David van der Spoel All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  ==========================================================================  CatDCD is released under the UIUC Open Source License: http://www.ks.uiuc.edu/Development/MDTools/catdcd/license.html  University of Illinois Open Source License Copyright 2003-2007 Theoretical and Computational Biophysics Group, All rights reserved.  Developed by:           Theoretical and Computational Biophysics Group University of Illinois at Urbana-Champaign http://www.ks.uiuc.edu/  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the Software), to deal with the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimers.  Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimers in the documentation and/or other materials provided with the distribution.  Neither the names of Theoretical and Computational Biophysics Group, University of Illinois at Urbana-Champaign, nor the names of its contributors may be used to endorse or promote products derived from this Software without specific prior written permission.  THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE SOFTWARE.  ==========================================================================  Biopython License Agreement  Permission to use, copy, modify, and distribute this software and its documentation with or without modifications and for any purpose and without fee is hereby granted, provided that any copyright notices appear in all copies and that both those copyright notices and this permission notice appear in supporting documentation, and that the names of the contributors or copyright holders not be used in advertising or publicity pertaining to distribution of the software without specific prior permission.  THE CONTRIBUTORS AND COPYRIGHT HOLDERS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE   ==========================================================================  transformations module - transformations.py - transformations.c  Copyright (c) 2006, Christoph Gohlke Copyright (c) 2006-2010, The Regents of the University of California All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the copyright holders nor the names of any contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  ==========================================================================  pyqcprot (src/pyqcprot) is released under the following 'BSD 3-clause' licence:  ----------------------------------------------------------------------------- PyQCPROT  Author(s) of Original Implementation: Douglas L. Theobald Department of Biochemistry MS 009 Brandeis University 415 South St Waltham, MA  02453 USA  dtheobald@brandeis.edu  Pu Liu Johnson & Johnson Pharmaceutical Research and Development, L.L.C. 665 Stockton Drive Exton, PA  19341 USA  pliu24@its.jnj.com  For the original code written in C see: http://theobald.brandeis.edu/qcp/   Author of Python Port: Joshua L. Adelman Department of Biological Sciences University of Pittsburgh Pittsburgh, PA 15260  jla65@pitt.edu   If you use this QCP rotation calculation method in a publication, please reference:  Douglas L. Theobald (2005) "Rapid calculation of RMSD using a quaternion-based characteristic polynomial." Acta Crystallographica A 61(4):478-480.  Pu Liu, Dmitris K. Agrafiotis, and Douglas L. Theobald (2010) "Fast determination of the optimal rotational matrix for macromolecular superpositions." J. Comput. Chem. 31, 1561-1563.   Copyright (c) 2009-2010, Pu Liu and Douglas L. Theobald Copyright (c) 2011       Joshua L. Adelman All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the <ORGANIZATION> nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.   ==========================================================================  MDAnalysis logo (see doc/sphinx/source/logos)  The MDAnalysis 'Atom' logo was created by Christian Beckstein and is  Copyright (c) 2011 Christian Beckstein  MDAnalysis Logo 'Atom' by Christian Beckstein is licensed under a Creative Commons Attribution-NoDerivs 3.0 Unported License. To view a copy of this license, visit http://creativecommons.org/licenses/by-nd/3.0/ or send a letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.  The logo is contained in the file 'mdanalysis-logo.png'.  Derivatives in the files 'mdanalysis-logo-127x55.png', 'mdanalysis-logo-200x150.png', 'mdanalysis-logo.ico' were created for inclusion in MDAnalysis and on websites related to MDAnalysis. They are distributed under the same license as the 'Atom' logo.  ==========================================================================


pkgId: 78bbf4f47f7adbbe96d45854de5f0bc346a99988f458d43b962fc7fa56225277
name: python-MDP
arch: src
version: 3.6
epoch: 0
release: 1
url: https://mdpdocs.readthedocs.io
rpm_license: https://raw.githubusercontent.com/mdp-toolkit/mdp-toolkit/master/COPYRIGHT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a32b080b-a812-4030-b090-05dd98b81767
location_href: 00004177-python-mdp/python-MDP-3.6-1.src.rpm
checksum_type: sha256
summary:
  MDP is a Python library for building complex data processing software by combining widely used machine learning algorithms into pipelines and networks.

description:
  **The Modular toolkit for Data Processing (MDP)** package is a library
  of widely used data processing algorithms, and the possibility to
  combine them together to form pipelines for building more complex
  data processing software.

  MDP has been designed to be used as-is and as a framework for
  scientific data processing development.

  From the user's perspective, MDP consists of a collection of *units*,
  which process data. For example, these include algorithms for
  supervised and unsupervised learning, principal and independent
  components analysis and classification.

  These units can be chained into data processing flows, to create
  pipelines as well as more complex feed-forward network
  architectures. Given a set of input data, MDP takes care of training
  and executing all nodes in the network in the correct order and
  passing intermediate data between the nodes. This allows the user to
  specify complex algorithms as a series of simpler data processing
  steps.

  The number of available algorithms is steadily increasing and includes
  signal processing methods (Principal Component Analysis, Independent
  Component Analysis, Slow Feature Analysis), manifold learning methods
  ([Hessian] Locally Linear Embedding), several classifiers,
  probabilistic methods (Factor Analysis, RBM), data pre-processing
  methods, and many others.

  Particular care has been taken to make computations efficient in terms
  of speed and memory. To reduce the memory footprint, it is possible to
  perform learning using batches of data. For large data-sets, it is
  also possible to specify that MDP should use single precision floating
  point numbers rather than double precision ones. Finally, calculations
  can be parallelised using the ``parallel`` subpackage, which offers a
  parallel implementation of the basic nodes and flows.

  From the developer's perspective, MDP is a framework that makes the
  implementation of new supervised and unsupervised learning algorithms
  easy and straightforward. The basic class, ``Node``, takes care of tedious
  tasks like numerical type and dimensionality checking, leaving the
  developer free to concentrate on the implementation of the learning
  and execution phases. Because of the common interface, the node then
  automatically integrates with the rest of the library and can be used
  in a network together with other nodes.

  A node can have multiple training phases and even an undetermined
  number of phases. Multiple training phases mean that the training data
  is presented multiple times to the same node. This allows the
  implementation of algorithms that need to collect some statistics on
  the whole input before proceeding with the actual training, and others
  that need to iterate over a training phase until a convergence
  criterion is satisfied. It is possible to train each phase using
  chunks of input data if the chunks are given as an iterable. Moreover,
  crash recovery can be optionally enabled, which will save the state of
  the flow in case of a failure for later inspection.

  MDP is distributed under the open source BSD license. It has been
  written in the context of theoretical research in neuroscience, but it
  has been designed to be helpful in any context where trainable data
  processing algorithms are used. Its simplicity on the user's side, the
  variety of readily available algorithms, and the reusability of the
  implemented nodes also make it a useful educational tool.

  http://mdp-toolkit.sourceforge.net


pkgId: 648162782c4dd1d8817c8cf8de86e705f098ab30178661cb21d0faff029d3d81
name: python-MEAutility
arch: src
version: 1.5.1
epoch: 0
release: 1
summary: Python package for multi-electrode array (MEA) handling and stimulation.
url: https://github.com/alejoe91/MEAutility
rpm_license: GNU General Public License v3 (GPLv3)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dc5f2198-800b-429a-b81e-fcf3ab0da727
location_href: 00004179-python-meautility/python-MEAutility-1.5.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/alejoe91/MEAutility.svg?branch=master)](https://travis-ci.org/alejoe91/MEAutility) [![PyPI version](https://badge.fury.io/py/MEAutility.svg)](https://badge.fury.io/py/MEAutility)



  Python package for multi-electrode array (MEA) handling and stimulation.



  To install run:
  `pip install MEAutility`

  If you want to install from sources and be updated with the latest development you can install with:
  ```
  git clone https://github.com/alejoe91/MEAutility
  cd MEAutility
  python setup.py install (or develop)
  ```

  The package can then imported in Python with:

  `import MEAutility as MEA`


  - numpy
  - pyyaml
  - matplotlib



  Please refer to https://meautility.readthedocs.io/en/latest/



  For any questions or comments, please contact Alessio Buccino: alessiob@ifi.uio.no


pkgId: 953c64db64c4d2fc97db59f87b0a84f247074372314e97e84b9f61a94637ba45
name: python-Mako
arch: src
version: 1.2.4
epoch: 0
release: 1
url: https://www.makotemplates.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1e59eebb-69aa-47ec-ad03-ef231adbf007
location_href: 00008963-python-mako/python-Mako-1.2.4-1.src.rpm
checksum_type: sha256
summary:
  A super-fast templating language that borrows the best ideas from the existing templating languages.


pkgId: f3ff4828b59b449e0c3f6d2348ad1e310c4c994c1c80dfd25dc0bf82a751d226
name: python-MarkupSafe
arch: src
version: 2.1.2
epoch: 0
release: 1
summary: Safely add untrusted strings to HTML/XML markup.
url: https://palletsprojects.com/p/markupsafe/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c3022f84-a5b9-4063-ade6-819c7446fd67
location_href: 00008898-python-markupsafe/python-MarkupSafe-2.1.2-1.src.rpm
checksum_type: sha256
description:
  MarkupSafe implements a text object that escapes characters so it is
  safe to use in HTML and XML. Characters that have special meanings are
  replaced so that they display as the actual characters. This mitigates
  injection attacks, meaning untrusted user input can safely be displayed
  on a page.


pkgId: 2579562f1c74a6ad2f1caa9115131482197f17dcbe36ef851b09b379e271bbd2
name: python-MarkupSafe-debuginfo
arch: x86_64
version: 2.1.2
epoch: 0
release: 1
summary: Debug information for package python-MarkupSafe
url: https://palletsprojects.com/p/markupsafe/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-c3022f84-a5b9-4063-ade6-819c7446fd67
rpm_sourcerpm: python-MarkupSafe-2.1.2-1.src.rpm
location_href: 00008898-python-markupsafe/python-MarkupSafe-debuginfo-2.1.2-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-MarkupSafe.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 95e9c905ccff14638cb52a7676961ff0daaaf7403ca89cc453630d99f42ba1fc
name: python-MarkupSafe-debugsource
arch: x86_64
version: 2.1.2
epoch: 0
release: 1
summary: Debug sources for package python-MarkupSafe
url: https://palletsprojects.com/p/markupsafe/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-c3022f84-a5b9-4063-ade6-819c7446fd67
rpm_sourcerpm: python-MarkupSafe-2.1.2-1.src.rpm
location_href: 00008898-python-markupsafe/python-MarkupSafe-debugsource-2.1.2-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-MarkupSafe.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: d371d172f065df7d40eca05098d25011b32af09eabea8fa78c7cc0a5255a239b
name: python-Markups
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: A wrapper around various text markups
url: https://github.com/retext-project/pymarkups
rpm_license: BSD 3-Clause License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cb69c9c8-4f26-4830-9f0f-7ee807826e1e
location_href: 00004162-python-markups/python-Markups-4.0.0-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://github.com/retext-project/pymarkups/workflows/tests/badge.svg
     :target: https://github.com/retext-project/pymarkups/actions
     :alt: GitHub Actions status
  .. image:: https://codecov.io/gh/retext-project/pymarkups/branch/master/graph/badge.svg
     :target: https://codecov.io/gh/retext-project/pymarkups
     :alt: Coverage status
  .. image:: https://readthedocs.org/projects/pymarkups/badge/?version=latest
     :target: https://pymarkups.readthedocs.io/en/latest/
     :alt: ReadTheDocs status

  This module provides a wrapper around various text markup languages.

  Available by default are Markdown_, reStructuredText_, Textile_ and AsciiDoc_,
  but you can easily add your own markups.

  Usage example:

  .. code:: python

    >>> import markups
    >>> markup = markups.get_markup_for_file_name("myfile.rst")
    >>> markup.name
    'reStructuredText'
    >>> markup.attributes[markups.common.SYNTAX_DOCUMENTATION]
    'https://docutils.sourceforge.io/docs/ref/rst/restructuredtext.html'
    >>> text = """
    ... Hello, world!
    ... =============
    ...
    ... This is an example **reStructuredText** document.
    ... """
    >>> result = markup.convert(text)
    >>> result.get_document_title()
    'Hello, world!'
    >>> print(result.get_document_body())  # doctest: +NORMALIZE_WHITESPACE
    <main id="hello-world">
    <h1 class="title" data-posmap="3">Hello, world!</h1>
    <p data-posmap="5">This is an example <strong>reStructuredText</strong> document.</p>
    </main>

  .. _Markdown: https://daringfireball.net/projects/markdown/
  .. _reStructuredText: https://docutils.sourceforge.io/rst.html
  .. _Textile: https://en.wikipedia.org/wiki/Textile_(markup_language)
  .. _AsciiDoc: https://asciidoc.org

  The release version can be downloaded from PyPI_ or installed using::

    pip install Markups

  .. _PyPI: https://pypi.org/project/Markups/

  The source code is hosted on GitHub_.

  .. _GitHub: https://github.com/retext-project/pymarkups

  The documentation is available online_ or can be generated from source by
  installing Sphinx_ and running::

    python3 -m sphinx docs build/sphinx/html

  .. _online: https://pymarkups.readthedocs.io/en/latest/
  .. _Sphinx: https://www.sphinx-doc.org/en/master/


pkgId: c82ae296ac2c9f4103baf5962d4bfde6dc044030bc84e4423553f800f7856a32
name: python-ModulemdTranslationHelpers
arch: src
version: 0.6
epoch: 0
release: 1
summary: Tools for working with translations of modulemd
url: https://github.com/fedora-modularity/ModulemdTranslationHelpers
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e2f64719-73a4-495a-9662-97e941642b0f
location_href: 00002860-python-ModulemdTranslationHelpers/python-ModulemdTranslationHelpers-0.6-1.src.rpm
checksum_type: sha256
description:
  * [libmodulemd](https://github.com/fedora-modularity/libmodulemd)
  * [koji](https://pagure.io/koji)

  To install on Fedora 28+, run:
  ```
  dnf install libmodulemd koji
  ```


  With the prerequisites installed, the latest version can be installed with
  `pip install ModulemdTranslationHelpers` or on Fedora 28+ with `dnf install
  python3-ModulemdTranslationHelpers` (recommended).




  To extract translatable strings from modules for a particular Fedora
  release (e.g. f29):
  ```
  ModulemdTranslationHelpers --branch f29 extract [--pot-file <path>]
  ```
  This will read all of the module metadata from the Koji build-system and
  convert the translatable strings to a portable object template (`.pot`)
  document.

  Specify the destination for the output file with `--pot-file`.

   
   To convert portable object (`.po`) files into
   modulemd-translations YAML documents that can be included in repodata:
   ```
   ModulemdTranslationHelpers --branch f29 generate_metadata \
                              [--pofile-dir <path>] \
                              [--yaml-file <path>]

   ```

   This will read all files with a `.po` suffix in the `pofile-dir` path and
   write the modulemd YAML to `yaml-file`.



  The ModulemdTranslationHelpers package has two primary functions:
  * get_module_catalog_from_tags()
  * get_modulemd_translations()


  This returns a `babel.message.Catalog` object containing all of the
  translatable strings from any module tagged with one of the passed tags. It
  can be passed to `babel.messages.pofile.write_po()` to create a portable
  object template (`.pot`) file.


  This returns an iterable of modulemd-translation objects generated from a
  set of paths to portable object (`.po`) files containing translation
  information.


  This package provides helper routines for dealing with translations in Fedora
  Modules.


  The URL to the standard Fedora Koji instance.


  Looks up which Fedora version the current Rawhide branch will become.


  Gets the list of tags for modules in a given Fedora branch. (For rawhide,
  make sure to use the value returned from get_fedora_rawhide_version.)


pkgId: 1ecb3bfb5eaa2e0b3e6d21ae76aaaa534f4011cc029f4c6ff59cc85865aece92
name: python-MonkeyType
arch: src
version: 23.3.0
epoch: 0
release: 1
summary: Generating type annotations from sampled production types
url: https://github.com/Instagram/MonkeyType
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2cb04385-4a70-4507-ac7d-93813a1e3569
location_href: 00013734-python-monkeytype/python-MonkeyType-23.3.0-1.src.rpm
checksum_type: sha256
description:
  MonkeyType collects runtime types of function arguments and return values, and
  can automatically generate stub files or even add draft type annotations
  directly to your Python code based on the types collected at runtime.


pkgId: 24d68aa754f06985f0a6a70a39c87c9c96248e443bbcd421affc240c9a094bb0
name: python-Moose
arch: src
version: 0.9.8
epoch: 0
release: 1
summary: Your manager for endless iterative tasks.
url: https://github.com/muma378/moose
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-113ca0d8-7058-45c1-a937-64ae3ace66b1
location_href: 00004228-python-moose/python-Moose-0.9.8-1.src.rpm
checksum_type: sha256
description:
  Moose是一个数据处理的自动化框架，旨在提供一套快速、灵活、便捷、幂等式的数据处理方案。它不仅提供了常用的数据处理类和函数，也提供了一套命令行式的接口以处理和维护版本内单一、重复、繁琐的任务。
  - - - -

      * Python 2.7 or Python 3.3+
      * Works on Linux, Windows, Mac OSX, BSD



  The quick way:

      pip install moose

  For more details see the install section in the documentation:
  https://moose-datatang.readthedocs.io/zh_CN/latest/intro/install.html



  Documentation is available online at https://moose-datatang.readthedocs.io/zh_CN/latest/ and in the `docs`
  directory.



  You can find release notes at https://moose-datatang.readthedocs.io/zh_CN/latest/news.html


  See https://moose-datatang.readthedocs.io/zh_CN/latest/contributing.html


pkgId: 4837687ccdf52f2e42e787176e664bf944d635d375de21f822f123e13c98f209
name: python-MouseInfo
arch: src
version: 0.1.3
epoch: 0
release: 1
url: https://github.com/asweigart/mouseinfo
rpm_license: GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2237c12f-5f50-4b77-bb7e-01d9bd0d96e0
location_href: 00010136-python-mouseinfo/python-MouseInfo-0.1.3-1.src.rpm
checksum_type: sha256
summary:
  An application to display XY position and RGB color information for the pixel currently under the mouse. Works on Python 2 and 3.

description:
  An application to display XY position and RGB color information for the pixel currently under the mouse. Works on Python 2 and 3. This is useful for GUI automation planning.
  The full documentation is at https://mouseinfo.readthedocs.io/en/latest/


pkgId: bd1fb2a730dc6f45fccf6d8c8e85d7909028ea9e975549990e5a5adceb466ecd
name: python-MultipartPostHandler2
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: A handler for urllib2 to enable multipart form uploading
url: https://github.com/sergiomb2/MultipartPostHandler2/
rpm_license: LGPLv2.1+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b40de441-e402-4119-a104-84ba2b7c17ed
location_href: 00002861-python-MultipartPostHandler2/python-MultipartPostHandler2-0.1.5-1.src.rpm
checksum_type: sha256
description:
  Usage:
    A handler for urllib2 to enable multipart/form-data for posting forms and uploading data.

  Inspirations:
    Upload files in python:
      http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/146306

  Example:
    import MultipartPostHandler, urllib2

    opener = urllib2.build_opener(MultipartPostHandler.MultipartPostHandler)
    params = { "username" : "bob", "password" : "riviera",
               "file" : open("filename", "rb") }
    opener.open("http://wwww.bobsite.com/upload/", params)

  Further Example:
    The main function of this file is a sample which downloads a page and
    then uploads it to the W3C validator.


pkgId: 37d767b2b3e923256c834779168bfefadd281b810789ba07484b072dba5d886a
name: python-MutatorMath
arch: src
version: 3.0.1
epoch: 0
release: 1
url: https://github.com/LettError/MutatorMath
rpm_license: BSD 3 Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f53b7636-6d37-4af2-8aac-84065d9931e5
location_href: 00004262-python-mutatormath/python-MutatorMath-3.0.1-1.src.rpm
checksum_type: sha256
summary:
  Python for piecewise linear interpolation in multiple dimensions with multiple, arbitrarily placed, masters.

description:
     A MutatorMath Colorfield
  MutatorMath is a Python library for the calculation of piecewise linear
  interpolations in n-dimensions with any number of masters. It was
  developed for interpolating data related to fonts, but if can handle any
  arithmetic object.
  -  The **objects/** subpackage contains the general calculation tools.
  -  The **ufo/** subpackage contains tools to specifically process UFO
     data.
  -  MutatorMath has no user interface, just the math.


pkgId: d05d26b4780a239f73564ccca5cbec47ba843d0504850163723d841bad01fb00
name: python-Nuitka
arch: src
version: 1.5.5
epoch: 0
release: 1
summary: Python compiler with full language support and CPython compatibility
url: https://nuitka.net
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9e2ba843-ea16-46b1-b694-6eae5ce2cdd3
location_href: 00013853-python-nuitka/python-Nuitka-1.5.5-1.src.rpm
checksum_type: sha256
description:
  -  C Compiler: You need a compiler with support for C11 or alternatively
     for C++03 [#]_
     Currently this means, you need to use one of these compilers:
     -  The MinGW64 C11 compiler on Windows, must be based on gcc 11.2 or
        higher. It will be *automatically* downloaded if no usable C
        compiler is found, which is the recommended way of installing it,
        as Nuitka will also upgrade it for you.
     -  Visual Studio 2022 or higher on Windows [#]_, older versions will
        work but only supported for commercial users. Configure to use the
        English language pack for best results (Nuitka filters away
        garbage outputs, but only for English language). It will be used
        by default if installed.
     -  On all other platforms, the ``gcc`` compiler of at least version
        5.1, and below that the ``g++`` compiler of at least version 4.4
        as an alternative.
     -  The ``clang`` compiler on macOS X and most FreeBSD architectures.
     -  On Windows the ``clang-cl`` compiler on Windows can be used if
        provided by the Visual Studio installer.
  -  Python: Version 2.6, 2.7 or 3.3, 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 3.10,
     3.11
        For Python 3.3/3.4 and *only* those, we need other Python version
        as a *compile time* dependency.
        Nuitka itself is fully compatible with all listed versions, but
        Scons as an internally used tool is not.
        For these versions, you *need* a Python2 or Python 3.5 or higher
        installed as well, but only during the compile time only. That is
        for use with Scons (which orchestrates the C compilation), which
        does not support the same Python versions as Nuitka.
        In addition, on Windows, Python2 cannot be used because
        ``clcache`` does not work with it, there a Python 3.5 or higher
        needs to be installed.
        Nuitka finds these needed Python versions (e.g. on Windows via
        registry) and you shouldn't notice it as long as they are
        installed.
        Increasingly, other functionality is available when another Python
        has a certain package installed. For example, onefile compression
        will work for a Python 2.x when another Python is found that has
        the ``zstandard`` package installed.
        The created binaries can be made executable independent of the
        Python installation, with ``--standalone`` and ``--onefile``
        options.
        The created binaries have an ``.exe`` suffix on Windows. On other
        platforms they have no suffix for standalone mode, or ``.bin``
        suffix, that you are free to remove or change, or specify with the
        ``-o`` option.
        The suffix for acceleration mode is added just to be sure that the
        original script name and the binary name do not ever collide, so
        we can safely do an overwrite without destroying the original
        source file.
        You need the standard Python implementation, called "CPython", to
        execute Nuitka, because it is closely tied to implementation
        details of it.
        It is known that Windows app store Python definitely does not
        work, it's checked against. And on macOS "pyenv" likely does
        **not** work.
  -  Operating System: Linux, FreeBSD, NetBSD, macOS X, and Windows
     (32bits/64 bits/ARM).
     Others may work as well. The portability is expected to be generally
     good, but the e.g. Scons usage may have to be adapted. Make sure to
     match Windows Python and C compiler architecture, or else you will
     get cryptic error messages.
  -  Architectures: x86, x86_64 (amd64), and arm, likely many more
     Other architectures are expected to also work, out of the box, as
     Nuitka is generally not using any hardware specifics. These are just
     the ones tested and known to be good. Feedback is welcome. Generally,
     the architectures that Debian supports can be considered good and
     tested too.
     Support for this C11 is a given with gcc 5.x or higher or any clang
     version.
     The MSVC compiler doesn't do it yet. But as a workaround, as the C++03
     language standard is very overlapping with C11, it is then used instead
     where the C compiler is too old. Nuitka used to require a C++ compiler
     in the past, but it changed.
     Download for free from
     https://www.visualstudio.com/en-us/downloads/download-visual-studio-vs.aspx
     (the community editions work just fine).
     The latest version is recommended but not required. On the other hand,
     there is no need to except to support pre-Windows 10 versions, and they
     might work for you, but support of these configurations is only
     available to commercial users.


pkgId: ba5b38bb6c019fa46b370750e3788c31cb060dde4cd41bd25bb9d9ecc61dcd7a
name: python-O365
arch: src
version: 2.0.26
epoch: 0
release: 1
summary: Microsoft Graph and Office 365 API made easy
url: https://github.com/O365/python-o365
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-36af9eb3-1a51-4e3e-bfe8-2f47fea75142
location_href: 00010649-python-o365/python-O365-2.0.26-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](https://pepy.tech/badge/O365)](https://pepy.tech/project/O365)
  [![PyPI](https://img.shields.io/pypi/v/O365.svg)](https://pypi.python.org/pypi/O365)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/O365.svg)](https://pypi.python.org/pypi/O365/)
  [![Build Status](https://travis-ci.org/O365/python-o365.svg?branch=master)](https://travis-ci.org/O365/python-o365)




  > Detailed usage documentation is [still in progress](https://o365.github.io/python-o365/latest/index.html)

  This project aims to make interacting with Microsoft Graph and Office 365 easy to do in a Pythonic way.
  Access to Email, Calendar, Contacts, OneDrive, etc. Are easy to do in a way that feel easy and straight forward to beginners and feels just right to seasoned python programmer.

  The project is currently developed and maintained by [Janscas](https://github.com/janscas).


  - [Janscas](https://github.com/janscas)
  - [Toben Archer](https://github.com/Narcolapser)
  - [Geethanadh](https://github.com/GeethanadhP)

  **We are always open to new pull requests!**


  - Install `sphinx` python library

      `pip install sphinx==2.2.2`

  - Run the shell script `build_docs.sh`, or copy the command from the file when using on windows




  ```python
  from O365 import Account

  credentials = ('client_id', 'client_secret')

  account = Account(credentials)
  m = account.new_message()
  m.to.add('to_example@example.com')
  m.subject = 'Testing!'
  m.body = "George Best quote: I've stopped drinking, but only while I'm asleep."
  m.send()
  ```



  - Almost Full Support for MsGraph and Office 365 Rest Api.
  - Good Abstraction layer between each Api. Change the api (Graph vs Office365) and don't worry about the api internal implementation.
  - Full oauth support with automatic handling of refresh tokens.
  - Automatic handling between local datetimes and server datetimes. Work with your local datetime and let this library do the rest.
  - Change between different resource with ease: access shared mailboxes, other users resources, SharePoint resources, etc.
  - Pagination support through a custom iterator that handles future requests automatically. Request Infinite items!
  - A query helper to help you build custom OData queries (filter, order, select and search).
  - Modular ApiComponents can be created and built to achieve further functionality.

  ___

  This project was also a learning resource for us. This is a list of not so common python idioms used in this project:
  - New unpacking technics: `def method(argument, *, with_name=None, **other_params):`
  - Enums: `from enum import Enum`
  - Factory paradigm
  - Package organization
  - Timezone conversion and timezone aware datetimes
  - Etc. ([see the code!](https://github.com/O365/python-o365/tree/master/O365))


  What follows is kind of a wiki...



  - [Install](#install)
  - [Usage](#usage)
  - [Authentication](#authentication)
  - [Protocols](#protocols)
  - [Account Class and Modularity](#account)
  - [MailBox](#mailbox)
  - [AddressBook](#addressbook)
  - [Directory and Users](#directory-and-users)
  - [Calendar](#calendar)
  - [Tasks](#tasks)
  - [OneDrive](#onedrive)
  - [Excel](#excel)
  - [SharePoint](#sharepoint)
  - [Planner](#planner)
  - [Outlook Categories](#outlook-categories)
  - [Utils](#utils)



  O365 is available on pypi.org. Simply run `pip install O365` to install it.

  Requirements: >= Python 3.4

  Project dependencies installed by pip:
   - requests
   - requests-oauthlib
   - beatifulsoup4
   - stringcase
   - python-dateutil
   - tzlocal
   - pytz



  The first step to be able to work with this library is to register an application and retrieve the auth token. See [Authentication](#authentication).

  It is highly recommended to add the "offline_access" permission and request this scope when authenticating. Otherwise the library will only have access to the user resources for 1 hour. See [Permissions and Scopes](#permissions-and-scopes).

  With the access token retrieved and stored you will be able to perform api calls to the service.

  A common pattern to check for authentication and use the library is this one:

  ```python
  scopes = ['my_required_scopes']  # you can use scope helpers here (see Permissions and Scopes section)

  account = Account(credentials)

  if not account.is_authenticated:  # will check if there is a token and has not expired
      
      
      account.authenticate(scopes=scopes)





  ```


  You can only authenticate using oauth athentication as Microsoft deprecated basic auth on November 1st 2018.

  There are currently three authentication methods:

  - [Authenticate on behalf of a user](https://docs.microsoft.com/en-us/graph/auth-v2-user?context=graph%2Fapi%2F1.0&view=graph-rest-1.0):
  Any user will give consent to the app to access it's resources.
  This oauth flow is called **authorization code grant flow**. This is the default authentication method used by this library.
  - [Authenticate on behalf of a user (public)](https://docs.microsoft.com/en-us/graph/auth-v2-user?context=graph%2Fapi%2F1.0&view=graph-rest-1.0):
  Same as the former but for public apps where the client secret can't be secured. Client secret is not required.
  - [Authenticate with your own identity](https://docs.microsoft.com/en-us/graph/auth-v2-service?context=graph%2Fapi%2F1.0&view=graph-rest-1.0):
  This will use your own identity (the app identity). This oauth flow is called **client credentials grant flow**.

      > 'Authenticate with your own identity' is not an allowed method for **Microsoft Personal accounts**.

  When to use one or the other and requirements:

    Topic                             | On behalf of a user *(auth_flow_type=='authorization')*  | On behalf of a user (public) *(auth_flow_type=='public')*  | With your own identity *(auth_flow_type=='credentials')*
   :---:                              | :---:                                                    | :---:                                                      | :---:
   **Register the App**               | Required                                                 | Required                                                   | Required
   **Requires Admin Consent**         | Only on certain advanced permissions                     | Only on certain advanced permissions                       | Yes, for everything
   **App Permission Type**            | Delegated Permissions (on behalf of the user)            | Delegated Permissions (on behalf of the user)              | Application Permissions
   **Auth requirements**              | Client Id, Client Secret, Authorization Code             | Client Id, Authorization Code                              | Client Id, Client Secret
   **Authentication**                 | 2 step authentication with user consent                  | 2 step authentication with user consent                    | 1 step authentication
   **Auth Scopes**                    | Required                                                 | Required                                                   | None
   **Token Expiration**               | 60 Minutes without refresh token or 90 days*             | 60 Minutes without refresh token or 90 days*               | 60 Minutes*
   **Login Expiration**               | Unlimited if there is a refresh token and as long as a re| Unlimited if there is a refresh token and as long as a refresh is done within the 90 days          | Unlimited
   **Resources**                      | Access the user resources, and any shared resources      | Access the user resources, and any shared resources        | All Azure AD users the app has access to
   **Microsoft Account Type**         | Any                                                      | Any                                                        | Not Allowed for Personal Accounts
   **Tenant ID Required**             | Defaults to "common"                                     | Defaults to "common"                                       | Required (can't be "common")

  **O365 will automatically refresh the token for you on either authentication method. The refresh token lasts 90 days but it's refreshed on each connection so as long as you connect within 90 days you can have unlimited access.*

  The `Connection` Class handles the authentication.



  This section is explained using Microsoft Graph Protocol, almost the same applies to the Office 365 REST API.


  1. To allow authentication you first need to register your application at [Azure App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps/ApplicationsListBlade).

      1. Login at [Azure Portal (App Registrations)](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps/ApplicationsListBlade)
      1. Create an app. Set a name.
      1. In Supported account types choose "Accounts in any organizational directory and personal Microsoft accounts (e.g. Skype, Xbox, Outlook.com)", if you are using a personal account.
      1. Set the redirect uri (Web) to: `https://login.microsoftonline.com/common/oauth2/nativeclient` and click register. This needs to be inserted into the "Redirect URI" text box as simply checking the check box next to this link seems to be insufficent. This is the default redirect uri used by this library, but you can use any other if you want.
      1. Write down the Application (client) ID. You will need this value.
      1. Under "Certificates & secrets", generate a new client secret. Set the expiration preferably to never. Write down the value of the client secret created now. It will be hidden later on.
      1. Under Api Permissions:
          - When authenticating "on behalf of a user":
              1. add the **delegated permissions** for Microsoft Graph you want (see scopes).
              1. It is highly recommended to add "offline_access" permission. If not the user you will have to re-authenticate every hour.
          - When authenticating "with your own identity":
              1. add the **application permissions** for Microsoft Graph you want.
              1. Click on the Grant Admin Consent button (if you have admin permissions) or wait until the admin has given consent to your application.

          As an example, to read and send emails use:
          1. Mail.ReadWrite
          1. Mail.Send
          1. User.Read

  1. Then you need to login for the first time to get the access token that will grant access to the user resources.

      To authenticate (login) you can use [different authentication interfaces](#different-authentication-interfaces). On the following examples we will be using the Console Based Interface but you can use any one.

      - When authenticating on behalf of a user:

          > **Important:** In case you can't secure the client secret you can use the auth flow type 'public' which only requires the client id.

          1. Instantiate an `Account` object with the credentials (client id and client secret).
          1. Call `account.authenticate` and pass the scopes you want (the ones you previously added on the app registration portal).

              > Note: when using the "on behalf of a user" authentication, you can pass the scopes to either the `Account` init or to the authenticate method. Either way is correct.

              You can pass "protocol scopes" (like: "https://graph.microsoft.com/Calendars.ReadWrite") to the method or use "[scope helpers](https://github.com/O365/python-o365/blob/master/O365/connection.py#L34)" like ("message_all").
              If you pass protocol scopes, then the `account` instance must be initialized with the same protocol used by the scopes. By using scope helpers you can abstract the protocol from the scopes and let this library work for you.
              Finally, you can mix and match "protocol scopes" with "scope helpers".
              Go to the [procotol section](#protocols) to know more about them.

              For Example (following the previous permissions added):

              ```python
              from O365 import Account
              credentials = ('my_client_id', 'my_client_secret')

              
              

              account = Account(credentials)
              if account.authenticate(scopes=['basic', 'message_all']):
                 print('Authenticated!')

              
              
              ```
              When using the "on behalf of the user" authentication method, this method call will print a url that the user must visit to give consent to the app on the required permissions.

              The user must then visit this url and give consent to the application. When consent is given, the page will rediret to: "https://login.microsoftonline.com/common/oauth2/nativeclient" by default (you can change this) with a url query param called 'code'.

              Then the user must copy the resulting page url and paste it back on the console.
              The method will then return True if the login attempt was succesful.

      - When authenticating with your own identity:

          1. Instantiate an `Account` object with the credentials (client id and client secret), specifying the parameter `auth_flow_type` to *"credentials"*. You also need to provide a 'tenant_id'. You don't need to specify any scopes.
          1. Call `account.authenticate`. This call will request a token for you and store it in the backend. No user interaction is needed. The method will store the token in the backend and return True if the authentication succeeded.

              For Example:
              ```python
              from O365 import Account

              credentials = ('my_client_id', 'my_client_secret')

              

              account = Account(credentials, auth_flow_type='credentials', tenant_id='my-tenant-id')
              if account.authenticate():
                 print('Authenticated!')
              ```

  1. At this point you will have an access token stored that will provide valid credentials when using the api.

      The access token only lasts **60 minutes**, but the app try will automatically request new access tokens.

      When using the "on behalf of a user" authentication method this is accomplished through the refresh tokens (if and only if you added the "offline_access" permission), but note that a refresh token only lasts for 90 days. So you must use it before or you will need to request a new access token again (no new consent needed by the user, just a login).
      If your application needs to work for more than 90 days without user interaction and without interacting with the API, then you must implement a periodic call to `Connection.refresh_token` before the 90 days have passed.

      **Take care: the access (and refresh) token must remain protected from unauthorized users.**

      Under the "on behalf of a user" authentication method, if you change the scope requested, then the current token won't work, and you will need the user to give consent again on the application to gain access to the new scopes requested.




  To acomplish the authentication you can basically use different approaches.
  The following apply to the "on behalf of a user" authentication method as this is 2-step authentication flow.
  For the "with your own identity" authentication method, you can just use `account.authenticate` as it's not going to require a console input.

  1. Console based authentication interface:

      You can authenticate using a console. The best way to achieve this is by using the `authenticate` method of the `Account` class.

      ```python
      account = Account(credentials)
      account.authenticate(scopes=['basic', 'message_all'])
      ```

      The `authenticate` method will print into the console a url that you will have to visit to achieve authentication.
      Then after visiting the link and authenticate you will have to paste back the resulting url into the console.
      The method will return `True` and print a message if it was succesful.

      **Tip:** When using MacOs the console is limited to 1024 characters. If your url has multiple scopes it can exceed this limit. To solve this. Just `import readline` a the top of your script.

  1. Web app based authentication interface:

      You can authenticate your users in a web environment by following this steps:

      1. First ensure you are using an appropiate TokenBackend to store the auth tokens (See Token storage below).
      1. From a handler redirect the user to the Microsoft login url. Provide a callback. Store the state.
      1. From the callback handler complete the authentication with the state and other data.

      The following example is done using Flask.
      ```python
      @route('/stepone')
      def auth_step_one():

          callback = 'my absolute url to auth_step_two_callback'
          account = Account(credentials)
          url, state = account.con.get_authorization_url(requested_scopes=my_scopes,
                                                         redirect_uri=callback)

          
          my_db.store_state(state) # example...

          return redirect(url)

      @route('/steptwo')
      def auth_step_two_callback():
          account = Account(credentials)

          
          my_saved_state = my_db.get_state()  # example...

          
          callback = 'my absolute url to auth_step_two_callback'

          result = account.con.request_token(request.url,
                                             state=my_saved_state,
                                             redirect_uri=callback)
          
          
          if result:
              return render_template('auth_complete.html')
          
      ```

  1. Other authentication interfaces:

      Finally you can configure any other flow by using `connection.get_authorization_url` and `connection.request_token` as you want.






  When using oauth, you create an application and allow some resources to be accessed and used by its users.
  These resources are managed with permissions. These can either be delegated (on behalf of a user) or aplication permissions.
  The former are used when the authentication method is "on behalf of a user". Some of these require administrator consent.
  The latter when using the "with your own identity" authentication method. All of these require administrator consent.



  The scopes only matter when using the "on behalf of a user" authentication method.

  > Note: You only need the scopes when login as those are kept stored within the token on the token backend.

  The user of this library can then request access to one or more of this resources by providing scopes to the oauth provider.

  > Note: If you latter on change the scopes requested, the current token will be invaled and you will have to re-authenticate. The user that logins will be asked for consent.

  For example your application can have Calendar.Read, Mail.ReadWrite and Mail.Send permissions, but the application can request access only to the Mail.ReadWrite and Mail.Send permission.
  This is done by providing scopes to the `Account` instance or `account.authenticate` method like so:

  ```python
  from O365 import Account

  credentials = ('client_id', 'client_secret')

  scopes = ['https://graph.microsoft.com/Mail.ReadWrite', 'https://graph.microsoft.com/Mail.Send']

  account = Account(credentials, scopes=scopes)
  account.authenticate()




  ```

  Scope implementation depends on the protocol used. So by using protocol data you can automatically set the scopes needed.
  This is implemented by using 'scope helpers'. Those are little helpers that group scope functionality and abstract the protocol used.

  Scope Helper                       | Scopes included
  :---                               | :---
  basic                              | 'offline_access' and 'User.Read'
  mailbox                            | 'Mail.Read'
  mailbox_shared                     | 'Mail.Read.Shared'
  mailbox_settings                   | 'MailboxSettings.ReadWrite'
  message_send                       | 'Mail.Send'
  message_send_shared                | 'Mail.Send.Shared'
  message_all                        | 'Mail.ReadWrite' and 'Mail.Send'
  message_all_shared                 | 'Mail.ReadWrite.Shared' and 'Mail.Send.Shared'
  address_book                       | 'Contacts.Read'
  address_book_shared                | 'Contacts.Read.Shared'
  address_book_all                   | 'Contacts.ReadWrite'
  address_book_all_shared            | 'Contacts.ReadWrite.Shared'
  calendar                           | 'Calendars.Read'
  calendar_shared                    | 'Calendars.Read.Shared'
  calendar_all                       | 'Calendars.ReadWrite'
  calendar_shared_all                | 'Calendars.ReadWrite.Shared'
  tasks                              | 'Tasks.Read'
  tasks_all                          | 'Tasks.ReadWrite'
  users                              | 'User.ReadBasic.All'
  onedrive                           | 'Files.Read.All'
  onedrive_all                       | 'Files.ReadWrite.All'
  sharepoint                         | 'Sites.Read.All'
  sharepoint_dl                      | 'Sites.ReadWrite.All'


  You can get the same scopes as before using protocols and scope helpers like this:

  ```python
  protocol_graph = MSGraphProtocol()

  scopes_graph = protocol.get_scopes_for('message all')


  account = Account(credentials, scopes=scopes_graph)
  ```

  ```python
  protocol_office = MSOffice365Protocol()

  scopes_office = protocol.get_scopes_for('message all')


  account = Account(credentials, scopes=scopes_office)
  ```

  > Note: When passing scopes at the `Account` initialization or on the `account.authenticate` method, the scope helpers are autommatically converted to the protocol flavor.
  >Those are the only places where you can use scope helpers. Any other object using scopes (such as the `Connection` object) expects scopes that are already set for the protocol.




  When authenticating you will retrieve oauth tokens. If you don't want a one time access you will have to store the token somewhere.
  O365 makes no assumptions on where to store the token and tries to abstract this from the library usage point of view.

  You can choose where and how to store tokens by using the proper Token Backend.

  **Take care: the access (and refresh) token must remain protected from unauthorized users.**

  The library will call (at different stages) the token backend methods to load and save the token.

  Methods that load tokens:
  - `account.is_authenticated` property will try to load the token if is not already loaded.
  - `connection.get_session`: this method is called when there isn't a request session set. By default it will not try to load the token. Set `load_token=True` to load it.

  Methods that stores tokens:
  - `connection.request_token`: by default will store the token, but you can set `store_token=False` to avoid it.
  - `connection.refresh_token`: by default will store the token. To avoid it change `connection.store_token` to False. This however it's a global setting (that only affects the `refresh_token` method). If you only want the next refresh operation to not store the token you will have to set it back to True afterwards.

  To store the token you will have to provide a properly configured TokenBackend.

  Actually there are only two implemented (but you can easely implement more like a CookieBackend, RedisBackend, etc.):
  - `FileSystemTokenBackend` (Default backend): Stores and retrieves tokens from the file system. Tokens are stored as files.
  - `FirestoreTokenBackend`: Stores and retrives tokens from a Google Firestore Datastore. Tokens are stored as documents within a collection.

  For example using the FileSystem Token Backend:

  ```python
  from O365 import Account, FileSystemTokenBackend

  credentials = ('id', 'secret')



  token_backend = FileSystemTokenBackend(token_path='my_folder', token_filename='my_token.txt')
  account = Account(credentials, token_backend=token_backend)




  ```

  And now using the same example using FirestoreTokenBackend:

  ```python
  from O365 import Account
  from O365.utils import FirestoreBackend
  from google.cloud import firestore

  credentials = ('id', 'secret')



  user_id = 'whatever the user id is'  # used to create the token document id
  document_id = 'token_{}'.format(user_id)  # used to uniquely store this token
  token_backend = FirestoreBackend(client=firestore.Client(), collection='tokens', doc_id=document_id)
  account = Account(credentials, token_backend=token_backend)




  ```

  To implement a new TokenBackend:

   1. Subclass `BaseTokenBackend`
   1. Implement the following methods:

       - `__init__` (don't forget to call `super().__init__`)
       - `load_token`: this should load the token from the desired backend and return a `Token` instance or None
       - `save_token`: this should store the `self.token` in the desired backend.
       - Optionally you can implement: `check_token`, `delete_token` and `should_refresh_token`

  The `should_refresh_token` method is intended to be implemented for environments where multiple Connection instances are running on paralel.
  This method should check if it's time to refresh the token or not.
  The chosen backend can store a flag somewhere to answer this question.
  This can avoid race conditions between different instances trying to refresh the token at once, when only one should make the refresh.
  The method should return three posible values:
  - **True**: then the Connection will refresh the token.
  - **False**: then the Connection will NOT refresh the token.
  - **None**: then this method already executed the refresh and therefore the Connection does not have to.

  By default this always returns True as it's asuming there is are no parallel connections running at once.

  There are two examples of this method in the examples folder [here](https://github.com/O365/python-o365/blob/master/examples/token_backends.py).



  Protocols handles the aspects of communications between different APIs.
  This project uses either the Microsoft Graph APIs (by default) or the Office 365 APIs.
  But, you can use many other Microsoft APIs as long as you implement the protocol needed.

  You can use one or the other:

  - `MSGraphProtocol` to use the [Microsoft Graph API](https://developer.microsoft.com/en-us/graph/docs/concepts/overview)
  - `MSOffice365Protocol` to use the [Office 365 API](https://msdn.microsoft.com/en-us/office/office365/api/api-catalog)

  Both protocols are similar but consider the following:

  Reasons to use `MSGraphProtocol`:
  - It is the recommended Protocol by Microsoft.
  - It can access more resources over Office 365 (for example OneDrive)

  Reasons to use `MSOffice365Protocol`:
  - It can send emails with attachments up to 150 MB. MSGraph only allows 4MB on each request (UPDATE: Starting 22 October'19 you can [upload files up to 150MB with MSGraphProtocol **beta** version](https://developer.microsoft.com/en-us/office/blogs/attaching-large-files-to-outlook-messages-in-microsoft-graph-preview/))

  The default protocol used by the `Account` Class is `MSGraphProtocol`.

  You can implement your own protocols by inheriting from `Protocol` to communicate with other Microsoft APIs.

  You can instantiate and use protocols like this:
  ```python
  from O365 import Account, MSGraphProtocol  # same as from O365.connection import MSGraphProtocol




  protocol = MSGraphProtocol(api_version='beta')  # MSGraphProtocol defaults to v1.0 api version
  account = Account(credentials, protocol=protocol)
  ```


  Each API endpoint requires a resource. This usually defines the owner of the data.
  Every protocol defaults to resource 'ME'. 'ME' is the user which has given consent, but you can change this behaviour by providing a different default resource to the protocol constructor.

  > Note: When using the "with your own identity" authentication method the resource 'ME' is overwritten to be blank as the authentication method already states that you are login with your own identity.

  For example when accessing a shared mailbox:


  ```python

  account = Account(credentials=my_credentials, main_resource='shared_mailbox@example.com')

  ```

  This can be done however at any point. For example at the protocol level:
  ```python

  protocol = MSGraphProtocol(default_resource='shared_mailbox@example.com')

  account = Account(credentials=my_credentials, protocol=protocol)


  shared_mailbox_messages = account.mailbox().get_messages()
  ```

  Instead of defining the resource used at the account or protocol level, you can provide it per use case as follows:
  ```python

  account = Account(credentials=my_credentials)  # account defaults to 'ME' resource

  mailbox = account.mailbox('shared_mailbox@example.com')  # mailbox is using 'shared_mailbox@example.com' resource instead of 'ME'



  message = Message(parent=account, main_resource='shared_mailbox@example.com')  # message is using 'shared_mailbox@example.com' resource
  ```

  Usually you will work with the default 'ME' resource, but you can also use one of the following:

  - **'me'**: the user which has given consent. the default for every protocol. Overwritten when using "with your own identity" authentication method (Only available on the authorization auth_flow_type).
  - **'user:user@domain.com'**: a shared mailbox or a user account for which you have permissions. If you don't provide 'user:' will be infered anyways.
  - **'site:sharepoint-site-id'**: a sharepoint site id.
  - **'group:group-site-id'**: a office365 group id.

  By setting the resource prefix (such as **'user:'** or **'group:'**) you help the library understand the type of resource. You can also pass it like 'users/example@exampl.com'. Same applies to the other resource prefixes.



  Usually you will only need to work with the `Account` Class. This is a wrapper around all functionality.

  But you can also work only with the pieces you want.

  For example, instead of:
  ```python
  from O365 import Account

  account = Account(('client_id', 'client_secret'))
  message = account.new_message()

  mailbox = account.mailbox()

  ```

  You can work only with the required pieces:

  ```python
  from O365 import Connection, MSGraphProtocol
  from O365.message import Message
  from O365.mailbox import MailBox

  protocol = MSGraphProtocol()
  scopes = ['...']
  con = Connection(('client_id', 'client_secret'), scopes=scopes)

  message = Message(con=con, protocol=protocol)

  mailbox = MailBox(con=con, protocol=protocol)
  message2 = Message(parent=mailbox)  # message will inherit the connection and protocol from mailbox when using parent.

  ```

  It's also easy to implement a custom Class.

  Just Inherit from `ApiComponent`, define the endpoints, and use the connection to make requests. If needed also inherit from Protocol to handle different comunications aspects with the API server.

  ```python
  from O365.utils import ApiComponent

  class CustomClass(ApiComponent):
      _endpoints = {'my_url_key': '/customendpoint'}

      def __init__(self, *, parent=None, con=None, **kwargs):
          
          self.con = parent.con if parent else con
          protocol = parent.protocol if parent else kwargs.get('protocol')
          main_resource = parent.main_resource

          super().__init__(protocol=protocol, main_resource=main_resource)
          

      def do_some_stuff(self):

          
          
          url = self.build_url(self._endpoints.get('my_url_key'))

          my_params = {'param1': 'param1'}

          response = self.con.get(url, params=my_params)  # note the use of the connection here.

          


  from O365 import Connection, MSGraphProtocol

  protocol = MSGraphProtocol()  # or maybe a user defined protocol
  con = Connection(('client_id', 'client_secret'), scopes=protocol.get_scopes_for(['...']))
  custom_class = CustomClass(con=con, protocol=protocol)

  custom_class.do_some_stuff()
  ```


  Mailbox groups the funcionality of both the messages and the email folders.

  These are the scopes needed to work with the `MailBox` and `Message` classes.

   Raw Scope                   |  Included in Scope Helper                  | Description
   :---:                       |  :---:                                     | ---
   *Mail.Read*                 |  *mailbox*                                 | To only read my mailbox
   *Mail.Read.Shared*          |  *mailbox_shared*                          | To only read another user / shared mailboxes
   *Mail.Send*                 |  *message_send, message_all*               | To only send message
   *Mail.Send.Shared*          |  *message_send_shared, message_all_shared* | To only send message as another user / shared mailbox
   *Mail.ReadWrite*            |  *message_all*                             | To read and save messages in my mailbox
   *MailboxSettings.ReadWrite* |  *mailbox_settings*                        | To read and write suer mailbox settings

  ```python
  mailbox = account.mailbox()

  inbox = mailbox.inbox_folder()

  for message in inbox.get_messages():
      print(message)

  sent_folder = mailbox.sent_folder()

  for message in sent_folder.get_messages():
      print(message)

  m = mailbox.new_message()

  m.to.add('to_example@example.com')
  m.body = 'George Best quote: In 1969 I gave up women and alcohol - it was the worst 20 minutes of my life.'
  m.save_draft()
  ```


  Represents a `Folder` within your email mailbox.

  You can get any folder in your mailbox by requesting child folders or filtering by name.

  ```python
  mailbox = account.mailbox()

  archive = mailbox.get_folder(folder_name='archive')  # get a folder with 'archive' name

  child_folders = archive.get_folders(25) # get at most 25 child folders of 'archive' folder

  for folder in child_folders:
      print(folder.name, folder.parent_id)

  new_folder = archive.create_child_folder('George Best Quotes')
  ```


  An email object with all its data and methods.

  Creating a draft message is as easy as this:
  ```python
  message = mailbox.new_message()
  message.to.add(['example1@example.com', 'example2@example.com'])
  message.sender.address = 'my_shared_account@example.com'  # changing the from address
  message.body = 'George Best quote: I might go to Alcoholics Anonymous, but I think it would be difficult for me to remain anonymous'
  message.attachments.add('george_best_quotes.txt')
  message.save_draft()  # save the message on the cloud as a draft in the drafts folder
  ```

  Working with saved emails is also easy:
  ```python
  query = mailbox.new_query().on_attribute('subject').contains('george best')  # see Query object in Utils
  messages = mailbox.get_messages(limit=25, query=query)

  message = messages[0]  # get the first one

  message.mark_as_read()
  reply_msg = message.reply()

  if 'example@example.com' in reply_msg.to:  # magic methods implemented
      reply_msg.body = 'George Best quote: I spent a lot of money on booze, birds and fast cars. The rest I just squandered.'
  else:
      reply_msg.body = 'George Best quote: I used to go missing a lot... Miss Canada, Miss United Kingdom, Miss World.'

  reply_msg.send()
  ```


  You can send inline images by doing this:

  ```python

  msg = account.new_message()
  msg.to.add('george@best.com')
  msg.attachments.add('my_image.png')
  att = msg.attachments[0]  # get the attachment object


  att.is_inline = True
  att.content_id = 'image.png'


  body = """
      <html>
          <body>
              <strong>There should be an image here:</strong>
              <p>
                  <img src="cid:image.png">
              </p>
          </body>
      </html>
      """
  msg.body = body
  msg.send()
  ```


  You can retrieve message headers by doing this:

  ```python

  mb = account.mailbox()
  msg = mb.get_message(query=mb.q().select('internet_message_headers'))
  print(msg.message_headers)  # returns a list of dicts.
  ```

  Note that only message headers and other properties added to the select statement will be present.


  Messages and attached messages can be saved as *.eml.

   - Save message as "eml":
      ```python
          msg.save_as_eml(to_path=Path('my_saved_email.eml'))
      ```
  - Save attached message as "eml":

      Carefull: there's no way to identify that an attachment is in fact a message. You can only check if the attachment.attachment_type == 'item'.
      if is of type "item" then it can be a message (or an event, etc...). You will have to determine this yourself.

      ```python
          msg_attachment = msg.attachments[0]  # the first attachment is attachment.attachment_type == 'item' and I know it's a message.
          msg.attachments.save_as_eml(msg_attachment, to_path=Path('my_saved_email.eml'))
      ```


  The mailbox settings and associated methods.

  Retrieve and update mailbox auto reply settings:
  ```python
  from O365.mailbox import AutoReplyStatus, ExternalAudience

  mailboxsettings = mailbox.get_settings()
  ars = mailboxsettings.automaticrepliessettings

  ars.scheduled_startdatetime = start # Sets the start date/time
  ars.scheduled_enddatetime = end # Sets the end date/time
  ars.status = AutoReplyStatus.SCHEDULED # DISABLED/SCHEDULED/ALWAYSENABLED - Uses start/end date/time if scheduled.
  ars.external_audience = ExternalAudience.NONE # NONE/CONTACTSONLY/ALL
  ars.internal_reply_message = "ARS Internal" # Internal message
  ars.external_reply_message = "ARS External" # External message
  mailboxsettings.save()
  ```

  Alternatively to enable and disable
  ```python
  mailboxsettings.save()

  mailbox.set_automatic_reply(
      "Internal",
      "External",
      scheduled_start_date_time=start, # Status will be 'scheduled' if start/end supplied, otherwise 'alwaysEnabled'
      scheduled_end_date_time=end,
      externalAudience=ExternalAudience.NONE, # Defaults to ALL
  )
  mailbox.set_disable_reply()
  ```


  AddressBook groups the functionality of both the Contact Folders and Contacts. Outlook Distribution Groups are not supported (By the Microsoft API's).

  These are the scopes needed to work with the `AddressBook` and `Contact` classes.

   Raw Scope                       |  Included in Scope Helper                        | Description
   :---:                           |  :---:                                          | ---
   *Contacts.Read*                 |  *address_book*                                 | To only read my personal contacts
   *Contacts.Read.Shared*          |  *address_book_shared*                          | To only read another user / shared mailbox contacts
   *Contacts.ReadWrite*            |  *address_book_all*                             | To read and save personal contacts
   *Contacts.ReadWrite.Shared*     |  *address_book_all_shared*                      | To read and save contacts from another user / shared mailbox
   *User.ReadBasic.All*            |  *users*                                        | To only read basic properties from users of my organization (User.Read.All requires administrator consent).


  Represents a Folder within your Contacts Section in Office 365.
  AddressBook class represents the parent folder (it's a folder itself).

  You can get any folder in your address book by requesting child folders or filtering by name.

  ```python
  address_book = account.address_book()

  contacts = address_book.get_contacts(limit=None)  # get all the contacts in the Personal Contacts root folder

  work_contacts_folder = address_book.get_folder(folder_name='Work Contacts')  # get a folder with 'Work Contacts' name

  message_to_all_contats_in_folder = work_contacts_folder.new_message()  # creates a draft message with all the contacts as recipients

  message_to_all_contats_in_folder.subject = 'Hallo!'
  message_to_all_contats_in_folder.body = """
  George Best quote:

  If you'd given me the choice of going out and beating four men and smashing a goal in
  from thirty yards against Liverpool or going to bed with Miss World,
  it would have been a difficult choice. Luckily, I had both.
  """
  message_to_all_contats_in_folder.send()


  child_folders = address_book.get_folders(25) # get at most 25 child folders

  for folder in child_folders:
      print(folder.name, folder.parent_id)


  address_book.create_child_folder('new folder')
  ```


  Office 365 API (Nor MS Graph API) has no concept such as the Outlook Global Address List.
  However you can use the [Users API](https://developer.microsoft.com/en-us/graph/docs/api-reference/v1.0/resources/users) to access all the users within your organization.

  Without admin consent you can only access a few properties of each user such as name and email and litte more.
  You can search by name or retrieve a contact specifying the complete email.

  - Basic Permision needed is Users.ReadBasic.All (limit info)
  - Full Permision is Users.Read.All but needs admin consent.

  To search the Global Address List (Users API):

  ```python
  global_address_list = account.directory()





  q = global_address_list.new_query('display_name')
  q.startswith('George Best')

  for user in global_address_list.get_users(query=q):
      print(user)
  ```


  To retrieve a contact by their email:

  ```python
  contact = global_address_list.get_user('example@example.com')
  ```


  Everything returned from an `AddressBook` instance is a `Contact` instance.
  Contacts have all the information stored as attributes

  Creating a contact from an `AddressBook`:

  ```python
  new_contact = address_book.new_contact()

  new_contact.name = 'George Best'
  new_contact.job_title = 'football player'
  new_contact.emails.add('george@best.com')

  new_contact.save()  # saved on the cloud

  message = new_contact.new_message()  #  Bonus: send a message to this contact



  new_contact.delete()  # Bonus: deteled from the cloud
  ```



  The Directory object can retrieve users.

  A User instance contains by default the [basic properties of the user](https://docs.microsoft.com/en-us/graph/api/user-list?view=graph-rest-1.0&tabs=http#optional-query-parameters).
  If you want to include more, you will have to select the desired properties manually.

  Check [The Global Address List](#the-global-address-list) for further information.

  ```python
  directory = account.directory()
  for user in directory.get_users():
      print(user)
  ```



  The calendar and events functionality is group in a `Schedule` object.

  A `Schedule` instance can list and create calendars. It can also list or create events on the default user calendar.
  To use other calendars use a `Calendar` instance.

  These are the scopes needed to work with the `Schedule`, `Calendar` and `Event` classes.

   Raw Scope                        |  Included in Scope Helper                        | Description
   :---:                            |  :---:                                          | ---
   *Calendars.Read*                 |  *calendar*                                     | To only read my personal calendars
   *Calendars.Read.Shared*          |  *calendar_shared*                              | To only read another user / shared mailbox calendars
   *Calendars.ReadWrite*            |  *calendar_all*                                 | To read and save personal calendars
   *Calendars.ReadWrite.Shared*     |  *calendar_shared_all*                          | To read and save calendars from another user / shared mailbox


  Working with the `Schedule` instance:
  ```python
  import datetime as dt


  schedule = account.schedule()

  calendar = schedule.get_default_calendar()
  new_event = calendar.new_event()  # creates a new unsaved event
  new_event.subject = 'Recruit George Best!'
  new_event.location = 'England'




  new_event.start = dt.datetime(2019, 9, 5, 19, 45)


  new_event.recurrence.set_daily(1, end=dt.datetime(2019, 9, 10))
  new_event.remind_before_minutes = 45

  new_event.save()
  ```

  Working with `Calendar` instances:

  ```python
  calendar = schedule.get_calendar(calendar_name='Birthdays')

  calendar.name = 'Football players birthdays'
  calendar.update()

  q = calendar.new_query('start').greater_equal(dt.datetime(2018, 5, 20))
  q.chain('and').on_attribute('end').less_equal(dt.datetime(2018, 5, 24))

  birthdays = calendar.get_events(query=q, include_recurring=True)  # include_recurring=True will include repeated events on the result set.

  for event in birthdays:
      if event.subject == 'George Best Birthday':
          
          event.accept("I'll attend!")  # send a response accepting
      else:
          event.decline("No way I'm comming, I'll be in Spain", send_response=False)  # decline the event but don't send a reponse to the organizer
  ```



  1. Include_recurring=True:
      > It's important to know that when querying events with `include_recurring=True` (which is the default), it is required that you must provide a query parameter with the start and end attributes defined.
      > Unlike when using `include_recurring=False` those attributes will NOT filter the data based on the operations you set on the query (greater_equal, less, etc.) but just filter the events start datetime between the provided start and end datetimes.

  1. Shared Calendars:

      There are some known issues when working with [shared calendars](https://docs.microsoft.com/en-us/graph/known-issues#calendars) in Microsoft Graph.

  1. Event attachments:

      For some unknow reason, microsoft does not allow to upload an attachment at the event creation time (as opposed with message attachments).
      See [this](https://stackoverflow.com/questions/46438302/office365-rest-api-creating-a-calendar-event-with-attachments?rq=1).
      So, to upload attachments to Events, first save the event, then attach the message and save again.



  The tasks functionality is grouped in a `ToDo` object.

  A `ToDo` instance can list and create task folders. It can also list or create tasks on the default user folder. To use other folders use a `Folder` instance.

  These are the scopes needed to work with the `ToDo`, `Folder` and `Task` classes.

   Raw Scope                        |  Included in Scope Helper                       | Description
   :---:                            |  :---:                                          | ---
   *Tasks.Read*                     |  *tasks*                                        | To only read my personal tasks
   *Tasks.ReadWrite*                |  *tasks_all*                                    | To read and save personal calendars

   Working with the `ToDo` instance:
  ```python
  import datetime as dt


  todo = account.tasks()


  folder = todo.get_default_folder()
  new_task = folder.new_task()  # creates a new unsaved task
  new_task.subject = 'Send contract to George Best'
  new_task.due = dt.datetime(2020, 9, 25, 18, 30)
  new_task.save()



  new_task.mark_completed()
  new_task.save()





  ```

  Working with `Folder` instances:

  ```python

  new_folder = todo.new_folder('Defenders')


  folder = todo.get_folder(folder_name='Strikers')
  folder.name = 'Forwards'
  folder.update()


  task_list = folder.get_tasks()
  for task in task_list:
      print(task)
      print('')
  ```


  The `Storage` class handles all functionality around One Drive and Document Library Storage in SharePoint.

  The `Storage` instance allows to retrieve `Drive` instances which handles all the Files and Folders from within the selected `Storage`.
  Usually you will only need to work with the default drive. But the `Storage` instances can handle multiple drives.

  A `Drive` will allow you to work with Folders and Files.

  These are the scopes needed to work with the `Storage`, `Drive` and `DriveItem` classes.

   Raw Scope                  |  Included in Scope Helper     | Description
   :---:                      |  :---:                       | ---
   *Files.Read*               |                              | To only read my files
   *Files.Read.All*           |  *onedrive*                  | To only read all the files the user has access
   *Files.ReadWrite*          |                              | To read and save my files
   *Files.ReadWrite.All*      |  *onedrive_all*              | To read and save all the files the user has access


  ```python
  account = Account(credentials=my_credentials)

  storage = account.storage()  # here we get the storage instance that handles all the storage options.


  drives = storage.get_drives()


  my_drive = storage.get_default_drive()  # or get_drive('drive-id')


  root_folder = my_drive.get_root_folder()
  attachments_folder = my_drive.get_special_folder('attachments')


  for item in root_folder.get_items(limit=25):
      if item.is_folder:
          print(list(item.get_items(2)))  # print the first to element on this folder.
      elif item.is_file:
          if item.is_photo:
              print(item.camera_model)  # print some metadata of this photo
          elif item.is_image:
              print(item.dimensions)  # print the image dimensions
          else:
              
              print(item.mime_type)  # print the mime type
  ```

  Both Files and Folders are DriveItems. Both Image and Photo are Files, but Photo is also an Image. All have some different methods and properties.
  Take care when using 'is_xxxx'.

  When copying a DriveItem the api can return a direct copy of the item or a pointer to a resource that will inform on the progress of the copy operation.

  ```python


  documents_folder = my_drive.get_special_folder('documents')

  files = my_drive.search('george best quotes', limit=1)

  if files:
      george_best_quotes = files[0]
      operation = george_best_quotes.copy(target=documents_folder)  # operation here is an instance of CopyOperation

      
      
      for status, progress in operation.check_status():  # if it's an async operations, this will request to the api for the status in every loop
          print('{} - {}'.format(status, progress))  # prints 'in progress - 77.3' until finally completed: 'completed - 100.0'
      copied_item = operation.get_item()  # the copy operation is completed so you can get the item.
      if copied_item:
          copied_item.delete()  # ... oops!
  ```

  You can also work with share permissions:

  ```python
  current_permisions = file.get_permissions()  # get all the current permissions on this drive_item (some may be inherited)


  permission = file.share_with_link(share_type='edit')
  if permission:
      print(permission.share_link)  # the link you can use to share this drive item

  permission = file.share_with_invite(recipients='george_best@best.com', send_email=True, message='Greetings!!', share_type='edit')
  if permission:
      print(permission.granted_to)  # the person you share this item with
  ```

  You can also:
  ```python

  file.download(to_path='/quotes/')





  uploaded_file = folder.upload_file(item='path_to_my_local_file')


  versions = file.get_versions()
  for version in versions:
      if version.name == '2.0':
          version.restore()  # restore the version 2.0 of this file


  ```



  You can interact with new excel files (.xlsx) stored in OneDrive or a SharePoint Document Library.
  You can retrieve workbooks, worksheets, tables, and even cell data.
  You can also write to any excel online.

  To work with excel files, first you have to retrieve a `File` instance using the OneDrive or SharePoint functionallity.

  The scopes needed to work with the `WorkBook` and Excel related classes are the same used by OneDrive.

  This is how you update a cell value:

  ```python
  from O365.excel import WorkBook


  excel_file = WorkBook(my_file_instance)  # my_file_instance should be an instance of File.

  ws = excel_file.get_worksheet('my_worksheet')
  cella1 = ws.get_range('A1')
  cella1.values = 35
  cella1.update()
  ```


  When interacting with excel, you can use a workbook session to efficiently make changes in a persistent or nonpersistent way.
  This sessions become usefull if you perform numerous changes to the excel file.

  The default is to use a session in a persistent way.
  Sessions expire after some time of inactivity. When working with persistent sessions, new sessions will automatically be created when old ones expire.

  You can however change this when creating the `Workbook` instance:

  ```python
  excel_file = WorkBook(my_file_instance, use_session=False, persist=False)
  ```



  After creating the `WorkBook` instance you will have access to the following objects:

  - WorkSheet
  - Range and NamedRange
  - Table, TableColumn and TableRow
  - RangeFormat (to format ranges)
  - Charts (not available for now)

  Some examples:

  Set format for a given range
  ```python

  my_range = ws.get_range('B2:C10')
  fmt = myrange.get_format()
  fmt.font.bold = True
  fmt.update()
  ```
  Autofit Columns:
  ```python
  ws.get_range('B2:C10').get_format().auto_fit_columns()
  ```

  Get values from Table:
  ```python
  table = ws.get_table('my_table')
  column = table.get_column_at_index(1)
  values = column.values[0]  # values returns a two dimensional array.
  ```


  The SharePoint api is done but there are no docs yet. Look at the sharepoint.py file to get insights.

  These are the scopes needed to work with the `SharePoint` and `Site` classes.

   Raw Scope                  |  Included in Scope Helper    | Description
   :---:                      |  :---:                       | ---
   *Sites.Read.All*           |  *sharepoint*                | To only read sites, lists and items
   *Sites.ReadWrite.All*      |  *sharepoint_dl*             | To read and save sites, lists and items


  The planner api is done but there are no docs yet. Look at the planner.py file to get insights.

  The planner functionality requires Administrator Permission.


  You can retrive, update, create and delete outlook categories.
  These categories can be used to categorize Messages, Events and Contacts.

  These are the scopes needed to work with the `SharePoint` and `Site` classes.

   Raw Scope                      |  Included in Scope Helper     | Description
   :---:                          |  :---:                        | ---
   *MailboxSettings.Read*         |  *-*                          | To only read outlook settingss
   *MailboxSettings.ReadWrite*    |  *settings_all*               | To read and write outlook settings

  Example:

  ```python
  from O365.category import CategoryColor

  oc = account.outlook_categories()
  categories = oc.get_categories()
  for category in categories:
      print(category.name, category.color)

  my_category = oc.create_category('Important Category', color=CategoryColor.RED)
  my_category.update_color(CategoryColor.DARKGREEN)

  my_category.delete()  # oops!
  ```





  When using certain methods, it is possible that you request more items than the api can return in a single api call.
  In this case the Api, returns a "next link" url where you can pull more data.

  When this is the case, the methods in this library will return a `Pagination` object which abstracts all this into a single iterator.
  The pagination object will request "next links" as soon as they are needed.

  For example:

  ```python
  mailbox = account.mailbox()

  messages = mailbox.get_messages(limit=1500)  # the Office 365 and MS Graph API have a 999 items limit returned per api call.







  for message in messages:
      print(message.subject)
  ```

  When using certain methods you will have the option to specify not only a limit option (the number of items to be returned) but a batch option.
  This option will indicate the method to request data to the api in batches until the limit is reached or the data consumed.
  This is usefull when you want to optimize memory or network latency.

  For example:

  ```python
  messages = mailbox.get_messages(limit=100, batch=25)




  for message in messages:  # 100 loops with 4 requests to the api server
      print(message.subject)
  ```



  When using the Office 365 API you can filter, order, select, expand or search on some fields.
  This filtering is tedious as is using [Open Data Protocol (OData)](http://docs.oasis-open.org/odata/odata/v4.0/errata03/os/complete/part2-url-conventions/odata-v4.0-errata03-os-part2-url-conventions-complete.html).

  Every `ApiComponent` (such as `MailBox`) implements a new_query method that will return a `Query` instance.
  This `Query` instance can handle the filtering, sorting, selecting, expanding and search very easily.

  For example:

  ```python
  query = mailbox.new_query()  # you can use the shorthand: mailbox.q()

  query = query.on_attribute('subject').contains('george best').chain('or').startswith('quotes')




  query = query.chain('and').on_attribute('created_date_time').greater(datetime(2018, 3, 21))

  print(query)





  filtered_messages = mailbox.get_messages(query=query)
  ```

  You can also specify specific data to be retrieved with "select":

  ```python

  query = mailbox.new_query().select('subject', 'to_recipients', 'created_date_time')

  messages_with_selected_properties = mailbox.get_messages(query=query)
  ```

  You can also search content. As said in the graph docs:

  > You can currently search only message and person collections. A $search request returns up to 250 results. You cannot use $filter or $orderby in a search request.

  > If you do a search on messages and specify only a value without specific message properties, the search is carried out on the default search properties of from, subject, and body.

  ```python

  query = mailbox.q().search('george best is da boss')
  messages = mailbox.get_messages(query=query)
  ```



  Whenever a Request error raises, the connection object will raise an exception.
  Then the exception will be captured and logged it to the stdout with it's message, an return Falsy (None, False, [], etc...)

  HttpErrors 4xx (Bad Request) and 5xx (Internal Server Error) are considered exceptions and raised also by the connection.
  You can tell the `Connection` to not raise http errors by passing `raise_http_errors=False` (defaults to True).


pkgId: 90cfd5ba6a5cffdcb45e0d20cf8352e5963e338aa4e945e8e88c1ddced635570
name: python-OSGridConverter
arch: src
version: 0.1.3
epoch: 0
release: 1
url: https://github.com/....
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-152dc9fc-c968-46e8-86ef-d0306fe6bba4
location_href: 00011726-python-osgridconverter/python-OSGridConverter-0.1.3-1.src.rpm
checksum_type: sha256
summary:
  Library to convert co-ordinates between the (UK) Ordnance Survey National Grid and latitude/longitude


pkgId: 2077baca68fde8b1d544fe199de45e1c313b01aaf1d22e27d1a486c9b874ebd8
name: python-OWSLib
arch: src
version: 0.28.1
epoch: 0
release: 1
summary: OGC Web Service utility library
url: https://geopython.github.io/OWSLib
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-03482871-9c20-44f1-9e3f-4c93ba750553
location_href: 00002865-python-OWSLib/python-OWSLib-0.28.1-1.src.rpm
checksum_type: sha256
description:
  OWSLib is a Python package for client programming with Open Geospatial
  Consortium (OGC) web service (hence OWS) interface standards, and their
  related content models.
  Full documentation is available at http://geopython.github.io/OWSLib
  OWSLib provides a common API for accessing service metadata and wrappers for
  numerous OGC Web Service interfaces.


pkgId: 8d7c0cd2c0558f856e8c9e18539351b9254cc125b3553e2a771c9c1ac8a2c8e6
name: python-Office365-REST-Python-Client
arch: src
version: 2.4.0
epoch: 0
release: 1
summary: Microsoft 365 & Microsoft Graph Library for Python
url: https://github.com/vgrem/Office365-REST-Python-Client
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-822a9a99-c090-459c-9e05-d398938c3e30
location_href: 00009995-python-office365-rest-python-client/python-Office365-REST-Python-Client-2.4.0-1.src.rpm
checksum_type: sha256
description:
  Office 365 & Microsoft Graph library for Python



  1. [Installation](#Installation)
  2. [Working with SharePoint API](#Working-with-SharePoint-API)
  3. [Working with Outlook API](#Working-with-Outlook-API)
  4. [Working with OneDrive API](#Working-with-OneDrive-API)
  5. [Working with Teams API](#Working-with-Microsoft-Teams-API)
  6. [Working with OneNote API](#Working-with-Microsoft-OneNote-API)
  7. [Working with Planner API](#Working-with-Microsoft-Planner-API)


  [![Downloads](https://pepy.tech/badge/office365-rest-python-client/month)](https://pepy.tech/project/office365-rest-python-client)
  [![PyPI](https://img.shields.io/pypi/v/Office365-REST-Python-Client.svg)](https://pypi.python.org/pypi/Office365-REST-Python-Client)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/Office365-REST-Python-Client.svg)](https://pypi.python.org/pypi/Office365-REST-Python-Client/)
  [![Build Status](https://travis-ci.com/vgrem/Office365-REST-Python-Client.svg?branch=master)](https://travis-ci.com/vgrem/Office365-REST-Python-Client)



  Use pip:

  ```
  pip install Office365-REST-Python-Client
  ```


  >

  >Alternatively the _latest_ version could be directly installed via GitHub:
  >```
  >pip install git+https://github.com/vgrem/Office365-REST-Python-Client.git
  >```


  For the following examples, relevant credentials can be found in the Azure Portal.

  Steps to access:
  1. Login to the home page of the Azure Portal
  2. Navigate to "Azure Active Directory" using the three bars in the top right corner of the portal
  3. Select "App registrations" in the navigation panel on the left
  4. Search for and select your relevant application
  5. In the application's "Overview" page, the client id can be found under "Application (client) id"
  6. In the application's "Certificates & Secrets" page, the client secret can be found under the "Value" of the "Client Secrets." If there is no client secret yet, create one here.



  The list of supported API versions:
  -   [SharePoint 2013 REST API](https://msdn.microsoft.com/en-us/library/office/jj860569.aspx) and above
  -   SharePoint Online & OneDrive for Business REST API



  The following auth flows are supported:

  - app principals flow:
    `ClientContext.with_credentials(client_credentials)`

    Usage:
    ```
    client_credentials = ClientCredential('{client_id}','{client_secret}')
    ctx = ClientContext('{url}').with_credentials(client_credentials)
    ```
    Documentation: refer [Granting access using SharePoint App-Only](https://docs.microsoft.com/en-us/sharepoint/dev/solution-guidance/security-apponly-azureacs) for a details

    Example: [connect_with_app_principal.py](examples/sharepoint/connect_with_app_only_principal.py)

  - user credentials flow: `ClientContext.with_credentials(user_credentials)`

    Usage:
    ```
    user_credentials = UserCredential('{username}','{password}')
    ctx = ClientContext('{url}').with_credentials(user_credentials)
    ```
    Example: [connect_with_user_credential.py](examples/sharepoint/connect_with_user_credential.py)

  - certificate credentials flow: `ClientContext.with_certificate(tenant, client_id, thumbprint, cert_path)`

    Documentation: [Granting access via Azure AD App-Only](https://docs.microsoft.com/en-us/sharepoint/dev/solution-guidance/security-apponly-azuread)

    Example: [connect_with_client_certificate.py](examples/sharepoint/connect_with_client_certificate.py)



  There are **two approaches** available to perform API queries:

  1. `ClientContext class` - where you target SharePoint resources such as `Web`, `ListItem` and etc (recommended)

  ```python
  from office365.runtime.auth.user_credential import UserCredential
  from office365.sharepoint.client_context import ClientContext
  site_url = "https://{your-tenant-prefix}.sharepoint.com"
  ctx = ClientContext(site_url).with_credentials(UserCredential("{username}", "{password}"))
  web = ctx.web
  ctx.load(web)
  ctx.execute_query()
  print("Web title: {0}".format(web.properties['Title']))
  ```
  or alternatively via method chaining (a.k.a Fluent Interface):

  ```python
  from office365.runtime.auth.user_credential import UserCredential
  from office365.sharepoint.client_context import ClientContext
  site_url = "https://{your-tenant-prefix}.sharepoint.com"
  ctx = ClientContext(site_url).with_credentials(UserCredential("{username}", "{password}"))
  web = ctx.web.get().execute_query()
  print("Web title: {0}".format(web.properties['Title']))
  ```


  2. `RequestOptions class` - where you construct REST queries (and no model is involved)

     The example demonstrates how to read `Web` properties:

  ```python
  import json
  from office365.runtime.auth.user_credential import UserCredential
  from office365.runtime.http.request_options import RequestOptions
  from office365.sharepoint.client_context import ClientContext
  site_url = "https://{your-tenant-prefix}.sharepoint.com"
  ctx = ClientContext(site_url).with_credentials(UserCredential("{username}", "{password}"))
  request = RequestOptions("{0}/_api/web/".format(site_url))
  response = ctx.pending_request().execute_request_direct(request)
  json = json.loads(response.content)
  web_title = json['d']['Title']
  print("Web title: {0}".format(web_title))
  ```


  The list of examples:

  - Working with files
    - [download a file](examples/sharepoint/files/download_file.py)
    - [upload a file](examples/sharepoint/files/upload_file.py)

  - Working with lists and list items
    -  [create a list item](examples/sharepoint/lists/data_generator.py)
    -  [read a list item](examples/sharepoint/lists/read_large_list.py)
    -  [update a list item](examples/sharepoint/listitems/update_items_batch.py)
    -  [delete a list item](examples/sharepoint/listitems/delete_list_item.py)

  Refer [examples section](examples/sharepoint) for another scenarios



  The list of supported APIs:
  -   [Outlook Contacts REST API](https://msdn.microsoft.com/en-us/office/office365/api/contacts-rest-operations)
  -   [Outlook Calendar REST API](https://msdn.microsoft.com/en-us/office/office365/api/calendar-rest-operations)
  -   [Outlook Mail REST API](https://msdn.microsoft.com/en-us/office/office365/api/mail-rest-operations)


  Since Outlook REST APIs are available in both Microsoft Graph and the Outlook API endpoint,
  the following clients are available:

  - `GraphClient` which targets Outlook API `v2.0` version (*preferable* nowadays, refer [transition to Microsoft Graph-based Outlook REST API](https://docs.microsoft.com/en-us/outlook/rest/compare-graph-outlook) for a details)
  ~~- `OutlookClient` which targets Outlook API `v1.0` version (not recommended for usage since `v1.0` version is being deprecated.)~~




  [The Microsoft Authentication Library (MSAL) for Python](https://pypi.org/project/msal/) which comes as a dependency
  is used as a default library to obtain tokens to call Microsoft Graph API.

  Using [Microsoft Authentication Library (MSAL) for Python](https://pypi.org/project/msal/)

  > Note: access token is getting acquired via [Client Credential flow](https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-client-creds-grant-flow)
  > in the provided examples. Other forms of token aquisition can be found here: https://msal-python.readthedocs.io/en/latest/

  ```python
  import msal
  from office365.graph_client import GraphClient

  def acquire_token():
      """
      Acquire token via MSAL
      """
      authority_url = 'https://login.microsoftonline.com/{tenant_id_or_name}'
      app = msal.ConfidentialClientApplication(
          authority=authority_url,
          client_id='{client_id}',
          client_credential='{client_secret}'
      )
      token = app.acquire_token_for_client(scopes=["https://graph.microsoft.com/.default"])
      return token


  client = GraphClient(acquire_token)

  ```

  But in terms of Microsoft Graph API authentication, another OAuth spec compliant libraries
  such as [adal](https://github.com/AzureAD/azure-activedirectory-library-for-python)
  are supported as well.

  Using [ADAL Python](https://adal-python.readthedocs.io/en/latest/#)

  Usage

  ```python
  import adal
  from office365.graph_client import GraphClient

  def acquire_token_func():
      authority_url = 'https://login.microsoftonline.com/{tenant_id_or_name}'
      auth_ctx = adal.AuthenticationContext(authority_url)
      token = auth_ctx.acquire_token_with_client_credentials(
          "https://graph.microsoft.com",
          "{client_id}",
          "{client_secret}")
      return token

  client = GraphClient(acquire_token_func)

  ```



  The example demonstrates how to send an email via [Microsoft Graph endpoint](https://docs.microsoft.com/en-us/graph/api/user-sendmail?view=graph-rest-1.0&tabs=http).

  > Note: access token is getting acquired  via [Client Credential flow](https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-client-creds-grant-flow)

  ```python
  from office365.graph_client import GraphClient

  client = GraphClient(acquire_token_func)

  client.me.send_mail(
      subject="Meet for lunch?",
      body="The new cafeteria is open.",
      to_recipients=["fannyd@contoso.onmicrosoft.com"]
  ).execute_query()

  ```

  > How to enable sending emails on behalf of another user in your organization: https://learn.microsoft.com/en-us/microsoft-365/solutions/allow-members-to-send-as-or-send-on-behalf-of-group?view=o365-worldwide&viewFallbackFrom=o365-worldwide%3FWT.mc_id%3D365AdminCSH_globalsearch

  Additional examples:

  -  [download a message](examples/outlook/download_messages.py)
  -  [list messages](examples/outlook/list_message.py)
  -  [move messages to a different folder](examples/outlook/move_message.py)
  -  [search messages](examples/outlook/search_message.py)
  -  [send messages](examples/outlook/send_message.py)
  -  [send messages with attachments](examples/outlook/send_message_with_attachment.py)

  Refer to [examples section](examples/outlook) for other scenarios






  [OneDrive Graph API reference](https://docs.microsoft.com/en-us/graph/api/resources/onedrive?view=graph-rest-1.0)



  [The Microsoft Authentication Library (MSAL) for Python](https://pypi.org/project/msal/) which comes as a dependency
  is used to obtain token

  ```python
  import msal

  def acquire_token_func():
      """
      Acquire token via MSAL
      """
      authority_url = 'https://login.microsoftonline.com/{tenant_id_or_name}'
      app = msal.ConfidentialClientApplication(
          authority=authority_url,
          client_id='{client_id}',
          client_credential='{client_secret}'
      )
      token = app.acquire_token_for_client(scopes=["https://graph.microsoft.com/.default"])
      return token
  ```






  The example demonstrates how to enumerate and print drive's url
  which corresponds to [`list available drives` endpoint](https://docs.microsoft.com/en-us/onedrive/developer/rest-api/api/drive_list?view=odsp-graph-online)

  > Note: access token is getting acquired  via [Client Credential flow](https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-client-creds-grant-flow)

  ```python
  from office365.graph_client import GraphClient

  tenant_name = "contoso.onmicrosoft.com"
  client = GraphClient(acquire_token_func)
  drives = client.drives.get().execute_query()
  for drive in drives:
      print("Drive url: {0}".format(drive.web_url))
  ```




  ```python
  from office365.graph_client import GraphClient
  client = GraphClient(acquire_token_func)

  drive = client.users["{user_id_or_principal_name}"].drive.get().execute_query()

  with tempfile.TemporaryDirectory() as path:
      download_files(drive.root, path)
  ```

  where

  ```python
  def download_files(remote_folder, local_path):
      drive_items = remote_folder.children.get().execute_query()
      for drive_item in drive_items:
          if drive_item.file is not None:  # is file?
              
              with open(os.path.join(local_path, drive_item.name), 'wb') as local_file:
                  drive_item.download(local_file).execute_query()
  ```

  Additional examples:

  -  [create list column](examples/onedrive/create_list_column.py)
  -  [download file](examples/onedrive/download_file_default.py)
  -  [export files](examples/onedrive/export_files.py)
  -  [import files](examples/onedrive/import_files.py)
  -  [list drives](examples/onedrive/list_drives.py)
  -  [list files](examples/onedrive/list_files.py)

  Refer to [OneDrive examples section](examples/onedrive) for more examples.






  [The Microsoft Authentication Library (MSAL) for Python](https://pypi.org/project/msal/) which comes as a dependency
  is used to obtain token





  The example demonstrates how create a new team under a group
  which corresponds to [`Create team` endpoint](https://docs.microsoft.com/en-us/graph/api/team-put-teams?view=graph-rest-1.0&tabs=http)

  ```python
  from office365.graph_client import GraphClient
  client = GraphClient(acquire_token_func)
  new_team = client.groups["{group_id}"].add_team().execute_query_retry()
  ```

  Additional examples:

  -  [create a team](examples/teams/create_team.py)
  -  [create team from group](examples/teams/create_team_from_group.py)
  -  [list all teams](examples/teams/list_all_teams.py)
  -  [list my teams](examples/teams/list_my_teams.py)
  -  [send messages](examples/teams/send_message.py)

  Refer to [examples section](examples/teams) for other scenarios



  The library supports OneNote API in terms of calls to a user's OneNote notebooks, sections, and pages in a personal or organization account

  Example: Create a new page

  ```python
  from office365.graph_client import GraphClient
  client = GraphClient(acquire_token_func)

  files = {}
  with open("./MyPage.html", 'rb') as f, \
      open("./MyImage.png", 'rb') as img_f, \
      open("./MyDoc.pdf", 'rb') as pdf_f:
      files["imageBlock1"] = img_f
      files["fileBlock1"] = pdf_f
      page = client.me.onenote.pages.add(presentation_file=f, attachment_files=files).execute_query()
  ```



  The example demonstrates how to create a new planner task
  which corresponds to [`Create plannerTask` endpoint](https://docs.microsoft.com/en-us/graph/api/planner-post-tasks?view=graph-rest-1.0):

  ```python
  from office365.graph_client import GraphClient

  client = GraphClient(acquire_token_func)
  task = client.planner.tasks.add(title="New task", planId="--plan id goes here--").execute_query()
  ```


  The following libraries will be installed when you install the client library:
  * [requests](https://github.com/kennethreitz/requests)
  * [Microsoft Authentication Library (MSAL) for Python](https://pypi.org/project/msal/)


pkgId: 840a08f10b2c55b9c86d8a30bf294e1e37fb0ffd66ab8223b208378104b07d44
name: python-Office365-REST-Python-Client-help
arch: noarch
version: 2.4.0
epoch: 0
release: 1
summary: Development documents and examples for Office365-REST-Python-Client
url: https://github.com/vgrem/Office365-REST-Python-Client
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-822a9a99-c090-459c-9e05-d398938c3e30
rpm_sourcerpm: python-Office365-REST-Python-Client-2.4.0-1.src.rpm
checksum_type: sha256
description:
  Office 365 & Microsoft Graph library for Python



  1. [Installation](#Installation)
  2. [Working with SharePoint API](#Working-with-SharePoint-API)
  3. [Working with Outlook API](#Working-with-Outlook-API)
  4. [Working with OneDrive API](#Working-with-OneDrive-API)
  5. [Working with Teams API](#Working-with-Microsoft-Teams-API)
  6. [Working with OneNote API](#Working-with-Microsoft-OneNote-API)
  7. [Working with Planner API](#Working-with-Microsoft-Planner-API)


  [![Downloads](https://pepy.tech/badge/office365-rest-python-client/month)](https://pepy.tech/project/office365-rest-python-client)
  [![PyPI](https://img.shields.io/pypi/v/Office365-REST-Python-Client.svg)](https://pypi.python.org/pypi/Office365-REST-Python-Client)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/Office365-REST-Python-Client.svg)](https://pypi.python.org/pypi/Office365-REST-Python-Client/)
  [![Build Status](https://travis-ci.com/vgrem/Office365-REST-Python-Client.svg?branch=master)](https://travis-ci.com/vgrem/Office365-REST-Python-Client)



  Use pip:

  ```
  pip install Office365-REST-Python-Client
  ```


  >

  >Alternatively the _latest_ version could be directly installed via GitHub:
  >```
  >pip install git+https://github.com/vgrem/Office365-REST-Python-Client.git
  >```


  For the following examples, relevant credentials can be found in the Azure Portal.

  Steps to access:
  1. Login to the home page of the Azure Portal
  2. Navigate to "Azure Active Directory" using the three bars in the top right corner of the portal
  3. Select "App registrations" in the navigation panel on the left
  4. Search for and select your relevant application
  5. In the application's "Overview" page, the client id can be found under "Application (client) id"
  6. In the application's "Certificates & Secrets" page, the client secret can be found under the "Value" of the "Client Secrets." If there is no client secret yet, create one here.



  The list of supported API versions:
  -   [SharePoint 2013 REST API](https://msdn.microsoft.com/en-us/library/office/jj860569.aspx) and above
  -   SharePoint Online & OneDrive for Business REST API



  The following auth flows are supported:

  - app principals flow:
    `ClientContext.with_credentials(client_credentials)`

    Usage:
    ```
    client_credentials = ClientCredential('{client_id}','{client_secret}')
    ctx = ClientContext('{url}').with_credentials(client_credentials)
    ```
    Documentation: refer [Granting access using SharePoint App-Only](https://docs.microsoft.com/en-us/sharepoint/dev/solution-guidance/security-apponly-azureacs) for a details

    Example: [connect_with_app_principal.py](examples/sharepoint/connect_with_app_only_principal.py)

  - user credentials flow: `ClientContext.with_credentials(user_credentials)`

    Usage:
    ```
    user_credentials = UserCredential('{username}','{password}')
    ctx = ClientContext('{url}').with_credentials(user_credentials)
    ```
    Example: [connect_with_user_credential.py](examples/sharepoint/connect_with_user_credential.py)

  - certificate credentials flow: `ClientContext.with_certificate(tenant, client_id, thumbprint, cert_path)`

    Documentation: [Granting access via Azure AD App-Only](https://docs.microsoft.com/en-us/sharepoint/dev/solution-guidance/security-apponly-azuread)

    Example: [connect_with_client_certificate.py](examples/sharepoint/connect_with_client_certificate.py)



  There are **two approaches** available to perform API queries:

  1. `ClientContext class` - where you target SharePoint resources such as `Web`, `ListItem` and etc (recommended)

  ```python
  from office365.runtime.auth.user_credential import UserCredential
  from office365.sharepoint.client_context import ClientContext
  site_url = "https://{your-tenant-prefix}.sharepoint.com"
  ctx = ClientContext(site_url).with_credentials(UserCredential("{username}", "{password}"))
  web = ctx.web
  ctx.load(web)
  ctx.execute_query()
  print("Web title: {0}".format(web.properties['Title']))
  ```
  or alternatively via method chaining (a.k.a Fluent Interface):

  ```python
  from office365.runtime.auth.user_credential import UserCredential
  from office365.sharepoint.client_context import ClientContext
  site_url = "https://{your-tenant-prefix}.sharepoint.com"
  ctx = ClientContext(site_url).with_credentials(UserCredential("{username}", "{password}"))
  web = ctx.web.get().execute_query()
  print("Web title: {0}".format(web.properties['Title']))
  ```


  2. `RequestOptions class` - where you construct REST queries (and no model is involved)

     The example demonstrates how to read `Web` properties:

  ```python
  import json
  from office365.runtime.auth.user_credential import UserCredential
  from office365.runtime.http.request_options import RequestOptions
  from office365.sharepoint.client_context import ClientContext
  site_url = "https://{your-tenant-prefix}.sharepoint.com"
  ctx = ClientContext(site_url).with_credentials(UserCredential("{username}", "{password}"))
  request = RequestOptions("{0}/_api/web/".format(site_url))
  response = ctx.pending_request().execute_request_direct(request)
  json = json.loads(response.content)
  web_title = json['d']['Title']
  print("Web title: {0}".format(web_title))
  ```


  The list of examples:

  - Working with files
    - [download a file](examples/sharepoint/files/download_file.py)
    - [upload a file](examples/sharepoint/files/upload_file.py)

  - Working with lists and list items
    -  [create a list item](examples/sharepoint/lists/data_generator.py)
    -  [read a list item](examples/sharepoint/lists/read_large_list.py)
    -  [update a list item](examples/sharepoint/listitems/update_items_batch.py)
    -  [delete a list item](examples/sharepoint/listitems/delete_list_item.py)

  Refer [examples section](examples/sharepoint) for another scenarios



  The list of supported APIs:
  -   [Outlook Contacts REST API](https://msdn.microsoft.com/en-us/office/office365/api/contacts-rest-operations)
  -   [Outlook Calendar REST API](https://msdn.microsoft.com/en-us/office/office365/api/calendar-rest-operations)
  -   [Outlook Mail REST API](https://msdn.microsoft.com/en-us/office/office365/api/mail-rest-operations)


  Since Outlook REST APIs are available in both Microsoft Graph and the Outlook API endpoint,
  the following clients are available:

  - `GraphClient` which targets Outlook API `v2.0` version (*preferable* nowadays, refer [transition to Microsoft Graph-based Outlook REST API](https://docs.microsoft.com/en-us/outlook/rest/compare-graph-outlook) for a details)
  ~~- `OutlookClient` which targets Outlook API `v1.0` version (not recommended for usage since `v1.0` version is being deprecated.)~~




  [The Microsoft Authentication Library (MSAL) for Python](https://pypi.org/project/msal/) which comes as a dependency
  is used as a default library to obtain tokens to call Microsoft Graph API.

  Using [Microsoft Authentication Library (MSAL) for Python](https://pypi.org/project/msal/)

  > Note: access token is getting acquired via [Client Credential flow](https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-client-creds-grant-flow)
  > in the provided examples. Other forms of token aquisition can be found here: https://msal-python.readthedocs.io/en/latest/

  ```python
  import msal
  from office365.graph_client import GraphClient

  def acquire_token():
      """
      Acquire token via MSAL
      """
      authority_url = 'https://login.microsoftonline.com/{tenant_id_or_name}'
      app = msal.ConfidentialClientApplication(
          authority=authority_url,
          client_id='{client_id}',
          client_credential='{client_secret}'
      )
      token = app.acquire_token_for_client(scopes=["https://graph.microsoft.com/.default"])
      return token


  client = GraphClient(acquire_token)

  ```

  But in terms of Microsoft Graph API authentication, another OAuth spec compliant libraries
  such as [adal](https://github.com/AzureAD/azure-activedirectory-library-for-python)
  are supported as well.

  Using [ADAL Python](https://adal-python.readthedocs.io/en/latest/#)

  Usage

  ```python
  import adal
  from office365.graph_client import GraphClient

  def acquire_token_func():
      authority_url = 'https://login.microsoftonline.com/{tenant_id_or_name}'
      auth_ctx = adal.AuthenticationContext(authority_url)
      token = auth_ctx.acquire_token_with_client_credentials(
          "https://graph.microsoft.com",
          "{client_id}",
          "{client_secret}")
      return token

  client = GraphClient(acquire_token_func)

  ```



  The example demonstrates how to send an email via [Microsoft Graph endpoint](https://docs.microsoft.com/en-us/graph/api/user-sendmail?view=graph-rest-1.0&tabs=http).

  > Note: access token is getting acquired  via [Client Credential flow](https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-client-creds-grant-flow)

  ```python
  from office365.graph_client import GraphClient

  client = GraphClient(acquire_token_func)

  client.me.send_mail(
      subject="Meet for lunch?",
      body="The new cafeteria is open.",
      to_recipients=["fannyd@contoso.onmicrosoft.com"]
  ).execute_query()

  ```

  > How to enable sending emails on behalf of another user in your organization: https://learn.microsoft.com/en-us/microsoft-365/solutions/allow-members-to-send-as-or-send-on-behalf-of-group?view=o365-worldwide&viewFallbackFrom=o365-worldwide%3FWT.mc_id%3D365AdminCSH_globalsearch

  Additional examples:

  -  [download a message](examples/outlook/download_messages.py)
  -  [list messages](examples/outlook/list_message.py)
  -  [move messages to a different folder](examples/outlook/move_message.py)
  -  [search messages](examples/outlook/search_message.py)
  -  [send messages](examples/outlook/send_message.py)
  -  [send messages with attachments](examples/outlook/send_message_with_attachment.py)

  Refer to [examples section](examples/outlook) for other scenarios






  [OneDrive Graph API reference](https://docs.microsoft.com/en-us/graph/api/resources/onedrive?view=graph-rest-1.0)



  [The Microsoft Authentication Library (MSAL) for Python](https://pypi.org/project/msal/) which comes as a dependency
  is used to obtain token

  ```python
  import msal

  def acquire_token_func():
      """
      Acquire token via MSAL
      """
      authority_url = 'https://login.microsoftonline.com/{tenant_id_or_name}'
      app = msal.ConfidentialClientApplication(
          authority=authority_url,
          client_id='{client_id}',
          client_credential='{client_secret}'
      )
      token = app.acquire_token_for_client(scopes=["https://graph.microsoft.com/.default"])
      return token
  ```






  The example demonstrates how to enumerate and print drive's url
  which corresponds to [`list available drives` endpoint](https://docs.microsoft.com/en-us/onedrive/developer/rest-api/api/drive_list?view=odsp-graph-online)

  > Note: access token is getting acquired  via [Client Credential flow](https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-client-creds-grant-flow)

  ```python
  from office365.graph_client import GraphClient

  tenant_name = "contoso.onmicrosoft.com"
  client = GraphClient(acquire_token_func)
  drives = client.drives.get().execute_query()
  for drive in drives:
      print("Drive url: {0}".format(drive.web_url))
  ```




  ```python
  from office365.graph_client import GraphClient
  client = GraphClient(acquire_token_func)

  drive = client.users["{user_id_or_principal_name}"].drive.get().execute_query()

  with tempfile.TemporaryDirectory() as path:
      download_files(drive.root, path)
  ```

  where

  ```python
  def download_files(remote_folder, local_path):
      drive_items = remote_folder.children.get().execute_query()
      for drive_item in drive_items:
          if drive_item.file is not None:  # is file?
              
              with open(os.path.join(local_path, drive_item.name), 'wb') as local_file:
                  drive_item.download(local_file).execute_query()
  ```

  Additional examples:

  -  [create list column](examples/onedrive/create_list_column.py)
  -  [download file](examples/onedrive/download_file_default.py)
  -  [export files](examples/onedrive/export_files.py)
  -  [import files](examples/onedrive/import_files.py)
  -  [list drives](examples/onedrive/list_drives.py)
  -  [list files](examples/onedrive/list_files.py)

  Refer to [OneDrive examples section](examples/onedrive) for more examples.






  [The Microsoft Authentication Library (MSAL) for Python](https://pypi.org/project/msal/) which comes as a dependency
  is used to obtain token





  The example demonstrates how create a new team under a group
  which corresponds to [`Create team` endpoint](https://docs.microsoft.com/en-us/graph/api/team-put-teams?view=graph-rest-1.0&tabs=http)

  ```python
  from office365.graph_client import GraphClient
  client = GraphClient(acquire_token_func)
  new_team = client.groups["{group_id}"].add_team().execute_query_retry()
  ```

  Additional examples:

  -  [create a team](examples/teams/create_team.py)
  -  [create team from group](examples/teams/create_team_from_group.py)
  -  [list all teams](examples/teams/list_all_teams.py)
  -  [list my teams](examples/teams/list_my_teams.py)
  -  [send messages](examples/teams/send_message.py)

  Refer to [examples section](examples/teams) for other scenarios



  The library supports OneNote API in terms of calls to a user's OneNote notebooks, sections, and pages in a personal or organization account

  Example: Create a new page

  ```python
  from office365.graph_client import GraphClient
  client = GraphClient(acquire_token_func)

  files = {}
  with open("./MyPage.html", 'rb') as f, \
      open("./MyImage.png", 'rb') as img_f, \
      open("./MyDoc.pdf", 'rb') as pdf_f:
      files["imageBlock1"] = img_f
      files["fileBlock1"] = pdf_f
      page = client.me.onenote.pages.add(presentation_file=f, attachment_files=files).execute_query()
  ```



  The example demonstrates how to create a new planner task
  which corresponds to [`Create plannerTask` endpoint](https://docs.microsoft.com/en-us/graph/api/planner-post-tasks?view=graph-rest-1.0):

  ```python
  from office365.graph_client import GraphClient

  client = GraphClient(acquire_token_func)
  task = client.planner.tasks.add(title="New task", planId="--plan id goes here--").execute_query()
  ```


  The following libraries will be installed when you install the client library:
  * [requests](https://github.com/kennethreitz/requests)
  * [Microsoft Authentication Library (MSAL) for Python](https://pypi.org/project/msal/)

location_href:
  00009995-python-office365-rest-python-client/python-Office365-REST-Python-Client-help-2.4.0-1.noarch.rpm


pkgId: ea6bc1af0fe792922bf1b671c79bcabb1e4bb93d195783fac2a0e1b6dc71285e
name: python-OnionBalance
arch: src
version: 0.2.1
epoch: 0
release: 1
url: https://github.com/asn-d6/onionbalance
rpm_license: GPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ed6e7589-a267-4e30-b34e-272c2b852334
location_href: 00004374-python-onionbalance/python-OnionBalance-0.2.1-1.src.rpm
checksum_type: sha256
summary:
  OnionBalance provides load-balancing and redundancy for Tor hidden services by distributing requests to multiple backend Tor instances.


pkgId: 2a157752149114b743b67fdec69c0c89821ffecedd744eb3fa6c67ad3cbef8a2
name: python-PGPy
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Pretty Good Privacy for Python
url: https://github.com/SecurityInnovation/PGPy
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-701e4368-8d76-404b-b6cb-997d0294af22
location_href: 00009795-python-pgpy/python-PGPy-0.6.0-1.src.rpm
checksum_type: sha256
description:
  `PGPy` is a Python library for implementing Pretty Good Privacy into Python programs, conforming to the OpenPGP specification per RFC 4880.


pkgId: 738a34a4168ec967ea16ee37259234af7ce24bb81923d6d9b2bc2e4d00a700f4
name: python-Pairtree
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Pairtree FS implementation.
url: http://packages.python.org/Pairtree/
rpm_license: http://www.apache.org/licenses/LICENSE-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-26f28360-5cc8-4134-9f77-88003542436a
location_href: 00013695-python-pairtree/python-Pairtree-0.8.1-1.src.rpm
checksum_type: sha256
description:
  From http://www.cdlib.org/inside/diglib/pairtree/pairtreespec.html : Pairtree, a filesystem hierarchy for holding objects that are located by mapping identifier strings to object directory (or folder) paths two characters at a time. If an object directory (folder) holds all the files, and nothing but the files, that comprise the object, a "pairtree" can be imported by a system that knows nothing about the nature or structure of the objects but can still deliver any object's files by requested identifier. The mapping is reversible, so the importing system can also walk the pairtree and reliably enumerate all the contained object identifiers. To the extent that object dependencies are stored inside the pairtree (e.g., fast indexes stored outside contain only derivative data), simple or complex collections built on top of pairtrees can recover from index failures and reconstruct a collection view simply by walking the trees. Pairtrees have the advantage that many object operations, including backup and restore, can be performed with native operating system tools.


pkgId: cb63e8c2b18c6af1222587cc2af46337a820dbd199905f6ad5425615b5994d56
name: python-Pallets-Sphinx-Themes
arch: src
version: 2.0.3
epoch: 0
release: 1
summary: Sphinx themes for Pallets and related projects.
url: https://github.com/pallets/pallets-sphinx-themes/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-81c0d358-b921-4cc6-8ddf-ca178e2b7a8d
location_href: 00002866-python-Pallets-Sphinx-Themes/python-Pallets-Sphinx-Themes-2.0.3-1.src.rpm
checksum_type: sha256
description:
  Themes for the Pallets projects. If you're writing an extension, use the
  appropriate theme to make your documentation look consistent.
  Available themes:
  -   flask
  -   jinja
  -   werkzeug
  -   click
  Install this package:
      pip install Pallets-Sphinx-Themes
  Enable the extension and choose the theme in ``docs/conf.py``:
      extensions = [
          "pallets_sphinx_themes",
      ]
      html_theme = "flask"


pkgId: 0edc1a587503dca0a645c93869265f36e290de465445e2edc3c443ed42bf69e9
name: python-Paste
arch: src
version: 3.5.2
epoch: 0
release: 1
summary: Tools for using a Web Server Gateway Interface stack
url: https://pythonpaste.readthedocs.io/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-97e7d5fe-0539-47b1-97cd-dab746d0aded
location_href: 00010079-python-paste/python-Paste-3.5.2-1.src.rpm
checksum_type: sha256
description:
  * A fixture for testing WSGI applications conveniently and in-process,
    in ``paste.fixture``
  * A fixture for testing command-line applications, also in
    ``paste.fixture``
  * Check components for WSGI-compliance in ``paste.lint``


pkgId: fb22b2736ce4bad0de4cfaf87f3c73c6250f81e1c0135596853dc43bd5484aa9
name: python-PasteDeploy
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: Load, configure, and compose WSGI applications and servers
url: https://docs.pylonsproject.org/projects/pastedeploy/en/latest/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bd690ff2-7d25-475e-b7d6-36e9b2edeb86
location_href: 00009501-python-pastedeploy/python-PasteDeploy-3.0.1-1.src.rpm
checksum_type: sha256
description:
  This tool provides code to load WSGI applications and servers from
  URIs. These URIs can refer to Python eggs for INI-style configuration
  files.  `Paste Script <https://github.com/cdent/pastescript>`_ provides
  commands to serve applications based on this configuration file.

  The latest version is available on `GitHub
  <https://github.com/Pylons/pastedeploy/>`_ (or download a wheel or tarball from
  `PyPI <https://pypi.org/project/PasteDeploy/#files>`_).

  For the latest changes see the `news file
  <https://docs.pylonsproject.org/projects/pastedeploy/en/latest/news.html>`_.


pkgId: f64c1d788f820520f3991f1223dabdec7812dbd3b1498dc5863f37f2a283063a
name: python-PasteScript
arch: src
version: 3.3.0
epoch: 0
release: 1
summary: A pluggable command-line frontend, including commands to setup package file layouts
url: https://pastescript.readthedocs.io/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b02842f4-8efe-4098-bcdc-145aa8974a15
location_href: 00011282-python-pastescript/python-PasteScript-3.3.0-1.src.rpm
checksum_type: sha256
description:
  PasteScript is a pluggable command-line tool.

  **Note**: Paste Script is being maintained on life support. That
  means that critical bugs will be fixed, and support for new versions
  of Python will be handled, but other than that new features are not
  being considered.

  It includes some built-in features;

  * Create file layouts for packages.  For instance, ``paster create
    --template=basic_package MyPackage`` will create a `setuptools
    <https://pythonhosted.org/setuptools/>`_-ready
    file layout.

  * Serving up web applications, with configuration based on
    `paste.deploy <https://docs.pylonsproject.org/projects/pastedeploy>`_.

  The latest version is available in a `GitHub repository
  <https://github.com/cdent/pastescript/>`_.

  For the latest changes see the `news file
  <https://pastescript.readthedocs.io/en/latest/news.html>`_.


pkgId: ffa58ee5731f99c3c54779c03be4763ddc99f40f80ffdf5bbf388a5dba5d893f
name: python-PeakUtils
arch: src
version: 1.3.4
epoch: 0
release: 1
summary: Peak detection utilities for 1D data
url: https://bitbucket.org/lucashnegri/peakutils
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3d7ab2cf-ac09-4255-9397-9d8b668ddc11
location_href: 00011387-python-peakutils/python-PeakUtils-1.3.4-1.src.rpm
checksum_type: sha256
description:
  This package provides utilities related to the detection of peaks on 1D data.
  Includes functions to estimate baselines, finding the indexes of peaks in the data
  and performing Gaussian fitting or centroid computation to further increase the
  resolution of the peak detection.
  The documentation is available at http://peakutils.readthedocs.io/en/latest .


pkgId: 227b994fd0ebb028e0cc580e8a77f99ae1f119c548e21bf81e33e2aced586dde
name: python-Pebble
arch: src
version: 5.0.3
epoch: 0
release: 1
summary: Threading and multiprocessing eye-candy.
url: https://github.com/noxdafox/pebble
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b9060b01-ebac-4bfb-b3fb-a955f75a5938
location_href: 00004517-python-pebble/python-Pebble-5.0.3-1.src.rpm
checksum_type: sha256
description:
  Pebble provides a neat API to manage threads and processes within an application.
  |build badge| |docs badge| |downloads badge|


pkgId: 3e6248d12ff16eab7b5e75c7b07500e4ed1659dbbfee5e069cc97e3575c1cbca
name: python-Persistence
arch: src
version: 4.0.post1
epoch: 0
release: 1
summary: Persistent ExtensionClass
url: https://github.com/zopefoundation/Persistence
rpm_license: ZPL 2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4ac07847-f66e-4f94-b4a5-75c695ecd121
location_href: 00013160-python-persistence/python-Persistence-4.0.post1-1.src.rpm
checksum_type: sha256
description:
  This package provides a variant of the persistent base class that's an
  ExtensionClass_. Unless you need ExtensionClass_ semantics, you probably want to
  use ``persistent.Persistent`` from the persistent_ distribution (formerly in ZODB3).


pkgId: 6d1efd7bfd95e549cfe4f3fb2304cda011ad07572d5375527d496700884068ea
name: python-Persistence-debuginfo
arch: x86_64
version: 4.0.post1
epoch: 0
release: 1
summary: Debug information for package python-Persistence
url: https://github.com/zopefoundation/Persistence
rpm_license: ZPL 2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-4ac07847-f66e-4f94-b4a5-75c695ecd121
rpm_sourcerpm: python-Persistence-4.0.post1-1.src.rpm
location_href: 00013160-python-persistence/python-Persistence-debuginfo-4.0.post1-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-Persistence.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: a6600f2e26eef9efc40dadc6435363ef7a3673694b4164cdbe138a162ec0ac5a
name: python-Persistence-debugsource
arch: x86_64
version: 4.0.post1
epoch: 0
release: 1
summary: Debug sources for package python-Persistence
url: https://github.com/zopefoundation/Persistence
rpm_license: ZPL 2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-4ac07847-f66e-4f94-b4a5-75c695ecd121
rpm_sourcerpm: python-Persistence-4.0.post1-1.src.rpm
location_href: 00013160-python-persistence/python-Persistence-debugsource-4.0.post1-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-Persistence.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: f27ccfac98e29bcbcec6ba24d546fad31f98b01717ef577d54c3e237fe7f8912
name: python-Pillow
arch: src
version: 9.4.0
epoch: 0
release: 1
summary: Python Imaging Library (Fork)
url: https://python-pillow.org
rpm_license: HPND
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bfa1a73c-0a52-487b-bb67-26b3a7e0137a
location_href: 00004548-python-pillow/python-Pillow-9.4.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <img width="248" height="250" src="https://raw.githubusercontent.com/python-pillow/pillow-logo/main/pillow-logo-248x250.png" alt="Pillow logo">
  </p>





  Pillow is the friendly PIL fork by [Alex Clark and
  Contributors](https://github.com/python-pillow/Pillow/graphs/contributors).
  PIL is the Python Imaging Library by Fredrik Lundh and Contributors.
  As of 2019, Pillow development is
  [supported by Tidelift](https://tidelift.com/subscription/pkg/pypi-pillow?utm_source=pypi-pillow&utm_medium=readme&utm_campaign=enterprise).

  <table>
      <tr>
          <th>docs</th>
          <td>
              <a href="https://pillow.readthedocs.io/?badge=latest"><img
                  alt="Documentation Status"
                  src="https://readthedocs.org/projects/pillow/badge/?version=latest"></a>
          </td>
      </tr>
      <tr>
          <th>tests</th>
          <td>
              <a href="https://github.com/python-pillow/Pillow/actions/workflows/lint.yml"><img
                  alt="GitHub Actions build status (Lint)"
                  src="https://github.com/python-pillow/Pillow/workflows/Lint/badge.svg"></a>
              <a href="https://github.com/python-pillow/Pillow/actions/workflows/test.yml"><img
                  alt="GitHub Actions build status (Test Linux and macOS)"
                  src="https://github.com/python-pillow/Pillow/workflows/Test/badge.svg"></a>
              <a href="https://github.com/python-pillow/Pillow/actions/workflows/test-windows.yml"><img
                  alt="GitHub Actions build status (Test Windows)"
                  src="https://github.com/python-pillow/Pillow/workflows/Test%20Windows/badge.svg"></a>
              <a href="https://github.com/python-pillow/Pillow/actions/workflows/test-mingw.yml"><img
                  alt="GitHub Actions build status (Test MinGW)"
                  src="https://github.com/python-pillow/Pillow/workflows/Test%20MinGW/badge.svg"></a>
              <a href="https://github.com/python-pillow/Pillow/actions/workflows/test-cygwin.yml"><img
                  alt="GitHub Actions build status (Test Cygwin)"
                  src="https://github.com/python-pillow/Pillow/workflows/Test%20Cygwin/badge.svg"></a>
              <a href="https://github.com/python-pillow/Pillow/actions/workflows/test-docker.yml"><img
                  alt="GitHub Actions build status (Test Docker)"
                  src="https://github.com/python-pillow/Pillow/workflows/Test%20Docker/badge.svg"></a>
              <a href="https://ci.appveyor.com/project/python-pillow/Pillow"><img
                  alt="AppVeyor CI build status (Windows)"
                  src="https://img.shields.io/appveyor/build/python-pillow/Pillow/main.svg?label=Windows%20build"></a>
              <a href="https://github.com/python-pillow/pillow-wheels/actions"><img
                  alt="GitHub Actions wheels build status (Wheels)"
                  src="https://github.com/python-pillow/pillow-wheels/workflows/Wheels/badge.svg"></a>
              <a href="https://app.travis-ci.com/github/python-pillow/pillow-wheels"><img
                  alt="Travis CI wheels build status (aarch64)"
                  src="https://img.shields.io/travis/com/python-pillow/pillow-wheels/main.svg?label=aarch64%20wheels"></a>
              <a href="https://app.codecov.io/gh/python-pillow/Pillow"><img
                  alt="Code coverage"
                  src="https://codecov.io/gh/python-pillow/Pillow/branch/main/graph/badge.svg"></a>
              <a href="https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:pillow"><img
                  alt="Fuzzing Status"
                  src="https://oss-fuzz-build-logs.storage.googleapis.com/badges/pillow.svg"></a>
          </td>
      </tr>
      <tr>
          <th>package</th>
          <td>
              <a href="https://zenodo.org/badge/latestdoi/17549/python-pillow/Pillow"><img
                  alt="Zenodo"
                  src="https://zenodo.org/badge/17549/python-pillow/Pillow.svg"></a>
              <a href="https://tidelift.com/subscription/pkg/pypi-pillow?utm_source=pypi-pillow&utm_medium=badge"><img
                  alt="Tidelift"
                  src="https://tidelift.com/badges/package/pypi/Pillow?style=flat"></a>
              <a href="https://pypi.org/project/Pillow/"><img
                  alt="Newest PyPI version"
                  src="https://img.shields.io/pypi/v/pillow.svg"></a>
              <a href="https://pypi.org/project/Pillow/"><img
                  alt="Number of PyPI downloads"
                  src="https://img.shields.io/pypi/dm/pillow.svg"></a>
              <a href="https://bestpractices.coreinfrastructure.org/projects/6331"><img
                  alt="OpenSSF Best Practices"
                  src="https://bestpractices.coreinfrastructure.org/projects/6331/badge"></a>
          </td>
      </tr>
      <tr>
          <th>social</th>
          <td>
              <a href="https://gitter.im/python-pillow/Pillow?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge"><img
                  alt="Join the chat at https://gitter.im/python-pillow/Pillow"
                  src="https://badges.gitter.im/python-pillow/Pillow.svg"></a>
              <a href="https://twitter.com/PythonPillow"><img
                  alt="Follow on https://twitter.com/PythonPillow"
                  src="https://img.shields.io/badge/tweet-on%20Twitter-00aced.svg"></a>
          </td>
      </tr>
  </table>



  The Python Imaging Library adds image processing capabilities to your Python interpreter.

  This library provides extensive file format support, an efficient internal representation, and fairly powerful image processing capabilities.

  The core image library is designed for fast access to data stored in a few basic pixel formats. It should provide a solid foundation for a general image processing tool.



  - [Documentation](https://pillow.readthedocs.io/)
    - [Installation](https://pillow.readthedocs.io/en/latest/installation.html)
    - [Handbook](https://pillow.readthedocs.io/en/latest/handbook/index.html)
  - [Contribute](https://github.com/python-pillow/Pillow/blob/main/.github/CONTRIBUTING.md)
    - [Issues](https://github.com/python-pillow/Pillow/issues)
    - [Pull requests](https://github.com/python-pillow/Pillow/pulls)
  - [Release notes](https://pillow.readthedocs.io/en/stable/releasenotes/index.html)
  - [Changelog](https://github.com/python-pillow/Pillow/blob/main/CHANGES.rst)
    - [Pre-fork](https://github.com/python-pillow/Pillow/blob/main/CHANGES.rst#pre-fork)



  To report a security vulnerability, please follow the procedure described in the [Tidelift security policy](https://tidelift.com/docs/security).


pkgId: 824a2764b456d2c995b6d899e283b46977f968e9d7a8518caea4b13b04aa56ae
name: python-Pint
arch: src
version: 0.20.1
epoch: 0
release: 1
summary: Physical quantities module
url: https://github.com/hgrecco/pint
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-633288a6-87fb-44db-8fad-76954fd623e2
location_href: 00004552-python-pint/python-Pint-0.20.1-1.src.rpm
checksum_type: sha256
description:
  Pint is a Python package to define, operate and manipulate physical
  quantities: the product of a numerical value and a unit of measurement.
  It allows arithmetic operations between them and conversions from and
  to different units.
  It is distributed with a comprehensive list of physical units, prefixes
  and constants. Due to its modular design, you can extend (or even rewrite!)
  the complete list without changing the source code. It supports a lot of
  numpy mathematical operations **without monkey patching or wrapping numpy**.
  It has a complete test coverage. It runs in Python 3.8+ with no other dependency.
  It is licensed under BSD.
  It is extremely easy and natural to use:
      >>> import pint
      >>> ureg = pint.UnitRegistry()
      >>> 3 * ureg.meter + 4 * ureg.cm
      <Quantity(3.04, 'meter')>
  and you can make good use of numpy if you want:
      >>> import numpy as np
      >>> [3, 4] * ureg.meter + [4, 3] * ureg.cm
      <Quantity([ 3.04  4.03], 'meter')>
      >>> np.sum(_)
      <Quantity(7.07, 'meter')>


pkgId: 91ca813c2b797217140a360b952a48a1bac835fb4ae331776c4064d3ddf80727
name: python-Pmw
arch: src
version: 2.1.1
epoch: 0
release: 1
summary: Python Megawidgets
url: http://pmw.sourceforge.net/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-35dcec77-42c7-4d67-b6ed-7e006428d9db
location_href: 00004572-python-pmw/python-Pmw-2.1.1-1.src.rpm
checksum_type: sha256
description:
  Pmw is a toolkit for building high-level compound widgets, or megawidgets,
          constructed using other widgets as component parts. It promotes consistent look and feel within
           and between graphical applications, is highly configurable to your needs and is easy to use.


pkgId: a0ceb384ea476f05d5a41857a89de3c5fe14faef7748bc031cd8f240a686904b
name: python-ProDy
arch: src
version: 2.4.0
epoch: 0
release: 1
summary: A Python Package for Protein Dynamics Analysis
url: http://www.csb.pitt.edu/ProDy
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-749844d8-c58f-49d1-bf39-90cce3c10f1b
location_href: 00002867-python-ProDy/python-ProDy-2.4.0-1.src.rpm
checksum_type: sha256
description:
  ProDy is a free and open-source Python package for protein structure, dynamics,
  and sequence analysis.  It allows for comparative analysis and modeling of
  protein structural dynamics and sequence co-evolution.  Fast and flexible ProDy
  API is for interactive usage as well as application development.  ProDy also
  comes with several analysis applications and a graphical user interface for
  visual analysis.


pkgId: e75daac67ee6f0af94889b42a9b2797a66293a4001870541d4d47f3c0b084456
name: python-PuLP
arch: src
version: 2.7.0
epoch: 0
release: 1
url: https://github.com/coin-or/pulp
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-97bcbc90-4396-4647-b1be-1a50c700ce8f
location_href: 00009913-python-pulp/python-PuLP-2.7.0-1.src.rpm
checksum_type: sha256
summary:
  PuLP is an LP modeler written in python. PuLP can generate MPS or LP files and call GLPK, COIN CLP/CBC, CPLEX, and GUROBI to solve linear problems.

description:
  The easiest way to install pulp is via `PyPi <https://pypi.python.org/pypi/PuLP>`_
  If pip is available on your system::
       python -m pip install pulp
  Otherwise follow the download instructions on the PyPi page.
  If you want to install the latest version from github you can run the following::
      python -m pip install -U git+https://github.com/coin-or/pulp
  On Linux and OSX systems the tests must be run to make the default
  solver executable.
       sudo pulptest


pkgId: 7ade35c5f44759f6f7dc4a26950f675f0d581528bd3fa2c1e92a2d28aa3349c0
name: python-PureCloudPlatformClientV2-help
arch: noarch
version: 168.0.0
epoch: 0
release: 1
summary: Development documents and examples for PureCloudPlatformClientV2
description: A Python library to interface with the PureCloud Platform API
url: https://developer.mypurecloud.com/api/rest/client-libraries/python/
rpm_license: None
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-66e39397-3eb7-402b-85c3-5ceb245bff13
rpm_sourcerpm: python-PureCloudPlatformClientV2-168.0.0-1.src.rpm
checksum_type: sha256
location_href:
  00012858-python-purecloudplatformclientv2/python-PureCloudPlatformClientV2-help-168.0.0-1.noarch.rpm


pkgId: 174821ea3da34698acca7565b157fcc887bd70d1cf04fe7edfca9bd5c2630971
name: python-PyAudio
arch: src
version: 0.2.13
epoch: 0
release: 1
summary: Cross-platform audio I/O with PortAudio
url: https://people.csail.mit.edu/hubert/pyaudio/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-49c9c393-1580-4c71-806a-6aa438f08c89
location_href: 00004637-python-pyaudio/python-PyAudio-0.2.13-1.src.rpm
checksum_type: sha256
description:
  <img align="right" width="200" style="margin-left: 3px" src="https://people.csail.mit.edu/hubert/pyaudio/images/snake-300.png">



  PyAudio provides Python bindings for PortAudio v19, the cross-platform audio I/O library. With PyAudio, you can easily use Python to play and record audio on a variety of platforms, such as GNU/Linux, Microsoft Windows, and Apple macOS.

  PyAudio is distributed under the MIT License.

  * [Homepage](https://people.csail.mit.edu/hubert/pyaudio/)
  * [API Documentation](https://people.csail.mit.edu/hubert/pyaudio/docs/)
  * [PyPi](https://pypi.python.org/pypi/PyAudio)



  See the INSTALLATION file in the source distribution for details. In summary, install PyAudio using `pip` on most platforms.



  ```sh
  python -m pip install pyaudio
  ```

  This installs the precompiled PyAudio library with PortAudio v19 19.7.0 included. The library is compiled with support for Windows MME API, DirectSound, WASAPI, and WDM-KS. It does not include support for ASIO. If you require support for APIs not included, you will need to compile PortAudio and PyAudio.



  Use [Homebrew](https://brew.sh) to install the prerequisite [portaudio](http://portaudio.com) library, then install PyAudio using `pip`:

  ```sh
  brew install portaudio
  pip install pyaudio
  ```



  Use the package manager to install PyAudio. For example, on Debian-based systems:

  ```sh
  sudo apt install python3-pyaudio
  ```

  Alternatively, if the latest version of PyAudio is not available, install it using `pip`. Be sure to first install development libraries for `portaudio19` and `python3`.



  See the INSTALLATION file.



  * Read the [API Documentation](https://people.csail.mit.edu/hubert/pyaudio/docs/), or generate it from the source using [`sphinx`](https://www.sphinx-doc.org/).

  * Usage examples are in the `examples` directory of the source distribution, or see the [project homepage](https://people.csail.mit.edu/hubert/pyaudio/).



  PyAudio is distributed under the MIT License. See LICENSE.txt.


pkgId: 921c1be6e656878525b61519c248c00c662f3547eb143fc00436db8fe33f8d98
name: python-PyAutoGUI
arch: src
version: 0.9.53
epoch: 0
release: 1
url: https://github.com/asweigart/pyautogui
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ae56105e-3f32-4781-adc8-1ccf347ffd64
location_href: 00009982-python-pyautogui/python-PyAutoGUI-0.9.53-1.src.rpm
checksum_type: sha256
summary:
  PyAutoGUI lets Python control the mouse and keyboard, and other GUI automation tasks. For Windows, macOS, and Linux, on Python 3 and 2.

description:
  PyAutoGUI is a  cross-platform GUI automation Python module for human beings. Used to programmatically control the mouse & keyboard.
  `pip install pyautogui`
  Full documentation available at https://pyautogui.readthedocs.org
  Simplified Chinese documentation available at https://muxuezi.github.io/posts/doc-pyautogui.html
  Source code available at https://github.com/asweigart/pyautogui
  If you need help installing Python, visit https://installpython3.com/


pkgId: ca4917a0a0965896996ac39591a0a415f7f001c684448714e071d733c495861f
name: python-PyByteBuffer
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: A bytes manipulation library inspired by Java ByteBuffer
url: https://github.com/iGio90/PyByteBuffer
rpm_license: GPL 3.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6cc8d2db-49f9-4748-8e5b-33d3ccfc3270
location_href: 00009614-python-pybytebuffer/python-PyByteBuffer-1.0.5-1.src.rpm
checksum_type: sha256
description:
  A library to manipulate buffers inspired by [Java nio ByteBuffer](https://docs.oracle.com/javase/7/docs/api/java/nio/ByteBuffer.html)

  > [>> DOCUMENTATION](https://igio90.github.io/PyByteBuffer/)



  ```
  pip3 install PyByteBuffer
  ```



  ```python
  from PyByteBuffer import ByteBuffer

  buf = ByteBuffer.allocate(50)

  buf.put(0x10)
  buf.put([0xcc, 0xdd, 0xee])
  buf.put('something')
  buf.put(bytes([00] * 4))


  buf.put(123456, 'little')
  buf.put(1234561434234234, 'big')


  value = buf.get(1)

  value = buf.get(10, 'little')


  buf = ByteBuffer.from_hex('deadbeef')
  buf = ByteBuffer.wrap(bytes())
  ```


  The performance analysis we can do in this library is all around the conversion between int->bytes bytes<-int.

  Tested with a cycle of 1/100/500/1000 conversion using python3 builtin api int.to_bytes/from_bytes, struct pack/unpack and a "primitive" solution
  posted in [stackoverflow](https://stackoverflow.com/a/35634239)


pkgId: 9406c1a01861dab5983f50b2ebd34a1059f38083074e1bfced06ad4d1d4a6e4d
name: python-PyChromecast
arch: src
version: 13.0.7
epoch: 0
release: 1
summary: Python module to talk to Google Chromecast.
url: https://github.com/balloob/pychromecast
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8c8a3a4d-9b43-4e19-8522-cee01eee9e9b
location_href: 00011136-python-pychromecast/python-PyChromecast-13.0.7-1.src.rpm
checksum_type: sha256
description:
  Library for Python 3.6+ to communicate with the Google Chromecast. It
  currently supports:
  -  Auto discovering connected Chromecasts on the network
  -  Start the default media receiver and play any online media
  -  Control playback of current playing media
  -  Implement Google Chromecast api v2
  -  Communicate with apps via channels
  -  Easily extendable to add support for unsupported namespaces
  -  Multi-room setups with Audio cast devices
  *Check out* `Home Assistant <https://home-assistant.io>`_ *for a
  ready-made solution using PyChromecast for controlling and automating
  your Chromecast or Cast-enabled device like Google Home.*


pkgId: 7c13967ac9e20d382c55db8db935c944757b36615e4cccfe18239991395e61c9
name: python-PyDictionary
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: A real dictionary module for Python
url: https://github.com/geekpradd/PyDictionary
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eecfbd7b-2f65-44ae-a92f-e32accbeea39
location_href: 00010037-python-pydictionary/python-PyDictionary-2.0.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](http://img.shields.io/travis/geekpradd/PyDictionary/master.svg?style=flat-square)](https://travis-ci.org/geekpradd/PyDictionary)
  [![Latest Version](http://img.shields.io/pypi/v/PyDictionary.svg?style=flat-square)](https://pypi.python.org/pypi/PyDictionary/)
  [![License](https://img.shields.io/pypi/l/PyDictionary.svg?style=flat-square)](https://pypi.python.org/pypi/PyDictionary/)
  [![Downloads](https://img.shields.io/pypi/dm/PyDictionary.svg?style=flat-square)](https://pypi.python.org/pypi/PyDictionary/)

  PyDictionary is a Dictionary Module for Python 2/3 to get meanings, translations, synonyms and Antonyms of words. It uses WordNet for getting meanings, Google for translations, and synonym.com for getting synonyms and antonyms.

  This module uses Python Requests, BeautifulSoup4 and goslate as dependencies



  Installation is very simple through pip (or easy_install)

  For pip

  ```
  pip install PyDictionary
  ```

  For Easy_Install

  ```
  easy_install  PyDictionary
  ```



  PyDictionary can be utilised in 2 ways, either by creating a dictionary instance which can take words as arguments or by creating a dictionary instance with a fixed amount of words.

  For example,

  ```python
  from PyDictionary import PyDictionary
  dictionary=PyDictionary()
  ```

  This is will create a local instance of the PyDictionary class and now it can be used to get meanings, translations etc.

  ```python
  print (dictionary.meaning("indentation"))
  ```

  This will return a dictionary containing the meanings of the word.
  For example the above code will return:

  ```
  {'Noun': ['a concave cut into a surface or edge (as in a coastline', 'the
   formation of small pits in a surface as a consequence of corrosion', 'th
  e space left between the margin and the start of an indented line', 'the
  act of cutting into an edge with toothlike notches or angular incisions']
  }
  ```
  The dictionary keys are the different types of the word. If a word is both a verb and a noun then there will be 2 keys:'Noun' and 'Verb'.
  Each key refers to a list containing the meanings


  For Synonyms,

  ```python
  print (dictionary.synonym("Life"))
  ```

  This will return a list containing the Synonyms of the word.

  For Antonyms,

  ```python
  print (dictionary.antonym("Life"))
  ```
  This will return a list containing the Antonyms of the word.

  For Translations,

  ```python
  print (dictionary.translate("Range",'es'))
  ```

  This will return the Translation of the word "Range" in Spanish. For Language codes consult Google Translate. The return value is string in Python 3 and unicode in Python 2

  Alternatively, you can set a fixed number of words to the PyDictionary Instance. This is useful if you just want to get the meanings of some words quickly without any development need.

  Example:

  ```python
  from PyDictionary import PyDictionary

  dictionary=PyDictionary("hotel","ambush","nonchalant","perceptive")
  'There can be any number of words in the Instance'

  print(dictionary.printMeanings()) '''This print the meanings of all the words'''
  print(dictionary.getMeanings()) '''This will return meanings as dictionaries'''
  print (dictionary.getSynonyms())

  print (dictionary.translateTo("hi")) '''This will translate all words to Hindi'''

  ```

  Similarly Synonyms and Antonyms can also be printed onto the screen.



  Current Version: 2.0.1
  Created By Pradipta Bora 2020.


pkgId: f9edc9db1ab3e416aa4173f479c9708e90de8f23b60bf6c2fc295469d611f0ac
name: python-PyDispatcher
arch: src
version: 2.0.7
epoch: 0
release: 1
summary: Multi-producer multi-consumer in-memory signal dispatch system
url: https://github.com/mcfletch/pydispatcher
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8b2c9ebb-ad58-49de-b1d5-535b70a6cc0e
location_href: 00004661-python-pydispatcher/python-PyDispatcher-2.0.7-1.src.rpm
checksum_type: sha256
description:
  PyDispatcher provides the Python programmer with a multiple-producer-multiple-consumer signal-registration and
  routing infrastructure for use in multiple contexts. The mechanism
  of PyDispatcher started life as a highly rated [recipe](http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/87056)
  in the [Python Cookbook](http://aspn.activestate.com/ASPN/Python/Cookbook/). The [project](https://github.com/mcfletch/pydispatcher) aims
  to include various enhancements to the recipe developed during use in
  various applications. It is primarily maintained by [Mike Fletcher](http://www.vrplumber.com). A derivative
  of the project provides the Django web framework's "signal" system.



  PyDispatcher is available on PyPI via standard PIP:
  ```
  pip install PyDispatcher
  ```
  [![Latest PyPI Version](https://img.shields.io/pypi/v/pydispatcher.svg)](https://pypi.python.org/pypi/pydispatcher)
  [![Latest PyPI Version](https://img.shields.io/pypi/dm/pydispatcher.svg)](https://pypi.python.org/pypi/pydispatcher)




  [Documentation](https://mcfletch.github.io/pydispatcher/) is available
  for detailed usage, but the basic idea is:

  ```
  from pydispatch import dispatcher

  metaKey = "moo"
  MyNode = object()
  event = {"sample": "event"}


  def callback(event=None):
      """Handle signal being sent"""
      print("Signal received", event)


  dispatcher.connect(callback, sender=MyNode, signal=metaKey)
  dispatcher.send(metaKey, MyNode, event=event)
  ```


pkgId: 85e6f5a5ba55e33de98a1da8776ef8e0cd9c9828a41caf74a27935f1fe3e5a14
name: python-PyDrive
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: Google Drive API made easy.
url: https://github.com/googledrive/PyDrive
rpm_license: LICENSE
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6fde8405-3aad-41af-bd99-f9121959f69a
location_href: 00002868-python-PyDrive/python-PyDrive-1.3.1-1.src.rpm
checksum_type: sha256
description:
  *PyDrive* is a wrapper library of
  `google-api-python-client <https://code.google.com/p/google-api-python-client/>`_
  that simplifies many common Google Drive API tasks.


pkgId: 332c1ea1d9a5e9b36148f3aec5934472f327f5e1c4747c81a1d12ac6c2b91921
name: python-PyDrive2
arch: src
version: 1.15.3
epoch: 0
release: 1
summary: Google Drive API made easy. Maintained fork of PyDrive.
url: https://github.com/iterative/PyDrive2
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-820db166-f9be-4425-a41c-3aff7b0bfcdf
location_href: 00012990-python-pydrive2/python-PyDrive2-1.15.3-1.src.rpm
checksum_type: sha256
description:
  *PyDrive2* is a wrapper library of
  `google-api-python-client <https://github.com/google/google-api-python-client>`_
  that simplifies many common Google Drive API V2 tasks. It is an actively
  maintained fork of `https://pypi.python.org/pypi/PyDrive <https://pypi.python.org/pypi/PyDrive>`_.
  By the authors and maintainers of the `Git for Data <https://dvc.org>`_ - DVC
  project.


pkgId: 87cca7599d96e3614fab055bf2dddbc7c761ab71d934d7796cd5281c2fa9ff12
name: python-PyExcelerate
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: Accelerated Excel XLSX Writing Library for Python 2/3
url: https://github.com/kz26/PyExcelerate
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7dfc9d24-5f28-4664-b4f0-b07b98917b25
location_href: 00010504-python-pyexcelerate/python-PyExcelerate-0.10.0-1.src.rpm
checksum_type: sha256
description:
  Accelerated Excel XLSX writing library for Python
  master: |build-status-master| dev: |build-status-dev| test coverage:
  |coverage-status|
  -  Authors: `Kevin Wang <https://github.com/kevmo314>`__ and `Kevin
     Zhang <https://github.com/kz26>`__
  -  Copyright 2015 Kevin Wang, Kevin Zhang. Portions copyright Google,
     Inc.
  -  License: Simplified BSD License
  -  `Source repository <https://github.com/kz26/PyExcelerate>`__
  -  `PyPI page <https://pypi.python.org/pypi/PyExcelerate>`__


pkgId: e78523717591e408884508690f49f68f86a7bf3c5d40530ec9cae069d88dd7d0
name: python-PyGetWindow
arch: src
version: 0.0.9
epoch: 0
release: 1
summary: A simple, cross-platform module for obtaining GUI information on application's windows.
url: https://github.com/asweigart/pygetwindow
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-78fa2a55-a13b-4747-af98-5b241de3b99e
location_href: 00010107-python-pygetwindow/python-PyGetWindow-0.0.9-1.src.rpm
checksum_type: sha256
description:
  A simple, cross-platform module for obtaining GUI information on and controlling application's windows.
  Still under development. Currently only the Windows platform is implemented. If you want to help contribute, please contact al@inventwithpython.com!


pkgId: 1092ec6093b91ab5d5b263af773122a3158b67abe4db7868a8dc828942569d19
name: python-PyGithub
arch: src
version: 1.58.0
epoch: 0
release: 1
summary: Use the full Github API v3
url: https://github.com/pygithub/pygithub
rpm_license: GNU Library or Lesser General Public License (LGPL)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-916ac1ad-798c-4028-8921-aadb79cf4347
location_href: 00004686-python-pygithub/python-PyGithub-1.58.0-1.src.rpm
checksum_type: sha256
description:
  First create a Github instance::
      from github import Github
      
      g = Github("user", "password")
      
      g = Github("access_token")
  Then play with your Github objects::
      for repo in g.get_user().get_repos():
          print(repo.name)
          repo.edit(has_wiki=False)


pkgId: d3921d8e656c1c11b1774c7af6dec06d136a676978d0476a15e46fa89657d377
name: python-PyGreSQL
arch: src
version: 5.2.4
epoch: 0
release: 1
summary: Python PostgreSQL Interfaces
url: http://www.pygresql.org
rpm_license: PostgreSQL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7ade2112-cfa1-4f4e-8525-b7664aa8af48
location_href: 00004696-python-pygresql/python-PyGreSQL-5.2.4-1.src.rpm
checksum_type: sha256
description:
  PyGreSQL is an open-source Python module that interfaces to a
  PostgreSQL database. It embeds the PostgreSQL query library to allow
  easy use of the powerful PostgreSQL features from a Python script.


pkgId: f64d1ec8a50027862bf7010e0735ebb4565bbc21c05de1738a7c6d5e457977da
name: python-PyICU
arch: src
version: 2.10.2
epoch: 0
release: 1
summary: Python extension wrapping the ICU C++ API
url: https://gitlab.pyicu.org/main/pyicu
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a2afb3fb-1a05-469b-8a38-bbc79caf5a02
location_href: 00004706-python-pyicu/python-PyICU-2.10.2-1.src.rpm
checksum_type: sha256
description:
  Welcome to PyICU, a Python extension wrapping the ICU C++ libraries.

  ICU stands for "International Components for Unicode".
  These are the i18n libraries of the Unicode Consortium.
  They implement much of the Unicode Standard,
  many of its companion Unicode Technical Standards,
  and much of Unicode CLDR.

  The PyICU source code is hosted at https://gitlab.pyicu.org/main/pyicu.

  The ICU homepage is https://icu.unicode.org/

  See also the CLDR homepage at http://cldr.unicode.org/



  PyICU is a python extension implemented in C++ that wraps the C/C++ ICU library.
  It is known to also work as a [PyPy](https://www.pypy.org/) extension.
  Unless ``pkg-config`` and the ICU libraries and headers are already installed,
  building PyICU from the sources on [PyPI](https://pypi.org/project/PyICU/)
  involves more than just a ``pip`` call. Many operating systems distribute
  pre-built binary packages of ICU and PyICU, see below.

    - Mac OS X
      - Ensure ICU is installed and can be found by `pkg-config` (as `icu-config` was [deprecated](https://unicode-org.github.io/icu/userguide/icu/howtouseicu.html#c-makefiles) as of ICU 63.1), either by following [ICU build instructions](https://unicode-org.github.io/icu/userguide/icu4c/build.html), or by using Homebrew:
        ```sh
        
        brew install pkg-config icu4c

        
        export PATH="/usr/local/opt/icu4c/bin:/usr/local/opt/icu4c/sbin:$PATH"
        export PKG_CONFIG_PATH="$PKG_CONFIG_PATH:/usr/local/opt/icu4c/lib/pkgconfig"
        ```
      - Install PyICU **with the same C++ compiler as your Python distribution**
        ([more info](https://gitlab.pyicu.org/main/pyicu/merge_requests/140#issuecomment-782283491)):
        ```sh
        
        export CC="$(which gcc)" CXX="$(which g++)"
        
        unset CC CXX

        
        pip install --no-binary=:pyicu: pyicu
        ```

      - ICU and PyICU binaries are both available via [Macports](https://www.macports.org/) as well. The same limitations about mixing binaries may apply.
        ```sh
        
        /opt/local/bin/port search pyicu
        sudo /opt/local/bin/port install ...
        ```

    - Debian
      ```sh
      apt-get update

      
      apt-get install python3-icu
      
      apt-get install pkg-config libicu-dev
      pip install --no-binary=:pyicu: pyicu
      ```

    - Ubuntu: similar to Debian, there is a pyicu
      [package](https://packages.ubuntu.com/source/xenial/python/pyicu)
      available via ``apt``.

    - Alpine Linux: there is a pyicu
      [package](https://pkgs.alpinelinux.org/package/edge/community/x86/py3-icu)
      available via ``apk``.

    - NetBSD: there is a pyicu [package](https://pkgsrc.se/textproc/py-ICU)
      available via ``pkg_add``.

    - OpenBSD: there is a pyicu [package](https://openports.se/textproc/py-ICU)
      available via ``pkg_add``.

    - Other operating systems: see below.



  *Please, refer to [next section](#building-pyicu-python-3-and-icu-from-sources) for building Python, ICU and PyICU from sources.
  The current section is about building only PyICU from sources, with all dependencies such as Python and ICU already present.*

  Before building PyICU the ICU libraries must be built and installed. Refer
  to each system's [instructions](https://unicode-org.github.io/icu/userguide/icu4c/build.html) for more information.

  PyICU is built from sources with ``setuptools`` or with ``build`` and ``pip``:

     - verify that ``pkg-config`` is available (the ``icu-config`` program is
       [deprecated](https://unicode-org.github.io/icu/userguide/icu/howtouseicu.html#c-makefiles)
       as of ICU 63.1)
       ```sh
       pkg-config --cflags --libs icu-i18n
       ```
       If this command returns an error or doesn't return the paths expected
       then ensure that the ``INCLUDES``, ``LFLAGS``, ``CFLAGS`` and ``LIBRARIES``
       dictionaries in ``setup.py`` contain correct values for your platform.
       Starting with ICU 60, ``-std=c++11`` must appear in your CFLAGS or be the
       default for your C++ compiler.

     - **either** build and install PyICU with ``setuptools``
       ```sh
       python setup.py build
       sudo python setup.py install
       ```

     - **or** build PyICU with ``build`` and install it with ``pip``
       ```sh
       python -m build
       sudo python -m pip install dist/PyICU-<version>-<platform>.whl
       ```

     - **either** test PyICU with ``setuptools``
       ```sh
       python setup.py test
       ```

     - **or** test PyICU with ``pytest``
       ```sh
       python -m pytest
       ```




  The instructions at [note_855](https://gitlab.pyicu.org/main/pyicu/-/issues/153#note_855) contain the complete steps for building everything from sources into
  a self-contained directory, without modifying any system directories. They were
  made and tested on an M1 Mac but they can be modified and reused for any unix
  environment. In particular, they outline how to build PyICU from sources
  without icu-config or pkg-config being present.




    - Mac OS X
      Make sure that ``DYLD_LIBRARY_PATH`` contains paths to the directory(ies)
      containing the ICU libs.

    - Linux & Solaris
      Make sure that ``LD_LIBRARY_PATH`` contains paths to the directory(ies)
      containing the ICU libs or that you added the corresponding ``-rpath``
      argument to ``LFLAGS``.

    - Windows
      Make sure that ``PATH`` contains paths to the directory(ies)
      containing the ICU DLLs.




  See the [CHANGES](https://gitlab.pyicu.org/main/pyicu/blob/main/CHANGES) file
  for an up to date log of changes and additions.




  There is no API documentation for PyICU. The API for ICU is documented at
  https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/ and the
  following patterns can be used to translate from the C++ APIs to the
  corresponding Python APIs.



  The ICU string type, [UnicodeString](https://unicode-org.github.io/icu-docs/apidoc/dev/icu4c/classicu_1_1UnicodeString.html), is a type pointing at a mutable array of [UChar](https://unicode-org.github.io/icu-docs/apidoc/dev/icu4c/umachine_8h.html#a6bb9fad572d65b305324ef288165e2ac) Unicode 16-bit wide characters and is described [here](https://unicode-org.github.io/icu-docs/apidoc/dev/icu4c/classicu_1_1UnicodeString.html#details). The Python 3 [str](https://docs.python.org/3/library/stdtypes.html#str) type is described [here](https://docs.python.org/3/library/stdtypes.html#index-26) and [here](https://docs.python.org/3/howto/unicode.html). The Python 2 [unicode](https://docs.python.org/2.7/reference/datamodel.html#index-23) type is described [here](https://docs.python.org/2.7/library/stdtypes.html#sequence-types-str-unicode-list-tuple-bytearray-buffer-xrange).

  Because of their differences, ICU's and Python's string objects are not merged
  into the same type when crossing the C++ boundary but converted.

  ICU APIs taking ``UnicodeString`` arguments have been overloaded to also
  accept arguments that are Python 3 ``str`` or Python 2 ``unicode`` objects.
  Python 2 ``str`` objects are auto-decoded into ICU strings using the ``utf-8``
  encoding.

  To convert a Python 3 ``bytes`` or a Python 2 ``str`` object encoded in an
  encoding other than ``utf-8`` to an ICU ``UnicodeString`` use the
  ``UnicodeString(str, encodingName)`` constructor.

  ICU's C++ APIs accept and return ``UnicodeString`` arguments in several
  ways: by value, by pointer or by reference.
  When an ICU C++ API is documented to accept a ``UnicodeString`` reference
  parameter, it is safe to assume that there are several corresponding
  PyICU python APIs making it accessible in simpler ways:

  For example, the ``'UnicodeString &Locale::getDisplayName(UnicodeString &)'``
  API, documented
  [here](https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1Locale.html#a61def321a9cfd9904b59e3f1897f835e),
  can be invoked from Python in several ways:

  1. The ICU way

          >>> from icu import UnicodeString, Locale
          >>> locale = Locale('pt_BR')
          >>> string = UnicodeString()
          >>> name = locale.getDisplayName(string)
          >>> name
          <UnicodeString: 'Portuguese (Brazil)'>
          >>> name is string
          True                  <-- string arg was returned, modified in place

  2. The Python way

          >>> from icu import Locale
          >>> locale = Locale('pt_BR')
          >>> name = locale.getDisplayName()
          >>> name
          'Portuguese (Brazil)'

      A ``UnicodeString`` object was allocated and converted to a Python
      ``str`` object.

  A UnicodeString can be converted to a Python unicode string with Python 3's
  ``str()`` or Python 2's ``unicode()`` constructor. The usual ``len()``,
  comparison, `[]`` and ``[:]`` operators are all available, with the additional
  twists that slicing is not read-only and that ``+=`` is also available since a
  UnicodeString is mutable. For example:

      >>> name = locale.getDisplayName()
      'Portuguese (Brazil)'
      >>> name = UnicodeString(name)
      >>> name
      <UnicodeString: 'Portuguese (Brazil)'>
      >>> str(name)
      'Portuguese (Brazil)'
      >>> len(name)
      19
      >>> str(name)
      'Portuguese (Brazil)'
      >>> name[3]
      't'
      >>> name[12:18]
      <UnicodeString: 'Brazil'>
      >>> name[12:18] = 'the country of Brasil'
      >>> name
      <UnicodeString: 'Portuguese (the country of Brasil)'>
      >>> name += ' oh joy'
      >>> name
      <UnicodeString: 'Portuguese (the country of Brasil) oh joy'>



  The C++ ICU library does not use C++ exceptions to report errors. ICU
  C++ APIs return errors via a ``UErrorCode`` reference argument. All such
  APIs are wrapped by Python APIs that omit this argument and throw an
  ``ICUError`` Python exception instead. The same is true for ICU APIs
  taking both a ``ParseError`` and a ``UErrorCode``, they are both to be
  omitted.

  For example, the ``'UnicodeString &DateFormat::format(const Formattable &, UnicodeString &, FieldPosition &, UErrorCode &)'`` API, documented [here](https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1DateFormat.html#aae63209f1202550c91e2beed5691b062) is invoked from Python with:

      >>> from icu import DateFormat, Formattable
      >>> df = DateFormat.createInstance()
      >>> df
      <SimpleDateFormat: M/d/yy h:mm a>
      >>> f = Formattable(940284258.0, Formattable.kIsDate)
      >>> df.format(f)
      '10/18/99 3:04 PM'

  Of course, the simpler ``'UnicodeString &DateFormat::format(UDate, UnicodeString &)'`` documented [here](https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1DateFormat.html#a5940ccf5676d3fa043d8255c55b7ddd1) can be used too:

      >>> from icu import DateFormat
      >>> df = DateFormat.createInstance()
      >>> df
      <SimpleDateFormat: M/d/yy h:mm a>
      >>> df.format(940284258.0)
      '10/18/99 3:04 PM'



  ICU uses a double floating point type called ``UDate`` that represents the
  number of milliseconds elapsed since 1970-jan-01 UTC for dates.

  In Python, the value returned by the ``time`` module's ``time()``
  function is the number of seconds since 1970-jan-01 UTC. Because of this
  difference, floating point values are multiplied by 1000 when passed to
  APIs taking ``UDate`` and divided by 1000 when returned as ``UDate``.

  Python's ``datetime`` objects, with or without timezone information, can
  also be used with APIs taking ``UDate`` arguments. The ``datetime``
  objects get converted to ``UDate`` when crossing into the C++ layer.



  Many ICU API take array arguments. A list of elements of the array
  element types is to be passed from Python.



  An ICU ``StringEnumeration`` has three ``next`` methods: ``next()`` which
  returns ``str`` objects, ``unext()`` which returns ``str`` objects in Python 3
  or ``unicode`` objects in Python 2 and ``snext()`` which returns
  ``UnicodeString`` objects. Any of these methods can be used as an iterator,
  using the Python built-in ``iter`` function.

  For example, let ``e`` be a ``StringEnumeration`` instance:

  ```python
  e = TimeZone.createEnumeration()
  [s for s in e] # a list of 'str' objects
  [s for s in iter(e.unext, '')] # a list of 'str' or 'unicode' objects
  [s for s in iter(e.snext, '')] # a list of 'UnicodeString' objects
  ```



  The ICU ``TimeZone`` type may be wrapped with an ``ICUtzinfo`` type for
  usage with Python's ``datetime`` type. For example:

  ```python
  from datetime import datetime
  tz = ICUtzinfo(TimeZone.createTimeZone('US/Mountain'))
  datetime.now(tz)
  ```

  or, even simpler:

  ```python
  tz = ICUtzinfo.getInstance('Pacific/Fiji')
  datetime.now(tz)
  ```

  To get the default time zone use:

  ```python
  defaultTZ = ICUtzinfo.getDefault()
  ```

  To get the time zone's id, use the ``tzid`` attribute or coerce the time
  zone to a string:

  ```python
  ICUtzinfo.getInstance('Pacific/Fiji').tzid -> 'Pacific/Fiji'
  str(ICUtzinfo.getInstance('Pacific/Fiji')) -> 'Pacific/Fiji'
  ```



  The [unit tests](https://gitlab.pyicu.org/main/pyicu/-/tree/main/test) have
  more examples of actual PyICU usage.

  There are also a few
  [samples](https://gitlab.pyicu.org/main/pyicu/-/tree/main/samples) ported from
  ICU C/C++.


pkgId: 9433e962d9d8b4b461729853603a9e0504eb4d6fc44450f6a3bb8cf0c00803e9
name: python-PyInquirer
arch: src
version: 1.0.3
epoch: 0
release: 1
url: https://github.com/CITGuru/PyInquirer/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c0d3852a-7753-4652-aa0f-e43275e6d9ad
location_href: 00012626-python-pyinquirer/python-PyInquirer-1.0.3-1.src.rpm
checksum_type: sha256
summary:
  A Python module for collection of common interactive command line user interfaces, based on Inquirer.js

description:
  A collection of common interactive command line user interfaces. It is
  originally called `whaaaaaat <https://github.com/finklabs/whaaaaat>`__
  created by **finklabs**, but due to bad naming and in need of fixes, I
  decided to rename and apply some necessary fixes on it. The reason is
  because I needed it for a tool that can be install through PyPI. I need
  to rewrite it for my own need. But don't worry any new fix on the main
  Repo, will be added to it if needed. Lastly, I am currently working on
  the author's TODO.


pkgId: 7aca839dfd27ce69a27b98c3b2ac2ac03a1639a7cd7e9ce0d12d1db925db5eed
name: python-PyLEMS
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: A Python library for working with the Low Entropy Model Specification language (LEMS)
url: https://github.com/LEMS/pylems
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6dfe8517-9b74-4919-9680-454dfdc30caf
location_href: 00002869-python-PyLEMS/python-PyLEMS-0.6.0-1.src.rpm
checksum_type: sha256
description:
  [![Build](https://github.com/LEMS/pylems/actions/workflows/ci.yml/badge.svg)](https://github.com/LEMS/pylems/actions/workflows/ci.yml) [![Documentation Status](https://readthedocs.org/projects/pylems/badge/?version=latest)](https://pylems.readthedocs.io/en/latest/?badge=latest)


  A LEMS (http://lems.github.io/LEMS) simulator written in Python which can be used to run NeuroML2 (http://neuroml.org/neuroml2.php) models.

  For more about PyLEMS see:

  Michael Vella, Robert C. Cannon, Sharon Crook, Andrew P. Davison, Gautham Ganapathy, Hugh P. C. Robinson, R. Angus Silver and Padraig Gleeson,
  **libNeuroML and PyLEMS: using Python to combine procedural and declarative modeling approaches in computational neuroscience**
  [Frontiers in Neuroinformatics 2014](http://journal.frontiersin.org/Journal/10.3389/fninf.2014.00038/abstract), doi: 10.3389/fninf.2014.00038

  _**PLEASE CITE THE PAPER ABOVE IF YOU USE PYLEMS!**_

  For more details on LEMS see:

  Robert C. Cannon, Padraig Gleeson, Sharon Crook, Gautham Ganapathy, Boris Marin, Eugenio Piasini and R. Angus Silver,
  **LEMS: A language for expressing complex biological models in concise and hierarchical form and its use in underpinning NeuroML 2**,
  [Frontiers in Neuroinformatics 2014](http://journal.frontiersin.org/Journal/10.3389/fninf.2014.00079/abstract), doi: 10.3389/fninf.2014.00079




  A stable version of PyLEMS is [available on PyPI](https://pypi.python.org/pypi/PyLEMS) using [pip](https://pip.pypa.io/en/latest/installing.html):

      pip install pylems

  To install as root:

      sudo pip install pylems

  Alternatively, you can obtain the latest version with

      git clone https://github.com/LEMS/pylems.git
      cd pylems
      git checkout development   # optional
      sudo python setup.py install



      pylems [options] LEMS_file

  **Options**

  - -I/-include path - Adds a directory to the model file include search path





  **NeuroML examples (from https://github.com/NeuroML/NeuroML2/tree/development/NeuroML2CoreTypes)**

  - Example 0 --  Working
  - Example 1 --  Working
  - Example 2 --  Working
  - Example 3 --  Working
  - Example 4 --  Not working (Unsupported in PyLEMS: KSChannel)
  - Example 5 --  Working
  - Example 6 --  Working
  - Example 7 --  Working
  - Example 8 --  Working
  - Example 9 --  Working
  - Example 10 -- Working
  - Example 11 -- Working
  - Example 12 -- Not working (Unsupported in PyLEMS: Property)
  - Example 13 -- Working
  - Example 14 -- Not working (Unsupported in PyLEMS: Property)
  - Example 15 -- Working
  - Example 16 -- Working (apart from spikeArray)
  - Example 17 -- Working
  - Example 18 -- Working


  **LEMS examples (in directory examples)**

  - example1.xml --  Working
  - example2.xml --  Working
  - example3.xml --  Working
  - example4.xml --  Not working (Unsupported in PyLEMS: KSChannel)
  - example5.xml --  Not working (Unsupported in PyLEMS: KSChannel)
  - example6.xml --  Working
  -- TODO: Rest of examples require an update to the `<Simulation>` element,
     i.e. use `<Simulation...>` not `<SimulationSet...>`, to work in PyLEMS


  **LEMS elements that do not work**

  - KSChannel
  - Property
  - XPath based parameters - PathParameter
  - Assertions

  **Tasks TODO**

  - Implement flattening
  - Decouple events from runnables
  - Improve dimension-checking on expressions.




  pylems is integrated with the the [Travis Continuous Integration service](http://travis-ci.com/).

  [![Build Status](https://travis-ci.com/LEMS/pylems.png?branch=master)](https://travis-ci.com/LEMS/pylems)

  This code is distributed under the terms of the GNU Lesser General Public License.


pkgId: 8fd0e3ba2c895029bcda5a407d906861a1f1b3c1a89efeb268f6d8687a9a394e
name: python-PyLTI1p3
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: LTI 1.3 Advantage Tool implementation in Python
url: https://github.com/dmitry-viskov/pylti1.3
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9c5305d7-7630-4b5a-83aa-e9146e38bbc9
location_href: 00013485-python-pylti1p3/python-PyLTI1p3-2.0.0-1.src.rpm
checksum_type: sha256
description:
  This project is a Python implementation of the similar `PHP tool`_.
  This library contains adapters for use with the Django and Flask web frameworks. However, there are no difficulties with adapting it to other frameworks; you just need to re-implement the ``OIDCLogin`` and ``MessageLaunch`` classes as it is already done in existing adapters.


pkgId: c441675b898c7caf8de5f76fcebf91c44754c4f0ea77ce3df1aceccce06650bb
name: python-PyLaTeX
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: A Python library for creating LaTeX files and snippets
url: https://github.com/JelteF/PyLaTeX
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f61e0429-8413-4387-9d7a-e686d7cb33cf
location_href: 00004720-python-pylatex/python-PyLaTeX-1.4.1-1.src.rpm
checksum_type: sha256
description:
  PyLaTeX is a Python library for creating and compiling LaTeX files or
  snippets. The goal of this library is being an easy, but extensible
  interface between Python and LaTeX.


pkgId: 08c6eaa639b2fb642ac9167adb6e1c00c567409f974fdf04759268c1b58b667c
name: python-PyLink
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: Universal communication interface using File-Like API
url: https://github.com/SalemHarrache/PyLink
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-18388a5f-3121-4955-8adc-544a46639710
location_href: 00002870-python-PyLink/python-PyLink-0.3.3-1.src.rpm
checksum_type: sha256
description:
  Pylink offers a universal communication interface using File-Like API.
  For now, only the **TCP**, **UDP**, **Serial** and **GSM** interfaces are
  supported.
  The aim of this project is to allow any type of communication.
  It is best suited for projects that have various ways of communicating
  including IP remote or local serial communication.


pkgId: 588edb7b5f7b37db5be70314d34db2994fd158dcd5ab9346fc761c3487c167ff
name: python-PyMeeus
arch: src
version: 0.5.12
epoch: 0
release: 1
summary: Python implementation of Jean Meeus astronomical routines
url: https://github.com/architest/pymeeus
rpm_license: LGPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8c0e89ed-69a2-46a6-ae0f-ab02597e0500
location_href: 00004735-python-pymeeus/python-PyMeeus-0.5.12-1.src.rpm
checksum_type: sha256
description:
     **Library of astronomical algorithms in Python**.
  PyMeeus is a Python implementation of the astronomical algorithms
  described in the classical book 'Astronomical Algorithms, 2nd Edition,
  Willmann-Bell Inc. (1998)' by Jean Meeus.
  There are great astronomical libraries out there. For instance, if
  you're looking for high precision and speed you should take a look at
  `libnova <http://libnova.sourceforge.net/>`__. For a set of python
  modules aimed at professional astronomers, you should look at
  `Astropy <http://www.astropy.org/>`__. On the other hand, the advantages
  of PyMeeus are its simplicity, ease of use, ease of reading, ease of
  installation (it has the minimum amount of dependencies) and abundant
  documentation.


pkgId: dda4accb33c93933026e2381c029eda011de26f6ef01811a6831035d26c4ffb8
name: python-PyMsgBox
arch: src
version: 1.0.9
epoch: 0
release: 1
summary: A simple, cross-platform, pure Python module for JavaScript-like message boxes.
url: https://github.com/asweigart/pymsgbox
rpm_license: GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9ecd5a1d-9580-4c05-ba99-048568fa85a6
location_href: 00010085-python-pymsgbox/python-PyMsgBox-1.0.9-1.src.rpm
checksum_type: sha256
description:
   A simple, cross-platform, pure Python module for JavaScript-like message boxes.
  To import, run:
      >>> from pymsgbox import *`
   There are four functions in PyMsgBox, which follow JavaScript's message box naming conventions:
      >>> alert(text='', title='', button='OK')`
      Displays a simple message box with text and a single OK button. Returns the text of the button clicked on.
      >>> confirm(text='', title='', buttons=['OK', 'Cancel'])`
      Displays a message box with OK and Cancel buttons. Number and text of buttons can be customized. Returns the text of the button clicked on.
      >>> prompt(text='', title='' , defaultValue='')`
      Displays a message box with text input, and OK & Cancel buttons. Returns the text entered, or None if Cancel was clicked.
      >>> password(text='', title='', defaultValue='', mask='*')`
      Displays a message box with text input, and OK & Cancel buttons. Typed characters appear as *. Returns the text entered, or None if Cancel was clicked.
  On Linux Python 2, you need to first install Tkinter by running: sudo apt-get install python-tk
  Modified BSD License
  Derived from Stephen Raymond Ferg's EasyGui http://easygui.sourceforge.net/


pkgId: 6f3d62d47a45117344a5a563d570a5560454332db00d5922aa386f46f5bceeba
name: python-PyNLPl
arch: src
version: 1.2.9
epoch: 0
release: 1
url: https://github.com/proycon/pynlpl
rpm_license: GPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-faefe83b-48b4-4c1e-8cb0-f46c0323dcaa
location_href: 00004747-python-pynlpl/python-PyNLPl-1.2.9-1.src.rpm
checksum_type: sha256
summary:
  PyNLPl, pronounced as 'pineapple', is a Python library for Natural Language Processing. It contains various modules useful for common, and less common, NLP tasks. PyNLPl contains modules for basic tasks, clients for interfacting with server, and modules for parsing several file formats common in NLP, most notably FoLiA.

description:
  PyNLPl, pronounced as 'pineapple', is a Python library for Natural Language
  Processing. It contains various modules useful for common, and less common, NLP
  tasks. PyNLPl can be used for basic tasks such as the extraction of n-grams and
  frequency lists, and to build simple language model. There are also more
  complex data types and algorithms. Moreover, there are parsers for file formats
  common in NLP (e.g. FoLiA/Giza/Moses/ARPA/Timbl/CQL). There are also clients to
  interface with various NLP specific servers. PyNLPl most notably features a
  very extensive library for working with FoLiA XML (Format for Linguistic
  Annotatation).
  The library is a divided into several packages and modules. It works on Python
  2.7, as well as Python 3.
  The following modules are available:
  - ``pynlpl.datatypes`` - Extra datatypes (priority queues, patterns, tries)
  - ``pynlpl.evaluation`` - Evaluation & experiment classes (parameter search, wrapped
    progressive sampling, class evaluation (precision/recall/f-score/auc), sampler, confusion matrix, multithreaded experiment pool)
  - ``pynlpl.formats.cgn`` - Module for parsing CGN (Corpus Gesproken Nederlands) part-of-speech tags
  - ``pynlpl.formats.folia`` - Extensive library for reading and manipulating the
    documents in `FoLiA <http://proycon.github.io/folia>`_ format (Format for Linguistic Annotation).
  - ``pynlpl.formats.fql`` - Extensive library for the FoLiA Query Language (FQL),
    built on top of ``pynlpl.formats.folia``. FQL is currently documented `here
    <https://github.com/proycon/foliadocserve>`__.
  - ``pynlpl.formats.cql`` - Parser for the Corpus Query Language (CQL), as also used by
    Corpus Workbench and Sketch Engine. Contains a convertor to FQL.
  - ``pynlpl.formats.giza`` - Module for reading GIZA++ word alignment data
  - ``pynlpl.formats.moses`` - Module for reading Moses phrase-translation tables.
  - ``pynlpl.formats.sonar`` - Largely obsolete module for pre-releases of the
    SoNaR corpus, use ``pynlpl.formats.folia`` instead.
  - ``pynlpl.formats.timbl`` - Module for reading Timbl output (consider using
    `python-timbl <https://github.com/proycon/python-timbl>`_ instead though)
  - ``pynlpl.lm.lm`` - Module for simple language model and reader for ARPA
    language model data as well (used by SRILM).
  - ``pynlpl.search`` - Various search algorithms (Breadth-first, depth-first,
    beam-search, hill climbing, A star, various variants of each)
  - ``pynlpl.statistics`` - Frequency lists, Levenshtein, common statistics and
    information theory functions
  - ``pynlpl.textprocessors`` - Simple tokeniser, n-gram extraction


pkgId: a19b56bf729a278c41b924c555e65c9955a8849c63aefd8bb807929e5b44a08b
name: python-PyNaCl-debuginfo
arch: x86_64
version: 1.5.0
epoch: 0
release: 1
summary: Debug information for package python-PyNaCl
url: https://github.com/pyca/pynacl/
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-9818e7a2-ac70-4bda-9a78-47a0b9fbb295
rpm_sourcerpm: python-PyNaCl-1.5.0-1.src.rpm
location_href: 00008983-python-pynacl/python-PyNaCl-debuginfo-1.5.0-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-PyNaCl.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 56512884845c3d71c8fe88af52bcf57034c7bc070b0c6c2a694125d177dfc554
name: python-PyNaCl-debugsource
arch: x86_64
version: 1.5.0
epoch: 0
release: 1
summary: Debug sources for package python-PyNaCl
url: https://github.com/pyca/pynacl/
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-9818e7a2-ac70-4bda-9a78-47a0b9fbb295
rpm_sourcerpm: python-PyNaCl-1.5.0-1.src.rpm
location_href: 00008983-python-pynacl/python-PyNaCl-debugsource-1.5.0-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-PyNaCl.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 83c3d8763756f42cf9daab60a398459c3647dedbd1922c71bddd91eca09c0177
name: python-PyOpenGL
arch: src
version: 3.1.6
epoch: 0
release: 1
summary: Standard OpenGL bindings for Python
url: http://pyopengl.sourceforge.net
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9b4c4e15-073b-4bbb-9dc6-f7ab9f5fa0cd
location_href: 00004755-python-pyopengl/python-PyOpenGL-3.1.6-1.src.rpm
checksum_type: sha256
description:
  PyOpenGL is normally distributed via PyPI using standard pip::
      $ pip install PyOpenGL PyOpenGL_accelerate
  You can install this repository by branching/cloning and running
  setup.py::
      $ cd pyopengl
      $ python setup.py develop
      $ cd accelerate
      $ python setup.py develop
  Note that to compile PyOpenGL_accelerate you will need to have
  a functioning Python extension-compiling environment.


pkgId: 0eb2279a8b3aec5bd701a5c94ec428986bcda3d8d363e1e427c882ddad53daa1
name: python-PyPDF4
arch: src
version: 1.27.0
epoch: 0
release: 1
summary: PDF toolkit
url: http://claird.github.com/PyPDF4
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-65f97157-4d45-4662-9689-24b9b8669e5a
location_href: 00011093-python-pypdf4/python-PyPDF4-1.27.0-1.src.rpm
checksum_type: sha256
description:
  A Pure-Python library built as a PDF toolkit.  It is capable of:

  - extracting document information (title, author, ...)
  - splitting documents page by page
  - merging documents page by page
  - cropping pages
  - merging multiple pages into a single page
  - encrypting and decrypting PDF files
  - and more!

  By being Pure-Python, it should run on any Python platform without any
  dependencies on external libraries.  It can also work entirely on StringIO
  objects rather than file streams, allowing for PDF manipulation in memory.
  It is therefore a useful tool for websites that manage or manipulate PDFs.


pkgId: 91ee0f8f5ced5435482bf9aca9e3267d5204e4272f0b7e2f3af83de4886f7512
name: python-PyPrind
arch: src
version: 2.11.3
epoch: 0
release: 1
summary: Python Progress Bar and Percent Indicator Utility
url: https://github.com/rasbt/pyprind
rpm_license: BSD 3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8354cde9-6efa-4734-993c-ce9b4fd21834
location_href: 00012142-python-pyprind/python-PyPrind-2.11.3-1.src.rpm
checksum_type: sha256
description:
  If you have any questions or comments about PyPrind,
  please feel free to contact me via
  email: mail@sebastianraschka.com
  or Twitter: https://twitter.com/rasbt


pkgId: 5d4da563fde11d43486f312b90683b20f87ca4947e12936ecf54185111072e08
name: python-PyQtChart
arch: src
version: 5.15.6
epoch: 0
release: 1
summary: Python bindings for the Qt Charts library
url: https://www.riverbankcomputing.com/software/pyqtchart/
rpm_license: GPL v3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-afddf60b-1696-489c-8d3a-5c89fac11759
location_href: 00004773-python-pyqtchart/python-PyQtChart-5.15.6-1.src.rpm
checksum_type: sha256
description:
  PyQtChart is a set of Python bindings for The Qt Company's Qt Charts library.
  The bindings sit on top of PyQt5 and are implemented as a single module.


pkgId: c70234df7153155f34080d555880e7f875b656d95f516442636c426953d272d9
name: python-PyRSS2Gen
arch: src
version: 1.1
epoch: 0
release: 1
summary: Generate RSS2 using a Python data structure
url: http://dalkescientific.com/Python/PyRSS2Gen.html
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5e2a9c32-0603-4409-8d25-85e4030982fc
location_href: 00002876-python-PyRSS2Gen/python-PyRSS2Gen-1.1-1.src.rpm
checksum_type: sha256
description:
  I've finally decided to catch up with 1999 and play around a bit with
  RSS.  I looked around, and while there are many ways to read RSS there
  are remarkably few which write them.  I could use a DOM or other
  construct, but I want the code to feel like Python.  There are more
  Pythonic APIs I might use, like the effbot's ElementTree, but I also
  wanted integers, dates, and lists to be real integers, dates, and
  lists.  (And I want bug-eyed monsters from Alpha Centauri to be *real*
  bug-eyed monsters from Alpha Centauri - is that too much I ask you?)
  The RSS generators I found were built around print statements.
  Workable, but they almost invariably left out proper HTML escaping the
  sort which leads to Mark Pilgrim's to write feed_parser, to make sense
  of documents which are neither XML nor HTML.  Annoying, but sadly all
  too common.
  So I messed around a bit with the spec from
   http://blogs.law.harvard.edu/tech/rss
  The result looks like this:
  import datetime
  import PyRSS2Gen
  rss = PyRSS2Gen.RSS2(
      title = "Andrew's PyRSS2Gen feed",
      link = "http://www.dalkescientific.com/Python/PyRSS2Gen.html",
      description = "The latest news about PyRSS2Gen, a "
                    "Python library for generating RSS2 feeds",
      lastBuildDate = datetime.datetime.now(),
      items = [
         PyRSS2Gen.RSSItem(
           title = "PyRSS2Gen-0.0 released",
           link = "http://www.dalkescientific.com/news/030906-PyRSS2Gen.html",
           description = "Dalke Scientific today announced PyRSS2Gen-0.0, "
                         "a library for generating RSS feeds for Python.  ",
           guid = PyRSS2Gen.Guid("http://www.dalkescientific.com/news/"
                            "030906-PyRSS2Gen.html"),
           pubDate = datetime.datetime(2003, 9, 6, 21, 31)),
         PyRSS2Gen.RSSItem(
           title = "Thoughts on RSS feeds for bioinformatics",
           link = "http://www.dalkescientific.com/writings/diary/"
                  "archive/2003/09/06/RSS.html",
           description = "One of the reasons I wrote PyRSS2Gen was to "
                         "experiment with RSS for data collection in "
                         "bioinformatics.  Last year I came across...",
           guid = PyRSS2Gen.Guid("http://www.dalkescientific.com/writings/"
                                 "diary/archive/2003/09/06/RSS.html"),
           pubDate = datetime.datetime(2003, 9, 6, 21, 49)),
      ])
  rss.write_xml(open("pyrss2gen.xml", "w"))
  The output does not contain newlines, so if you want to read it,
  you'll need to use your favorite XML tools to reformat it.
  RSS is not a fixed format.  People are free to add various metadata,
  like Dublin Core elements.
  The RSS objects are converted to XML using the 'publish' method, which
  takes a SAX2 ContentHandler.  If you want different output, implement
  your own 'publish'.  The "simple" data types which takes a string,
  int, or date, can be replaced with a publishable object, so you can
  add metadata to, say, the "description" field.  To support new
  elements for RSS and RSSItem, derive from them and use the
  'publish_extensions" hook.  To add your own attributes (needed for
  namespace declarations), redefine 'element_attrs' or 'rss_attrs' in
  your subclass.
  To use a different encoding, create your own ContentHandler instead of
  using the helper methods 'to_xml' and 'write_xml.'  You'll need to
  make sure the 'characters' method in the handler does the appropriate
  translation.
  The "categories" list is somewhat special.  It needs to be a list and
  doesn't have a publish method.  That's because the RSS spec doesn't
  have an explicit concept for the set of categories -- an RSS2 channel
  can have 0 or more 'category' elements, but doesn't have a "list of
  categories" -- my "categories" attribute is an API fiction.
  BUGS:
  Several people have used this package since its first release in
  September of 2003 and reported a couple of bugs.  All those are fixed.
  There are no known bugs.
  The name PyRSS2Gen is a mouthful.  It didn't think it was useful to
  come up with a cute name.  You might consider having
     import PyRSS2Gen as RSS2
  in any code which uses this module.  I'm not changing the name because
  anyone who reads "RSS2" will likely think it's a parser and not a
  generator.  Plus, the current name is very easy to find via a web
  search.
  LICENSE:
  This is copyright (c) by Andrew Dalke Scientific, AB (previously
  'Dalke Scientific Software, LLC') and released under the BSD
  license. See the file LICENSE in the distribution, or
    http://www.opensource.org/licenses/bsd-license.php
  for details.
  CHANGES for 1.1: Released August 25, 2012
    - Ported to Python 3.x. Thanks to Graham Bell for the initial patch.
  CHANGES for 1.0: Released November 6, 2005
    - Many people (Richard Chamberlain, Daniel Hsu, Leonart Richardson
    and Daniel Holth) pointed out that Guid sets "isPermaLink" (with a
    "L" not "l").  Fixed, and changed it so the isPermaLink RSS attribute
    is always either "true" or "false" instead of assuming empty means false.
    - Added patches from Erik de Jonge and MATSUNO Tokuhiro to set the
    output encoding.
    - Implemented a suggestion by Daniel Hoth to convert the enclosure
    length to a string.
  CHANGES for 0.1.1: Released in September 2003
    - retroactively renamed "0.0" to "0.1"
    - fixed bug in Image height.  Patch thanks to Edward Dale.


