# packages

pkgId: 839a4b64ee98e57f56296994b2719cc4b241e106caca82bd3d36eed92a8b7970
name: python-rauth
arch: src
version: 0.7.3
epoch: 0
release: 1
summary: A Python library for OAuth 1.0/a, 2.0, and Ofly.
url: https://github.com/litl/rauth
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5c49a22b-2fd5-48ab-951e-881bb1b3289d
location_href: 00011160-python-rauth/python-rauth-0.7.3-1.src.rpm
checksum_type: sha256
description:
      A simple Python OAuth 1.0/a, OAuth 2.0, and Ofly consumer library built on
      top of Requests.
      Links
      `````
      * `documentation <https://rauth.readthedocs.org/en/latest/>`_
      * `development version <https://github.com/maxcountryman/rauth>`_


pkgId: 4b2b9417ed074dd87ec21f08a61056dce2fa8afd477cecdd9f27b5e45efc90ed
name: python-raven
arch: src
version: 6.10.0
epoch: 0
release: 1
summary: Raven is a client for Sentry (https://getsentry.com)
url: https://github.com/getsentry/raven-python
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7c5f0bda-ed19-458c-8f2d-8f77933605e3
location_href: 00004929-python-raven/python-raven-6.10.0-1.src.rpm
checksum_type: sha256
description:
  Raven is a Python client for `Sentry <http://getsentry.com/>`_. It provides
  full out-of-the-box support for many of the popular frameworks, including
  `Django <djangoproject.com>`_, `Flask <http://flask.pocoo.org/>`_, and `Pylons
  <http://www.pylonsproject.org/>`_. Raven also includes drop-in support for any
  `WSGI <https://wsgi.readthedocs.io/>`_-compatible web application.


pkgId: 3a39c2d65cfbd3a0b75c60edeb8d6227fe76885a95b03a2a725080bd358b770b
name: python-rawkit
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: CTypes based LibRaw bindings
url: https://rawkit.readthedocs.org
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-79caac73-d9bb-4a8a-9a8f-e2dae40cc5ac
location_href: 00004931-python-rawkit/python-rawkit-0.6.0-1.src.rpm
checksum_type: sha256
description:
  ``rawkit`` (pronounced `rocket`) is a ctypes-based LibRaw_ binding for
  Python inspired by the Wand_ API.
      from rawkit.raw import Raw
      from rawkit.options import WhiteBalance
      with Raw(filename='some/raw/image.CR2') as raw:
        raw.options.white_balance = WhiteBalance(camera=False, auto=True)
        raw.save(filename='some/destination/image.ppm')
  for more info, see the docs_


pkgId: f826d102926a578d35fadad998b7c47b60595c8c517c9756b4e16f1f7c555252
name: python-rdopkg
arch: src
version: 1.5.1
epoch: 0
release: 1
summary: RPM packaging automation tool
url: https://github.com/softwarefactory-project/rdopkg
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bcb84373-3bc0-4736-88fd-e1347969f14d
location_href: 00004935-python-rdopkg/python-rdopkg-1.5.1-1.src.rpm
checksum_type: sha256
description:
  `rdopkg` is an RPM packaging automation tool. It provides automation for
  package maintenance including git-based patches management and automagic
  rebases to new upstream versions with nice .spec changes, changelogs and
  commit messages for both CLI and CI usage.
  It also contains various functionality we needed for
  [RDO](https://www.rdoproject.org/) packaging, such as advanced
  `requirements.txt` management for python projects and
  [rdoinfo](https://github.com/redhat-openstack/rdoinfo) integration.

  Generic
  [distgit](https://www.rdoproject.org/documentation/intro-packaging/#distgit---where-the-spec-file-lives)
  and patches management functionality and conventions provided by `rdopkg`
  proved to be efficient way of packaging fast-moving upstream projects with
  minimal human effort but without losing control over individual packages.

  `rdopkg` is now considered **stable**. It was originally developed to serve
  the needs of the mighty [RDO](https://www.rdoproject.org/) packager-warriors
  and their weapons such as
  [DLRN](https://github.com/softwarefactory-project/DLRN), but it can help with
  any RPM package. For example, see [how you can manage your RPMs with
  rdopkg](https://www.rdoproject.org//blog/2017/03/let-rdopkg-manage-your-RPM-package/).

  `rdopkg` uses [software factory](https://softwarefactory-project.io/)
  for CI and every commit goes through automatic unit, feature, and integration
  testing as well as human reviews.

  See [open rdopkg reviews](https://softwarefactory-project.io/r/#/q/status:open+project:rdopkg).




  `rdopkg` is currently compatible with both python 3 and python 2.




  `rdopkg` is available on **Fedora 25** and newer:

      dnf install rdopkg

  On CentOS/RHEL 7, `rdopkg` is available from
  [EPEL](https://fedoraproject.org/wiki/EPEL).

  On **CentOS 7**:

      yum install epel-release
      yum install rdopkg

  On **RHEL 7**:

      yum install https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
      yum install rdopkg




  If you want to hack `rdopkg` or just have the latest fixes without waiting for
  next release, I suggest using the git repo directly:

      git clone https://github.com/softwarefactory-project/rdopkg
      cd rdopkg
      python setup.py develop --user

  You may set the preference over `rdopkg` RPM by correctly positioning
  `~/.local/bin/rdopkg` in your `$PATH`.

  Or you can use virtualenv to avoid conflicts with RPM:

      git clone https://github.com/softwarefactory-project/rdopkg
      cd rdopkg
      virtualenv --system-site-packages ~/rdopkg-venv
      source ~/rdopkg-venv/bin/activate
      python setup.py develop
      ln `which rdopkg` ~/bin/rdopkg-dev

      rdopkg-dev --version

  Required python modules are listed in
  [requirements.txt](requirements.txt) and also in
  [rdopkg.spec](https://src.fedoraproject.org/rpms/rdopkg/blob/master/f/rdopkg.spec) as
  RPM Requires.




  For your convenience, `rdopkg` is also available from the Cheese
  Shop. This should come in handy especially if you want to reuse `rdopkg` as
  a module.

      pip install rdopkg

  Note that you need to have python2-rpm(resp. python3-rpm) package installed in
  order for RPM macro related featuers to work as it isn't available from
  PyPI.




  Exhaustive `rdopkg` manual is available, you can:

   * read it nicely rendered on github: [rdopkg manual](https://github.com/softwarefactory-project/rdopkg/blob/master/doc/rdopkg.1.adoc)
   * run `man rdopkg` if you installed from RPM
   * render it to HTML/man using `make doc`

  You might also be interested in
  [RDO packaging intro](https://www.rdoproject.org/documentation/intro-packaging/)
  which contains some examples of `rdopkg` usage and more.




  Please use the
  [github Issues](https://github.com/softwarefactory-project/rdopkg/issues)
  to report bugs. I usually fix critical bugs within days.


pkgId: ea89fad8df017647c18f48da0520587bd79b7a443535033c24d19c2a1a48a796
name: python-rdt
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Reversible Data Transforms
url: https://github.com/sdv-dev/RDT
rpm_license: BSL-1.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-adcde2dc-20e7-4add-8850-f6c8191a7a67
location_href: 00014071-python-rdt/python-rdt-1.3.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
  <a href="https://datacebo.com"><img align="center" width=40% src="https://github.com/sdv-dev/SDV/blob/master/docs/images/DataCebo.png"></img></a>
  </div>
  <br/>
  <br/>
  [The Synthetic Data Vault Project](https://sdv.dev) was first created at MIT's [Data to AI Lab](
  https://dai.lids.mit.edu/) in 2016. After 4 years of research and traction with enterprise, we
  created [DataCebo](https://datacebo.com) in 2020 with the goal of growing the project.
  Today, DataCebo is the proud developer of SDV, the largest ecosystem for
  synthetic data generation & evaluation. It is home to multiple libraries that support synthetic
  data, including:
  * 🔄 Data discovery & transformation. Reverse the transforms to reproduce realistic data.
  * 🧠 Multiple machine learning models -- ranging from Copulas to Deep Learning -- to create tabular,
    multi table and time series data.
  * 📊 Measuring quality and privacy of synthetic data, and comparing different synthetic data
    generation models.
  [Get started using the SDV package](https://sdv.dev/SDV/getting_started/install.html) -- a fully
  integrated solution and your one-stop shop for synthetic data. Or, use the standalone libraries
  for specific needs.


  This release makes changes to the way that individual transformers are stored in the `HyperTransformer`. When accessing the config via `HyperTransformer.get_config()`, the transformers listed in the config are now the actual transformer instances used during fitting and transforming. These instances can now be accessed and used to examine their properties post fitting. For example, you can now view the mapping for a `PseudoAnonymizedFaker` instance using `PseudoAnonymizedFaker.get_mapping()` on the instance retrieved from the config.
  Additionally, the output of `reverse_tranform` no longer appends the `.value` suffix to every unnamed output column. Only output columns that are created from context extracted from the input columns will have suffixes (eg. `.normalized` in the `ClusterBasedNormalizer`).
  The `AnonymizedFaker` and `RegexGenerator` now have an `enforce_uniqueness` parameter, which controls whether the data returned by `reverse_transform` should be unique. The `HyperTransformer` now has a method called `create_anonymized_columns` that can be used to generate columns that are matched with anonymizing transformers like `AnonymizedFaker` and `RegexGenerator`. The method can be used as follows:
  `HyperTransformer.create_anonymized_columns(num_rows=5, column_names=['email_optin', 'credit_card'])`
  Another major change in this release is the ability to control randomization. Every time a `HyperTransformer` is initialized, its randomness will be reset to the same seed, and it will yield the same results for `reverse_transform` if given the same input. Every subsequent call to `reverse_transform` yields a different result. If a user desires to reset the seed, they can call `HyperTransformer.reset_randomization`.
  Finally, this release adds support for Python 3.10 and drops support for 3.6.

  * The reset_randomization should also apply to fit and transform - Issue [#608](https://github.com/sdv-dev/RDT/issues/608) by @amontanez24
  * Cannot print CustomLabelEncoder: ValueError - Issue [#607](https://github.com/sdv-dev/RDT/issues/607) by @amontanez24
  * Float formatter learn_rounding_scheme doesn't work on all digits - Issue [#556](https://github.com/sdv-dev/RDT/issues/556) by @fealho
  * Warnings not showing on update_transformers_by_sdtype - Issue [#582](https://github.com/sdv-dev/RDT/issues/582) by @amontanez24
  * OneHotEncoder doesn't work with boolean sdtype - Issue [#583](https://github.com/sdv-dev/RDT/issues/583) by @pvk-developer
  * Setting config on HyperTransformer does not read supported_sdtypes - Issue [#560](https://github.com/sdv-dev/RDT/issues/560) by @pvk-developer
  * https://github.com/sdv-dev/RDT/issues/545 - Issue [#545](https://github.com/sdv-dev/RDT/issues/545) by @pvk-developer
  * Add error to NullTransformer when data only contains nans - PR [#567](https://github.com/sdv-dev/RDT/pull/567) by @fealho
  * Update update_transformers validation - PR [#563](https://github.com/sdv-dev/RDT/pull/563) by @fealho

  * Support Python 3.10 - Issue [#593](https://github.com/sdv-dev/RDT/issues/593) by @pvk-developer
  * RDT 1.3 Package Maintenance Updates - Issue [#594](https://github.com/sdv-dev/RDT/issues/594) by @pvk-developer

  * Update errors - Issue [#599](https://github.com/sdv-dev/RDT/issues/599) by @amontanez24
  * Add ability to control randomness - Issue [#584](https://github.com/sdv-dev/RDT/issues/584) by @amontanez24
  * Printing and error improvements - Issue [#581](https://github.com/sdv-dev/RDT/issues/581) by @amontanez24
  * Make RegexGenerator not to reset itself - Issue [#558](https://github.com/sdv-dev/RDT/issues/558) by @pvk-developer
  * Add a reset_anonymization method - Issue [#559](https://github.com/sdv-dev/RDT/issues/559) by @pvk-developer
  * Don't copy instances of tranformer - Issue [#541](https://github.com/sdv-dev/RDT/issues/541) by @fealho
  * Remove '.value' suffix - Issue [#533](https://github.com/sdv-dev/RDT/issues/533) by @fealho
  * Change the NEXT_TRANSFORMERS logic - Issue [#557](https://github.com/sdv-dev/RDT/issues/557) by @fealho
  * Add utility functions to AnonymizedFaker - Issue [#561](https://github.com/sdv-dev/RDT/issues/561) by @pvk-developer
  * Update API for update_transformers_by_sdtype to be more explicit about instances vs. copies - Issue [#540](https://github.com/sdv-dev/RDT/issues/540) by @fealho
  * Add create_anonymized_columns method to anonymize data from scratch - Issue [#546](https://github.com/sdv-dev/RDT/issues/546) by @pvk-developer
  * Add parameter to AnonymizedFaker() and RegexGenerator() to generate only unique values - Issue [#542](https://github.com/sdv-dev/RDT/issues/542) by @pvk-developer

  This release fixes a bug that caused the `UnixTimestampEncoder` to return data with the incorrect datetime format. It also fixes a bug that caused the null column
  not to be reverse transformed when using the `UnixTimestampEncoder` when the `missing_value_replacement` was not set.

  * Inconsistency in date format after reverse transform - Issue [#515](https://github.com/sdv-dev/RDT/issues/515) by @pvk-developer
  * Fix calling null_transformer with model_missing_values. - PR [#550](https://github.com/sdv-dev/RDT/pull/550) by @pvk-developer

  This release adds a new transformer called the `PseudoAnonymizedFaker`. This transformer enables the pseudo-anonymization of your data by mapping all of a column's original values to fake values that get returned during the reverse transformation process. Each original value is always mapped to the same fake value.
  Additionally, this release enables the `HyperTransformer` to use categorical transformers on boolean columns. It also introduces a new parameter called `computer_representation` to the `FloatFormatter` that will allow for values to be clipped to certain bounds based on the computer type used for a numerical column.
  Finally, this release patches a bug that caused unpredicatable results from the `reverse_transform` method of the `FrequencyEncoder` when `add_noise` is enabled.

  * Add PseudoAnonymizedFaker transformer - Issue [#517](https://github.com/sdv-dev/RDT/issues/517) by @pvk-developer
  * Boolean columns should be able to use any of the categorical transformers - Issue[#527](https://github.com/sdv-dev/RDT/issues/527) by @pvk-developer
  * Update FloatFormatter with parameters for the computer representation - Issue[#521](https://github.com/sdv-dev/RDT/issues/521) by @fealho

  * Unpredictable results for FrequencyEncoder(add_noise=True) - Issue [#528](https://github.com/sdv-dev/RDT/issues/528) by @fealho

  * Performance Tests update - Issue [#524](https://github.com/sdv-dev/RDT/issues/524) by @pvk-developer

  This release adds multiple new transformers: the `CustomLabelEncoder` and the `RegexGenerator`. The `CustomLabelEncoder` works similarly
  to the `LabelEncoder`, except it allows users to provide the order of the categories. The `RegexGenerator` allows users to specify a regex
  pattern and will generate values that match that pattern.
  This release also improves current transformers. The `LabelEncoder` now has a parameter called `order_by` that allows users to specify the
  ordering scheme for their data (eg. order numerically or alphabetically). The `LabelEncoder` also now has a parameter called `add_noise`
  that allows users to specify whether or not uniform noise should be added to the transformed data. Performance enhancements were made for the
  `GaussianNormalizer` by removing an unnecessary distribution search and the `FloatFormatter` will no longer round values to any place higher
  than the ones place by default.

  * Add noise parameter to LabelEncoder - Issue [#500](https://github.com/sdv-dev/RDT/issues/500) by @fealho
  * Remove parameters related to distribution search and change default for GaussianNormalizer - Issue [#499](https://github.com/sdv-dev/RDT/issues/499)
  by @amontanez24
  * Add order_by parameter to LabelEncoder - Issue [#510](https://github.com/sdv-dev/RDT/issues/506) by @amontanez24
  * Only round to decimal places in FloatFormatter - Issue [#508](https://github.com/sdv-dev/RDT/issues/508) by @fealho
  * Add CustomLabelEncoder transformer - Issue [#507](https://github.com/sdv-dev/RDT/issues/507) by @amontanez24
  * Add RegexGenerator Transformer - Issue [#505](https://github.com/sdv-dev/RDT/issues/505) by @pvk-developer

  The main update of this release is the introduction of a `config`, which describes the `sdtypes` and `transformers` that will be used by the `HyperTransformer` for each column of the data, where `sdtype` stands for the **semantic** or **statistical** meaning of a datatype. The user can interact with this config through the newly created methods `update_sdtypes`, `get_config`, `set_config`, `update_transformers`, `update_transformers_by_sdtype` and `remove_transformer_by_sdtype`.
  This release also included various new features and updates, including:
  * Users can now transform subsets of the data using its own methods, `transform_subset` and `reverse_transform_subset`.
  * User validation was added for the following methods: `transform`, `reverse_transform`, `update_sdtypes`, `update_transformers`, `set_config`.
  * Unnecessary warnings were removed from `GaussianNormalizer.fit` and `FrequencyEncoder.transform`.
  * The user can now set a transformers as None.
  * Transformers that cannot work with missing values will automatically fill them in.
  * Added support for additional datetime formats.
  * Setting  `model_missing_values = False` in a transformer was updated to keep track of the percentage of missing values, instead of producing data containing `NaN`'s.
  * All parameters were removed from the `HyperTransformer`.
  * The demo dataset `get_demo` was improved to be more intuitive.
  Finally, a number of transformers were redesigned to be more user friendly. Among them, the following transformers have also been renamed:
  * `BayesGMMTransformer` -> `ClusterBasedNormalizer`
  * `GaussianCopulaTransformer` -> `GaussianNormalizer`
  * `DateTimeRoundedTransformer` -> `OptimizedTimestampEncoder`
  * `DateTimeTransformer` -> `UnixTimestampEncoder`
  * `NumericalTransformer` -> `FloatFormatter`
  * `LabelEncodingTransformer` -> `LabelEncoder`
  * `OneHotEncodingTransformer` -> `OneHotEncoder`
  * `CategoricalTransformer` -> `FrequencyEncoder`
  * `BooleanTransformer` -> `BinaryEncoder`
  * `PIIAnonymizer` -> `AnonymizedFaker`

  * Fix using None as transformer when update_transformers_by_sdtype - Issue [#496](https://github.com/sdv-dev/RDT/issues/496) by @pvk-developer
  * Rename PIIAnonymizer --> AnonymizedFaker - Issue [#483](https://github.com/sdv-dev/RDT/issues/483) by @pvk-developer
  * User validation for reverse_transform - Issue [#480](https://github.com/sdv-dev/RDT/issues/480) by @amontanez24
  * User validation for transform - Issue [#479](https://github.com/sdv-dev/RDT/issues/479) by @fealho\
  * User validation for set_config - Issue [#478](https://github.com/sdv-dev/RDT/issues/478) by @fealho
  * User validation for update_transformers_by_sdtype - Issue [#477](https://github.com/sdv-dev/RDT/issues/477) by @amontanez24
  * User validation for update_transformers - Issue [#475](https://github.com/sdv-dev/RDT/issues/475) by @fealho
  * User validation for update_sdtypes - Issue [#474](https://github.com/sdv-dev/RDT/issues/474) by @fealho
  * Allow columns to not have a transformer - Issue [#473](https://github.com/sdv-dev/RDT/issues/473) by @pvk-developer
  * Create methods to transform a subset of the data (& reverse transform it) - Issue [#472](https://github.com/sdv-dev/RDT/issues/472) by @amontanez24
  * Throw a warning if you use set_config on a HyperTransformer that's already fit - Issue [#466](https://github.com/sdv-dev/RDT/issues/466) by @amontanez24
  * Update README for RDT 1.0 - Issue [#454](https://github.com/sdv-dev/RDT/issues/454) by @amontanez24
  * Issue with printing PIIAnonymizer in HyperTransformer - Issue [#452](https://github.com/sdv-dev/RDT/issues/452) by @pvk-developer
  * Pretty print get_config - Issue [#450](https://github.com/sdv-dev/RDT/issues/450) by @pvk-developer
  * Silence warning for GaussianNormalizer.fit - Issue [#443](https://github.com/sdv-dev/RDT/issues/443) by @pvk-developer
  * Transformers that cannot work with missing values should automatically fill them in - Issue [#442](https://github.com/sdv-dev/RDT/issues/442) by @amontanez24
  * More descriptive error message in PIIAnonymizer when provider_name and function_name don't align - Issue [#440](https://github.com/sdv-dev/RDT/issues/440) by @pvk-developer
  * Can we support additional datetime formats? - Issue [#439](https://github.com/sdv-dev/RDT/issues/439) by @pvk-developer
  * Update FrequencyEncoder.transform so that pandas won't throw a warning - Issue [#436](https://github.com/sdv-dev/RDT/issues/436) by @pvk-developer
  * Update functionality when model_missing_values=False - Issue [#435](https://github.com/sdv-dev/RDT/issues/435) by @amontanez24
  * Create methods for getting and setting a config - Issue [#418](https://github.com/sdv-dev/RDT/issues/418) by @amontanez24
  * Input validation & error handling in HyperTransformer - Issue [#408](https://github.com/sdv-dev/RDT/issues/408) by @fealho and @amontanez24
  * Remove unneeded params from HyperTransformer - Issue [#407](https://github.com/sdv-dev/RDT/issues/407) by @pvk-developer
  * Rename property: _valid_output_sdtypes - Issue [#406](https://github.com/sdv-dev/RDT/issues/406) by @amontanez24
  * Add pii as a new sdtype in HyperTransformer - Issue [#404](https://github.com/sdv-dev/RDT/issues/404) by @pvk-developer
  * Update transformers by data type (in HyperTransformer) - Issue [#403](https://github.com/sdv-dev/RDT/issues/403) by @pvk-developer
  * Update transformers by column name in HyperTransformer - Issue [#402](https://github.com/sdv-dev/RDT/issues/402) by @pvk-developer
  * Improve updating field_data_types in HyperTransformer - Issue [#400](https://github.com/sdv-dev/RDT/issues/400) by @amontanez24
  * Create method to auto detect HyperTransformer config from data - Issue [#399](https://github.com/sdv-dev/RDT/issues/399) by @fealho
  * Update HyperTransformer default transformers - Issue [#398](https://github.com/sdv-dev/RDT/issues/398) by @fealho
  * Add PIIAnonymizer - Issue [#397](https://github.com/sdv-dev/RDT/issues/397) by @pvk-developer
  * Improve the way we print an individual transformer - Issue [#395](https://github.com/sdv-dev/RDT/issues/395) by @amontanez24
  * Rename columns parameter in fit for each individual transformer - Issue [#376](https://github.com/sdv-dev/RDT/issues/376) by @fealho and @pvk-developer
  * Create a more descriptive demo dataset - Issue [#374](https://github.com/sdv-dev/RDT/issues/374) by @fealho
  * Delete unnecessary transformers - Issue [#373](https://github.com/sdv-dev/RDT/issues/373) by @fealho
  * Update NullTransformer to make it user friendly - Issue [#372](https://github.com/sdv-dev/RDT/issues/372) by @pvk-developer
  * Update BayesGMMTransformer to make it user friendly - Issue [#371](https://github.com/sdv-dev/RDT/issues/371) by @amontanez24
  * Update GaussianCopulaTransformer to make it user friendly - Issue [#370](https://github.com/sdv-dev/RDT/issues/370) by @amontanez24
  * Update DateTimeRoundedTransformer to make it user friendly - Issue [#369](https://github.com/sdv-dev/RDT/issues/369) by @amontanez24
  * Update DateTimeTransformer to make it user friendly - Issue [#368](https://github.com/sdv-dev/RDT/issues/368) by @amontanez24
  * Update NumericalTransformer to make it user friendly - Issue [#367](https://github.com/sdv-dev/RDT/issues/367) by @amontanez24
  * Update LabelEncodingTransformer to make it user friendly - Issue [#366](https://github.com/sdv-dev/RDT/issues/366) by @fealho
  * Update OneHotEncodingTransformer to make it user friendly - Issue [#365](https://github.com/sdv-dev/RDT/issues/365) by @fealho
  * Update CategoricalTransformer to make it user friendly - Issue [#364](https://github.com/sdv-dev/RDT/issues/364) by @fealho
  * Update BooleanTransformer to make it user friendly - Issue [#363](https://github.com/sdv-dev/RDT/issues/363) by @fealho
  * Update names & functionality for handling missing values - Issue [#362](https://github.com/sdv-dev/RDT/issues/362) by @pvk-developer

  * Checking keys of config as set - Issue [#497](https://github.com/sdv-dev/RDT/issues/497) by @amontanez24
  * Only update transformer used when necessary for update_sdtypes - Issue [#469](https://github.com/sdv-dev/RDT/issues/469) by @amontanez24
  * Fix how get_config prints transformers - Issue [#468](https://github.com/sdv-dev/RDT/issues/468) by @pvk-developer
  * NullTransformer reverse_transform alters input data due to not copying - Issue [#455](https://github.com/sdv-dev/RDT/issues/455) by @amontanez24
  * Attempting to transform a subset of the data should lead to an Error - Issue [#451](https://github.com/sdv-dev/RDT/issues/451) by @amontanez24
  * Detect_initial_config isn't detecting sdtype "numerical" - Issue [#449](https://github.com/sdv-dev/RDT/issues/449) by @pvk-developer
  * PIIAnonymizer not generating multiple locales - Issue [#447](https://github.com/sdv-dev/RDT/issues/447) by @pvk-developer
  * Error when printing ClusterBasedNormalizer and GaussianNormalizer - Issue [#441](https://github.com/sdv-dev/RDT/issues/441) by @pvk-developer
  * Datetime reverse transform crashes if datetime_format is specified - Issue [#438](https://github.com/sdv-dev/RDT/issues/438) by @amontanez24
  * Correct datetime format is not recovered on reverse_transform - Issue [#437](https://github.com/sdv-dev/RDT/issues/437) by @pvk-developer
  * Use numpy NaN values in BinaryEncoder - Issue [#434](https://github.com/sdv-dev/RDT/issues/434) by @pvk-developer
  * Duplicate _output_columns during fitting - Issue [#423](https://github.com/sdv-dev/RDT/issues/423) by @fealho

  * Making methods that aren't part of API private - Issue [#489](https://github.com/sdv-dev/RDT/issues/489) by @amontanez24
  * Fix columns missing in config and update transformers to None - Issue [#495](https://github.com/sdv-dev/RDT/issues/495) by @pvk-developer

  This release fixes multiple bugs concerning the `HyperTransformer`. One is that the `get_transformer_tree_yaml` method no longer crashes on
  every call. Another is that calling the `update_field_data_types` and `update_default_data_type_transformers` after fitting no longer breaks the `transform`
  method.
  The `HyperTransformer` now sorts its outputs for both `transform` and `reverse_transform` based on the order of the input's columns. It is also now possible
  to create transformers that simply drops columns during `transform` and don't return any new columns.

  * Support dropping a column trough a transformer - Issue [#393](https://github.com/sdv-dev/RDT/issues/393) by @pvk-developer
  * HyperTransformer should sort columns after transform and reverse_transform - Issue [#405](https://github.com/sdv-dev/RDT/issues/405) by @fealho

  * get_transformer_tree_yaml fails - Issue [#389](https://github.com/sdv-dev/RDT/issues/389) by @amontanez24
  * HyperTransformer _unfit method not working correctly - Issue [#390](https://github.com/sdv-dev/RDT/issues/390) by @amontanez24
  * Blank dataframe after updating the data types - Issue [#401](https://github.com/sdv-dev/RDT/issues/401) by @amontanez24

  This release adds a new module to the `RDT` library called `performance`. This module can be used to evaluate the speed and peak memory usage
  of any transformer in RDT. This release also increases the maximum acceptable version of scikit-learn to make it more compatible with other libraries
  in the `SDV` ecosystem. On top of that, it fixes a bug related to a new version of `pandas`.

  * Move profiling functions into RDT library - Issue [#353](https://github.com/sdv-dev/RDT/issues/353) by @amontanez24

  * Increase scikit-learn dependency range - Issue [#351](https://github.com/sdv-dev/RDT/issues/351) by @amontanez24
  * pandas 1.4.0 release causes a small error - Issue [#358](https://github.com/sdv-dev/RDT/issues/358) by @fealho

  * Performance tests get stuck on Unix if multiprocessing is involved - Issue [#337](https://github.com/sdv-dev/RDT/issues/337) by @amontanez24

  This release adds a new `BayesGMMTransformer`. This transformer can be used to convert a numerical column into two
  columns: a discrete column indicating the selected `component` of the GMM for each row, and a continuous column containing
  the normalized value of each row based on the `mean` and `std` of the selected `component`. It is useful when the column being transformed
  came from multiple distributions.
  This release also adds multiple new methods to the `HyperTransformer` API. These allow for users to access the specfic
  transformers used on each input field, as well as view the entire tree of transformers that are used when running `transform`.
  The exact methods are:
  * `BaseTransformer.get_input_columns()` - Return list of input columns for a transformer.
  * `BaseTransformer.get_output_columns()` - Return list of output columns for a transformer.
  * `HyperTransformer.get_transformer(field)` - Return the transformer instance used for a field.
  * `HyperTransformer.get_output_transformers(field)` - Return dictionary mapping output columns of a field to the transformers used on them.
  * `HyperTransformer.get_final_output_columns(field)` - Return list of all final output columns related to a field.
  * `HyperTransformer.get_transformer_tree_yaml()` - Return YAML representation of transformers tree.
  Additionally, this release fixes a bug where the `HyperTransformer` was incorrectly raising a `NotFittedError`. It also improved the
  `DatetimeTransformer` by autonomously detecting if a column needs to be converted from `dtype` `object` to `dtype` `datetime`.

  * Cast column to datetime if specified in field transformers - Issue [#321](https://github.com/sdv-dev/RDT/issues/321) by @amontanez24
  * Add a BayesianGMM Transformer - Issue [#183](https://github.com/sdv-dev/RDT/issues/183) by @fealho
  * Add transformer tree structure and traversal methods - Issue [#330](https://github.com/sdv-dev/RDT/issues/330) by @amontanez24

  * HyperTransformer raises NotFittedError after fitting - Issue [#332](https://github.com/sdv-dev/RDT/issues/332) by @amontanez24

  This release adds support for Python 3.9! It also removes unused document files.

  * Add support for Python 3.9 - Issue [#323](https://github.com/sdv-dev/RDT/issues/323) by @amontanez24
  * Remove docs - PR [#322](https://github.com/sdv-dev/RDT/pull/322) by @pvk-developer

  This release makes major changes to the underlying code for RDT as well as the API for both the `HyperTransformer` and `BaseTransformer`.
  The changes enable the following functionality:
  * The `HyperTransformer` can now apply a sequence of transformers to a column.
  * Transformers can now take multiple columns as an input.
  * RDT has been expanded to allow for infinite data types to be added instead of being restricted to `pandas.dtypes`.
  * Users can define acceptable output types for running `HyperTransformer.transform`.
  * The `HyperTransformer` will continuously apply transformations to the input fields until only acceptable data types are in the output.
  * Transformers can return data of any data type.
  * Transformers now have named outputs and output types.
  * Transformers can suggest which transformer to use on any of their outputs.
  To take advantage of this functionality, the following API changes were made:
  * The `HyperTransformer` has new initialization parameters that allow users to specify data types for any field in their data as well as
  specify which transformer to use for a field or data type. The parameters are:
      * `field_transformers` - A dictionary allowing users to specify which transformer to use for a field or derived field. Derived fields
      are fields created by running `transform` on the input data.
      * `field_data_types` - A dictionary allowing users to specify the data type of a field.
      * `default_data_type_transformers` - A dictionary allowing users to specify the default transformer to use for a data type.
      * `transform_output_types` - A dictionary allowing users to specify which data types are acceptable for the output of `transform`.
      This is a result of the fact that transformers can now be applied in a sequence, and not every transformer will return numeric data.
  * Methods were also added to the `HyperTransformer` to allow these parameters to be modified. These include `get_field_data_types`,
  `update_field_data_types`, `get_default_data_type_transformers`, `update_default_data_type_transformers` and `set_first_transformers_for_fields`.
  * The `BaseTransformer` now requires the column names it will transform to be provided to `fit`, `transform` and `reverse_transform`.
  * The `BaseTransformer` added the following method to allow for users to see its output fields and output types: `get_output_types`.
  * The `BaseTransformer` added the following method to allow for users to see the next suggested transformer for each output field:
  `get_next_transformers`.
  On top of the changes to the API and the capabilities of RDT, many automated checks and tests were also added to ensure that contributions
  to the library abide by the current code style, stay performant and result in data of a high quality. These tests run on every push to the
  repository. They can also be run locally via the following functions:
  * `validate_transformer_code_style` - Checks that new code follows the code style.
  * `validate_transformer_quality` - Tests that new transformers yield data that maintains relationships between columns.
  * `validate_transformer_performance` - Tests that new transformers don't take too much time or memory.
  * `validate_transformer_unit_tests` - Checks that the unit tests cover all new code, follow naming conventions and pass.
  * `validate_transformer_integration` - Checks that the integration tests follow naming conventions and pass.

  * Update HyperTransformer API - Issue [#298](https://github.com/sdv-dev/RDT/issues/298) by @amontanez24
  * Create validate_pull_request function - Issue [#254](https://github.com/sdv-dev/RDT/issues/254) by @pvk-developer
  * Create validate_transformer_unit_tests function - Issue [#249](https://github.com/sdv-dev/RDT/issues/249) by @pvk-developer
  * Create validate_transformer_performance function - Issue [#251](https://github.com/sdv-dev/RDT/issues/251) by @katxiao
  * Create validate_transformer_quality function - Issue [#253](https://github.com/sdv-dev/RDT/issues/253) by @amontanez24
  * Create validate_transformer_code_style function - Issue [#248](https://github.com/sdv-dev/RDT/issues/248) by @pvk-developer
  * Create validate_transformer_integration function - Issue [#250](https://github.com/sdv-dev/RDT/issues/250) by @katxiao
  * Enable users to specify transformers to use in HyperTransformer - Issue [#233](https://github.com/sdv-dev/RDT/issues/233) by @amontanez24 and @csala
  * Addons implementation - Issue [#225](https://github.com/sdv-dev/RDT/issues/225) by @pvk-developer
  * Create ways for HyperTransformer to know which transformers to apply to each data type - Issue [#232](https://github.com/sdv-dev/RDT/issues/232) by @amontanez24 and @csala
  * Update categorical transformers - PR [#231](https://github.com/sdv-dev/RDT/pull/231) by @fealho
  * Update numerical transformer - PR [#227](https://github.com/sdv-dev/RDT/pull/227) by @fealho
  * Update datetime transformer - PR [#230](https://github.com/sdv-dev/RDT/pull/230) by @fealho
  * Update boolean transformer - PR [#228](https://github.com/sdv-dev/RDT/pull/228) by @fealho
  * Update null transformer - PR [#229](https://github.com/sdv-dev/RDT/pull/229) by @fealho
  * Update the baseclass - PR [#224](https://github.com/sdv-dev/RDT/pull/224) by @fealho

  * If the input data has a different index, the reverse transformed data may be out of order - Issue [#277](https://github.com/sdv-dev/RDT/issues/277) by @amontanez24

  * RDT contributing guide - Issue [#301](https://github.com/sdv-dev/RDT/issues/301) by @katxiao and @amontanez24

  * Add PR template for new transformers - Issue [#307](https://github.com/sdv-dev/RDT/issues/307) by @katxiao
  * Implement Quality Tests for Transformers - Issue [#252](https://github.com/sdv-dev/RDT/issues/252) by @amontanez24
  * Update performance test structure - Issue [#257](https://github.com/sdv-dev/RDT/issues/257) by @katxiao
  * Automated integration test for transformers - Issue [#223](https://github.com/sdv-dev/RDT/issues/223) by @katxiao
  * Move datasets to its own module - Issue [#235](https://github.com/sdv-dev/RDT/issues/235) by @katxiao
  * Fix missing coverage in rdt unit tests - Issue [#219](https://github.com/sdv-dev/RDT/issues/219) by @fealho
  * Add repo-wide automation - Issue [#309](https://github.com/sdv-dev/RDT/issues/309) by @katxiao

  * DeprecationWarning: np.float is a deprecated alias for the builtin float - Issue [#304](https://github.com/sdv-dev/RDT/issues/304) by @csala
  * Add pip check to CI workflows - Issue [#290](https://github.com/sdv-dev/RDT/issues/290) by @csala
  * Should Transformers subclasses exist for specific configurations? - Issue [#243](https://github.com/sdv-dev/RDT/issues/243) by @fealho

  This release fixes a bug with learning rounding digits in the `NumericalTransformer`,
  and includes a few housekeeping improvements.

  * Update learn rounding digits to handle all nan data - Issue [#244](https://github.com/sdv-dev/RDT/issues/244) by @katxiao
  * Adapt to latest PyLint housekeeping - Issue [#216](https://github.com/sdv-dev/RDT/issues/216) by @fealho

  This release fixes a couple of bugs introduced by the previous release regarding the
  `OneHotEncodingTransformer` and the `BooleanTransformer`.

  * BooleanTransformer.reverse_transform sometimes crashes with TypeError - Issue [#210](https://github.com/sdv-dev/RDT/issues/210) by @katxiao
  * OneHotEncodingTransformer causing shape misalignment in CopulaGAN, CTGAN, and TVAE - Issue [#208](https://github.com/sdv-dev/RDT/issues/208) by @sarahmish
  * Boolean.transformer.reverse_transform modifies the input data - Issue [#211](https://github.com/sdv-dev/RDT/issues/211) by @katxiao

  This release improves the overall performance of the library, both in terms of memory and time consumption.
  More specifically, it makes the following modules more efficient: `NullTransformer`, `DatetimeTransformer`,
  `LabelEncodingTransformer`, `NumericalTransformer`, `CategoricalTransformer`, `BooleanTransformer` and `OneHotEncodingTransformer`.
  It also adds performance-based testing and a script for profiling the performance.

  * Add performance-based testing - Issue [#194](https://github.com/sdv-dev/RDT/issues/194) by @amontanez24
  * Audit the NullTransformer - Issue [#192](https://github.com/sdv-dev/RDT/issues/192) by @amontanez24
  * Audit DatetimeTransformer - Issue [#189](https://github.com/sdv-dev/RDT/issues/189) by @sarahmish
  * Audit the LabelEncodingTransformer - Issue [#184](https://github.com/sdv-dev/RDT/issues/184) by @amontanez24
  * Audit the NumericalTransformer - Issue [#181](https://github.com/sdv-dev/RDT/issues/181) by @fealho
  * Audit CategoricalTransformer - Issue [#180](https://github.com/sdv-dev/RDT/issues/180) by @katxiao
  * Audit BooleanTransformer - Issue [#179](https://github.com/sdv-dev/RDT/issues/179) by @katxiao
  * Auditing OneHotEncodingTransformer - Issue [#178](https://github.com/sdv-dev/RDT/issues/178) by @sarahmish
  * Create script for profiling - Issue [#176](https://github.com/sdv-dev/RDT/issues/176) by @amontanez24
  * Create folder structure for performance testing - Issue [#174](https://github.com/sdv-dev/RDT/issues/174) by @amontanez24

  This release updates the `NumericalTransformer` by adding a new `rounding` argument.
  Users can now obtain numerical values with precision, either pre-specified or automatically computed from the given data.

  * Add `rounding` argument to `NumericalTransformer` - Issue [#166](https://github.com/sdv-dev/RDT/issues/166) by @amontanez24 and @csala
  * `NumericalTransformer` rounding error with infinity - Issue [#169](https://github.com/sdv-dev/RDT/issues/169) by @amontanez24
  * Add min and max arguments to NumericalTransformer - Issue [#106](https://github.com/sdv-dev/RDT/issues/106) by @amontanez24

  This release adds a new method to the `CategoricalTransformer` to solve a bug where
  the transformer becomes unusable after being pickled and unpickled if it had `NaN`
  values in the data which it was fit on.
  It also fixes some grammar mistakes in the documentation.

  * CategoricalTransformer with NaN values cannot be pickled bug - Issue [#164](https://github.com/sdv-dev/RDT/issues/164) by @pvk-developer and @csala

  * docs: fix typo - PR [#163](https://github.com/sdv-dev/RDT/issues/163) by @sbrugman

  This release improves the `HyperTransformer` memory usage when working with a
  high number of columns or a high number of categorical values when using one hot encoding.

  * `Boolean`, `Datetime` and `LabelEncoding` transformers fail with 2D `ndarray` - Issue [#160](https://github.com/sdv-dev/RDT/issues/160) by @pvk-developer
  * `HyperTransformer`: Memory usage increase when `reverse_transform` is called - Issue [#156](https://github.com/sdv-dev/RDT/issues/152) by @pvk-developer and @AnupamaGangadhar

  In this release a change in the HyperTransformer allows using it to transform and
  reverse transform a subset of the columns seen during training.
  The anonymization functionality which was deprecated and not being used has also
  been removed along with the Faker dependency.

  * Allow the HyperTransformer to be used on a subset of the columns - Issue [#152](https://github.com/sdv-dev/RDT/issues/152) by @csala
  * Remove faker - Issue [#150](https://github.com/sdv-dev/RDT/issues/150) by @csala

  This release changes the behavior of the `HyperTransformer` to prevent it from
  modifying any column in the given `DataFrame` if the `transformers` dictionary
  is passed empty.

  * If transformers is an empty dict, do nothing - Issue [#149](https://github.com/sdv-dev/RDT/issues/149) by @csala

  This release adds a new argument to the `HyperTransformer` which gives control over
  which transformers to use by default for each `dtype` if no specific transformer
  has been specified for the field.
  This is also the first version to be officially released on conda.

  * Add `dtype_transformers` argument to HyperTransformer - Issue [#148](https://github.com/sdv-dev/RDT/issues/148) by @csala
  * Makes Copulas an optional dependency - Issue [#144](https://github.com/sdv-dev/RDT/issues/144) by @fealho

  This release fixes a bug that prevented the `CategoricalTransformer` from working properly
  when being passed data that contained numerical data only, without any strings, but also
  contained `None` or `NaN` values.

  * KeyError: nan - CategoricalTransformer fails on numerical + nan data only - Issue [#142](https://github.com/sdv-dev/RDT/issues/142) by @csala

  This release fixes a few minor bugs, including some which prevented RDT from fully working
  on Windows systems.
  Thanks to this fixes, as well as a new testing infrastructure that has been set up, from now
  on RDT is officially supported on Windows systems, as well as on the Linux and macOS systems
  which were previously supported.

  * TypeError: unsupported operand type(s) for: 'NoneType' and 'int' - Issue [#132](https://github.com/sdv-dev/RDT/issues/132) by @csala
  * Example does not work on Windows - Issue [#114](https://github.com/sdv-dev/RDT/issues/114) by @csala
  * OneHotEncodingTransformer producing all zeros - Issue [#135](https://github.com/sdv-dev/RDT/issues/135) by @fealho
  * OneHotEncodingTransformer support for lists and lists of lists - Issue [#137](https://github.com/sdv-dev/RDT/issues/137) by @fealho

  In this release we drop the support for the now officially dead Python 3.5
  and introduce a new feature in the DatetimeTransformer which reduces the dimensionality
  of the generated numerical values while also ensuring that the reverted datetimes
  maintain the same level as time unit precision as the original ones.
  * Drop Py35 support - Issue [#129](https://github.com/sdv-dev/RDT/issues/129) by @csala
  * Add option to drop constant parts of the datetimes - Issue [#130](https://github.com/sdv-dev/RDT/issues/130) by @csala

  * Add GaussianCopulaTransformer - Issue [#125](https://github.com/sdv-dev/RDT/issues/125) by @csala
  * dtype category error - Issue [#124](https://github.com/sdv-dev/RDT/issues/124) by @csala

  Miunor bugfixing release.

  * Handle NaNs in OneHotEncodingTransformer - Issue [#118](https://github.com/sdv-dev/RDT/issues/118) by @csala
  * OneHotEncodingTransformer fails if there is only one category - Issue [#119](https://github.com/sdv-dev/RDT/issues/119) by @csala
  * All NaN column produces NaN values enhancement - Issue [#121](https://github.com/sdv-dev/RDT/issues/121) by @csala
  * Make the CategoricalTransformer learn the column dtype and restore it back - Issue [#122](https://github.com/sdv-dev/RDT/issues/122) by @csala


  * Support Python 3.8 - Issue [#117](https://github.com/sdv-dev/RDT/issues/117) by @csala
  * Support pandas >1 - Issue [#116](https://github.com/sdv-dev/RDT/issues/116) by @csala

  * Implement OneHot and Label encoding as transformers - Issue [#112](https://github.com/sdv-dev/RDT/issues/112) by @csala


  * Escape `column_name` in hypertransformer - Issue [#110](https://github.com/sdv-dev/RDT/issues/110) by @csala


  * Boolean Transformer fails to revert when there are NO nulls - Issue [#103](https://github.com/sdv-dev/RDT/issues/103) by @JDTheRipperPC

  This version comes with a brand new API and internal implementation, removing the old
  metadata JSON from the user provided arguments, and making each transformer work only
  with `pandas.Series` of their corresponding data type.
  As part of this change, several transformer names have been changed and a new BooleanTransformer
  and a feature to automatically decide which transformers to use based on dtypes have been added.
  Unit test coverage has also been increased to 100%.
  Special thanks to @JDTheRipperPC and @csala for the big efforts put in making this
  release possible.

  * Drop the usage of meta - Issue [#72](https://github.com/sdv-dev/RDT/issues/72) by @JDTheRipperPC
  * Make CatTransformer.probability_map deterministic - Issue [#25](https://github.com/sdv-dev/RDT/issues/25) by @csala


  * Add attributes NullTransformer and col_meta - Issue [#30](https://github.com/sdv-dev/RDT/issues/30) by @ManuelAlvarezC

  * Integrate with CodeCov - Issue [#89](https://github.com/sdv-dev/RDT/issues/89) by @csala
  * Remake Sphinx Documentation - Issue [#96](https://github.com/sdv-dev/RDT/issues/96) by @JDTheRipperPC
  * Improve README - Issue [#92](https://github.com/sdv-dev/RDT/issues/92) by @JDTheRipperPC
  * Document RELEASE workflow - Issue [#93](https://github.com/sdv-dev/RDT/issues/93) by @JDTheRipperPC
  * Add support to Python 3.7 - Issue [#38](https://github.com/sdv-dev/RDT/issues/38) by @ManuelAlvarezC
  * Create way to pass HyperTransformer table dict - Issue [#45](https://github.com/sdv-dev/RDT/issues/45) by @ManuelAlvarezC

  * Add a numerical transformer for positive numbers.
  * Add option to anonymize data on categorical transformer.
  * Move the `col_meta` argument from method-level to class-level.
  * Move the logic for missing values from the transformers into the `HyperTransformer`.
  * Removed unreacheble lines in `NullTransformer`.
  * `Numbertransfomer` to set default value to 0 when the column is null.
  * Add a CLA for collaborators.
  * Refactor performance-wise the transformers.

  * Improve handling of NaN in NumberTransformer and CatTransformer.
  * Add unittests for HyperTransformer.
  * Remove unused methods `get_types` and `impute_table` from HyperTransformer.
  * Make NumberTransformer enforce dtype int on integer data.
  * Make DTTransformer check data format before transforming.
  * Add minimal API Reference.
  * Merge `rdt.utils` into `HyperTransformer` class.

  * First release on PyPI.


pkgId: 7dd6c31f52a4ab2c20f5d9dfac6543979b6d9aba5febc2084cb3442c13083f87
name: python-readability
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Measure the readability of a given text using surface characteristics
url: https://github.com/andreasvc/readability/
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6dd52a05-c485-4b98-85ff-1128401786d2
location_href: 00004936-python-readability/python-readability-0.3.1-1.src.rpm
checksum_type: sha256
description:
  An implementation of traditional readability measures based on simple surface
  characteristics. These measures are basically linear regressions based on the
  number of words, syllables, and sentences.
  The functionality is modeled after the UNIX ``style(1)`` command. Compared to the
  implementation as part of `GNU diction <http://www.moria.de/~michael/diction/>`_,
  this version supports UTF-8 encoded text, but expects sentence-segmented and
  tokenized text. The syllabification and word type recognition is based on
  simple heuristics and only provides a rough measure. The supported languages
  are English, German, and Dutch. Adding support for a new language involves the
  addition of heuristics for the aforementioned syllabification and word type
  recognition; see ``langdata.py``.
  NB: all readability formulas were developed for English, so the scales of the
  outcomes are only meaningful for English texts. The Dale-Chall measure uses the
  original word list for English, but for Dutch and German lists of frequent
  words are used that were not specifically selected for recognizability by
  school children.


pkgId: 75e8bb1a0069351a78ef2fa67531403a33c65f30187130b694bde393bfd9e381
name: python-readability-lxml
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: fast html to text parser (article readability tool) with python 3 support
url: http://github.com/buriy/python-readability
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8093f2ee-8b59-4f3f-886c-8bc45e9c0c25
location_href: 00004937-python-readability-lxml/python-readability-lxml-0.8.1-1.src.rpm
checksum_type: sha256
description:
  Given a html document, it pulls out the main body text and cleans it up.
  This is a python port of a ruby port of `arc90's readability
  project <http://lab.arc90.com/experiments/readability/>`__.


pkgId: 7eb213a2bd7341c9dea4a4c54ba9b948836c9892a7b67ec405d2fe24d35c788b
name: python-readchar
arch: src
version: 4.0.5
epoch: 0
release: 1
summary: Library to easily read single chars and key strokes
url: https://github.com/magmax/python-readchar
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3ece94ea-3d3d-4af8-a47e-5e193f8dddff
location_href: 00009765-python-readchar/python-readchar-4.0.5-1.src.rpm
checksum_type: sha256
description:
  [![GitHub Repository](https://img.shields.io/badge/-GitHub-%230D0D0D?logo=github&labelColor=gray)](https://github.com/magmax/python-readchar)
  [![Latest PyPi version](https://img.shields.io/pypi/v/readchar.svg)](https://pypi.python.org/pypi/readchar)
  [![supported Python versions](https://img.shields.io/pypi/pyversions/readchar)](https://pypi.python.org/pypi/readchar)
  [![Project licence](https://img.shields.io/pypi/l/readchar?color=blue)](LICENCE) <br>
  [![Automated testing results](https://img.shields.io/github/actions/workflow/status/magmax/python-readchar/run-tests.yaml?branch=master)](https://github.com/magmax/python-readchar/actions/workflows/run-tests.yaml?query=branch%3Amaster)
  [![Coveralls results](https://coveralls.io/repos/github/magmax/python-readchar/badge.svg?branch=master)](https://coveralls.io/github/magmax/python-readchar?branch=master)
  [![Number of PyPi downloads](https://img.shields.io/pypi/dd/readchar.svg)](https://pypi.python.org/pypi/readchar)



  Library to easily read single chars and keystrokes.

  Born as a [python-inquirer](https://github.com/magmax/python-inquirer) requirement.



  simply install it via `pip`:

  ```bash
  pip install readchar
  ```

  Or download the source code from [PyPi](https://pypi.python.org/pypi/readchar).



  Simply read a character or keystroke:

  ```python
  import readchar

  key = readchar.readkey()
  ```

  React to different kinds of key-presses:

  ```python
  from readchar import readkey, key

  while True:
    k = readkey()
    if k == "a":
      
    if k == key.DOWN:
      
    if k == key.ENTER:
      break
  ```



  There are just two methods:



  Reads one character from `stdin`, returning it as a string with length 1. Waits until a
  character is available.

  As only ASCII characters are actually a single character, you usually want to use the
  next function, that also handles longer keys.



  Reads the next keystroke from `stdin`, returning it as a string. Waits until a keystroke
  is available.

  A keystroke can be:

  - single characters as returned by `readchar()`. These include:
    - character for normal keys: <kbd>a</kbd>, <kbd>Z</kbd>, <kbd>9</kbd>,...
    - special characters like <kbd>ENTER</kbd>, <kbd>BACKSPACE</kbd>, <kbd>TAB</kbd>,...
    - combinations with <kbd>CTRL</kbd>: <kbd>CTRL</kbd>+<kbd>A</kbd>,...
  - keys that are made up of multiple characters:
    - characters for cursors/arrows: <kbd>🡩</kbd>, <kbd>🡪</kbd>, <kbd>🡫</kbd>,
      <kbd>🡨</kbd>
    - navigation keys: <kbd>INSERT</kbd>, <kbd>HOME</kbd>,...
    - function keys: <kbd>F1</kbd> to <kbd>F12</kbd>
    - combinations with <kbd>ALT</kbd>: <kbd>ALT</kbd>+<kbd>A</kbd>,...
    - combinations with <kbd>CTRL</kbd> and <kbd>ALT</kbd>:
      <kbd>CTRL</kbd>+<kbd>ALT</kbd>+<kbd>SUPR</kbd>,...

  > **Note** <kbd>CTRL</kbd>+<kbd>C</kbd> will not be returned by `readkey()`, but instead
  > raise a `KeyboardInterupt`. If you what to handle it yourself, use `readchar()`.



  This submodule contains a list of available keys to compare against. The constants are
  defined depending on your operating system, so it should be fully portable. If a key is
  listed here for your platform, `readkey()` can read it, and you can compare against it.



  This static class contains configurations for `readchar`. It holds constants that are
  used in other parts of the code as class attributes. You can override/change these to
  modify its behaviour. Here is a description of the existing attributes:

  <dl>
  <dt><code>INTERRUPT_KEYS</code></dt>
  <dd>

  List of keys that will result in `readkey()` raising a `KeyboardInterrupt`. <br>
  *Default:* `[key.CTRL_C]`

  </dd>
  </dl>



  This library actively supports these operating systems:

  - Linux
  - Windows

  Some operating systems are enabled, but not actively tested or supported:

  - macOS
  - FreeBSD / OpenBSD

  Theoretically every Unix based system should work, but they will not be actively tested.
  It is also required that somebody provides initial test results before the OS is enabled
  and added to the list. Feel free to open a PR for that.

  Thank you!



  You have an issue problem or found a bug? You have a great new idea or just want to fix
  a typo? Great :+1:. We are happy to accept your issue or pull request, but first, please
  read our
  [contribution guidelines](https://github.com/magmax/python-readchar/blob/master/CONTRIBUTING.md).
  They will also tell you how to write code for this repo and how to properly prepare an
  issue or a pull request.

  ______________________________________________________________________

  *Copyright (c) 2014-2022 Miguel Ángel García*


pkgId: 7a86a6eb1322ba64229140cdda504d6877ced55b3a90efee512fd8495f0ea958
name: python-readerwriterlock
arch: src
version: 1.0.9
epoch: 0
release: 1
summary: A python implementation of the three Reader-Writer problems.
url: https://github.com/elarivie/pyReaderWriterLock
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6db6a026-544e-41e5-82a9-b0128d7a63a1
location_href: 00010178-python-readerwriterlock/python-readerwriterlock-1.0.9-1.src.rpm
checksum_type: sha256
description:
  **A python implementation of a solution for the three Reader-Writer problems.**
  [![repo status Active](https://www.repostatus.org/badges/latest/active.svg "repo status Active")](https://www.repostatus.org/#active)
  [![Build Status](https://travis-ci.org/elarivie/pyReaderWriterLock.svg?branch=master)](https://travis-ci.org/elarivie/pyReaderWriterLock)
  [![Coverage Status](https://codecov.io/gh/elarivie/pyreaderwriterlock/branch/master/graph/badge.svg)](https://codecov.io/gh/elarivie/pyreaderwriterlock)
  [![BugTracker](https://img.shields.io/github/issues/elarivie/pyReaderWriterLock.svg)][pyReaderWriterLock_BugTracker]
  [![Python Version](https://img.shields.io/pypi/pyversions/readerwriterlock.svg)][python]
  [![Pypi Version](https://img.shields.io/pypi/v/readerwriterlock.svg)][pyReaderWriterLock_Pypi]
  [![Code size in bytes](https://img.shields.io/github/languages/code-size/elarivie/pyReaderWriterLock.svg)][pyReaderWriterLock_repo]
  [![License](https://img.shields.io/pypi/l/readerwriterlock.svg)][pyReaderWriterLock_License]
  [![Downloads](https://pepy.tech/badge/readerwriterlock)](https://pepy.tech/project/readerwriterlock)
  [![Downloads](https://pepy.tech/badge/readerwriterlock/month)](https://pepy.tech/project/readerwriterlock/month)
  [![Downloads](https://pepy.tech/badge/readerwriterlock/week)](https://pepy.tech/project/readerwriterlock/week)
  [![pyReaderWriterLock_repo_star](https://img.shields.io/github/stars/elarivie/pyReaderWriterLock.svg?style=social&label=Stars)][pyReaderWriterLock_repo_star]
  Not only does it implement the reader-writer problems, it is also compliant with the python [lock interface](https://docs.python.org/3/library/threading.html#threading.Lock) which among others include support for timeout.
  For reading about the theory behind the reader-writer problems refer to [Wikipedia](https://wikipedia.org/wiki/Readers–writers_problem).

  Install the python package [readerwriterlock](https://pypi.python.org/pypi/readerwriterlock)
  ```bash
  python3 -m pip install -U readerwriterlock
  ```

  1. Choose a rwlock class base on your access priority need and feature need which is going to be use by the threads:
  | Priority                                                      | +Speed  | +Downgradable*         |
  |---------------------------------------------------------------|-----------------|---------------|
  | **Reader priority** (*aka First readers-writers problem*)     |   RWLockRead    |  RWLockReadD  |
  | **Writer priority** (*aka Second readers-writers problem*)    |   RWLockWrite   |  RWLockWriteD |
  | **Fair priority** (*aka Third readers-writers problem*)       |   RWLockFair    |  RWLockFairD  |
  &ast; **Downgradable** feature allows the locks to be atomically downgraded from being locked in write-mode to locked in read-mode
  ⓘ Downgradable classes come with a theoretical ~20% negative effect on performance for acquiring and releasing locks.
  2. Instantiate an instance of the chosen RWLock class:
  ```python
  from readerwriterlock import rwlock
  a = rwlock.RWLockFairD()
  ```
  3. Generate read locks and write locks using the following methods:
  ```python
        a_reader_lock = a.gen_rlock()
        a_writer_lock = a.gen_wlock()
  ```
  4. Use the generated read/write locks to protect section in your code:

  ```python
  with a.gen_rlock():
    
  with a.gen_wlock():
    
  ```

  ```python
  b = a.gen_wlock()
  if b.acquire(blocking=True, timeout=5):
    try:
      
    finally:
      b.release()
  ```

  ```python
  b = a.gen_wlock()
  if b.acquire():
      try:
          
          b = b.downgrade()
          
      finally:
          b.release()
  ```

  Refer to the file [test_rwlock.py](tests/test_rwlock.py) which has above 90% line coverage of [rwlock.py](readerwriterlock/rwlock.py).
  The tests can be initiated by doing
  ```bash
  make check.test.coverage
  ```


pkgId: 6f336cf3b1b3f05ab93b40befe501068d4d01e5f52efbbf966d713e725748a8a
name: python-readlike
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: GNU Readline-like line editing module
url: https://github.com/jangler/readlike
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-05769805-8548-4e50-b745-79fee5c6c212
location_href: 00004938-python-readlike/python-readlike-0.1.3-1.src.rpm
checksum_type: sha256
description:
  A Python module that provides `GNU Readline`_-like line editing functions (the
  default Emacs-style ones). If you just want to use Readline, use the readline_
  package in the standard library--but this package allows access to those
  capabilties in settings outside of a standard CLI.
  Currently, all stateless Readline commands are implemented. This means that
  yanking and history are not supported.
  This module is especially well-suited to interfacing with Urwid_ due to a
  shared syntax for describing key inputs.


pkgId: ebdaf81d10982d00bc5316ac79437a25cfaa51cde495f5de5820366b42dfd547
name: python-readme-renderer
arch: src
version: 37.3
epoch: 0
release: 1
summary: readme_renderer is a library for rendering "readme" descriptions for Warehouse
url: https://github.com/pypa/readme_renderer
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-164d2d4f-d852-450d-8f51-a15ced644ce7
location_href: 00004939-python-readme-renderer/python-readme-renderer-37.3-1.src.rpm
checksum_type: sha256
description:
  Readme Renderer is a library that will safely render arbitrary
  ``README`` files into HTML. It is designed to be used in Warehouse_ to
  render the ``long_description`` for packages. It can handle Markdown,
  reStructuredText (``.rst``), and plain text.


pkgId: 8d98853570a4d3a8d9b635337ea8ff652f50220cf0eeeeb9ecca9cfe4fe0ae08
name: python-readthedocs-sphinx-ext
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Sphinx extension for Read the Docs overrides
url: http://github.com/readthedocs/readthedocs-sphinx-ext
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0015805f-9d20-4347-b9a4-b764b80765f0
location_href: 00004940-python-readthedocs-sphinx-ext/python-readthedocs-sphinx-ext-2.2.0-1.src.rpm
checksum_type: sha256
description:
  This module adds extensions that make Sphinx easier to use.
  Some of them require Read the Docs features,
  others are just code that we ship and enable during builds on Read the Docs.
  We currently ship:
  * An extension for building docs like Read the Docs
  * ``template-meta`` - Allows users to specify template overrides in per-page context.


pkgId: 751b60b9495ddcd7a4e15cedc9622a6a3b609082680f5d4aa2b5e4fe03b86148
name: python-rebulk
arch: src
version: 3.2.0
epoch: 0
release: 1
summary: Rebulk - Define simple search patterns in bulk to perform advanced matching on any string.
url: https://github.com/Toilal/rebulk/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-98414cb0-33f3-4eab-bcc0-776b31322292
location_href: 00004941-python-rebulk/python-rebulk-3.2.0-1.src.rpm
checksum_type: sha256
description:
  [![Latest Version](http://img.shields.io/pypi/v/rebulk.svg)](https://pypi.python.org/pypi/rebulk)
  [![MIT License](http://img.shields.io/badge/license-MIT-blue.svg)](https://pypi.python.org/pypi/rebulk)
  [![Build Status](https://img.shields.io/github/workflow/status/Toilal/rebulk/ci)](https://github.com/Toilal/rebulk/actions?query=workflow%3Aci)
  [![Coveralls](http://img.shields.io/coveralls/Toilal/rebulk.svg)](https://coveralls.io/r/Toilal/rebulk?branch=master)
  [![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/relekang/python-semantic-release)
  ReBulk is a python library that performs advanced searches in strings
  that would be hard to implement using [re
  module](https://docs.python.org/3/library/re.html) or [String
  methods](https://docs.python.org/3/library/stdtypes.html#str) only.
  It includes some features like `Patterns`, `Match`, `Rule` that allows
  developers to build a custom and complex string matcher using a readable
  and extendable API.
  This project is hosted on GitHub: <https://github.com/Toilal/rebulk>


pkgId: 2402067321d79e2fdf09f49d94bcf1e12d88430dfb9430ae24034f23cb06b6d3
name: python-recommonmark
arch: src
version: 0.7.1
epoch: 0
release: 1
url: https://github.com/rtfd/recommonmark
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0b533e49-5259-42d0-8db0-81b893b1512d
location_href: 00009731-python-recommonmark/python-recommonmark-0.7.1-1.src.rpm
checksum_type: sha256
summary:
  A docutils-compatibility bridge to CommonMark, enabling you to write CommonMark inside of Docutils & Sphinx projects.


pkgId: e8b1a4990fad97d4971c73e20bb5d0d10902af639593a347ab4d3c977d21ee6a
name: python-recordclass
arch: src
version: 0.18.3
epoch: 0
release: 1
url: https://bitbucket.org/intellimath/recordclass
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a5a881a8-3182-4812-968c-d1f94724a077
location_href: 00010456-python-recordclass/python-recordclass-0.18.3-1.src.rpm
checksum_type: sha256
summary:
  Mutable variant of namedtuple -- recordclass, which support assignments, and other memory saving variants.

description:
  **Recordclass** is [MIT Licensed](http://opensource.org/licenses/MIT) python library.
  It was started as a "proof of concept" for the problem of fast "mutable"
  alternative of `namedtuple` (see [question](https://stackoverflow.com/questions/29290359/existence-of-mutable-named-tuple-in-python) on [stackoverflow](https://stackoverflow.com)).
  It was evolved further in order to provide more memory saving, fast and flexible types.

  **Recordclass** library provide record/data-like classes that do not by default participate in cyclic *garbage collection* (GC) mechanism, but support only *reference counting* for garbage collection.
  The instances of such classes havn't `PyGC_Head` prefix in the memory, which decrease their size and have a little faster path for the instance creation and deallocation.
  This may make sense in cases where it is necessary to limit the size of the objects as much as possible, provided that they will never be part of references cycles in the application.
  For example, when an object represents a record with fields with values of simple types by convention (`int`, `float`, `str`, `date`/`time`/`datetime`, `timedelta`, etc.).

  In order to illustrate this, consider a simple class with type hints:

      class Point:
          x: int
          y: int

  By tacit agreement instances of the class `Point` is supposed to have attributes `x` and `y` with values of `int` type. Assigning other types of values, which are not subclass of `int`, should be considered as a violation of the agreement.

  Other examples are non-recursive data structures in which all leaf elements represent a value of an atomic type.
  Of course, in python, nothing prevent you from “shooting yourself in the foot" by creating the reference cycle in the script or application code.
  But in many cases, this can still be avoided provided that the developer understands what he is doing and uses such classes in the codebase with care.
  Another option is to use static code analyzers along with type annotations to monitor compliance with typehints.

  The library is built on top of the base class `dataobject`. The type of `dataobject` is special metaclass `datatype`.
     It control creation  of subclasses, which  will not participate in cyclic GC and do not contain `__dict__`  and `__weakref__`  by default.
     As the result the instance of such class need less memory.
     It's memory footprint is similar to memory footprint of instances of the classes with `__slots__` but without `PyGC_Head`. So the difference in memory size is equal to the size of `PyGC_Head`.
     It also tunes `basicsize` of the instances, creates descriptors for the fields and etc.
     All subclasses of `dataobject` created by `class statement` support `attrs`/`dataclasses`-like API.
     For example:

          from recordclass import dataobject, astuple, asdict
          class Point(dataobject):
              x:int
              y:int

          >>> p = Point(1, 2)
          >>> astuple(p)
          (1, 2)
          >>> asdict(p)
          {'x':1, 'y':2}

  The `recordclass` factory create dataobject-based subclass with specified fields and the support of `namedtuple`-like API.
     By default it will not participate in cyclic GC too.

          >>> from recordclass import recordclass
          >>> Point = recordclass('Point', 'x y')
          >>> p = Point(1, 2)
          >>> p.y = -1
          >>> print(p._astuple)
          (1, -1)
          >>> x, y = p
          >>> print(p._asdict)
          {'x':1, 'y':-1}

  It also provide a factory function `make_dataclass` for creation of subclasses of `dataobject` with the specified field names.
     These subclasses support `attrs`/`dataclasses`-like API. It's equivalent to creating subclasses of dataobject using `class statement`.
     For example:

          >>> Point = make_dataclass('Point', 'x y')
          >>> p = Point(1, 2)
          >>> p.y = -1
          >>> print(p.x, p.y)
          1 -1

  There is also a factory function `make_arrayclass` for creation of the subclass of `dataobject`, which can be considered as a compact array of simple objects.
     If one want to use some sequence for initialization then:

          >>> p = Point(*sequence)

     For example:

          >>> Pair = make_arrayclass(2)
          >>> p = Pair(2, 3)
          >>> p[1] = -1
          >>> print(p)
          Pair(2, -1)

  It provide in addition the classes `lightlist` (immutable) and `litetuple`, which considers as list-like and tuple-like *light* containers in order to save memory. They do not supposed to participate in cyclic GC too. Mutable variant of litetuple is called by `mutabletuple`.
      For example:

          >>> lt = litetuple(1, 2, 3)
          >>> mt = mutabletuple(1, 2, 3)
          >>> lt == mt
          True
          >>> mt[-1] = -3
          >>> lt == mt
          False
          >>> print(sys.getsizeof((1,2,3)), sys.getsizeof(litetuple(1,2,3)))
          64 48



  The following table explain memory footprints of the  `dataobject`-based objects and litetuples:

  <table border="1" class="dataframe">
    <thead>
      <tr style="text-align: right;">
        <th>tuple/namedtuple</th>
        <th>class with __slots__</th>
        <th>recordclass/dataobject</th>
        <th>litetuple/mutabletuple</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>g+b+s+n&times;p</td>
        <td>g+b+n&times;p</td>
        <td>b+n&times;p</td>
        <td>b+s+n&times;p</td>
      </tr>
    </tbody>
  </table>

  where:

   * b = sizeof(PyObject)
   * s = sizeof(Py_ssize_t)
   * n = number of items
   * p = sizeof(PyObject*)
   * g = sizeof(PyGC_Head)

  This is useful in that case when you absolutely sure that reference cycle isn't supposed.
  For example, when all field values are instances of atomic types.
  As a result the size of the instance is decreased by 24-32 bytes for cpython 3.4-3.7 and by 16 bytes for cpython >=3.8.



  Here is the table with performance counters, which was measured using `tools/perfcounts.py` script:

  * python 3.10, debian/testing linux, x86-64:

  <table border="1" class="dataframe">
    <thead>
      <tr style="text-align: right;">
        <th>id</th>
        <th>size</th>
        <th>new</th>
        <th>getattr</th>
        <th>setattr</th>
        <th>getitem</th>
        <th>setitem</th>
        <th>getkey</th>
        <th>setkey</th>
        <th>iterate</th>
        <th>copy</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>litetuple</td>
        <td>48</td>
        <td>0.25</td>
        <td></td>
        <td></td>
        <td>0.21</td>
        <td></td>
        <td></td>
        <td></td>
        <td>0.33</td>
        <td>0.19</td>
      </tr>
      <tr>
        <td>mutabletuple</td>
        <td>48</td>
        <td>0.25</td>
        <td></td>
        <td></td>
        <td>0.2</td>
        <td>0.22</td>
        <td></td>
        <td></td>
        <td>0.33</td>
        <td>0.19</td>
      </tr>
      <tr>
        <td>tuple</td>
        <td>64</td>
        <td>0.23</td>
        <td></td>
        <td></td>
        <td>0.19</td>
        <td></td>
        <td></td>
        <td></td>
        <td>0.33</td>
        <td>0.17</td>
      </tr>
      <tr>
        <td>namedtuple</td>
        <td>64</td>
        <td>0.73</td>
        <td>0.25</td>
        <td></td>
        <td>0.19</td>
        <td></td>
        <td></td>
        <td></td>
        <td>0.32</td>
        <td>0.22</td>
      </tr>
      <tr>
        <td>class+slots</td>
        <td>56</td>
        <td>0.66</td>
        <td>0.33</td>
        <td>0.33</td>
        <td></td>
        <td></td>
        <td></td>
        <td></td>
        <td></td>
        <td></td>
      </tr>
      <tr>
        <td>dataobject</td>
        <td>40</td>
        <td>0.25</td>
        <td>0.24</td>
        <td>0.31</td>
        <td>0.21</td>
        <td>0.22</td>
        <td></td>
        <td></td>
        <td>0.32</td>
        <td>0.19</td>
      </tr>
      <tr>
        <td>dataobject+gc</td>
        <td>56</td>
        <td>0.27</td>
        <td>0.23</td>
        <td>0.31</td>
        <td>0.2</td>
        <td>0.22</td>
        <td></td>
        <td></td>
        <td>0.31</td>
        <td>0.22</td>
      </tr>
      <tr>
        <td>dict</td>
        <td>232</td>
        <td>0.33</td>
        <td></td>
        <td></td>
        <td></td>
        <td></td>
        <td>0.2</td>
        <td>0.25</td>
        <td>0.38</td>
        <td>0.24</td>
      </tr>
      <tr>
        <td>dataobject+map</td>
        <td>40</td>
        <td>0.25</td>
        <td>0.24</td>
        <td>0.31</td>
        <td></td>
        <td></td>
        <td>0.28</td>
        <td>0.32</td>
        <td>0.31</td>
        <td>0.19</td>
      </tr>
    </tbody>
  </table>

  * python 3.11, debian/testing linux, x86-64:

  <table border="1" class="dataframe">
    <thead>
      <tr style="text-align: right;">
        <th>id</th>
        <th>size</th>
        <th>new</th>
        <th>getattr</th>
        <th>setattr</th>
        <th>getitem</th>
        <th>setitem</th>
        <th>getkey</th>
        <th>setkey</th>
        <th>iterate</th>
        <th>copy</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>litetuple</td>
        <td>48</td>
        <td>0.24</td>
        <td></td>
        <td></td>
        <td>0.18</td>
        <td></td>
        <td></td>
        <td></td>
        <td>0.26</td>
        <td>0.14</td>
      </tr>
      <tr>
        <td>mutabletuple</td>
        <td>48</td>
        <td>0.24</td>
        <td></td>
        <td></td>
        <td>0.17</td>
        <td>0.2</td>
        <td></td>
        <td></td>
        <td>0.27</td>
        <td>0.14</td>
      </tr>
      <tr>
        <td>tuple</td>
        <td>64</td>
        <td>0.16</td>
        <td></td>
        <td></td>
        <td>0.12</td>
        <td></td>
        <td></td>
        <td></td>
        <td>0.26</td>
        <td>0.15</td>
      </tr>
      <tr>
        <td>namedtuple</td>
        <td>64</td>
        <td>0.70</td>
        <td>0.2</td>
        <td></td>
        <td>0.16</td>
        <td></td>
        <td></td>
        <td></td>
        <td>0.26</td>
        <td>0.2</td>
      </tr>
      <tr>
        <td>class+slots</td>
        <td>56</td>
        <td>0.47</td>
        <td>0.1</td>
        <td>0.11</td>
        <td></td>
        <td></td>
        <td></td>
        <td></td>
        <td></td>
        <td></td>
      </tr>
      <tr>
        <td>dataobject</td>
        <td>40</td>
        <td>0.24</td>
        <td>0.1</td>
        <td>0.1</td>
        <td>0.18</td>
        <td>0.2</td>
        <td></td>
        <td></td>
        <td>0.26</td>
        <td>0.18</td>
      </tr>
      <tr>
        <td>dataobject+gc</td>
        <td>56</td>
        <td>0.28</td>
        <td>0.1</td>
        <td>0.1</td>
        <td>0.18</td>
        <td>0.2</td>
        <td></td>
        <td></td>
        <td>0.25</td>
        <td>0.21</td>
      </tr>
      <tr>
        <td>dict</td>
        <td>184</td>
        <td>0.32</td>
        <td></td>
        <td></td>
        <td></td>
        <td></td>
        <td>0.19</td>
        <td>0.23</td>
        <td>0.29</td>
        <td>0.19</td>
      </tr>
      <tr>
        <td>dataobject+map</td>
        <td>40</td>
        <td>0.27</td>
        <td>0.1</td>
        <td>0.1</td>
        <td></td>
        <td></td>
        <td>0.21</td>
        <td>0.27</td>
        <td>0.25</td>
        <td>0.18</td>
      </tr>
    </tbody>
  </table>

  Main repository for `recordclass` is on [bitbucket](https://bitbucket.org/intellimath/recordclass).

  Here is also a simple [example](http://nbviewer.ipython.org/urls/bitbucket.org/intellimath/recordclass/raw/master/examples/what_is_recordclass.ipynb).

  More examples can be found in the folder [examples](https://bitbucket.org/intellimath/recordclass/examples).







  Install:

      >>> python3 setup.py install

  Run tests:

      >>> python3 test_all.py



  Install:

      >>> pip3 install recordclass

  Run tests:

      >>> python3 -c "from recordclass.test import *; test_all()"



  `Dataobject` is the base class for creation of data classes with fast instance creation and small memory footprint. They provide `dataclass`-like API.

  First load inventory:

      >>> from recordclass import dataobject, asdict, astuple, as_dataclass

  Define class one of three ways:

      class Point(dataobject):
          x: int
          y: int

  or

      @as_dataclass()
      class Point:
          x: int
          y: int

  or

      >>> Point = make_dataclass("Point", [("x",int), ("y",int)])

  Annotations of the fields are defined as a dict in `__annotations__`:

      >>> print(Point.__annotations__)
      {'x': <class 'int'>, 'y': <class 'int'>}

  There is default text representation:

      >>> p = Point(1, 2)
      >>> print(p)
      Point(x=1, y=2)

  The instances has a minimum memory footprint that is possible for CPython object, which contain only Python objects:

      >>> sys.getsizeof(p) # the output below for python 3.8+ (64bit)
      40
      >>> p.__sizeof__() == sys.getsizeof(p) # no additional space for cyclic GC support
      True

  The instance is mutable by default:

      >>> p_id = id(p)
      >>> p.x, p.y = 10, 20
      >>> id(p) == p_id
      True
      >>> print(p)
      Point(x=10, y=20)

  There are functions `asdict` and `astuple` for converting to `dict` and to `tuple`:

      >>> asdict(p)
      {'x':10, 'y':20}
      >>> astuple(p)
      (10, 20)

  By default subclasses of dataobject are mutable. If one want make it immutable then there is the option `readonly=True`:

      class Point(dataobject, readonly=True):
          x: int
          y: int

      >>> p = Point(1,2)
      >>> p.x = -1
      . . . . . . . . . . . . .
      TypeError: item is readonly

  By default subclasses of dataobject are not iterable by default.
  If one want make it iterable then there is the option `iterable=True`:

      class Point(dataobject, iterable=True):
          x: int
          y: int

      >>> p = Point(1,2)
      >>> for x in p: print(x)
      1
      2

  Default values are also supported::

      class CPoint(dataobject):
          x: int
          y: int
          color: str = 'white'

  or

      >>> CPoint = make_dataclass("CPoint", [("x",int), ("y",int), ("color",str)], defaults=("white",))

      >>> p = CPoint(1,2)
      >>> print(p)
      Point(x=1, y=2, color='white')

  But

      class PointInvalidDefaults(dataobject):
          x:int = 0
          y:int

  is not allowed. A fields without default value may not appear after a field with default value.

  There is the options `fast_new=True`. It allows faster creation path of the instances. Here is an example:

      class FastPoint(dataobject, fast_new=True):
          x: int
          y: int

  The followings timings explain (in jupyter notebook) boosting effect of `fast_new` option:

      %timeit l1 = [Point(i,i) for i in range(100000)]
      %timeit l2 = [FastPoint(i,i) for i in range(100000)]
      
      25.6 ms ± 2.4 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
      10.4 ms ± 426 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

  The downside of `fast_new=True` option is less options for introspection of the instance.



  The `recordclass` factory function is designed to create classes that support `namedtuple`'s API, can be mutable and immutable, provide fast creation of the instances and have a minimum memory footprint.

  First load inventory:

      >>> from recordclass import recordclass

  Example with `recordclass`:

      >>> Point = recordclass('Point', 'x y')
      >>> p = Point(1,2)
      >>> print(p)
      Point(1, 2)
      >>> print(p.x, p.y)
      1 2
      >>> p.x, p.y = 1, 2
      >>> print(p)
      Point(1, 2)
      >>> sys.getsizeof(p) # the output below is for 64bit cpython3.8+
      32

  Example with class statement and typehints:

      >>> from recordclass import RecordClass

      class Point(RecordClass):
         x: int
         y: int

      >>> print(Point.__annotations__)
      {'x': <class 'int'>, 'y': <class 'int'>}
      >>> p = Point(1, 2)
      >>> print(p)
      Point(1, 2)
      >>> print(p.x, p.y)
      1 2
      >>> p.x, p.y = 1, 2
      >>> print(p)
      Point(1, 2)

  By default `recordclass`-based class instances doesn't participate in cyclic GC and therefore they are smaller than `namedtuple`-based ones. If one want to use it in scenarios with reference cycles then one have to use option `gc=True` (`gc=False` by default):

      >>> Node = recordclass('Node', 'root children', gc=True)

  or

      class Node(RecordClass, gc=True):
           root: 'Node'
           chilren: list

  The `recordclass` factory can also specify type of the fields:

      >>> Point = recordclass('Point', [('x',int), ('y',int)])

  or

      >>> Point = recordclass('Point', {'x':int, 'y':int})



      class FastMapingPoint(dataobject, mapping=True):
          x: int
          y: int

  or

      FastMapingPoint = make_dataclass("FastMapingPoint", [("x", int), ("y", int)], mapping=True)

      >>> p = FastMappingPoint(1,2)
      >>> print(p['x'], p['y'])
      1 2
      >>> sys.getsizeof(p) # the output below for python 3.10 (64bit)
      32



  There is the option `deep_dealloc` (default value is `False`) for deallocation of recursive datastructures.
  Let consider simple example:

      class LinkedItem(dataobject):
          val: object
          next: 'LinkedItem'

      class LinkedList(dataobject, deep_dealloc=True):
          start: LinkedItem = None
          end: LinkedItem = None

          def append(self, val):
              link = LinkedItem(val, None)
              if self.start is None:
                  self.start = link
              else:
                  self.end.next = link
              self.end = link

  Without `deep_dealloc=True` deallocation of the instance of `LinkedList` will be failed if the length of the linked list is too large.
  But it can be resolved with `__del__` method for clearing the linked list:

      def __del__(self):
          curr = self.start
          while curr is not None:
              next = curr.next
              curr.next = None
              curr = next

  There is builtin more fast deallocation method using finalization mechanizm when `deep_dealloc=True`. In such case one don't need `__del__`  method for clearing the linked list.

  > Note that for classes with `gc=True` (cyclic GC is used) this method is disabled: the python's cyclic GC is used in these cases.

  For more details see notebook [example_datatypes](examples/example_datatypes.ipynb).





  * Fix bug with a tuple as default value of the field.
  * Fix defaults propagtion to subclasses.
  * Fix some issues with pickling in the context of dill.



  * Slightly improve performance in the default `__init__`  when fields have default values or kwargs.
  * Remove experimental pypy support: slow and difficult to predict memory footprint.
  * Exclude experimental cython modules.



  * Repackage 0.18.1 with `use_cython=0`



  * Allow to initialize fields in the user defined `__init__`  method instead of `__new__`  (issue 29).
    If `__init__`  is defined by user then it's responsible for initialization of all fields.
    Note that this feature only work for mutable fields.
    Instances of the class with `readonly=True` must be initialized only in the default `__new__`.
    For example:

          class A(dataobject):
                x:int
                y:int

                def __init__(self, x, y):
                    self.x = x
                    self.y = y

  * `fast_new=True` by default.
  * Add `make_row_factory` for `sqlite3` :

          class Planet(dataobject):
              name:str
              radius:int

          >>> con = sql.connect(":memory:")
          >>> cur = con.execute("SELECT 'Earth' AS name, 6378 AS radius")
          >>> cur.row_factory = make_row_factory(Planet)
          >>> row = cur.fetchone()
          >>> print(row)
          Planet(name='Earth', radius=6378)



  * Exclude test_dataobject_match.py (for testing `match` statement) for python < 3.10.



  * Python 3.11 support.
  * Adapt data object to take benefit from bytecode specialization in 3.11.
  * Fix issue for argument with default value in `__new__`, which havn't `__repr__`
    that can be interpreted as valid python expression
    for creation of the default value.
  * Add support for typing.ClassVar.
  * Add `Py_TPFLAGS_SEQUENCE`  and `Py_TPFLAGS_MAPPING`.
  * Add `__match_args__`  to support match protocol for dataobject-based subclasses.



  * Make to compile, to build and to test successfully for python 3.11.



  * Fixed error with missing `_PyObject_GC_Malloc` in 3.11.



  * Fix compatibility issue: restore gnu98 C-syntax.
  * Fix remained issues with use of "Py_SIZE(op)" and "Py_TYPE(op)" as l-value.



  * Add support for python 3.10.
  * There are no use of "Py_SIZE(op)" and "Py_TYPE(op)" as l-value.



  * Fix packaging issue with cython=1 in setup.py



  * Now recordclass library may be compiled for pypy3, but there is still no complete runtime compatibility with pypy3.
  * Slighly imporove performance of `litetuple` / `mutabletuple`.
  * Slighly imporove performance of `dataobject`-based subclasses.
  * Add adapter `as_dataclass`. For example:

          @as_dataclass()
          class Point:
              x:int
              y:int

  * Module _litelist is implemented in pure C.
  * Make dataobject.__copy__ faster.



  * Add possibility for recordclasses to assighn values by key:

          A = recordclass("A", "x y", mapping=True)
          a = A(1,2)
          a['x'] = 100
          a['y'] = 200



  * Fix the packaging bug in 0.16.1.



  * Add `dictclass` factory function to generate class with `dict-like` API and without attribute access to the fields.
    Features: fast instance creation, small memory footprint.



  * `RecordClass` started to be a direct subclass of dataobject with `sequence=True` and support
    of `namedtuple`-like API.
    Insted of `RecordClass(name, fields, **kw)` for class creation
    use factory function `recordclass(name, fields, **kw)`
    (it allows to specify types).
  * Add option api='dict'  to `make_dataclass` for creating class that support dict-like API.
  * Now one can't remove dataobject's property from it's class using del or builting delattr.
    For example:

          >>> Point = make_dataclass("Point", "x y")
          >>> del Point.x
          ...........
          AttributeError: Attribute x of the class Point can't be deleted

  * Now one can't delete field's value using del or builting delattr.
    For example:

          >>> p = Point(1, 2)
          >>> del p.x
          ...........
          AttributeError: The value can't be deleted"
    Insted one can use assighnment to None:

          >>> p = Point(1, 2)
          >>> p.x = None

  * Slightly improve performance of the access by index of dataobject-based classes with option `sequence=True`.




  * Options `readonly` and `iterable` now can be sspecified via keyword arguments in class statement.
    For example:

          class Point(dataobject, readonly=True, iterable=True):
               x:int
               y:int

  * Add `update(cls, **kwargs)` function to update attribute values.`




  * Now library supports only Python >= 3.6
  * 'gc' and 'fast_new' options now can be specified as kwargs in class statement.
  * Add a function `astuple(ob)` for transformation dataobject instance `ob` to a tuple.
  * Drop datatuple based classes.
  * Add function `make(cls, args, **kwargs)` to create instance of the class `cls`.
  * Add function `clone(ob, **kwargs)` to clone dataobject instance `ob`.
  * Make structclass as alias of make_dataclass.
  * Add option 'deep_dealloc' (@clsconfig(deep_dealloc=True)) for deallocation
    instances of dataobject-based recursive subclasses.



  * Subclasses of `dataobject` now support iterable and hashable protocols by default.



  * Fix compilation issue for python 3.9.



  * Fix issue with __hash__ when subclassing recordclass-based classes.



  * Add __doc__ to generated  `dataobject`-based class in order to support `inspect.signature`.
  * Add `fast_new` argument/option for fast instance creation.
  * Fix refleak in `litelist`.
  * Fix sequence protocol ability for `dataobject`/`datatuple`.
  * Fix typed interface for `StructClass`.



  * Fix issue #14 with deepcopy of dataobjects.



  * Restore ``join_classes` and add new function `join_dataclasses`.



  * Remove redundant debug code.




  * Make `recordclass` compiled and work with cpython 3.8.
  * Move repository to **git** instead of mercurial since bitbucket will drop support of mercurial repositories.
  * Fix some potential reference leaks.




  * Fix missing .h files.



  * `clsconfig` now become the main decorator for tuning dataobject-based classes.
  * Fix concatenation of mutabletuples (issue `#10`).



  * `dataobject` instances may be deallocated faster now.



  * Rename `memoryslots` to `mutabletuple`.
  * `mutabletuple` and `immutabletuple` dosn't participate in cyclic garbage collection.
  * Add `litelist` type for list-like objects, which doesn't participate in cyglic garbage collection.



  * Introduce DataclassStorage and RecordclassStorage.
    They allow cache classes and used them without creation of new one.
  * Add `iterable` decorator and argument. Now dataobject with fields isn't iterable by default.
  * Move `astuple` to `dataobject.c`.



  * Fix error with dataobject's `__copy__`.
  * Fix error with pickling of recordclasses and structclasses, which was appeared since 0.8.5
    (Thanks to Connor Wolf).



  * Now by default sequence protocol is not supported by default if dataobject has fields,
    but iteration is supported.
  * By default argsonly=False for usability reasons.



  * Invent new factory function `make_class` for creation of different kind of dataobject classes
    without GC support by default.
  * Invent new metaclass `datatype` and new base class `dataobject` for creation dataobject class using
    `class` statement.
    It have disabled GC support, but could be enabled by decorator `dataobject.enable_gc`.
    It support type hints (for python >= 3.6) and default values.
    It may not specify sequence of field names in `__fields__` when type hints are applied to all
    data attributes (for python >= 3.6).
  * Now `recordclass`-based classes may not support cyclic garbage collection too.
    This reduces the memory footprint by the size of `PyGC_Head`.
    Now by default recordclass-based classes doesn't support cyclic garbage collection.



  * Change version to 0.9 to indicate a step forward.
  * Cleanup `dataobject.__cinit__`.



  * Make `arrayclass`-based objects support setitem/getitem and `structclass`-based objects able
    to not support them. By default, as before `structclass`-based objects support setitem/getitem protocol.
  * Now only instances of `dataobject` are comparable to 'arrayclass'-based and `structclass`-based instances.
  * Now generated classes can be hashable.




  * Improve support for readonly mode for structclass and arrayclass.
  * Add tests for arrayclass.



  * Add typehints support to structclass-based classes.




  * Remove `usedict`, `gc`, `weaklist` from the class `__dict__`.



  * Remove Cython dependence by default for building `recordclass` from the sources [Issue #7].



  * Add `structclass` factory function. It's analog of `recordclass` but with less memory
    footprint for it's instances (same as for instances of classes with `__slots__`) in the camparison
    with `recordclass` and `namedtuple`
    (it currently implemented with `Cython`).
  * Add `arrayclass` factory function which produce a class for creation fixed size array.
    The benefit of such approach is also less memory footprint
    (it currently currently implemented with `Cython`).
  * `structclass` factory has argument `gc` now. If `gc=False` (by default) support of cyclic garbage collection
    will switched off for instances of the created class.
  * Add function `join(C1, C2)` in order to join two `structclass`-based classes C1 and C2.
  * Add `sequenceproxy` function for creation of immutable and hashable proxy object from class instances,
    which implement access by index
    (it currently currently implemented with `Cython`).
  * Add support for access to recordclass object attributes by idiom: `ob['attrname']` (Issue #5).
  * Add argument `readonly` to recordclass factory to produce immutable namedtuple.
    In contrast to `collection.namedtuple` it use same descriptors as for
    regular recordclasses for performance increasing.



  * Make mutabletuple objects creation faster. As a side effect: when number of fields >= 8
    recordclass instance creation time is not biger than creation time of instaces of
    dataclasses with `__slots__`.
  * Recordclass factory function now create new recordclass classes in the same way as namedtuple in 3.7
    (there is no compilation of generated python source of class).



  * Add support for default values in recordclass factory function in correspondence
    to same addition to namedtuple in python 3.7.



  * Change version to 0.5



  * Add support for default values in RecordClass (patches from Pedro von Hertwig)
  * Add tests for RecorClass (adopted from python tests for NamedTuple)



  * Add support for typing for python 3.6 (patches from Vladimir Bolshakov).
  * Resolve memory leak issue.



  * Fix memory leak in property getter/setter


pkgId: 84331a07d3b6019a881c82f73fc74f7b32018a2e040daf9e7601f05fa68f8f27
name: python-recordclass-debuginfo
arch: aarch64
version: 0.18.3
epoch: 0
release: 1
summary: Debug information for package python-recordclass
url: https://bitbucket.org/intellimath/recordclass
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-a5a881a8-3182-4812-968c-d1f94724a077
rpm_sourcerpm: python-recordclass-0.18.3-1.src.rpm
location_href: 00010456-python-recordclass/python-recordclass-debuginfo-0.18.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-recordclass.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: dc0c342842a5367dfdf81d0b3856daf921e37eca25b520b7fc8fae4152af744b
name: python-recordclass-debugsource
arch: aarch64
version: 0.18.3
epoch: 0
release: 1
summary: Debug sources for package python-recordclass
url: https://bitbucket.org/intellimath/recordclass
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-a5a881a8-3182-4812-968c-d1f94724a077
rpm_sourcerpm: python-recordclass-0.18.3-1.src.rpm
location_href: 00010456-python-recordclass/python-recordclass-debugsource-0.18.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-recordclass.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 2c613b8477bb14a794a8a4f9607f6d519f23b1d090504425cf59006da29bc40b
name: python-recordlinkage
arch: src
version: 0.15
epoch: 0
release: 1
summary: A record linkage toolkit for linking and deduplication
url: https://github.com/J535D165/recordlinkage
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dd279ae3-121e-4f58-b1a4-b7019612f6ef
location_href: 00011055-python-recordlinkage/python-recordlinkage-0.15-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <img src="https://raw.githubusercontent.com/J535D165/recordlinkage/master/docs/images/recordlinkage-banner-transparent.svg"><br>
  </div>



  [![Pypi Version](https://badge.fury.io/py/recordlinkage.svg)](https://pypi.python.org/pypi/recordlinkage/)
  [![Github Actions CI Status](https://github.com/J535D165/recordlinkage/workflows/tests/badge.svg?branch=master)](https://github.com/J535D165/recordlinkage/actions)
  [![Code Coverage](https://codecov.io/gh/J535D165/recordlinkage/branch/master/graph/badge.svg)](https://codecov.io/gh/J535D165/recordlinkage)
  [![Documentation Status](https://readthedocs.org/projects/recordlinkage/badge/?version=latest)](https://recordlinkage.readthedocs.io/en/latest/?badge=latest)
  [![Zenodo DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.3559042.svg)](https://doi.org/10.5281/zenodo.3559042)

  **RecordLinkage** is a powerful and modular record linkage toolkit to
  link records in or between data sources. The toolkit provides most of
  the tools needed for record linkage and deduplication. The package
  contains indexing methods, functions to compare records and classifiers.
  The package is developed for research and the linking of small or medium
  sized files.

  This project is inspired by the [Freely Extensible Biomedical Record
  Linkage (FEBRL)](https://sourceforge.net/projects/febrl/) project, which
  is a great project. In contrast with FEBRL, the recordlinkage project
  uses [pandas](http://pandas.pydata.org/) and
  [numpy](http://www.numpy.org/) for data handling and computations. The
  use of *pandas*, a flexible and powerful data analysis and manipulation
  library for Python, makes the record linkage process much easier and
  faster. The extensive *pandas* library can be used to integrate your
  record linkage directly into existing data manipulation projects.

  One of the aims of this project is to make an easily extensible record
  linkage framework. It is easy to include your own indexing algorithms,
  comparison/similarity measures and classifiers.



  Import the `recordlinkage` module with all important tools for record
  linkage and import the data manipulation framework **pandas**.

  ``` python
  import recordlinkage
  import pandas
  ```

  Load your data into pandas DataFrames.

  ``` python
  df_a = pandas.DataFrame(YOUR_FIRST_DATASET)
  df_b = pandas.DataFrame(YOUR_SECOND_DATASET)
  ```

  Comparing all record can be computationally intensive. Therefore, we
  make set of candidate links with one of the built-in indexing techniques
  like **blocking**. In this example, only pairs of records that agree on
  the surname are returned.

  ``` python
  indexer = recordlinkage.Index()
  indexer.block('surname')
  candidate_links = indexer.index(df_a, df_b)
  ```

  For each candidate link, compare the records with one of the comparison
  or similarity algorithms in the Compare class.

  ``` python
  c = recordlinkage.Compare()

  c.string('name_a', 'name_b', method='jarowinkler', threshold=0.85)
  c.exact('sex', 'gender')
  c.date('dob', 'date_of_birth')
  c.string('str_name', 'streetname', method='damerau_levenshtein', threshold=0.7)
  c.exact('place', 'placename')
  c.numeric('income', 'income', method='gauss', offset=3, scale=3, missing_value=0.5)


  feature_vectors = c.compute(candidate_links, df_a, df_b)
  ```

  Classify the candidate links into matching or distinct pairs based on
  their comparison result with one of the [classification
  algorithms](https://recordlinkage.readthedocs.io/en/latest/ref-classifiers.html).
  The following code classifies candidate pairs with a Logistic Regression
  classifier. This (supervised machine learning) algorithm requires
  training data.

  ``` python
  logrg = recordlinkage.LogisticRegressionClassifier()
  logrg.fit(TRAINING_COMPARISON_VECTORS, TRAINING_PAIRS)

  logrg.predict(feature_vectors)
  ```

  The following code shows the classification of candidate pairs with the
  Expectation-Conditional Maximisation (ECM) algorithm. This variant of
  the Expectation-Maximisation algorithm doesn't require training data
  (unsupervised machine learning).

  ``` python
  ecm = recordlinkage.ECMClassifier()
  ecm.fit_predict(feature_vectors)
  ```



  The main features of this Python record linkage toolkit are:

  -   Clean and standardise data with easy to use tools
  -   Make pairs of records with smart indexing methods such as
      **blocking** and **sorted neighbourhood indexing**
  -   Compare records with a large number of comparison and similarity
      measures for different types of variables such as strings, numbers
      and dates.
  -   Several classifications algorithms, both supervised and unsupervised
      algorithms.
  -   Common record linkage evaluation tools
  -   Several built-in datasets.



  The most recent documentation and API reference can be found at
  [recordlinkage.readthedocs.org](http://recordlinkage.readthedocs.org/en/latest/).
  The documentation provides some basic usage examples like
  [deduplication](http://recordlinkage.readthedocs.io/en/latest/notebooks/data_deduplication.html)
  and
  [linking](http://recordlinkage.readthedocs.io/en/latest/notebooks/link_two_dataframes.html)
  census data. More examples are coming soon. If you do have interesting
  examples to share, let us know.



  The Python Record linkage Toolkit requires Python 3.6 or higher. Install the
  package easily with pip

  ``` sh
  pip install recordlinkage
  ```

  Python 2.7 users can use version \<= 0.13, but it is advised to use
  Python \>= 3.5.

  The toolkit depends on popular packages like
  [Pandas](https://github.com/pydata/pandas),
  [Numpy](http://www.numpy.org), [Scipy](https://www.scipy.org/) and,
  [Scikit-learn](http://scikit-learn.org/). A complete list of
  dependencies can be found in the [installation
  manual](https://recordlinkage.readthedocs.io/en/latest/installation.html)
  as well as recommended and optional dependencies.



  The license for this record linkage tool is BSD-3-Clause.



  Please cite this package when being used in an academic context. Ensure
  that the DOI and version match the installed version. Citatation styles
  can be found on the publishers website
  [10.5281/zenodo.3559042](https://doi.org/10.5281/zenodo.3559042).

  ``` text
  @software{de_bruin_j_2019_3559043,
    author       = {De Bruin, J},
    title        = {{Python Record Linkage Toolkit: A toolkit for
                     record linkage and duplicate detection in Python}},
    month        = dec,
    year         = 2019,
    publisher    = {Zenodo},
    version      = {v0.14},
    doi          = {10.5281/zenodo.3559043},
    url          = {https://doi.org/10.5281/zenodo.3559043}
  }
  ```



  Stuck on your record linkage code or problem? Any other questions? Don't
  hestitate to send me an email (<jonathandebruinos@gmail.com>).


pkgId: 619407e5133fb38d4e3a683e9859b06c2fbba0bc7d1434a2af10af744d813fd2
name: python-records
arch: src
version: 0.5.3
epoch: 0
release: 1
summary: SQL for Humans
url: https://github.com/kennethreitz/records
rpm_license: ISC
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4925a1fe-b20c-4f3a-9c2b-7049b49f34a3
location_href: 00010568-python-records/python-records-0.5.3-1.src.rpm
checksum_type: sha256
description:
  **Records is a very simple, but powerful, library for making raw SQL queries
  to most relational databases.**
  Just write SQL. No bells, no whistles. This common task can be
  surprisingly difficult with the standard tools available.
  This library strives to make this workflow as simple as possible,
  while providing an elegant interface to work with your query results.


pkgId: 70c775402e698c700652d31c422584e606b119a1a465454de2c150115ba7ad4d
name: python-recsim
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: RecSim: A Configurable Recommender Systems Simulation Platform
url: https://github.com/google-research/recsim
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3fab8ea5-564f-44ed-a675-45a4bd69e3fc
location_href: 00012470-python-recsim/python-recsim-0.2.4-1.src.rpm
checksum_type: sha256
description:
  RecSim is a configurable platform for authoring simulation environments for
  recommender systems (RSs) that naturally supports **sequential interaction**
  with users. RecSim allows the creation of new environments that reflect
  particular aspects of user behavior and item structure at a level of abstraction
  well-suited to pushing the limits of current reinforcement learning (RL) and RS
  techniques in sequential interactive recommendation problems. Environments can
  be easily configured that vary assumptions about: user preferences and item
  familiarity; user latent state and its dynamics; and choice models and other
  user response behavior. We outline how RecSim offers value to RL and RS
  researchers and practitioners, and how it can serve as a vehicle for
  academic-industrial collaboration. For a detailed description of the RecSim
  architecture please read [Ie et al](https://arxiv.org/abs/1909.04847). Please
  cite the paper if you use the code from this repository in your work.



  ```
  @article{ie2019recsim,
      title={RecSim: A Configurable Simulation Platform for Recommender Systems},
      author={Eugene Ie and Chih-wei Hsu and Martin Mladenov and Vihan Jain and Sanmit Narvekar and Jing Wang and Rui Wu and Craig Boutilier},
      year={2019},
      eprint={1909.04847},
      archivePrefix={arXiv},
      primaryClass={cs.LG}
  }
  ```

  <a id='Disclaimer'></a>



  This is not an officially supported Google product.



  *   **12/13/2019:** Added (abstract) classes for both multi-user environments
      and agents. Added bandit algorithms for generalized linear models.



  It is recommended to install RecSim using (https://pypi.org/project/recsim/):

  ```shell
  pip install recsim
  ```

  However, the latest version of Dopamine is not in PyPI as of December, 2019. We
  want to install the latest version from Dopamine's repository like the following
  before we install RecSim. Note that Dopamine requires Tensorflow 1.15.0 which is
  the final 1.x release including GPU support for Ubuntu and Windows.

  ```
  pip install git+https://github.com/google/dopamine.git
  ```

  Here are some sample commands you could use for testing the installation:

  ```
  git clone https://github.com/google-research/recsim
  cd recsim/recsim
  python main.py --logtostderr \
    --base_dir="/tmp/recsim/interest_exploration_full_slate_q" \
    --agent_name=full_slate_q \
    --environment_name=interest_exploration \
    --episode_log_file='episode_logs.tfrecord' \
    --gin_bindings=simulator.runner_lib.Runner.max_steps_per_episode=100 \
    --gin_bindings=simulator.runner_lib.TrainRunner.num_iterations=10 \
    --gin_bindings=simulator.runner_lib.TrainRunner.max_training_steps=100 \
    --gin_bindings=simulator.runner_lib.EvalRunner.max_eval_episodes=5
  ```

  You could then start a tensorboard and view the output

  ```
  tensorboard --logdir=/tmp/recsim/interest_exploration_full_slate_q/ --port=2222
  ```

  You could also find the simulated logs in /tmp/recsim/episode_logs.tfrecord



  To get started, please check out our Colab tutorials. In
  [**RecSim: Overview**](recsim/colab/RecSim_Overview.ipynb),
  we give a brief overview about RecSim. We then talk about each configurable
  component:
  [**environment**](recsim/colab/RecSim_Developing_an_Environment.ipynb)
  and
  [**recommender agent**](recsim/colab/RecSim_Developing_an_Agent.ipynb).




  Please refer to the [white paper](http://arxiv.org/abs/1909.04847) for the
  high-level design.


pkgId: 5ec2d7eb8c1032359624ecb3e7e74d288ab4739ad010f2823f59e1eaaa02178a
name: python-redis
arch: src
version: 4.5.4
epoch: 0
release: 1
summary: Python client for Redis database and key-value store
url: https://github.com/redis/redis-py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-049a2e88-d7bd-4758-bf6e-e9f4528e066f
location_href: 00008981-python-redis/python-redis-4.5.4-1.src.rpm
checksum_type: sha256
description:
  Start a redis via docker:
  ``` bash
  docker run -p 6379:6379 -it redis/redis-stack:latest
  ```
  To install redis-py, simply:
  ``` bash
  $ pip install redis
  ```
  For faster performance, install redis with hiredis support, this provides a compiled response parser, and *for most cases* requires zero code changes.
  By default, if hiredis >= 1.0 is available, redis-py will attempt to use it for response parsing.
  ``` bash
  $ pip install "redis[hiredis]"
  ```
  Looking for a high-level library to handle object mapping? See [redis-om-python](https://github.com/redis/redis-om-python)!

  The most recent version of this library supports redis version [5.0](https://github.com/redis/redis/blob/5.0/00-RELEASENOTES), [6.0](https://github.com/redis/redis/blob/6.0/00-RELEASENOTES), [6.2](https://github.com/redis/redis/blob/6.2/00-RELEASENOTES), and [7.0](https://github.com/redis/redis/blob/7.0/00-RELEASENOTES).
  The table below higlights version compatibility of the most-recent library versions and redis versions.
  | Library version | Supported redis versions |
  |-----------------|-------------------|
  | 3.5.3 | <= 6.2 Family of releases |
  | >= 4.1.0 | Version 5.0 to current |


  ``` python
  >>> import redis
  >>> r = redis.Redis(host='localhost', port=6379, db=0)
  >>> r.set('foo', 'bar')
  True
  >>> r.get('foo')
  b'bar'
  ```
  The above code connects to localhost on port 6379, sets a value in Redis, and retrieves it. All responses are returned as bytes in Python, to receive decoded strings, set *decode_responses=True*.  For this, and more connection options, see [these examples](https://redis.readthedocs.io/en/stable/examples.html).

  By default, redis-py uses a connection pool to manage connections. Each instance of a Redis class receives its own connection pool. You can however define your own [redis.ConnectionPool](https://redis.readthedocs.io/en/stable/connections.html#connection-pools).
  ``` python
  >>> pool = redis.ConnectionPool(host='localhost', port=6379, db=0)
  >>> r = redis.Redis(connection_pool=pool)
  ```
  Alternatively, you might want to look at [Async connections](https://redis.readthedocs.io/en/stable/examples/asyncio_examples.html), or [Cluster connections](https://redis.readthedocs.io/en/stable/connections.html#cluster-client), or even [Async Cluster connections](https://redis.readthedocs.io/en/stable/connections.html#async-cluster-client).

  There is built-in support for all of the [out-of-the-box Redis commands](https://redis.io/commands). They are exposed using the raw Redis command names (`HSET`, `HGETALL`, etc.) except where a word (i.e. del) is reserved by the language. The complete set of commands can be found [here](https://github.com/redis/redis-py/tree/master/redis/commands), or [the documentation](https://redis.readthedocs.io/en/stable/commands.html).

  The [official Redis command documentation](https://redis.io/commands)
  does a great job of explaining each command in detail. redis-py attempts
  to adhere to the official command syntax. There are a few exceptions:
  -   **MULTI/EXEC**: These are implemented as part of the Pipeline class.
      The pipeline is wrapped with the MULTI and EXEC statements by
      default when it is executed, which can be disabled by specifying
      transaction=False. See more about Pipelines below.
  -   **SUBSCRIBE/LISTEN**: Similar to pipelines, PubSub is implemented as
      a separate class as it places the underlying connection in a state
      where it can\'t execute non-pubsub commands. Calling the pubsub
      method from the Redis client will return a PubSub instance where you
      can subscribe to channels and listen for messages. You can only call
      PUBLISH from the Redis client (see [this comment on issue
      
      for details).
  For more details, please see the documentation on [advanced topics page](https://redis.readthedocs.io/en/stable/advanced_features.html).

  The following is a basic example of a [Redis pipeline](https://redis.io/docs/manual/pipelining/), a method to optimize round-trip calls, by batching Redis commands, and receiving their results as a list.
  ``` python
  >>> pipe = r.pipeline()
  >>> pipe.set('foo', 5)
  >>> pipe.set('bar', 18.5)
  >>> pipe.set('blee', "hello world!")
  >>> pipe.execute()
  [True, True, True]
  ```

  The following example shows how to utilize [Redis Pub/Sub](https://redis.io/docs/manual/pubsub/) to subscribe to specific channels.
  ``` python
  >>> r = redis.Redis(...)
  >>> p = r.pubsub()
  >>> p.subscribe('my-first-channel', 'my-second-channel', ...)
  >>> p.get_message()
  {'pattern': None, 'type': 'subscribe', 'channel': b'my-second-channel', 'data': 1}


pkgId: dfa95d3d90bcfd738d2d7d93b56cf8e45d2105ee79e8aa2b4922703ac0a11066
name: python-redis-collections
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: Set of basic Python collections backed by Redis.
url: https://github.com/redis-collections/redis-collections
rpm_license: ISC
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c8bbdcaa-4a25-49e8-8e3c-77b604248a66
location_href: 00014263-python-redis-collections/python-redis-collections-0.11.0-1.src.rpm
checksum_type: sha256
description:
  `redis-collections` is a Python library that provides a high-level
  interface to `Redis <http://redis.io/>`_, the excellent key-value store.


pkgId: 06d2302e641f9b1f49d74dd034d94f3eb92631925501e372939891ca7e276466
name: python-redis-lock
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: A simple pessimistic lock implementation using Redis
url: http://github.com/cezarsa/redis_lock
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d4f33591-9a4a-4d7c-be7d-0fb17ce0306e
location_href: 00010500-python-redis-lock/python-redis-lock-0.2.0-1.src.rpm
checksum_type: sha256
description:
  A simple pessimistic lock implementation using Redis based on
    the algorithm described in http://redis.io/commands/setnx


pkgId: 00e802411cb6bb51a27eb21ae2c5651225f71a0faea1791d5ad2aa8cd8adb102
name: python-regenmaschine
arch: src
version: 2022.11.2
epoch: 0
release: 1
summary: A simple API for RainMachine sprinkler controllers
url: https://github.com/bachya/regenmaschine
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ce50f359-7ff6-44f0-821d-d2159c095797
location_href: 00004942-python-regenmaschine/python-regenmaschine-2022.11.2-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/bachya/regenmaschine/workflows/CI/badge.svg)](https://github.com/bachya/regenmaschine/actions)
  [![PyPi](https://img.shields.io/pypi/v/regenmaschine.svg)](https://pypi.python.org/pypi/regenmaschine)
  [![Version](https://img.shields.io/pypi/pyversions/regenmaschine.svg)](https://pypi.python.org/pypi/regenmaschine)
  [![License](https://img.shields.io/pypi/l/regenmaschine.svg)](https://github.com/bachya/regenmaschine/blob/main/LICENSE)
  [![Code Coverage](https://codecov.io/gh/bachya/regenmaschine/branch/main/graph/badge.svg)](https://codecov.io/gh/bachya/regenmaschine)
  [![Maintainability](https://api.codeclimate.com/v1/badges/a99a88d28ad37a79dbf6/maintainability)](https://codeclimate.com/github/bachya/regenmaschine/maintainability)
  [![Say Thanks](https://img.shields.io/badge/SayThanks-!-1EAEDB.svg)](https://saythanks.io/to/bachya)

  <a href="https://www.buymeacoffee.com/bachya1208P" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/default-orange.png" alt="Buy Me A Coffee" height="41" width="174"></a>

  `regenmaschine` (German for "rain machine") is a simple, clean, well-tested
  Python library for interacting with
  [RainMachine™ smart sprinkler controllers](http://www.rainmachine.com/).
  It gives developers an easy API to manage their controllers over their local
  LAN or remotely via the RainMachine™ cloud.

  - [Remote Access Announcement](#remote-access-announcement-2022-06-26)
  - [Python Versions](#python-versions)
  - [Installation](#installation)
  - [Usage](#usage)
  - [Loading Controllers Multiple Times](#loading-controllers-multiple-times)
  - [Contributing](#contributing)



  On June 2, 2022, RainMachine announced a
  [Premium Services](https://www.rainmachine.com/premium/) addition; under this new
  model, remote access is _only_ available to subscribers of these Premium Services.

  I do not currently intend to subscribe to Premium Services; as such, the remote access
  abilities of `regenmaschine` will remain as-is from here on out unless spurred on by
  others. They may stop working at any time. PRs from subscribing users are always
  welcome.



  `regenmaschine` is currently supported on:

  - Python 3.9
  - Python 3.10
  - Python 3.11



  ```bash
  pip install regenmaschine
  ```



  Creating a `regenmaschine` `Client` might be the easiest thing you do all day:

  ```python
  import asyncio

  from aiohttp import ClientSession

  from regenmaschine import Client


  async def main() -> None:
      """Run!"""
      client = Client()

      


  asyncio.run(main())
  ```

  By default, the library creates a new connection to the sprinkler controller with each
  coroutine. If you are calling a large number of coroutines (or merely want to squeeze
  out every second of runtime savings possible), an
  [`aiohttp`](https://github.com/aio-libs/aiohttp) `ClientSession` can be used for connection
  pooling:

  See the module docstrings throughout the library for full info on all parameters, return
  types, etc.

  ```python
  import asyncio

  from aiohttp import ClientSession

  from regenmaschine import Client


  async def main() -> None:
      """Run!"""
      async with ClientSession() as session:
          client = Client(session=session)


  asyncio.run(main())
  ```



  Once you have a client, you can load a local controller (i.e., one that is
  accessible over the LAN) very easily:

  ```python
  import asyncio

  from aiohttp import ClientSession

  from regenmaschine import Client


  async def main() -> None:
      """Run!"""
      async with ClientSession() as session:
          client = Client(session=session)

          await client.load_local("192.168.1.101", "my_password", port=8080, use_ssl=True)

          controllers = client.controllers
          


  asyncio.run(main())
  ```



  If you have 1, 2 or 100 other local controllers, you can load them in the same
  way – `client.controllers` will keep your controllers all organized.

  What if you have controllers around the world and can't access them all over
  the same local network? No problem! `regenmaschine` allows you to load remote
  controllers very easily, as well:

  ```python
  import asyncio

  from aiohttp import ClientSession

  from regenmaschine import Client


  async def main() -> None:
      """Run!"""
      async with ClientSession() as session:
          client = Client(session=session)

          await client.load_remote("rainmachine_email@host.com", "my_password")

          controllers = client.controllers
          


  asyncio.run(main())
  ```

  Bonus tip: `client.load_remote` will load _all_ controllers owned by that email
  address.



  Regardless of the type of controller you have loaded (local or remote), the
  same properties and methods are available to each:

  ```python
  import asyncio
  import datetime

  from aiohttp import ClientSession

  from regenmaschine import Client


  async def main() -> None:
      """Run!"""
      async with ClientSession() as session:
          client = Client(session=session)

          
          await client.load_local("192.168.1.101", "my_password", port=8080, use_ssl=True)

          
          await client.load_remote("rainmachine_email@host.com", "my_password")

          
          
          for mac_address, controller in client.controllers:
              
              print(f"Name: {controller.name}")
              print(f"Host: {controller.host}")
              print(f"MAC Address: {controller.mac}")
              print(f"API Version: {controller.api_version}")
              print(f"Software Version: {controller.software_version}")
              print(f"Hardware Version: {controller.hardware_version}")

              
              diagnostics = await controller.diagnostics.current()

              
              parsers = await controller.parsers.current()

              
              programs = await controller.programs.all()

              
              programs = await controller.programs.all(include_inactive=True)

              
              program_1 = await controller.programs.get(1)

              
              await controller.programs.enable(1)
              await controller.programs.disable(1)

              
              runs = await controller.programs.next()

              
              programs = await controller.programs.running()

              
              await controller.programs.start(1)
              await controller.programs.stop(1)

              
              zones = await controller.zones.all()

              
              zones = await controller.zones.all(details=True)

              
              zones = await controller.zones.all(include_inactive=True)

              
              zone_1 = await controller.zones.get(1)

              
              zone_1 = await controller.zones.get(1, details=True)

              
              await controller.zones.enable(1)
              await controller.zones.disable(1)

              
              await controller.zones.start(1, 60)

              
              await controller.zones.stop(1)

              
              programs = await controller.zones.running()

              
              name = await controller.provisioning.device_name

              
              settings = await controller.provisioning.settings()

              
              wifi = await controller.provisioning.wifi()

              
              current = await controller.restrictions.current()
              universal = await controller.restrictions.universal()
              hourly = await controller.restrictions.hourly()
              raindelay = await controller.restrictions.raindelay()

              
              
              await controller.restrictions.set_universal(
                  {
                      "hotDaysExtraWatering": False,
                      "freezeProtectEnabled": True,
                  }
              )

              
              today = await controller.stats.on_date(datetime.date.today())
              upcoming_days = await controller.stats.upcoming(details=True)

              
              log = await controller.watering.log(datetime.date.today(), 2)
              queue = await controller.watering.queue()
              runs = await controller.watering.runs(datetime.date.today())

              
              await controller.watering.pause_all(30)

              
              await controller.watering.unpause_all()

              
              await controller.watering.stop_all()

              
              update_data = await controller.machine.get_firmware_update_status()
              
              update_data = await controller.machine.update_firmware()

              
              update_data = await controller.machine.reboot()

              
              flowmeter = await controller.watering.flowmeter()

              
              
              
              await controller.watering.post_flowmeter({"value": 2000, "units": "clicks"})


  asyncio.run(main())
  ```

  Check out `example.py`, the tests, and the source files themselves for method
  signatures and more examples. For additional reference, the full RainMachine™ API documentation is available [here](https://rainmachine.docs.apiary.io/).



  It is technically possible to load a controller multiple times. Let's pretend
  for a moment that:

  - We have a local controller named `Home` (available at `192.168.1.101`).
  - We have a remote controller named `Grandma's House`.
  - Both controllers live under our email address: `user@host.com`

  If we load them thus:

  ```python
  import asyncio

  from aiohttp import ClientSession

  from regenmaschine import Client


  async def main() -> None:
      """Run!"""
      async with ClientSession() as session:
          client = Client(session=session)

          
          await client.load_local("192.168.1.101", "my_password")

          
          await client.load_remote("user@host.com", "my_password")


  asyncio.run(main())
  ```

  ...then we will have the following:

  1. `Home` will be a `LocalController` and accessible over the LAN.
  2. `Grandma's House` will be a `RemoteController` and accessible only over the
     RainMachine™ cloud.

  Notice that `regenmaschine` is smart enough to not overwrite a controller that
  already exists: even though `Home` exists as a remote controller owned by
  `user@host.com`, it had already been loaded locally. By default,
  `regenmaschine` will only load a controller if it hasn't been loaded before
  (locally _or_ remotely). If you want to change this behavior, both `load_local`
  and `load_remote` accept an optional `skip_existing` parameter:

  ```python
  import asyncio

  from aiohttp import ClientSession

  from regenmaschine import Client


  async def main() -> None:
      """Run!"""
      async with ClientSession() as session:
          client = Client(session=session)

          
          await client.load_remote("user@host.com", "my_password")

          
          await client.load_local("192.168.1.101", "my_password", skip_existing=False)


  asyncio.run(main())
  ```



  1. [Check for open features/bugs](https://github.com/bachya/regenmaschine/issues)
     or [initiate a discussion on one](https://github.com/bachya/regenmaschine/issues/new).
  2. [Fork the repository](https://github.com/bachya/regenmaschine/fork).
  3. (_optional, but highly recommended_) Create a virtual environment: `python3 -m venv .venv`
  4. (_optional, but highly recommended_) Enter the virtual environment: `source ./.venv/bin/activate`
  5. Install the dev environment: `script/setup`
  6. Code your new feature or bug fix.
  7. Write tests that cover your new functionality.
  8. Run tests and ensure 100% code coverage: `poetry run pytest --cov regenmaschine tests`
  9. Update `README.md` with any new documentation.
  10. Add yourself to `AUTHORS.md`.
  11. Submit a pull request!


pkgId: 0d3e0f1d2543d0d46d00c0358aa561627787cb1c44f4f2cd3108ec8859de0e58
name: python-regex
arch: src
version: 2022.10.31
epoch: 0
release: 1
summary: Alternative regular expression module, to replace re.
url: https://github.com/mrabarnett/mrab-regex
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3a295628-4345-435f-9015-b4350ebfdd4b
location_href: 00004943-python-regex/python-regex-2022.10.31-1.src.rpm
checksum_type: sha256
description:
  This regex implementation is backwards-compatible with the standard 're' module, but offers additional functionality.


pkgId: bcce632cfeb9b49c1b88f558eeda35cbcf4bef187be4ece4beea689aca92f593
name: python-regex-debuginfo
arch: aarch64
version: 2022.10.31
epoch: 0
release: 1
summary: Debug information for package python-regex
url: https://github.com/mrabarnett/mrab-regex
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-3a295628-4345-435f-9015-b4350ebfdd4b
rpm_sourcerpm: python-regex-2022.10.31-1.src.rpm
location_href: 00004943-python-regex/python-regex-debuginfo-2022.10.31-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-regex.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 4b55032254c4413875091bcd9b8eafd5290d9b6cc083e4b23e4d023d36dba51e
name: python-regex-debugsource
arch: aarch64
version: 2022.10.31
epoch: 0
release: 1
summary: Debug sources for package python-regex
url: https://github.com/mrabarnett/mrab-regex
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-3a295628-4345-435f-9015-b4350ebfdd4b
rpm_sourcerpm: python-regex-2022.10.31-1.src.rpm
location_href: 00004943-python-regex/python-regex-debugsource-2022.10.31-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-regex.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 7f8d44e2d1796f22f71cd39e5b1c4f4313e00b4ba682b31925e7bffeb00ec58c
name: python-registry
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: Windows registry API
url: UNKNOWN
rpm_license: Public domain
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b31fd036-be9e-4959-8fa3-4431adc87fa7
location_href: 00004944-python-registry/python-registry-0.4.2-1.src.rpm
checksum_type: sha256
description:
  Wrapper around Windows API registry calls.

  Registry calls are handled through ctypes by calling functions
  from advapi32.dll.


pkgId: b4a9d2d495a1da3dc19e34164a4a92ace7d508e5435198b55b47b496629fe6d5
name: python-relatorio
arch: src
version: 0.10.1
epoch: 0
release: 1
summary: A templating library able to output odt and pdf files
url: https://pypi.python.org/pypi/relatorio
rpm_license: GPL License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-92b95109-032d-424b-ba8b-4dfefb513ccb
location_href: 00004945-python-relatorio/python-relatorio-0.10.1-1.src.rpm
checksum_type: sha256
description:
  Relatorio is a templating library which provides a way to easily output several
  kinds of files (odt, ods, png, svg, ...). Support for more filetypes can
  be easily added by creating plugins for them.
  Relatorio also provides a report repository allowing you to link python objects
  and report together, find reports by mimetype/name/python object.


pkgId: c590e8d45733f3f10775a10e9379793cfd589a52905164ee20cafe44346ebeb8
name: python-remote-pdb
arch: src
version: 2.1.0
epoch: 0
release: 1
url: https://github.com/ionelmc/python-remote-pdb
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d9f057a8-0f92-4970-8017-4e054c2c9890
location_href: 00012401-python-remote-pdb/python-remote-pdb-2.1.0-1.src.rpm
checksum_type: sha256
summary:
  Remote vanilla PDB (over TCP sockets) *done right*: no extras, proper handling around connection failures and CI. Based on `pdbx <https://pypi.python.org/pypi/pdbx>`_.


pkgId: aed9f0c7640fcf1f899e18316ece7d6be5bf9271fc37f9ba4fa376408804a844
name: python-rencode
arch: src
version: 1.0.6
epoch: 0
release: 1
summary: Web safe object pickling/unpickling
url: https://github.com/aresch/rencode
rpm_license: GPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b5832495-ba30-4f30-ae47-153f91e4eb60
location_href: 00004946-python-rencode/python-rencode-1.0.6-1.src.rpm
checksum_type: sha256
description:
  The rencode module is similar to bencode from the BitTorrent project.  For complex, heterogeneous data structures with many small elements, r-encodings take up significantly less space than b-encodings:

  ```
  >>> len(rencode.dumps({'a':0, 'b':[1,2], 'c':99}))
  13

  >>> len(bencode.bencode({'a':0, 'b':[1,2], 'c':99}))
  26
  ```

  This version of rencode is a complete rewrite in Cython to attempt to increase the performance over the pure Python module written by Petru Paler, Connelly Barnes et al.



  The test program used for these results is included in the repository:
  https://github.com/aresch/rencode/blob/master/tests/timetest.py


  ```
  test_encode_fixed_pos_int:
  	rencode.pyx: 0.003s (+0.013s) 589.17%
  	rencode.py:  0.016s

  test_encode_int_int_size:
  	rencode.pyx: 0.006s (+0.032s) 625.99%
  	rencode.py:  0.038s

  test_encode_int_long_long_size:
  	rencode.pyx: 0.014s (+0.026s) 279.96%
  	rencode.py:  0.040s

  test_encode_int_short_size:
  	rencode.pyx: 0.006s (+0.030s) 629.80%
  	rencode.py:  0.036s

  test_encode_str:
  	rencode.pyx: 0.006s (+0.010s) 263.96%
  	rencode.py:  0.017s

  test_encode_dict:
  	rencode.pyx: 0.135s (+0.302s) 324.68%
  	rencode.py:  0.437s

  test_encode_fixed_list:
  	rencode.pyx: 0.012s (+0.025s) 307.78%
  	rencode.py:  0.037s

  test_encode_fixed_neg_int:
  	rencode.pyx: 0.003s (+0.012s) 536.97%
  	rencode.py:  0.015s

  test_encode_fixed_dict:
  	rencode.pyx: 0.046s (+0.105s) 331.07%
  	rencode.py:  0.151s

  test_encode_int_char_size:
  	rencode.pyx: 0.005s (+0.029s) 687.64%
  	rencode.py:  0.034s

  test_encode_fixed_str:
  	rencode.pyx: 0.003s (+0.011s) 438.07%
  	rencode.py:  0.015s

  test_encode_list:
  	rencode.pyx: 0.148s (+0.228s) 253.68%
  	rencode.py:  0.376s

  test_encode_none:
  	rencode.pyx: 0.004s (+0.011s) 386.06%
  	rencode.py:  0.014s

  test_encode_int_big_number:
  	rencode.pyx: 0.011s (+0.019s) 264.32%
  	rencode.py:  0.030s

  test_encode_float_64bit:
  	rencode.pyx: 0.003s (+0.011s) 416.19%
  	rencode.py:  0.014s

  test_encode_bool:
  	rencode.pyx: 0.004s (+0.014s) 447.57%
  	rencode.py:  0.018s

  test_encode_float_32bit:
  	rencode.pyx: 0.003s (+0.010s) 417.86%
  	rencode.py:  0.014s

  Encode functions totals:
  	rencode.pyx: 0.412s (+0.888s) 315.49%
  	rencode.py:  1.301s
  ```


  ```
  test_decode_fixed_list:
  	rencode.pyx: 0.003s (+0.020s) 848.67%
  	rencode.py:  0.022s

  test_decode_int_long_long_size:
  	rencode.pyx: 0.003s (+0.013s) 484.80%
  	rencode.py:  0.016s

  test_decode_dict:
  	rencode.pyx: 0.267s (+0.406s) 251.81%
  	rencode.py:  0.673s

  test_decode_fixed_dict:
  	rencode.pyx: 0.087s (+0.123s) 241.32%
  	rencode.py:  0.211s

  test_decode_float_32bit:
  	rencode.pyx: 0.002s (+0.007s) 536.88%
  	rencode.py:  0.009s

  test_decode_int_big_number:
  	rencode.pyx: 0.007s (+0.010s) 256.05%
  	rencode.py:  0.017s

  test_decode_int_char_size:
  	rencode.pyx: 0.002s (+0.014s) 754.12%
  	rencode.py:  0.016s

  test_decode_fixed_neg_int:
  	rencode.pyx: 0.001s (+0.004s) 389.03%
  	rencode.py:  0.006s

  test_decode_fixed_str:
  	rencode.pyx: 0.009s (+0.009s) 199.78%
  	rencode.py:  0.019s

  test_decode_float_64bit:
  	rencode.pyx: 0.002s (+0.007s) 540.17%
  	rencode.py:  0.009s

  test_decode_bool:
  	rencode.pyx: 0.002s (+0.004s) 369.49%
  	rencode.py:  0.006s

  test_decode_fixed_pos_int:
  	rencode.pyx: 0.002s (+0.004s) 368.96%
  	rencode.py:  0.006s

  test_decode_list:
  	rencode.pyx: 0.019s (+0.247s) 1403.77%
  	rencode.py:  0.266s

  test_decode_none:
  	rencode.pyx: 0.002s (+0.004s) 367.05%
  	rencode.py:  0.006s

  test_decode_int_short_size:
  	rencode.pyx: 0.002s (+0.014s) 716.47%
  	rencode.py:  0.016s

  test_decode_str:
  	rencode.pyx: 0.010s (+0.026s) 364.51%
  	rencode.py:  0.036s

  test_decode_int_int_size:
  	rencode.pyx: 0.002s (+0.014s) 705.92%
  	rencode.py:  0.016s

  Decode functions totals:
  	rencode.pyx: 0.421s (+0.926s) 319.79%
  	rencode.py:  1.348s
  ```



  ```
  test_overall_encode:
  	rencode.pyx: 0.069s (+0.120s) 274.42%
  	rencode.py:  0.189s

  test_overall_decode:
  	rencode.pyx: 0.051s (+0.153s) 400.57%
  	rencode.py:  0.204s

  Overall functions totals:
  	rencode.pyx: 0.120s (+0.273s) 327.98%
  	rencode.py:  0.393s
  ```



  * Andrew Resch <andrewresch@gmail.com>
  * Website: https://github.com/aresch/rencode


  See [COPYING](https://github.com/aresch/rencode/blob/master/COPYING)  for license information.


pkgId: 5b47bcc47498e3543838ecd8b0e6931de9c3ff50406ebe1487c7ebe8b12847ee
name: python-replit
arch: src
version: 3.2.5
epoch: 0
release: 1
summary: A library for interacting with features of repl.it
url: https://github.com/replit/replit-py
rpm_license: ISC
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-29b1851e-8b40-42cc-9e60-8751bc0f67ac
location_href: 00009301-python-replit/python-replit-3.2.5-1.src.rpm
checksum_type: sha256
description:
  ![compute](https://github.com/kennethreitz42/replit-py/blob/kr-cleanup/ext/readme.gif?raw=true)

  This repository is the home for the `replit` Python package, which provides:

  - A fully-featured database client for [Replit DB](https://docs.repl.it/misc/database).
  - A Flask–based application framework for accelerating development on the platform.
  - Replit user profile metadata retrieval (more coming here!).
  - A simple audio library that can play tones and audio files!



  This library is licensed under the [ISC License](https://en.wikipedia.org/wiki/ISC_license) and is free for you to use, change, or even profit from!


pkgId: dd0ce356101c56efb72968cf505860a447aed0d0907cdc4b274c45ade19911ed
name: python-repomd
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Library for reading dnf/yum repositories
url: https://github.com/carlwgeorge/repomd
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3616925b-94ae-4626-af97-86f300296fc4
location_href: 00004950-python-repomd/python-repomd-0.2.1-1.src.rpm
checksum_type: sha256
description:
  [![build status](https://api.cirrus-ci.com/github/carlwgeorge/repomd.svg)](https://cirrus-ci.com/github/carlwgeorge/repomd/master)



  This library provides an object-oriented interface to get information out of dnf/yum repositories.



  ```python
  >>> import repomd

  >>> repo = repomd.load('https://mirror.rackspace.com/centos/7/updates/x86_64/')

  >>> repo
  <Repo: "https://mirror.rackspace.com/centos/7/updates/x86_64/">
  ```

  The length of the `Repo` object indicates the number of packages in the repository.

  ```python
  >>> len(repo)
  1602
  ```

  Find a package by name.

  ```python
  >>> repo.find('systemd')
  <Package: "systemd-219-57.el7_5.3.x86_64">
  ```

  Find all packages of a given name.

  ```python
  >>> repo.findall('systemd')
  [<Package: "systemd-219-57.el7_5.1.x86_64">, <Package: "systemd-219-57.el7_5.3.x86_64">]
  ```

  A `Package` instance has many useful properties.

  ```python
  >>> package = repo.find('systemd')

  >>> package.name
  'systemd'

  >>> package.version
  '219'

  >>> package.build_time
  datetime.datetime(2018, 9, 26, 14, 11, 37)

  >>> package.nevr
  'systemd-219-57.el7_5.3'
  ```

  Iterate through packages in the repository.

  ```python
  >>> for package in repo:
  ...     print(package.nvr)
  389-ds-base-1.3.7.5-19.el7_5
  389-ds-base-1.3.7.5-21.el7_5
  389-ds-base-1.3.7.5-24.el7_5
  (and so on)
  ```


pkgId: b143e71317887235759b6faaa0102b527e89b72b7b901fb8d7c670ecbf5ad970
name: python-reportportal-client
arch: src
version: 5.3.0
epoch: 0
release: 1
summary: Python client for Report Portal v5.
url: https://github.com/reportportal/client-Python
rpm_license: Apache 2.0.
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-40970d33-7ebe-482c-92ce-4bf7a166f4b4
location_href: 00011398-python-reportportal-client/python-reportportal-client-5.3.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/reportportal-client.svg?maxAge=259200)](https://pypi.python.org/pypi/reportportal-client)
  [![Python versions](https://img.shields.io/pypi/pyversions/reportportal-client.svg)](https://pypi.org/project/reportportal-client)
  [![Build Status](https://github.com/reportportal/client-Python/actions/workflows/tests.yml/badge.svg)](https://github.com/reportportal/client-Python/actions/workflows/tests.yml)
  [![codecov.io](https://codecov.io/gh/reportportal/client-Python/branch/master/graph/badge.svg)](https://codecov.io/gh/reportportal/client-Python)
  [![Join Slack chat!](https://slack.epmrpp.reportportal.io/badge.svg)](https://slack.epmrpp.reportportal.io/)
  [![stackoverflow](https://img.shields.io/badge/reportportal-stackoverflow-orange.svg?style=flat)](http://stackoverflow.com/questions/tagged/reportportal)
  [![Build with Love](https://img.shields.io/badge/build%20with-❤%EF%B8%8F%E2%80%8D-lightgrey.svg)](http://reportportal.io?style=flat)

  Library used only for implementors of custom listeners for ReportPortal




  - [PyTest Framework](https://github.com/reportportal/agent-python-pytest)
  - [Robot Framework](https://github.com/reportportal/agent-Python-RobotFramework)
  - [Behave Framework](https://github.com/reportportal/agent-python-behave)
  - [Nose Framework](https://github.com/reportportal/agent-python-nosetests)




  The latest stable version is available on PyPI:

  ```
  pip install reportportal-client
  ```

  **IMPORTANT!**
  The latest client version **does** not support Report Portal versions below
  5.0.0.

  Version 3 is the latest one which supports Report Portal versions below 5.0.0
  to install it:

  ```
  pip install reportportal-client~=3.0
  ```




  All the fixes for the client that supports Report Portal versions below 5.0.0
  should go into the v3 branch. The master branch will store the code base for
  the client for Report Portal versions 5 and above.




  Main classes are:

  - reportportal_client.ReportPortalService
  - reportportal_client.ReportPortalServiceAsync(Client version 3.x only)

  Basic usage example:

  ```python
  import os
  import subprocess
  import traceback
  from mimetypes import guess_type
  from time import time


  from reportportal_client import ReportPortalServiceAsync


  from reportportal_client import ReportPortalService


  def timestamp():
      return str(int(time() * 1000))


  endpoint = "http://10.6.40.6:8080"
  project = "default"

  token = "1adf271d-505f-44a8-ad71-0afbdf8c83bd"
  launch_name = "Test launch"
  launch_doc = "Testing logging with attachment."


  def my_error_handler(exc_info):
      """
      This callback function will be called by async service client when error occurs.
      Return True if error is not critical and you want to continue work.
      :param exc_info: result of sys.exc_info() -> (type, value, traceback)
      :return:
      """
      print("Error occurred: {}".format(exc_info[1]))
      traceback.print_exception(*exc_info)



  service = ReportPortalServiceAsync(endpoint=endpoint, project=project,
                                     token=token, error_handler=my_error_handler)


  service = ReportPortalService(endpoint=endpoint, project=project,
                                     token=token)


  launch = service.start_launch(name=launch_name,
                                start_time=timestamp(),
                                description=launch_doc)


  test = service.start_test_item(name="Test Case",
                                 description="First Test Case",
                                 tags=["Image", "Smoke"],
                                 start_time=timestamp(),
                                 item_type="STEP",
                                 parameters={"key1": "val1",
                                             "key2": "val2"})


  item_id = service.start_test_item(name="Test Case",
                                    description="First Test Case",
                                    start_time=timestamp(),
                                    item_type="STEP",
                                    parameters={"key1": "val1",
                                                "key2": "val2"})



  service.log(time=timestamp(),
              message="Hello World!",
              level="INFO")


  service.log(time=timestamp(),
              message="Too high memory usage!",
              level="WARN",
              attachment={
                  "name": "free_memory.txt",
                  "data": subprocess.check_output("free -h".split()),
                  "mime": "text/plain"
              })


  image = "/tmp/image.png"
  with open(image, "rb") as fh:
      attachment = {
          "name": os.path.basename(image),
          "data": fh.read(),
          "mime": guess_type(image)[0] or "application/octet-stream"
      }
      service.log(timestamp(), "Screen shot of issue.", "INFO", attachment)


  service.log(
      timestamp(),
      "running processes",
      "INFO",
      attachment=subprocess.check_output("ps aux".split()))


  service.finish_test_item(end_time=timestamp(), status="PASSED")


  service.finish_test_item(item_id=item_id, end_time=timestamp(), status="PASSED")


  service.finish_launch(end_time=timestamp())




  service.terminate()
  ```




  [python-client](https://github.com/reportportal/client-Python/blob/64550693ec9c198b439f8f6e8b23413812d9adf1/reportportal_client/service.py#L259) uses `requests` library for working with RP and the same semantics to work with attachments (data).

  There are two ways to pass data as attachment:


  ```
  with open(screenshot_file_path, "rb") as image_file:
      rp_logger.info("Some Text Here",
                     attachment={"name": "test_name_screenshot.png",
                                 "data": image_file,
                                 "mime": "image/png"})
  ```


  ```
  with open(screenshot_file_path, "rb") as image_file:
          file_data = image_file.read()

  rp_logger.info("Some Text Here",
                 attachment={"name": "test_name_screenshot.png",
                             "data": file_data,
                             "mime": "image/png"})
  ```




  Licensed under the [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0)
  license (see the LICENSE.txt file).


pkgId: 884ec69c8ec8f2e91968e3d196857785a04b63ef1c9bc0c49aea41101c56fef2
name: python-repoze.sendmail
arch: src
version: 4.4.1
epoch: 0
release: 1
summary: Repoze Sendmail
url: http://www.repoze.org
rpm_license: ZPL 2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e325d1ff-ab04-49de-bc06-d0e50c19431d
location_href: 00013732-python-repoze-sendmail/python-repoze.sendmail-4.4.1-1.src.rpm
checksum_type: sha256
description:
  `repoze.sendmail` allows coupling the sending of email messages with a
  transaction, using the Zope transaction manager.  This allows messages to
  only be sent out when and if a transaction is committed, preventing users
  from receiving notifications about events which may not have completed
  successfully.
  Please see `docs/index.rst` for complete documentation, or read the
  docs online at http://docs.repoze.org/sendmail
  Change history
  ~~~~~~~~~~~~~~


pkgId: 241b6583c0c77bf1b51ed4b28796d43ba0e8ca91fb0efeee8bbd9eab1a5d10f2
name: python-repoze.tm2
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Per-request transactions via WSGI middleware
url: http://www.repoze.org
rpm_license: BSD-derived (http://www.repoze.org/LICENSE.txt)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f47d5daa-1912-4aa6-9a92-b2ab82ffaa58
location_href: 00004952-python-repoze-tm2/python-repoze.tm2-2.2.0-1.src.rpm
checksum_type: sha256
description:
  Middleware which uses the ZODB transaction manager to wrap a call to
  its pipeline children inside a transaction.  This is a fork of the
  ``repoze.tm`` package which depends only on the ``transaction``
  package rather than the entirety of ZODB (for users who don't rely on ZODB).


pkgId: febf2b4f432eacabd2253e23518ce406aea9d8415b447d05f2c79bd02d29b19d
name: python-repoze.who.plugins.sa
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: The repoze.who SQLAlchemy plugin
url: http://code.gustavonarea.net/repoze.who.plugins.sa/
rpm_license: BSD-derived (http://www.repoze.org/LICENSE.txt)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7b8b490b-bfc3-4233-89d4-7494b24e716c
location_href: 00004954-python-repoze-who-plugins-sa/python-repoze.who.plugins.sa-1.0.1-1.src.rpm
checksum_type: sha256
description:
  ********************************
  The repoze.who SQLAlchemy plugin
  ********************************

  This plugin provides one repoze.who authenticator and one metadata provider
  which works with SQLAlchemy or Elixir-based models.


pkgId: 3d5dd0d8f1a369ad2f0dd4e67c1c72c3eb101b894540f2bcf07c656573f29e50
name: python-reproject
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: Reproject astronomical images
url: https://reproject.readthedocs.io
rpm_license: BSD 3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-82b26c69-3be5-4bd5-a967-874230662795
location_href: 00004956-python-reproject/python-reproject-0.10.0-1.src.rpm
checksum_type: sha256
description:
  The `reproject` package is a Python package to reproject astronomical
  images using various techniques via a uniform interface. By
  *reprojection*, we mean the re-gridding of images from one world
  coordinate system to another (for example changing the pixel resolution,
  orientation, coordinate system). Currently, we have implemented
  reprojection of celestial images by interpolation (like
  `SWARP <http://www.astromatic.net/software/swarp>`__), by the adaptive and
  anti-aliased algorithm of `DeForest (2004)
  <https://doi.org/10.1023/B:SOLA.0000021743.24248.b0>`_, and by finding the
  exact overlap between pixels on the celestial sphere (like `Montage
  <http://montage.ipac.caltech.edu/index.html>`__). It can also reproject to/from
  HEALPIX projections by relying on the `astropy-healpix
  <https://github.com/astropy/astropy-healpix>`__ package.
  For more information, including on how to install the package, see
  https://reproject.readthedocs.io


pkgId: 767d76851bc01366f8de8dea1f05632e753fce7b912778e62da63579ec6f93b0
name: python-requests
arch: src
version: 2.28.2
epoch: 0
release: 1
summary: Python HTTP for Humans.
url: https://requests.readthedocs.io
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-567827fb-f671-455f-9496-d79ea7967dfe
location_href: 00008882-python-requests/python-requests-2.28.2-1.src.rpm
checksum_type: sha256
description:
  [![Kenneth Reitz](https://raw.githubusercontent.com/psf/requests/main/ext/kr.png)](https://kennethreitz.org) [![Python Software Foundation](https://raw.githubusercontent.com/psf/requests/main/ext/psf.png)](https://www.python.org/psf)


pkgId: 1fa3305b082d787c8aa7016e2caa9dc555890a08184e651a96894c6f84d7802e
name: python-requests-cache
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: A persistent cache for python requests
url: https://github.com/requests-cache/requests-cache
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3a899d4a-0eb1-47f3-8ceb-9b562feecab4
location_href: 00004959-python-requests-cache/python-requests-cache-1.0.0-1.src.rpm
checksum_type: sha256
description:
  [![](docs/_static/requests-cache-logo-header.png)](https://requests-cache.readthedocs.io)

  [![Build](https://github.com/requests-cache/requests-cache/actions/workflows/build.yml/badge.svg)](https://github.com/requests-cache/requests-cache/actions/workflows/build.yml)
  [![Codecov](https://codecov.io/gh/requests-cache/requests-cache/branch/main/graph/badge.svg?token=FnybzVWbt2)](https://codecov.io/gh/requests-cache/requests-cache)
  [![Documentation](https://img.shields.io/readthedocs/requests-cache/stable)](https://requests-cache.readthedocs.io/en/stable/)
  [![Code Shelter](https://www.codeshelter.co/static/badges/badge-flat.svg)](https://www.codeshelter.co/)

  [![PyPI](https://img.shields.io/pypi/v/requests-cache?color=blue)](https://pypi.org/project/requests-cache)
  [![Conda](https://img.shields.io/conda/vn/conda-forge/requests-cache?color=blue)](https://anaconda.org/conda-forge/requests-cache)
  [![PyPI - Python Versions](https://img.shields.io/pypi/pyversions/requests-cache)](https://pypi.org/project/requests-cache)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/requests-cache?color=blue)](https://pypi.org/project/requests-cache)


  **requests-cache** is a persistent HTTP cache that provides an easy way to get better
  performance with the python [requests](https://requests.readthedocs.io/) library.

  <!-- RTD-IGNORE -->
  Complete project documentation can be found at [requests-cache.readthedocs.io](https://requests-cache.readthedocs.io).
  <!-- END-RTD-IGNORE -->


  * 🍰 **Ease of use:** Keep using the `requests` library you're already familiar with. Add caching
    with a [drop-in replacement](https://requests-cache.readthedocs.io/en/stable/user_guide/general.html#sessions)
    for `requests.Session`, or
    [install globally](https://requests-cache.readthedocs.io/en/stable/user_guide/general.html#patching)
    to add transparent caching to all `requests` functions.
  * 🚀 **Performance:** Get sub-millisecond response times for cached responses. When they expire, you
    still save time with
    [conditional requests](https://requests-cache.readthedocs.io/en/stable/user_guide/headers.html#conditional-requests).
  * 💾 **Persistence:** Works with several
    [storage backends](https://requests-cache.readthedocs.io/en/stable/user_guide/backends.html)
    including SQLite, Redis, MongoDB, and DynamoDB; or save responses as plain JSON files, YAML,
    and more
  * 🕗 **Expiration:** Use
    [Cache-Control](https://requests-cache.readthedocs.io/en/stable/user_guide/headers.html#cache-control)
    and other standard HTTP headers, define your own expiration schedule, keep your cache clutter-free
    with backends that natively support TTL, or any combination of strategies
  * ⚙️ **Customization:** Works out of the box with zero config, but with a robust set of features for
    configuring and extending the library to suit your needs
  * 🧩 **Compatibility:** Can be combined with other
    [popular libraries based on requests](https://requests-cache.readthedocs.io/en/stable/user_guide/compatibility.html)


  First, install with pip:
  ```bash
  pip install requests-cache
  ```

  Then, use [requests_cache.CachedSession](https://requests-cache.readthedocs.io/en/stable/session.html)
  to make your requests. It behaves like a normal
  [requests.Session](https://requests.readthedocs.io/en/latest/user/advanced/#session-objects),
  but with caching behavior.

  To illustrate, we'll call an endpoint that adds a delay of 1 second, simulating a slow or
  rate-limited website.

  **This takes 1 minute:**
  ```python
  import requests

  session = requests.Session()
  for i in range(60):
      session.get('https://httpbin.org/delay/1')
  ```

  **This takes 1 second:**
  ```python
  import requests_cache

  session = requests_cache.CachedSession('demo_cache')
  for i in range(60):
      session.get('https://httpbin.org/delay/1')
  ```

  With caching, the response will be fetched once, saved to `demo_cache.sqlite`, and subsequent
  requests will return the cached response near-instantly.


  If you don't want to manage a session object, or just want to quickly test it out in your
  application without modifying any code, requests-cache can also be installed globally, and all
  requests will be transparently cached:
  ```python
  import requests
  import requests_cache

  requests_cache.install_cache('demo_cache')
  requests.get('https://httpbin.org/delay/1')
  ```


  By default, requests-cache will keep cached responses indefinitely. In most cases, you will want to
  use one of the two following strategies to balance cache freshness and performance:

  **Define exactly how long to keep responses:**

  Use the `expire_after` parameter to set a fixed expiration time for all responses:
  ```python
  from requests_cache import CachedSession
  from datetime import timedelta


  session = CachedSession('demo_cache', expire_after=360)


  session = CachedSession('demo_cache', expire_after=timedelta(hours=1))
  ```
  See [Expiration](https://requests-cache.readthedocs.io/en/stable/user_guide/expiration.html) for
  more features and settings.

  **Use Cache-Control headers:**

  Use the `cache_control` parameter to enable automatic expiration based on `Cache-Control` and other
  standard HTTP headers sent by the server:
  ```python
  from requests_cache import CachedSession

  session = CachedSession('demo_cache', cache_control=True)
  ```
  See [Cache Headers](https://requests-cache.readthedocs.io/en/stable/user_guide/headers.html)
  for more details.



  The default settings work well for most use cases, but there are plenty of ways to customize
  caching behavior when needed. Here is a quick example of some of the options available:
  ```python
  from datetime import timedelta
  from requests_cache import CachedSession

  session = CachedSession(
      'demo_cache',
      use_cache_dir=True,                # Save files in the default user cache dir
      cache_control=True,                # Use Cache-Control response headers for expiration, if available
      expire_after=timedelta(days=1),    # Otherwise expire responses after one day
      allowable_codes=[200, 400],        # Cache 400 responses as a solemn reminder of your failures
      allowable_methods=['GET', 'POST'], # Cache whatever HTTP methods you want
      ignored_parameters=['api_key'],    # Don't match this request param, and redact if from the cache
      match_headers=['Accept-Language'], # Cache a different response per language
      stale_if_error=True,               # In case of request errors, use stale cache data if possible
  )
  ```

  <!-- RTD-IGNORE -->

  To find out more about what you can do with requests-cache, see:

  * [User Guide](https://requests-cache.readthedocs.io/en/stable/user_guide.html)
  * [Examples](https://requests-cache.readthedocs.io/en/stable/examples.html)
  * [API Reference](https://requests-cache.readthedocs.io/en/stable/reference.html)
  * [Project Info](https://requests-cache.readthedocs.io/en/stable/project_info.html)
  <!-- END-RTD-IGNORE -->


pkgId: 164b3600c695389884c6df83c11a60ebc876b94252e27f3e216529177343228b
name: python-requests-credssp
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: HTTPS CredSSP authentication with the requests library.
url: https://github.com/jborean93/requests-credssp
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e6bf169a-caf9-4f73-9e60-c14b4cb206ae
location_href: 00004960-python-requests-credssp/python-requests-credssp-2.0.0-1.src.rpm
checksum_type: sha256
description:
  [![Test workflow](https://github.com/jborean93/requests-credssp/actions/workflows/ci.yml/badge.svg)](https://github.com/jborean93/requests-credssp/actions/workflows/ci.yml)
  [![codecov](https://codecov.io/gh/jborean93/requests-credssp/branch/master/graph/badge.svg)](https://codecov.io/gh/jborean93/requests-credssp)
  [![PyPI version](https://badge.fury.io/py/requests-credssp.svg)](https://badge.fury.io/py/requests-credssp)
  [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/jborean93/request-credssp/blob/master/LICENSE)




  This package allows for HTTPS CredSSP authentication using the requests
  library. CredSSP is a Microsoft authentication that allows your credentials to
  be delegated to a server giving you double hop authentication.




  This library supports the following CredSSP features

  * Protocol version 2 to 6
  * Initial authentication with NTLM or Kerberos
  * Message encryption support using the `wrap` and `unwrap` functions




  The following Python libraries are required;

  * Python 3.6+
  * [cryptography](https://github.com/pyca/cryptography)
  * [pyspnego](https://github.com/jborean93/pyspnego)
  * [requests>=2.0.0](https://pypi.python.org/pypi/requests)
  * For Kerberos authentication on Unix [python-gssapi](https://github.com/pythongssapi/python-gssapi) and [pykrb5](https://github.com/jborean93/pykrb5) installed with `requests-credssp[kerberos]`

  By default, this library can authenticate with a Windows host using NTLM
  messages, if Kerberos authentication is desired, please read the below.




  To install requests-credssp, simply run

  ```
  pip install requests-credssp


  pip install requests-credssp[kerberos]
  ```




  To add support for Kerberos authentication on a non-Windows host, the Kerberos
  system headers must be installed and the `python-gssapi` library installed. To
  install the Kerberos system headers you can install the following packages;

  ```

  yum -y install python-devel krb5-devel krb5-libs krb5-workstation


  dnf -y install python-devel krb5-devel krb5-libs krb5-workstation


  apt-get -y install python-dev libkrb5-dev krb5-user


  emerge -av app-crypt/mit-krb5
  emerge -av dev-python/setuptools


  sudo pkg install security/krb5


  pkgadd -d http://get.opencsw.org/now
  /opt/csw/bin/pkgutil -U
  /opt/csw/bin/pkgutil -y -i libkrb5_3


  pacman -S krb5
  ```

  Once installed, the Python Kerberos libraries can be installed with

  ```
  pip install requests-credssp[kerberos]
  ```

  Once installed, the file `/etc/krb5.conf` should be configured so it can talk
  with the Kerberos KDC.

  To add proper SPNEGO support with `python-gssapi`, the
  [gss-ntlmssp](https://github.com/simo5/gss-ntlmssp) should also be installed
  which adds NTLM as a supported GSSAPI mechanism required for proper SPNEGO
  interoperability with Windows. This package can be installed with;

  ```

  yum -y install epel-release
  yum -y install gssntlmssp


  dnf -y install gssntlmssp


  apt-get -y install gss-ntlmssp


  pacman -S gss-ntlmssp
  ```



  The CredSSP protocol is quite complex and uses a lot of other protocols or
  standards to work properly. This unfortunately means some older hosts or
  settings are incompatible or require some workarounds to get working. Currently
  you can configure the following settings when initialising the CredSSP class;

  * `auth_mechanism`: The authentication mechanism to use initially, default is `auto`
  * `disable_tlsv1_2`: Whether to disable `TLSv1.2` support and work with older protocols like `TLSv1.0`, default is `False`
  * `minimum_version`: The minimum CredSSP server version that is required by the client, default is `2`



  Part of the CredSSP protocol is to authenticate the user's credentials using
  the SPNEGO protocol. The SPNEGO protocol is also called `Negotiate` and is
  able to negotiate a common protocol between the client and the server which
  can currently be either `NTLM` or `Kerberos`. Kerberos is a tricky protocol
  to have set up but should be used wherever it is possible as NTLM uses older
  standards that are considered broken from a security perspective.

  Due to historical decisions and that Kerberos is not always available by
  default, the base install of `requests-credssp` will only work with `NTLM`.
  When the Kerberos packages are installed and configured, `requests-credssp`
  will automatically attempt to use `Kerberos` if possible but fall back to
  `NTLM` if it fails like it would with `SPNEGO`. If you wish to force either
  `Kerberos` or `NTLM` instead of relying on the `SPNEGO` mechanism, you can set
  `auth_mechanism=<auth_mech>` when creating `HttpCredSSPAuth` like so;

  ```
  import requests
  from requests_credssp import HttpCredSSPAuth


  credssp_auth = HttpCredSSPAuth('domain\\user', 'password',
                                 auth_mechanism='auto')


  credssp_auth = HttpCredSSPAuth('user@REALM.COM', 'password',
                                 auth_mechanism='kerberos')



  credssp_auth = HttpCredSSPAuth('domain\\user', 'password',
                                 auth_mechanism='ntlm')


  r = requests.get("https://server:5986/wsman", auth=credssp_auth)
  ```



  As CredSSP uses TLS to encrypt the tokens that are transferred between the
  client and the server, it is succeptible to differing implementations of SSL.
  By default, `requests-credssp` will work with server's that offer TLSv1.2
  but older Windows hosts that do not support this newer protocol version will

  TLSv1.2 was added in Windows Server 2012 and Windows 8 where older hosts need
  an optional update to be installed for it to work. If this update cannot be
  installed or you are willing to accept the risks of using the older TLS
  protocols, `requests-credssp` can be set to disable TLSv1.2 and work with
  older protocols like so;


  ```python
  import requests
  from requests_credssp import HttpCredSSPAuth

  credssp_auth = HttpCredSSPAuth('domain\\user', 'password', disable_tlsv1_2=True)
  r = requests.get("https://server:5986/wsman", auth=credssp_auth)
  ```



  Recently Microsoft has released a security update to CredSSP to mitigate
  [CVE 2018-0886](https://support.microsoft.com/en-us/help/4093492/credssp-updates-for-cve-2018-0886-march-13-2018).
  The update added 2 new CredSSP protocol versions, `5` and `6` which changes
  the way the client and server authenticate each other. While these changes are
  transparent to someone who uses this library, it may be prudent to set the
  minimum version that this client would authenticate with. This means that any
  older server's who have not been patched for this vulnerability will be
  rejected.

  To set a minimum protocol version that will only allow servers that have been
  patched for `CVE 2018-0886`, set `minimum_version=5` when creating
  `HttpCredSSPAuth` like so;

  ```
  import requests
  from requests_credssp import HttpCredSSPAuth

  credssp_auth = HttpCredSSPAuth('domain\\user', 'password', minimum_version=5)
  r = requests.get("https://server:5986/wsman", auth=credssp_auth)
  ```



  You can use this library to encrypt and decrypt messages sent to and from the
  server. Message encryption is done over the TLS channel that was negotiated in
  the authentication stage. The below is an example of encrypting and decrypting
  messages, note this is only a basic example and not a working script and the
  actual implementation depends on the protocol that is reading the messages.

  ```python
  import requests
  from requests_credssp import HttpCredSSPAuth


  hostname = "server"
  session = requests.Session()
  session.auth = HttpCredSSPAuth('domain\\user', 'password')

  request = requests.Request('POST', "https://%s:5986/wsman" % server, data=None)
  prepared_request = self.session.prepare_request(request)
  response = session.send(prepared_request)

  context = session.auth.contexts[hostname]

  message = b'hi server'
  encrypted_message = context.wrap(message)


  request = requests.Request('POST', 'https://server:5986/wsman', data=encrypted_message)
  prepared_request = self.session.prepare_request(request)
  response = session.send(prepared_request)


  encrypted_response = response.content
  decrypted_response = context.unwrap(encrypted_response)
  ```




  This library uses the standard Python logging facilities. Log messages are
  logged to the `requests_credssp` and `requests_credssp.credssp` named loggers.

  If you are receiving any errors or wish to debug the CredSSP process you should
  enable DEBUG level logs. These logs show fine grain information such as the
  protocol and cipher negotiated and each CredSSP token used in the
  authentication process.




  * Add support for different credential types like smart card and redirected credentials


pkgId: 9ad9fea76ccb7a6466c1310f2ff8d409ccf1dd4bc1c58e649433ed8b3cfddb32
name: python-requests-futures
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Asynchronous Python HTTP for Humans.
url: https://github.com/ross/requests-futures
rpm_license: Apache License v2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d913f1d7-df5b-42dd-83f4-ac2c0ba8ff0a
location_href: 00009575-python-requests-futures/python-requests-futures-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Small add-on for the python requests_ http library. Makes use of python 3.2's
  `concurrent.futures`_ or the backport_ for prior versions of python.
  The additional API and changes are minimal and strives to avoid surprises.
  The following synchronous code:
      from requests import Session
      session = Session()
      
      response_one = session.get('http://httpbin.org/get')
      
      response_two = session.get('http://httpbin.org/get?foo=bar')
      
      print('response one status: {0}'.format(response_one.status_code))
      print(response_one.content)
      print('response two status: {0}'.format(response_two.status_code))
      print(response_two.content)
  Can be translated to make use of futures, and thus be asynchronous by creating
  a FuturesSession and catching the returned Future in place of Response. The
  Response can be retrieved by calling the result method on the Future:
      from requests_futures.sessions import FuturesSession
      session = FuturesSession()
      
      future_one = session.get('http://httpbin.org/get')
      
      future_two = session.get('http://httpbin.org/get?foo=bar')
      
      response_one = future_one.result()
      print('response one status: {0}'.format(response_one.status_code))
      print(response_one.content)
      
      response_two = future_two.result()
      print('response two status: {0}'.format(response_two.status_code))
      print(response_two.content)
  By default a ThreadPoolExecutor is created with 8 workers. If you would like to
  adjust that value or share a executor across multiple sessions you can provide
  one to the FuturesSession constructor.
      from concurrent.futures import ThreadPoolExecutor
      from requests_futures.sessions import FuturesSession
      session = FuturesSession(executor=ThreadPoolExecutor(max_workers=10))
      
  As a shortcut in case of just increasing workers number you can pass
  `max_workers` straight to the `FuturesSession` constructor:
      from requests_futures.sessions import FuturesSession
      session = FuturesSession(max_workers=10)
  FutureSession will use an existing session object if supplied:
      from requests import session
      from requests_futures.sessions import FuturesSession
      my_session = session()
      future_session = FuturesSession(session=my_session)
  That's it. The api of requests.Session is preserved without any modifications
  beyond returning a Future rather than Response. As with all futures exceptions
  are shifted (thrown) to the future.result() call so try/except blocks should be
  moved there.


pkgId: 01521e4110e2372f68c352291c3fd28f68b3f0d5b6d518e1120fc45c7dbe6244
name: python-requests-gssapi
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: A GSSAPI authentication handler for python-requests
url: https://github.com/pythongssapi/requests-gssapi
rpm_license: ISC License (ISCL)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a170b3eb-d688-4372-9bc1-3323556c30d9
location_href: 00014118-python-requests-gssapi/python-requests-gssapi-1.2.3-1.src.rpm
checksum_type: sha256
description:
  Requests is an HTTP library, written in Python, for human beings. This library
  adds optional GSSAPI authentication support and supports mutual
  authentication.
  It provides a fully backward-compatible shim for the old
  python-requests-kerberos library: simply replace ``import requests_kerberos``
  with ``import requests_gssapi``.  A more powerful interface is provided by the
  HTTPSPNEGOAuth component, but this is of course not guaranteed to be
  compatible.  Documentation below is written toward the new interface.
  Basic GET usage:
      >>> import requests
      >>> from requests_gssapi import HTTPSPNEGOAuth
      >>> r = requests.get("http://example.org", auth=HTTPSPNEGOAuth())
  The entire ``requests.api`` should be supported.


pkgId: b0fce6dc0f402c370db97360d79efc0df3480b091206742ed22533fb7f803e5d
name: python-requests-http-signature
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: A Requests auth module for HTTP Message Signatures
url: https://github.com/pyauth/requests-http-signature
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4d29fce5-7cd6-4861-afe6-87e8d8b06524
location_href: 00011579-python-requests-http-signature/python-requests-http-signature-0.7.1-1.src.rpm
checksum_type: sha256
description:
  **requests-http-signature** is a `Requests <https://github.com/requests/requests>`_ `authentication plugin
  <http://docs.python-requests.org/en/master/user/authentication/>`_ (``requests.auth.AuthBase`` subclass) implementing
  the `IETF HTTP Message Signatures draft standard <https://datatracker.ietf.org/doc/draft-ietf-httpbis-message-signatures/>`_.


pkgId: acce54444f980b10524e77951dd91edfc7693437480b7fac535466902cb03bd5
name: python-requests-kerberos
arch: src
version: 0.14.0
epoch: 0
release: 1
summary: A Kerberos authentication handler for python-requests
url: https://github.com/requests/requests-kerberos
rpm_license: ISC License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-11f6b779-6740-4700-abf8-146a6e41940e
location_href: 00004962-python-requests-kerberos/python-requests-kerberos-0.14.0-1.src.rpm
checksum_type: sha256
description:
  Requests is an HTTP library, written in Python, for human beings. This library
  adds optional Kerberos/GSSAPI authentication support and supports mutual
  authentication. Basic GET usage:
      >>> import requests
      >>> from requests_kerberos import HTTPKerberosAuth
      >>> r = requests.get("http://example.org", auth=HTTPKerberosAuth())
  The entire ``requests.api`` should be supported.


pkgId: 00035cfce95c4089a40edc80b46e8d50fbd1c0a3e921628e911a3495bc8a5162
name: python-requests-oauthlib
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: OAuthlib authentication support for Requests.
url: https://github.com/requests/requests-oauthlib
rpm_license: ISC
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2527781e-7e60-4d94-a421-a598c9e81bf3
location_href: 00008916-python-requests-oauthlib/python-requests-oauthlib-1.3.1-1.src.rpm
checksum_type: sha256
description:
  This project provides first-class OAuth library support for `Requests <http://python-requests.org>`_.


pkgId: 3c0162e34d0599dbaffd5003c3dda9ec5211bd76a15fdf5df33ae3e4b7ad996e
name: python-requests-pkcs12
arch: src
version: 1.15
epoch: 0
release: 1
url: https://github.com/m-click/requests_pkcs12
rpm_license: ISC
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-358e1a7a-5979-4e93-be35-8ca3604fe174
location_href: 00004964-python-requests-pkcs12/python-requests-pkcs12-1.15-1.src.rpm
checksum_type: sha256
summary:
  Add PKCS#12 support to the requests library in a clean way, without monkey patching or temporary files

description:
  This library adds PKCS#12 support to the Python `requests <http://python-requests.org>`__ library.
  It is a **clean implementation**: it uses neither monkey patching nor temporary files. Instead, it is integrated into ``requests`` as
  recommended by its authors: creating a custom ``TransportAdapter``, which provides a custom ``SSLContext``.
  This library is meant to be a transitional solution until this functionality is provided by ``requests`` directly. However, that will take some time. See the `corresponding issue <https://github.com/requests/requests/issues/1573>`__ for more details.


pkgId: 7755ef48a15503f7503ffffe56d8527bb5f03aef29870d3ff1e0e9170992b1d3
name: python-requests-toolbelt
arch: src
version: 0.10.1
epoch: 0
release: 1
summary: A utility belt for advanced users of python-requests
url: https://toolbelt.readthedocs.io/
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5bc794ff-2acc-4274-a8d5-9b231fc71f11
location_href: 00008988-python-requests-toolbelt/python-requests-toolbelt-0.10.1-1.src.rpm
checksum_type: sha256
description:
  This is just a collection of utilities for `python-requests`_, but don't
  really belong in ``requests`` proper. The minimum tested requests version is
  ``2.1.0``. In reality, the toolbelt should work with ``2.0.1`` as well, but
  some idiosyncracies prevent effective or sane testing on that version.
  ``pip install requests-toolbelt`` to get started!


pkgId: b4b3b5f258bd9e3199346f9c23da5cfbd4b58f9c2d592796d9ecdb70e312ff67
name: python-requests_download
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Download files using requests and save them to a target path
url: https://www.github.com/takluyver/requests_download
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-92f1b7a3-676f-41af-bb05-b507bc74bd72
location_href: 00004961-python-requests-download/python-requests_download-0.1.2-1.src.rpm
checksum_type: sha256
description:
  A convenient function to download to a file using requests.

  Basic usage:

  .. code-block:: python

      url = "https://github.com/takluyver/requests_download/archive/master.zip"
      download(url, "requests_download.zip")

  An optional ``headers=`` parameter is passed through to requests.

  **Trackers** are a lightweight way to monitor the data being downloaded.
  Two trackers are included:

  - ``ProgressTracker`` - displays a progress bar, using the `progressbar2
    <https://pypi.python.org/pypi/progressbar2>`_ package.
  - ``HashTracker`` - wraps a hashlib object to calculate a hash (e.g. sha256 or
    md5) of the file as you download it.

  Here's an example of using both of them:

  .. code-block:: python

      import hashlib
      
      from progressbar import DataTransferBar
      from requests_download import download, HashTracker, ProgressTracker

      hasher = HashTracker(hashlib.sha256())
      progress = ProgressTracker(DataTransferBar())

      download('https://github.com/takluyver/requests_download/archive/master.zip',
               'requests_download.zip', trackers=(hasher, progress))

      assert hasher.hashobj.hexdigest() == '...'

  To make your own tracker, subclass TrackerBase and define any of these methods:

  .. code-block:: python

      from requests_download import TrackerBase

      class MyTracker(TrackerBase):
          def on_start(self, response):
              """Called with requests.Response object, which has response headers"""
              pass

          def on_chunk(self, chunk):
              """Called multiple times, with bytestrings of data received"""
              pass

          def on_finish(self):
              """Called when the download has completed"""
              pass


pkgId: fe1ada83cd63521b8f112f8de7be17993dc54253140b7eae2d03087ae28ccf87
name: python-requestsexceptions
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Import exceptions from potentially bundled packages in requests.
url: http://www.openstack.org/
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f0fa42fd-e46c-42f7-98c1-c8d995813e4c
location_href: 00004966-python-requestsexceptions/python-requestsexceptions-1.4.0-1.src.rpm
checksum_type: sha256
description:
  The python requests library bundles the urllib3 library, however, some
  software distributions modify requests to remove the bundled library.
  This makes some operations, such as supressing the "insecure platform
  warning" messages that urllib emits difficult.  This is a simple
  library to find the correct path to exceptions in the requests library
  regardless of whether they are bundled.


pkgId: 3fa13582659d55e349fcc1bd50548e395f9a39beb1e382301c54b60908910189
name: python-requirementslib
arch: src
version: 2.2.4
epoch: 0
release: 1
summary: A tool for converting between pip-style and pipfile requirements.
url: https://github.com/sarugaku/requirementslib
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-08e6f0ab-de1e-4752-afd0-8accfde1b823
location_href: 00012817-python-requirementslib/python-requirementslib-2.2.4-1.src.rpm
checksum_type: sha256
description:
  Install from `PyPI`_:
      $ pipenv install requirementslib
  Install from `Github`_:
      $ pipenv install -e git+https://github.com/sarugaku/requirementslib.git#egg=requirementslib


pkgId: f040cde2492c47f50a60c66e0005508bb01dcd6c8b4b53ccf2fa5c9570c46cd3
name: python-requre
arch: src
version: 0.8.2
epoch: 0
release: 1
url: https://github.com/packit-service/requre
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2d398096-9528-450b-9e03-f651cfcc28bb
location_href: 00004967-python-requre/python-requre-0.8.2-1.src.rpm
checksum_type: sha256
summary:
  Library for testing python code what allows store output of various objects and use stored data for testing

description:
  [![PyPI version](https://badge.fury.io/py/requre.svg)](https://badge.fury.io/py/requre)



  Requre \[rekure\]

  Is a library for storing output of various function and methods to
  persistent storage and be able to replay the stored output to functions
  back

  [Documentation](https://requre.readthedocs.io/en/latest/)



  - Used for testing [packit-service](https://github.com/packit-service) organization projects
    - ogr
    - packit



  On Fedora:

  ```
  $ dnf install python3-requre
  ```

  Or from PyPI:

  ```
  $ pip3 install --user requre
  ```

  You can also install `requre` from `main` branch, if you are brave enough:

  You can use our [`packit/packit-dev` Copr repository](https://copr.fedorainfracloud.org/coprs/packit/packit-dev/):

  ```
  $ dnf copr enable packit/packit-dev
  $ dnf install python3-requre
  ```

  Or

  ```
  $ pip3 install --user git+https://github.com/packit/requre.git
  ```


pkgId: af18cc1110ae1ad907a0d71485286411acd439a932aafd1243b446c3734b6a47
name: python-resampy
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: Efficient signal resampling
url: https://github.com/bmcfee/resampy
rpm_license: ISC
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b41bf6bb-e27e-457d-b7d4-06e6f17f00fb
location_href: 00009760-python-resampy/python-resampy-0.4.2-1.src.rpm
checksum_type: sha256
description:
  [![GitHub license](https://img.shields.io/badge/license-ISC-blue.svg)](https://raw.githubusercontent.com/bmcfee/resampy/master/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/resampy.svg)](https://pypi.python.org/pypi/resampy)
  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/resampy/badges/version.svg)](https://anaconda.org/conda-forge/resampy)
  [![CI](https://github.com/bmcfee/resampy/actions/workflows/ci.yml/badge.svg)](https://github.com/bmcfee/resampy/actions/workflows/ci.yml)
  [![codecov](https://codecov.io/gh/bmcfee/resampy/branch/main/graph/badge.svg?token=o6a0xO89rz)](https://codecov.io/gh/bmcfee/resampy)
  [![Documentation Status](https://readthedocs.org/projects/resampy/badge/?version=stable)](https://resampy.readthedocs.io/en/stable/?badge=stable)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.596633.svg)](https://doi.org/10.5281/zenodo.596633)

  Efficient sample rate conversion in Python.

  This package implements the band-limited sinc interpolation method for sampling rate conversion as described by:
  > Smith, Julius O. Digital Audio Resampling Home Page
  > Center for Computer Research in Music and Acoustics (CCRMA),
  > Stanford University, 2015-02-23.
  > Web published at [http://ccrma.stanford.edu/~jos/resample/](http://ccrma.stanford.edu/~jos/resample/).




  `resampy` can be installed `pip` by the following command:
  ```
  python -m pip install resampy
  ```

  It can also be installed by `conda` as follows:
  ```
  conda install -c conda-forge resampy
  ```


pkgId: 3ad7e0b1955fb447400cfb8cc0ae789ff8aed71d437a40b1dfa2e807cac097f6
name: python-resnest
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: ResNeSt
url: https://github.com/zhanghang1989/ResNeSt
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5d91e121-4a33-446e-a6e6-2e06d84b24e1
location_href: 00013844-python-resnest/python-resnest-0.0.5-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/resnest.svg)](https://pypi.python.org/pypi/resnest)
  [![PyPI Pre-release](https://img.shields.io/badge/pypi--prerelease-v0.0.5-ff69b4.svg)](https://pypi.org/project/resnest/#history)
  [![PyPI Nightly](https://github.com/zhanghang1989/ResNeSt/workflows/Pypi%20Nightly/badge.svg)](https://github.com/zhanghang1989/ResNeSt/actions)
  [![Downloads](http://pepy.tech/badge/resnest)](http://pepy.tech/project/resnest)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![Unit Test](https://github.com/zhanghang1989/ResNeSt/workflows/Unit%20Test/badge.svg)](https://github.com/zhanghang1989/ResNeSt/actions)
  [![arXiv](http://img.shields.io/badge/cs.CV-arXiv%3A2004.08955-B31B1B.svg)](https://arxiv.org/abs/2004.08955)

  [![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/resnest-split-attention-networks/instance-segmentation-on-coco)](https://paperswithcode.com/sota/instance-segmentation-on-coco?p=resnest-split-attention-networks)
  [![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/resnest-split-attention-networks/object-detection-on-coco)](https://paperswithcode.com/sota/object-detection-on-coco?p=resnest-split-attention-networks)
  [![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/resnest-split-attention-networks/panoptic-segmentation-on-coco-panoptic)](https://paperswithcode.com/sota/panoptic-segmentation-on-coco-panoptic?p=resnest-split-attention-networks)
  [![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/resnest-split-attention-networks/semantic-segmentation-on-ade20k)](https://paperswithcode.com/sota/semantic-segmentation-on-ade20k?p=resnest-split-attention-networks)
  [![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/resnest-split-attention-networks/semantic-segmentation-on-cityscapes-val)](https://paperswithcode.com/sota/semantic-segmentation-on-cityscapes-val?p=resnest-split-attention-networks)
  [![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/resnest-split-attention-networks/semantic-segmentation-on-pascal-context)](https://paperswithcode.com/sota/semantic-segmentation-on-pascal-context?p=resnest-split-attention-networks)



  Split-Attention Network, A New ResNet Variant. It significantly boosts the performance of downstream models such as Mask R-CNN, Cascade R-CNN and DeepLabV3.

  ![](./miscs/abstract.jpg)


  0. [Pretrained Models](#pretrained-models)
  0. [Transfer Learning Models](#transfer-learning-models)
  0. [Verify Backbone Models](#verify-backbone-models)
  0. [How to Train](#how-to-train)
  0. [Reference](#reference)




  0. Install this package repo, note that you only need to choose one of the options

  ```bash

  pip install git+https://github.com/zhanghang1989/ResNeSt


  pip install resnest --pre
  ```



  |             | crop size | PyTorch | Gluon |
  |-------------|-----------|---------|-------|
  | ResNeSt-50  | 224       | 81.03   | 81.04 |
  | ResNeSt-101 | 256       | 82.83   | 82.81 |
  | ResNeSt-200 | 320       | 83.84   | 83.88 |
  | ResNeSt-269 | 416       | 84.54   | 84.53 |

  - **3rd party implementations** are available: [Tensorflow](https://github.com/QiaoranC/tf_ResNeSt_RegNet_model), [Caffe](https://github.com/NetEase-GameAI/ResNeSt-caffe).

  - Extra ablation study models are available in [link](./ablation.md)



  - Load using Torch Hub

  ```python
  import torch

  torch.hub.list('zhanghang1989/ResNeSt', force_reload=True)


  net = torch.hub.load('zhanghang1989/ResNeSt', 'resnest50', pretrained=True)
  ```


  - Load using python package

  ```python

  from resnest.torch import resnest50
  net = resnest50(pretrained=True)
  ```




  - Load pretrained model:

  ```python

  from resnest.gluon import resnest50
  net = resnest50(pretrained=True)
  ```





  Training code and pretrained models are released at our [Detectron2 Fork](https://github.com/zhanghang1989/detectron2-ResNeSt).




  <table class="tg">
    <tr>
      <th class="tg-0pky">Method</th>
      <th class="tg-0pky">Backbone</th>
      <th class="tg-0pky">mAP%</th>
    </tr>
    <tr>
      <td rowspan="4" class="tg-0pky">Faster R-CNN</td>
      <td class="tg-0pky">ResNet-50</td>
      <td class="tg-0pky">39.25</td>
    </tr>
    <tr>
      <td class="tg-0lax">ResNet-101</td>
      <td class="tg-0lax">41.37</td>
    </tr>
    <tr>
      <td class="tg-0lax">ResNeSt-50 (<span style="color:red">ours</span>)</td>
      <td class="tg-0lax"><b>42.33</b></td>
    </tr>
    <tr>
      <td class="tg-0lax">ResNeSt-101 (<span style="color:red">ours</span>)</td>
      <td class="tg-0lax"><b>44.72</b></td>
    </tr>
    <tr>
      <td rowspan="5" class="tg-0lax">Cascade R-CNN</td>
      <td class="tg-0lax">ResNet-50</td>
      <td class="tg-0lax">42.52</td>
    </tr>
    <tr>
      <td class="tg-0lax">ResNet-101</td>
      <td class="tg-0lax">44.03</td>
    </tr>
    <tr>
      <td class="tg-0lax">ResNeSt-50 (<span style="color:red">ours</span>)</td>
      <td class="tg-0lax"><b>45.41</b></td>
    </tr>
    <tr>
      <td class="tg-0lax">ResNeSt-101 (<span style="color:red">ours</span>)</td>
      <td class="tg-0lax"><b>47.50</b></td>
    </tr>
    <tr>
      <td class="tg-0lax">ResNeSt-200 (<span style="color:red">ours</span>)</td>
      <td class="tg-0lax"><b>49.03</b></td>
    </tr>
  </table>




  <table class="tg">
    <tr>
      <th class="tg-0pky">Method</th>
      <th class="tg-0pky">Backbone</th>
      <th class="tg-0pky">bbox</th>
      <th class="tg-0lax">mask</th>
    </tr>
    <tr>
      <td rowspan="4" class="tg-0pky">Mask R-CNN</td>
      <td class="tg-0pky">ResNet-50</td>
      <td class="tg-0pky">39.97</td>
      <td class="tg-0lax">36.05</td>
    </tr>
    <tr>
      <td class="tg-0lax">ResNet-101</td>
      <td class="tg-0lax">41.78</td>
      <td class="tg-0lax">37.51</td>
    </tr>
    <tr>
      <td class="tg-0lax">ResNeSt-50 (<span style="color:red">ours</span>)</td>
      <td class="tg-0lax"><b>42.81</b></td>
      <td class="tg-0lax"><b>38.14</td>
    </tr>
    <tr>
      <td class="tg-0lax">ResNeSt-101 (<span style="color:red">ours</span>)</td>
      <td class="tg-0lax"><b>45.75</b></td>
      <td class="tg-0lax"><b>40.65</b></td>
    </tr>
    <tr>
      <td rowspan="7" class="tg-0lax">Cascade R-CNN</td>
      <td class="tg-0lax">ResNet-50</td>
      <td class="tg-0lax">43.06</td>
      <td class="tg-0lax">37.19</td>
    </tr>
    <tr>
      <td class="tg-0lax">ResNet-101</td>
      <td class="tg-0lax">44.79</td>
      <td class="tg-0lax">38.52</td>
    </tr>
    <tr>
      <td class="tg-0lax">ResNeSt-50 (<span style="color:red">ours</span>)</td>
      <td class="tg-0lax"><b>46.19</b></td>
      <td class="tg-0lax"><b>39.55</b></td>
    </tr>
    <tr>
      <td class="tg-0lax">ResNeSt-101 (<span style="color:red">ours</span>)</td>
      <td class="tg-0lax"><b>48.30</b></td>
      <td class="tg-0lax"><b>41.56</b></td>
    </tr>
    <tr>
      <td class="tg-0lax">ResNeSt-200 (w/ tricks <span style="color:red">ours</span>)</td>
      <td class="tg-0lax"><b>50.54</b></td>
      <td class="tg-0lax"><b>44.21</b></td>
    </tr>
     <tr>
      <td rowspan="2" class="tg-0lax">ResNeSt-200-dcn (w/ tricks <span style="color:red">ours</span>)</td>
      <td class="tg-0lax"><b>50.91</b></td>
      <td class="tg-0lax"><b>44.50</b></td>
    </tr>
     <tr>
      <td class="tg-0lax"><b>53.30*</b></td>
      <td class="tg-0lax"><b>47.10*</b></td>
    </tr>
  </table>

  All of results are reported on COCO-2017 validation dataset. The values with * demonstrate the mutli-scale testing performance on the test-dev2019.


  <table class="tg">
    <tr>
      <th class="tg-0pky">Backbone</th>
      <th class="tg-0pky">bbox</th>
      <th class="tg-0lax">mask</th>
      <th class="tg-0lax">PQ</th>
    </tr>
    <tr>
      <td class="tg-0pky">ResNeSt-200</td>
      <td class="tg-0pky">51.00</td>
      <td class="tg-0lax">43.68</td>
      <td class="tg-0lax">47.90</td>
     </tr>
  </table>



  - PyTorch models and training: Please visit [PyTorch Encoding Toolkit](https://hangzhang.org/PyTorch-Encoding/model_zoo/segmentation.html).
  - Training with Gluon: Please visit [GluonCV Toolkit](https://gluon-cv.mxnet.io/model_zoo/segmentation.html#ade20k-dataset).



  <table class="tg">
    <tr>
      <th class="tg-cly1">Method</th>
      <th class="tg-cly1">Backbone</th>
      <th class="tg-cly1">pixAcc%</th>
      <th class="tg-cly1">mIoU%</th>
    </tr>
    <tr>
      <td rowspan="6" class="tg-cly1">Deeplab-V3<br></td>
      <td class="tg-cly1">ResNet-50</td>
      <td class="tg-cly1">80.39</td>
      <td class="tg-cly1">42.1</td>
    </tr>
    <tr>
      <td class="tg-cly1">ResNet-101</td>
      <td class="tg-cly1">81.11</b></td>
      <td class="tg-cly1">44.14</b></td>
    </tr>
    <tr>
      <td class="tg-cly1">ResNeSt-50 (<span style="color:red">ours</span>)</td>
      <td class="tg-cly1"><b>81.17</b></td>
      <td class="tg-cly1"><b>45.12</b></td>
    </tr>
    <tr>
      <td class="tg-0lax">ResNeSt-101 (<span style="color:red">ours</span>)</td>
      <td class="tg-0lax"><b>82.07</td>
      <td class="tg-0lax"><b>46.91</b></td>
    </tr>
    <tr>
      <td class="tg-0lax">ResNeSt-200 (<span style="color:red">ours</span>)</td>
      <td class="tg-0lax"><b>82.45</td>
      <td class="tg-0lax"><b>48.36</b></td>
    </tr>
    <tr>
      <td class="tg-0lax">ResNeSt-269 (<span style="color:red">ours</span>)</td>
      <td class="tg-0lax"><b>82.62</td>
      <td class="tg-0lax"><b>47.60</b></td>
    </tr>
  </table>



  <table class="tg">
    <tr>
      <th class="tg-cly1">Method</th>
      <th class="tg-cly1">Backbone</th>
      <th class="tg-cly1">Split</th>
      <th class="tg-cly1">w Mapillary</th>
      <th class="tg-cly1">mIoU%</th>
    </tr>
    <tr>
      <td rowspan="3" class="tg-cly1">Deeplab-V3+<br></td>
      <td class="tg-cly1">ResNeSt-200 (<span style="color:red">ours</span>)</td>
      <td class="tg-cly1">Validation</td>
      <td class="tg-cly1">no</td>
      <td class="tg-cly1">82.7</td>
    </tr>
    <tr>
      <td class="tg-cly1">ResNeSt-200 (<span style="color:red">ours</span>)</td>
      <td class="tg-cly1">Validation</td>
      <td class="tg-cly1">yes</td>
      <td class="tg-cly1"><b>83.8<b></td>
    </tr>
    <tr>
      <td class="tg-0lax">ResNeSt-200 (<span style="color:red">ours</span>)</td>
      <td class="tg-0lax">Test</td>
      <td class="tg-cly1">yes</td>
      <td class="tg-0lax"><b>83.3<b></td>
    </tr>
  </table>




  **Note:** the inference speed reported in the paper are tested using Gluon implementation with RecordIO data.



  Here we use raw image data format for simplicity, please follow [GluonCV tutorial](https://gluon-cv.mxnet.io/build/examples_datasets/recordio.html) if you would like to use RecordIO format.

  ```bash
  cd scripts/dataset/

  python prepare_imagenet.py --download-dir ./
  ```



  ```bash

  cd scripts/torch/
  python verify.py --model resnest50 --crop-size 224
  ```



  ```bash

  cd scripts/gluon/
  python verify.py --model resnest50 --crop-size 224
  ```





  - Training with MXNet Gluon: Please visit [Gluon folder](./scripts/gluon/).
  - Training with PyTorch: Please visit [PyTorch Encoding Toolkit](https://hangzhang.org/PyTorch-Encoding/model_zoo/imagenet.html) (slightly worse than Gluon implementation).



  For object detection and instance segmentation models, please visit our [detectron2-ResNeSt fork](https://github.com/zhanghang1989/detectron2-ResNeSt).



  - Training with PyTorch: [Encoding Toolkit](https://hangzhang.org/PyTorch-Encoding/model_zoo/segmentation.html).
  - Training with MXNet: [GluonCV Toolkit](https://gluon-cv.mxnet.io/model_zoo/segmentation.html#ade20k-dataset).



  **ResNeSt: Split-Attention Networks** [[arXiv](https://arxiv.org/pdf/2004.08955.pdf)]

  Hang Zhang, Chongruo Wu, Zhongyue Zhang, Yi Zhu, Zhi Zhang, Haibin Lin, Yue Sun, Tong He, Jonas Muller, R. Manmatha, Mu Li and Alex Smola

  ```
  @article{zhang2020resnest,
  title={ResNeSt: Split-Attention Networks},
  author={Zhang, Hang and Wu, Chongruo and Zhang, Zhongyue and Zhu, Yi and Zhang, Zhi and Lin, Haibin and Sun, Yue and He, Tong and Muller, Jonas and Manmatha, R. and Li, Mu and Smola, Alexander},
  journal={arXiv preprint arXiv:2004.08955},
  year={2020}
  }
  ```



  - ResNeSt Backbone ([Hang Zhang](https://hangzhang.org/))
  - Detectron Models ([Chongruo Wu](https://github.com/chongruo), [Zhongyue Zhang](http://zhongyuezhang.com/))
  - Semantic Segmentation ([Yi Zhu](https://sites.google.com/view/yizhu/home))
  - Distributed Training ([Haibin Lin](https://sites.google.com/view/haibinlin/))


pkgId: 0682f0f02868d803951cb8a3b0c3fd24e06c6d5c0d978915365cad9e1813772f
name: python-responses
arch: src
version: 0.22.0
epoch: 0
release: 1
summary: A utility library for mocking out the `requests` Python library.
url: https://github.com/getsentry/responses
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-33b77385-b995-4fe6-9ed8-9db21513ff2f
location_href: 00004969-python-responses/python-responses-0.22.0-1.src.rpm
checksum_type: sha256
description:
  A utility library for mocking out the ``requests`` Python library.
      Responses requires Python 3.7 or newer, and requests >= 2.22.0


pkgId: ba2ada209c2d667ac47186bb119840952d3b8ab5d72c6ccec7a2b5c521325bdf
name: python-respx
arch: src
version: 0.20.1
epoch: 0
release: 1
summary: A utility for mocking out the Python HTTPX and HTTP Core libraries.
url: https://lundberg.github.io/respx/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ba2d4455-82e2-497c-92da-c540ec0154c1
location_href: 00004970-python-respx/python-respx-0.20.1-1.src.rpm
checksum_type: sha256
description:
  [![tests](https://img.shields.io/github/workflow/status/lundberg/respx/test?label=tests&logo=github&logoColor=white&style=for-the-badge)](https://github.com/lundberg/respx/actions/workflows/test.yml)
  [![codecov](https://img.shields.io/codecov/c/github/lundberg/respx?logo=codecov&logoColor=white&style=for-the-badge)](https://codecov.io/gh/lundberg/respx)
  [![PyPi Version](https://img.shields.io/pypi/v/respx?logo=pypi&logoColor=white&style=for-the-badge)](https://pypi.org/project/respx/)
  [![Python Versions](https://img.shields.io/pypi/pyversions/respx?logo=python&logoColor=white&style=for-the-badge)](https://pypi.org/project/respx/)

  Full documentation is available at
  [lundberg.github.io/respx](https://lundberg.github.io/respx/)

  RESPX is a simple, _yet powerful_, utility for mocking out the
  [HTTPX](https://www.python-httpx.org/), _and
  [HTTP Core](https://www.encode.io/httpcore/)_, libraries.
  Start by [patching](https://lundberg.github.io/respx/guide/#mock-httpx) `HTTPX`, using
  `respx.mock`, then add request
  [routes](https://lundberg.github.io/respx/guide/#routing-requests) to mock
  [responses](https://lundberg.github.io/respx/guide/#mocking-responses).
  ```python
  import httpx
  import respx
  from httpx import Response
  @respx.mock
  def test_example():
      my_route = respx.get("https://example.org/").mock(return_value=Response(204))
      response = httpx.get("https://example.org/")
      assert my_route.called
      assert response.status_code == 204
  ```
  > Read the [User Guide](https://lundberg.github.io/respx/guide/) for a complete
  > walk-through.

  For a neater `pytest` experience, RESPX includes a `respx_mock` _fixture_ for easy
  `HTTPX` mocking, along with an optional `respx` _marker_ to fine-tune the mock
  [settings](https://lundberg.github.io/respx/api/#configuration).
  ```python
  import httpx
  import pytest
  def test_default(respx_mock):
      respx_mock.get("https://foo.bar/").mock(return_value=httpx.Response(204))
      response = httpx.get("https://foo.bar/")
      assert response.status_code == 204
  @pytest.mark.respx(base_url="https://foo.bar")
  def test_with_marker(respx_mock):
      respx_mock.get("/baz/").mock(return_value=httpx.Response(204))
      response = httpx.get("https://foo.bar/baz/")
      assert response.status_code == 204
  ```

  Install with pip:
  ```console
  $ pip install respx
  ```
  Requires Python 3.7+ and HTTPX 0.21+. See
  [Changelog](https://github.com/lundberg/respx/blob/master/CHANGELOG.md) for older HTTPX
  compatibility.


pkgId: bb5c3942f9ee9edec70fb0b4e1f5f756d373de344a1f919e4cec3165ab916081
name: python-restfly
arch: src
version: 1.4.7
epoch: 0
release: 1
summary: REST API library framework
url: https://github.com/librestfly/restfly
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8edb2b90-ce98-41b5-9683-0f91ac2f7cca
location_href: 00004971-python-restfly/python-restfly-1.4.7-1.src.rpm
checksum_type: sha256
description:
  **RESTfly** (pronounced restfully) is a framework for building libraries to
  easily interact with RESTful APIs.
  RESTfly is a simple library designed to provide the scaffolding to make API
  interaction libraries for just about any RESTful API.  With an emphasis on
  simplicity and readability of the resulting library code thats written, the
  idea here is provide something that is not only useful for folks to use, but
  can also serve as a reference implementation of the given APIs.
  Please refer to the full documentation at https://restfly.readthedocs.io.


pkgId: 04ce6b2f6a66767161d7343e64a3d7caef9a81e89cd5087493cebf884ac32d75
name: python-restructuredtext-lint
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: reStructuredText linter
url: https://github.com/twolfson/restructuredtext-lint
rpm_license: UNLICENSE
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-40096ba9-bfd8-41cb-a682-fd6bb0f8fe3f
location_href: 00004972-python-restructuredtext-lint/python-restructuredtext-lint-1.4.0-1.src.rpm
checksum_type: sha256
description:
  `reStructuredText`_ `linter`_
  This was created out of frustration with `PyPI`_; it sucks finding out your `reST`_ is invalid **after** uploading it. It is being developed in junction with a `Sublime Text`_ linter.


pkgId: 80f4e2a2cc9c30a3046728520da71f24da7906c6666fa74d5c17269b95e103de
name: python-resultsdb-conventions
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Module for conveniently reporting to ResultsDB following conventions
url: https://pagure.io/fedora-qa/resultsdb_conventions
rpm_license: GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b4c0d29b-4cec-4e8d-b5ca-29d6039ee4fe
location_href: 00004976-python-resultsdb_conventions/python-resultsdb-conventions-2.1.0-1.src.rpm
checksum_type: sha256
description:
  resultsdb_conventions is a Python library that represents various
  conventions for reporting test results to
  `ResultsDB <https://fedoraproject.org/wiki/ResultsDB>`__. It allows you
  to report results easily and without a lot of boilerplate, and be
  relatively confident their ResultsDB metadata will be consistent with
  other results of the same basic nature.


pkgId: bb3064ac583690ab5bd83410a1b53b9c6fccc76b1f875e36c4f4ebd9eebe949a
name: python-retask
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Task Queue implementation in python using redis.
url: https://pypi.org/project/retask/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e02eddee-4aa0-4691-929f-b81be8caeec6
location_href: 00004979-python-retask/python-retask-1.1.0-1.src.rpm
checksum_type: sha256
description:
  retask is a python module to create distributed task
  queues using Redis.
  You can read the latest documentation `here <http://retask.readthedocs.org/>`_.
  Release build is done via [asaman](https://pypi.org/project/asaman/) from the tarball.


pkgId: 034adfd815f14bcfce6f27472bd27e843818dca9dc761d11ef2c52e9473105b4
name: python-retrying
arch: src
version: 1.3.4
epoch: 0
release: 1
summary: Retrying
url: https://github.com/groodt/retrying
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ab736b18-b454-4489-9277-69e0b85296a0
location_href: 00009131-python-retrying/python-retrying-1.3.4-1.src.rpm
checksum_type: sha256
description:
  Retrying is an Apache 2.0 licensed general-purpose retrying library, written in
  Python, to simplify the task of adding retry behavior to just about anything.
  The simplest use case is retrying a flaky function whenever an Exception occurs
  until a value is returned.
      import random
      from retrying import retry
      @retry
      def do_something_unreliable():
          if random.randint(0, 10) > 1:
              raise IOError("Broken sauce, everything is hosed!!!111one")
          else:
              return "Awesome sauce!"
      print do_something_unreliable()


pkgId: db260c2c6822f9575e2fd512f80a4a12803a75b441a4d97f8ddfc09b4e9ce603
name: python-rfc3339
arch: src
version: 6.2
epoch: 0
release: 1
summary: Format dates according to the RFC 3339.
url: http://pypi.python.org/pypi/rfc3339/
rpm_license: ISCL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3c4f6e14-b2be-42f9-b135-a509c455d547
location_href: 00011889-python-rfc3339/python-rfc3339-6.2-1.src.rpm
checksum_type: sha256
description:
  Formats dates according to the :RFC:`3339`.

  Report bugs and feature requests on Sourcehut_

  Source availabe on this Mercurial repository: https://hg.sr.ht/~henryprecheur/rfc3339

  .. _Sourcehut: https://todo.sr.ht/~henryprecheur/rfc3339


pkgId: 6bd47c9768c8e5a7532132b8acfcc83da7b1089afcabd8049aae37806679ff02
name: python-rfc3987
arch: src
version: 1.3.8
epoch: 0
release: 1
summary: Parsing and validation of URIs (RFC 3986) and IRIs (RFC 3987)
url: http://pypi.python.org/pypi/rfc3987
rpm_license: GNU GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0087e0ac-98c6-4adf-a697-0c86db82c325
location_href: 00004983-python-rfc3987/python-rfc3987-1.3.8-1.src.rpm
checksum_type: sha256
description:
  **match** (string, rule='IRI_reference')
      Convenience function for checking if `string` matches a specific rule.
      Returns a match object or None::
          >>> assert match('%C7X', 'pct_encoded') is None
          >>> assert match('%C7', 'pct_encoded')
          >>> assert match('%c7', 'pct_encoded')
  **parse** (string, rule='IRI_reference')
      Parses `string` according to `rule` into a dict of subcomponents.
      If `rule` is None, parse an IRI_reference `without validation
      <http://tools.ietf.org/html/rfc3986#appendix-B>`_.
      If regex_ is available, any rule is supported; with re_, `rule` must be
      'IRI_reference' or some special case thereof ('IRI', 'absolute_IRI',
      'irelative_ref', 'irelative_part', 'URI_reference', 'URI', 'absolute_URI',
      'relative_ref', 'relative_part'). ::
          >>> d = parse('http://tools.ietf.org/html/rfc3986#appendix-A',
          >>> assert all([ d['scheme'] == 'http',
  **compose** (\*\*parts)
      Returns an URI composed_ from named parts.
  **resolve** (base, uriref, strict=True, return_parts=False)
      Resolves_ an `URI reference` relative to a `base` URI.
      `Test cases <http://tools.ietf.org/html/rfc3986#section-5.4>`_::
          >>> base = resolve.test_cases_base
          >>> for relative, resolved in resolve.test_cases.items():
      If `return_parts` is True, returns a dict of named parts instead of
      a string.
      Examples::
          >>> assert resolve('urn:rootless', '../../name') == 'urn:name'
          >>> assert resolve('urn:root/less', '../../name') == 'urn:/name'
          >>> assert resolve('http://a/b', 'http:g') == 'http:g'
          >>> assert resolve('http://a/b', 'http:g', strict=False) == 'http://a/g'
  **patterns**
      A dict of regular expressions with useful group names.
      Compilable (with regex_ only) without need for any particular compilation
      flag.
  **[bmp_][u]patterns[_no_names]**
      Alternative versions of `patterns`.
      [u]nicode strings without group names for the re_ module.
      BMP only for narrow builds.
  **get_compiled_pattern** (rule, flags=0)
      Returns a compiled pattern object for a rule name or template string.
      Usage for validation::
          >>> uri = get_compiled_pattern('^s$')
          >>> assert uri.match('http://tools.ietf.org/html/rfc3986#appendix-A')
          >>> assert not get_compiled_pattern('^s$').match('#f#g')
          >>> from unicodedata import lookup
          >>> smp = 'urn:' + lookup('OLD ITALIC LETTER A')  # U+00010300
          >>> assert not uri.match(smp)
          >>> m = get_compiled_pattern('^s$').match(smp)
      On narrow builds, non-BMP characters are (incorrectly) excluded::
          >>> assert NARROW_BUILD == (not m)
      For parsing, some subcomponents are captured in named groups (*only if*
      regex_ is available, otherwise see `parse`)::
          >>> match = uri.match('http://tools.ietf.org/html/rfc3986#appendix-A')
          >>> d = match.groupdict()
          >>> if REGEX:
          >>> for r in patterns.keys():
  **format_patterns** (\*\*names)
      Returns a dict of patterns (regular expressions) keyed by
      `rule names for URIs`_ and `rule names for IRIs`_.
      See also the module level dicts of patterns, and `get_compiled_pattern`.
      To wrap a rule in a named capture group, pass it as keyword argument:
      rule_name='group_name'. By default, the formatted patterns contain no
      named groups.
      Patterns are `str` instances (be it in python 2.x or 3.x) containing ASCII
      characters only.
      Caveats:
        - with re_, named capture groups cannot occur on multiple branches of an
          alternation
        - with re_ before python 3.3, ``\u`` and ``\U`` escapes must be
          preprocessed (see `issue3665 <http://bugs.python.org/issue3665>`_)
        - on narrow builds, character ranges beyond BMP are not supported


pkgId: 05c6cd1ecb094d39f03c05a6f171f2f6223a2cc7c18bdd82e3b6f5ea39f3c6a2
name: python-rich
arch: src
version: 13.3.2
epoch: 0
release: 1
summary: Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal
url: https://github.com/Textualize/rich
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2e626a86-b7f5-45d5-b468-22cd0f92c1c9
location_href: 00004984-python-rich/python-rich-13.3.2-1.src.rpm
checksum_type: sha256
description:
  [![Supported Python Versions](https://img.shields.io/pypi/pyversions/rich/13.2.0)](https://pypi.org/project/rich/) [![PyPI version](https://badge.fury.io/py/rich.svg)](https://badge.fury.io/py/rich)

  [![Downloads](https://pepy.tech/badge/rich/month)](https://pepy.tech/project/rich)
  [![codecov](https://img.shields.io/codecov/c/github/Textualize/rich?label=codecov&logo=codecov)](https://codecov.io/gh/Textualize/rich)
  [![Rich blog](https://img.shields.io/badge/blog-rich%20news-yellowgreen)](https://www.willmcgugan.com/tag/rich/)
  [![Twitter Follow](https://img.shields.io/twitter/follow/willmcgugan.svg?style=social)](https://twitter.com/willmcgugan)

  ![Logo](https://github.com/textualize/rich/raw/master/imgs/logo.svg)

  [English readme](https://github.com/textualize/rich/blob/master/README.md)
   • [简体中文 readme](https://github.com/textualize/rich/blob/master/README.cn.md)
   • [正體中文 readme](https://github.com/textualize/rich/blob/master/README.zh-tw.md)
   • [Lengua española readme](https://github.com/textualize/rich/blob/master/README.es.md)
   • [Deutsche readme](https://github.com/textualize/rich/blob/master/README.de.md)
   • [Läs på svenska](https://github.com/textualize/rich/blob/master/README.sv.md)
   • [日本語 readme](https://github.com/textualize/rich/blob/master/README.ja.md)
   • [한국어 readme](https://github.com/textualize/rich/blob/master/README.kr.md)
   • [Français readme](https://github.com/textualize/rich/blob/master/README.fr.md)
   • [Schwizerdütsch readme](https://github.com/textualize/rich/blob/master/README.de-ch.md)
   • [हिन्दी readme](https://github.com/textualize/rich/blob/master/README.hi.md)
   • [Português brasileiro readme](https://github.com/textualize/rich/blob/master/README.pt-br.md)
   • [Italian readme](https://github.com/textualize/rich/blob/master/README.it.md)
   • [Русский readme](https://github.com/textualize/rich/blob/master/README.ru.md)
   • [Indonesian readme](https://github.com/textualize/rich/blob/master/README.id.md)
   • [فارسی readme](https://github.com/textualize/rich/blob/master/README.fa.md)
   • [Türkçe readme](https://github.com/textualize/rich/blob/master/README.tr.md)
   • [Polskie readme](https://github.com/textualize/rich/blob/master/README.pl.md)


  Rich is a Python library for _rich_ text and beautiful formatting in the terminal.

  The [Rich API](https://rich.readthedocs.io/en/latest/) makes it easy to add color and style to terminal output. Rich can also render pretty tables, progress bars, markdown, syntax highlighted source code, tracebacks, and more — out of the box.

  ![Features](https://github.com/textualize/rich/raw/master/imgs/features.png)

  For a video introduction to Rich see [calmcode.io](https://calmcode.io/rich/introduction.html) by [@fishnets88](https://twitter.com/fishnets88).

  See what [people are saying about Rich](https://www.willmcgugan.com/blog/pages/post/rich-tweets/).



  Rich works with Linux, OSX, and Windows. True color / emoji works with new Windows Terminal, classic terminal is limited to 16 colors. Rich requires Python 3.7 or later.

  Rich works with [Jupyter notebooks](https://jupyter.org/) with no additional configuration required.



  Install with `pip` or your favorite PyPI package manager.

  ```sh
  python -m pip install rich
  ```

  Run the following to test Rich output on your terminal:

  ```sh
  python -m rich
  ```



  To effortlessly add rich output to your application, you can import the [rich print](https://rich.readthedocs.io/en/latest/introduction.html#quick-start) method, which has the same signature as the builtin Python function. Try this:

  ```python
  from rich import print

  print("Hello, [bold magenta]World[/bold magenta]!", ":vampire:", locals())
  ```

  ![Hello World](https://github.com/textualize/rich/raw/master/imgs/print.png)



  Rich can be installed in the Python REPL, so that any data structures will be pretty printed and highlighted.

  ```python
  >>> from rich import pretty
  >>> pretty.install()
  ```

  ![REPL](https://github.com/textualize/rich/raw/master/imgs/repl.png)



  For more control over rich terminal content, import and construct a [Console](https://rich.readthedocs.io/en/latest/reference/console.html#rich.console.Console) object.

  ```python
  from rich.console import Console

  console = Console()
  ```

  The Console object has a `print` method which has an intentionally similar interface to the builtin `print` function. Here's an example of use:

  ```python
  console.print("Hello", "World!")
  ```

  As you might expect, this will print `"Hello World!"` to the terminal. Note that unlike the builtin `print` function, Rich will word-wrap your text to fit within the terminal width.

  There are a few ways of adding color and style to your output. You can set a style for the entire output by adding a `style` keyword argument. Here's an example:

  ```python
  console.print("Hello", "World!", style="bold red")
  ```

  The output will be something like the following:

  ![Hello World](https://github.com/textualize/rich/raw/master/imgs/hello_world.png)

  That's fine for styling a line of text at a time. For more finely grained styling, Rich renders a special markup which is similar in syntax to [bbcode](https://en.wikipedia.org/wiki/BBCode). Here's an example:

  ```python
  console.print("Where there is a [bold cyan]Will[/bold cyan] there [u]is[/u] a [i]way[/i].")
  ```

  ![Console Markup](https://github.com/textualize/rich/raw/master/imgs/where_there_is_a_will.png)

  You can use a Console object to generate sophisticated output with minimal effort. See the [Console API](https://rich.readthedocs.io/en/latest/console.html) docs for details.



  Rich has an [inspect](https://rich.readthedocs.io/en/latest/reference/init.html?highlight=inspect#rich.inspect) function which can produce a report on any Python object, such as class, instance, or builtin.

  ```python
  >>> my_list = ["foo", "bar"]
  >>> from rich import inspect
  >>> inspect(my_list, methods=True)
  ```

  ![Log](https://github.com/textualize/rich/raw/master/imgs/inspect.png)

  See the [inspect docs](https://rich.readthedocs.io/en/latest/reference/init.html#rich.inspect) for details.



  Rich contains a number of builtin _renderables_ you can use to create elegant output in your CLI and help you debug your code.

  Click the following headings for details:

  <details>
  <summary>Log</summary>

  The Console object has a `log()` method which has a similar interface to `print()`, but also renders a column for the current time and the file and line which made the call. By default Rich will do syntax highlighting for Python structures and for repr strings. If you log a collection (i.e. a dict or a list) Rich will pretty print it so that it fits in the available space. Here's an example of some of these features.

  ```python
  from rich.console import Console
  console = Console()

  test_data = [
      {"jsonrpc": "2.0", "method": "sum", "params": [None, 1, 2, 4, False, True], "id": "1",},
      {"jsonrpc": "2.0", "method": "notify_hello", "params": [7]},
      {"jsonrpc": "2.0", "method": "subtract", "params": [42, 23], "id": "2"},
  ]

  def test_log():
      enabled = False
      context = {
          "foo": "bar",
      }
      movies = ["Deadpool", "Rise of the Skywalker"]
      console.log("Hello from", console, "!")
      console.log(test_data, log_locals=True)


  test_log()
  ```

  The above produces the following output:

  ![Log](https://github.com/textualize/rich/raw/master/imgs/log.png)

  Note the `log_locals` argument, which outputs a table containing the local variables where the log method was called.

  The log method could be used for logging to the terminal for long running applications such as servers, but is also a very nice debugging aid.

  </details>
  <details>
  <summary>Logging Handler</summary>

  You can also use the builtin [Handler class](https://rich.readthedocs.io/en/latest/logging.html) to format and colorize output from Python's logging module. Here's an example of the output:

  ![Logging](https://github.com/textualize/rich/raw/master/imgs/logging.png)

  </details>

  <details>
  <summary>Emoji</summary>

  To insert an emoji in to console output place the name between two colons. Here's an example:

  ```python
  >>> console.print(":smiley: :vampire: :pile_of_poo: :thumbs_up: :raccoon:")
  😃 🧛 💩 👍 🦝
  ```

  Please use this feature wisely.

  </details>

  <details>
  <summary>Tables</summary>

  Rich can render flexible [tables](https://rich.readthedocs.io/en/latest/tables.html) with unicode box characters. There is a large variety of formatting options for borders, styles, cell alignment etc.

  ![table movie](https://github.com/textualize/rich/raw/master/imgs/table_movie.gif)

  The animation above was generated with [table_movie.py](https://github.com/textualize/rich/blob/master/examples/table_movie.py) in the examples directory.

  Here's a simpler table example:

  ```python
  from rich.console import Console
  from rich.table import Table

  console = Console()

  table = Table(show_header=True, header_style="bold magenta")
  table.add_column("Date", style="dim", width=12)
  table.add_column("Title")
  table.add_column("Production Budget", justify="right")
  table.add_column("Box Office", justify="right")
  table.add_row(
      "Dec 20, 2019", "Star Wars: The Rise of Skywalker", "$275,000,000", "$375,126,118"
  )
  table.add_row(
      "May 25, 2018",
      "[red]Solo[/red]: A Star Wars Story",
      "$275,000,000",
      "$393,151,347",
  )
  table.add_row(
      "Dec 15, 2017",
      "Star Wars Ep. VIII: The Last Jedi",
      "$262,000,000",
      "[bold]$1,332,539,889[/bold]",
  )

  console.print(table)
  ```

  This produces the following output:

  ![table](https://github.com/textualize/rich/raw/master/imgs/table.png)

  Note that console markup is rendered in the same way as `print()` and `log()`. In fact, anything that is renderable by Rich may be included in the headers / rows (even other tables).

  The `Table` class is smart enough to resize columns to fit the available width of the terminal, wrapping text as required. Here's the same example, with the terminal made smaller than the table above:

  ![table2](https://github.com/textualize/rich/raw/master/imgs/table2.png)

  </details>

  <details>
  <summary>Progress Bars</summary>

  Rich can render multiple flicker-free [progress](https://rich.readthedocs.io/en/latest/progress.html) bars to track long-running tasks.

  For basic usage, wrap any sequence in the `track` function and iterate over the result. Here's an example:

  ```python
  from rich.progress import track

  for step in track(range(100)):
      do_step(step)
  ```

  It's not much harder to add multiple progress bars. Here's an example taken from the docs:

  ![progress](https://github.com/textualize/rich/raw/master/imgs/progress.gif)

  The columns may be configured to show any details you want. Built-in columns include percentage complete, file size, file speed, and time remaining. Here's another example showing a download in progress:

  ![progress](https://github.com/textualize/rich/raw/master/imgs/downloader.gif)

  To try this out yourself, see [examples/downloader.py](https://github.com/textualize/rich/blob/master/examples/downloader.py) which can download multiple URLs simultaneously while displaying progress.

  </details>

  <details>
  <summary>Status</summary>

  For situations where it is hard to calculate progress, you can use the [status](https://rich.readthedocs.io/en/latest/reference/console.html#rich.console.Console.status) method which will display a 'spinner' animation and message. The animation won't prevent you from using the console as normal. Here's an example:

  ```python
  from time import sleep
  from rich.console import Console

  console = Console()
  tasks = [f"task {n}" for n in range(1, 11)]

  with console.status("[bold green]Working on tasks...") as status:
      while tasks:
          task = tasks.pop(0)
          sleep(1)
          console.log(f"{task} complete")
  ```

  This generates the following output in the terminal.

  ![status](https://github.com/textualize/rich/raw/master/imgs/status.gif)

  The spinner animations were borrowed from [cli-spinners](https://www.npmjs.com/package/cli-spinners). You can select a spinner by specifying the `spinner` parameter. Run the following command to see the available values:

  ```
  python -m rich.spinner
  ```

  The above command generates the following output in the terminal:

  ![spinners](https://github.com/textualize/rich/raw/master/imgs/spinners.gif)

  </details>

  <details>
  <summary>Tree</summary>

  Rich can render a [tree](https://rich.readthedocs.io/en/latest/tree.html) with guide lines. A tree is ideal for displaying a file structure, or any other hierarchical data.

  The labels of the tree can be simple text or anything else Rich can render. Run the following for a demonstration:

  ```
  python -m rich.tree
  ```

  This generates the following output:

  ![markdown](https://github.com/textualize/rich/raw/master/imgs/tree.png)

  See the [tree.py](https://github.com/textualize/rich/blob/master/examples/tree.py) example for a script that displays a tree view of any directory, similar to the linux `tree` command.

  </details>

  <details>
  <summary>Columns</summary>

  Rich can render content in neat [columns](https://rich.readthedocs.io/en/latest/columns.html) with equal or optimal width. Here's a very basic clone of the (MacOS / Linux) `ls` command which displays a directory listing in columns:

  ```python
  import os
  import sys

  from rich import print
  from rich.columns import Columns

  directory = os.listdir(sys.argv[1])
  print(Columns(directory))
  ```

  The following screenshot is the output from the [columns example](https://github.com/textualize/rich/blob/master/examples/columns.py) which displays data pulled from an API in columns:

  ![columns](https://github.com/textualize/rich/raw/master/imgs/columns.png)

  </details>

  <details>
  <summary>Markdown</summary>

  Rich can render [markdown](https://rich.readthedocs.io/en/latest/markdown.html) and does a reasonable job of translating the formatting to the terminal.

  To render markdown import the `Markdown` class and construct it with a string containing markdown code. Then print it to the console. Here's an example:

  ```python
  from rich.console import Console
  from rich.markdown import Markdown

  console = Console()
  with open("README.md") as readme:
      markdown = Markdown(readme.read())
  console.print(markdown)
  ```

  This will produce output something like the following:

  ![markdown](https://github.com/textualize/rich/raw/master/imgs/markdown.png)

  </details>

  <details>
  <summary>Syntax Highlighting</summary>

  Rich uses the [pygments](https://pygments.org/) library to implement [syntax highlighting](https://rich.readthedocs.io/en/latest/syntax.html). Usage is similar to rendering markdown; construct a `Syntax` object and print it to the console. Here's an example:

  ```python
  from rich.console import Console
  from rich.syntax import Syntax

  my_code = '''
  def iter_first_last(values: Iterable[T]) -> Iterable[Tuple[bool, bool, T]]:
      """Iterate and generate a tuple with a flag for first and last value."""
      iter_values = iter(values)
      try:
          previous_value = next(iter_values)
      except StopIteration:
          return
      first = True
      for value in iter_values:
          yield first, False, previous_value
          first = False
          previous_value = value
      yield first, True, previous_value
  '''
  syntax = Syntax(my_code, "python", theme="monokai", line_numbers=True)
  console = Console()
  console.print(syntax)
  ```

  This will produce the following output:

  ![syntax](https://github.com/textualize/rich/raw/master/imgs/syntax.png)

  </details>

  <details>
  <summary>Tracebacks</summary>

  Rich can render [beautiful tracebacks](https://rich.readthedocs.io/en/latest/traceback.html) which are easier to read and show more code than standard Python tracebacks. You can set Rich as the default traceback handler so all uncaught exceptions will be rendered by Rich.

  Here's what it looks like on OSX (similar on Linux):

  ![traceback](https://github.com/textualize/rich/raw/master/imgs/traceback.png)

  </details>

  All Rich renderables make use of the [Console Protocol](https://rich.readthedocs.io/en/latest/protocol.html), which you can also use to implement your own Rich content.




  See also [Rich CLI](https://github.com/textualize/rich-cli) for a command line application powered by Rich. Syntax highlight code, render markdown, display CSVs in tables, and more, directly from the command prompt.


  ![Rich CLI](https://raw.githubusercontent.com/Textualize/rich-cli/main/imgs/rich-cli-splash.jpg)



  See also Rich's sister project, [Textual](https://github.com/Textualize/textual), which you can use to build sophisticated User Interfaces in the terminal.

  ![Textual screenshot](https://raw.githubusercontent.com/Textualize/textual/main/imgs/textual.png)



  For some examples of projects using Rich, see the [Rich Gallery](https://www.textualize.io/rich/gallery) on [Textualize.io](https://www.textualize.io).

  Would you like to add your own project to the gallery? You can! Follow [these instructions](https://www.textualize.io/gallery-instructions).

  <!-- This is a test, no need to translate -->


pkgId: 9644e4f99d304981c42b63a445803e98fbf726a852ca1dd116b464ace6fa5c90
name: python-riot
arch: src
version: 0.17.1
epoch: 0
release: 1
summary: A simple Python test runner runner.
url: https://github.com/DataDog/riot
rpm_license: Apache 2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e4e8ea25-281e-42fb-b389-046d357a4872
location_href: 00012272-python-riot/python-riot-0.17.1-1.src.rpm
checksum_type: sha256
description:
  A Python virtual environment constructor and command runner.

  [![Read the Docs](https://img.shields.io/readthedocs/ddriot?style=for-the-badge)](https://ddriot.readthedocs.io/)
  [![Pyversions](https://img.shields.io/pypi/pyversions/riot.svg?style=for-the-badge)](https://pypi.org/project/riot/)
  [![PypiVersions](https://img.shields.io/pypi/v/riot.svg?style=for-the-badge)](https://pypi.org/project/riot/)
  [![Tests](https://img.shields.io/github/workflow/status/DataDog/riot/CI?label=Tests&style=for-the-badge)](https://github.com/DataDog/riot/actions?query=workflow%3ACI)
  [![Codecov](https://img.shields.io/codecov/c/github/DataDog/riot?style=for-the-badge)](https://codecov.io/gh/DataDog/riot)




  Install from PyPI:

  ```sh
  pip install riot
  ```

  or install from source:

  ```sh
  pip install git+https://github.com/DataDog/riot.git
  ```


pkgId: 886978150cab7989826f3156e4d069c6ab1695c0e4a4d6aa500bb1cc5339a39c
name: python-rlbot
arch: src
version: 1.67.3
epoch: 0
release: 1
summary: A framework for writing custom Rocket League bots that run offline.
url: https://github.com/RLBot/RLBot
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-498d8f7b-f61f-4cc3-a37c-69ab1bf9f332
location_href: 00010228-python-rlbot/python-rlbot-1.67.3-1.src.rpm
checksum_type: sha256
description:
  The RLBot framework helps people create bots for use in Rocket League's offline modes, just for fun.
  It provides values from the game like car and ball position, and carries back button presses.
  RLBot works for up to 10 bots.

  To get started quickly with a simple working bot, you can clone this repository:
  https://github.com/RLBot/RLBotPythonExample


  Windows, Rocket League, Python 3.6+ (Python 3.7 recommended)



  For more details, visit the [Setup guide](https://github.com/RLBot/RLBot/wiki/Setup-Instructions-%28current%29). When you're done, there are [more wikis](https://github.com/RLBot/RLBot/wiki) with additional information.




   - We have a [Discord server](https://discord.gg/zbaAKPt) (the heart of the community, please join!)
   - [We also have a subreddit.](https://www.reddit.com/r/RocketLeagueBots/)
   - We are now on v4 of RLBot so be wary of outdated information.


pkgId: 9283996561febc4b8bcaf786ccab981b0ae19e34ef6d631aee0ac366cb6edee1
name: python-rmol
arch: src
version: 1.0.6.post1
epoch: 0
release: 1
summary: Simple Python wrapper for RMOL
url: https://github.com/airsim/rmol
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e5ed6793-c903-4120-a05e-3fb24aba9dfd
location_href: 00004987-python-rmol/python-rmol-1.0.6.post1-1.src.rpm
checksum_type: sha256
description:
  RMOL is a C++ library of Revenue Management and Optimisation classes
  and functions. Typically, that library may be used by service providers
  (_e.g._, airlines offering flight seats, hotels offering rooms, rental car
  companies offering rental days, broadcasting company offering advertisement
  slots, theaters offering seats, _etc_) to help in optimising their revenues
  from seat capacities.
  Most of the algorithms implemented are public and documented in the
  following book:
  The Theory and practice of Revenue Management, by Kalyan T. Talluri and
  Garrett J. van Ryzin, Kluwer Academic Publishers, 2004, ISBN 1-4020-7701-7
  RMOL makes an extensive use of existing open-source libraries for
  increased functionality, speed and accuracy. In particular the
  Boost (C++ Standard Extensions: http://www.boost.org) library is used.
  RMOL is the one of the components of the Travel Market Simulator
  (https://travel-sim.org). However, it may be used in a
  stand-alone mode.


  Just use DNF:
  ```bash
  $ dnf -y install rmol-devel rmol-doc
  ```
  You can also get the RPM packages (which may work on Linux
  distributions like Suse and Mandriva) from the Fedora repository
  (_e.g._, for Fedora 32,
  https://fr2.rpmfind.net/linux/RPM/fedora/32/x86_64/)

  The Git repository may be cloned as following:
  ```bash
  $ git clone git@github.com:airsim/rmol.git rmolgit # through SSH
  $ git clone https://github.com/airsim/rmol.git # if the firewall filters SSH
  $ cd rmolgit
  ```
  Then, you need the following packages (Fedora/RedHat/CentOS names here,
  but names may vary according to distributions):
  * `cmake`
  * `gcc-c++`
  * `boost-devel` / `libboost-dev`
  * `python-devel` / `python-dev`
  * `gettext-devel` / `gettext`
  * `sqlite3-devel` / `libsqlite3-dev`
  * `readline-devel` / `libreadline-dev`
  * `libncurses5-devel`
  * `soci-mysql-devel`, `soci-sqlite3-devel`
  * `stdair-devel` / `libstdair-dev`
  * `airrac-devel` / `libairrac-dev`
  * `doxygen`, `ghostscript`, `graphviz`
  * `tetex-latex` (optional)
  * `rpm-build` (optional)

  The latest stable source tarball (`rmol*.tar.gz` or `.bz2`) can be
  found on GitHub: http://github.com/airsim/rmol/releases, _e.g._,
  https://github.com/airsim/rmol/archive/rmol-1.00.6.tar.gz
  As RMOL depends on other
  [Travel Market Simulator (TvlSim/AirSim)](https://github.com/airsim/)
  modules, more specifically [StdAir](https://github.com/airsim/stdair)
  and [AirRAC](https://github.com/airsim/airrac), it may be
  convenient to use the
  [MetaSim project](https://github.com/airsim/metasim),
  which pulls at once all the components of TvlSim in the same place,
  and then orchestrates the dependencies for the builds, installations
  and use of components.
  If MetaSim is not used, in order to customise the following to your
  environment, you can alter the path to the installation directory:
  ```bash
  export INSTALL_BASEDIR="${HOME}/dev/deliveries"
  export RMOL_VER="1.00.6"
  if [ -d /usr/lib64 ]; then LIBSUFFIX="64"; fi
  export LIBSUFFIX_4_CMAKE="-DLIB_SUFFIX=$LIBSUFFIX"
  ```
  Then, as usual:
  * To configure the project, type something like:
  ```bash
    mkdir build && cd build
    cmake -DCMAKE_INSTALL_PREFIX=${INSTALL_BASEDIR}/rmol-$RMOL_VER \
     -DWITH_STDAIR_PREFIX=${INSTALL_BASEDIR}/stdair-stable \
     -DWITH_AIRRAC_PREFIX=${INSTALL_BASEDIR}/airrac-stable \
     -DCMAKE_BUILD_TYPE:STRING=Debug -DENABLE_TEST:BOOL=ON -DINSTALL_DOC:BOOL=ON \
     -DRUN_GCOV:BOOL=OFF ${LIBSUFFIX_4_CMAKE} ..
     ${LIBSUFFIX_4_CMAKE} ..
  ```
  * To build the project, type:
  ```bash
    make
  ```
  * To test the project, type:
  ```bash
    make check
  ```
  * To install the library (`librmol*.so*`) and the binary (`rmol`),
  ```bash
    make install
    cd ${INSTALL_BASEDIR}
    rm -f rmol-stable && ln -s rmol-${RMOL_VER} rmol-stable
    cd -
  ```
  * To package the source files, type:
  ```bash
    make dist
  ```
  * To package the binary and the (HTML and PDF) documentation:
  ```bash
    make package
  ```
  * To browse the (just installed, if enabled) HTML documentation:
  ```bash
    open file://${INSTALL_BASEDIR}/rmol-${RMOL_VER}/share/doc/rmol/html/index.html
  ```
  * To browse the (just installed, if enabled) PDF documentation:
  ```bash
    open ${INSTALL_BASEDIR}/rmol-${RMOL_VER}/share/doc/rmol/html/refman.pdf
  ```
  * To run the local binary version:
  ```
    ./rmol/rmol -b
  ```
  * To run the installed version:
  ```bash
    ${INSTALL_BASEDIR}/rmol-$RMOL_VER/bin/rmol -b
  ```

  The way to interact with a C++-based Python extension is extensively described
  in the [OpenTREP project](https://github.com/trep/opentrep).
  Only a quick start is given here.

  * Install Python dependencies:
  ```bash
  $ python3 -m pip install -U pip
  $ python3 -m pip install -U wheel
  $ python3 -m pip install -U build setuptools scikit-build tox pytest sphinx twine
  ```

  * Build the Python extension with SciKit-Build:
  ```bash
  $ rm -rf _skbuild/ dist/ MANIFEST_
  $ python3 setup.py --build-type=Debug build sdist bdist_wheel
  ```
  * The Python artifacts should be similar to:
  ```bash
  $ ls -lFh dist/
  total 5872
  -rw-r--r-- 1 user staff 2.0M Jun  1 15:49 rmol-1.0.5.post1-cp38-cp38-macosx_10_15_x86_64.whl
  -rw-r--r-- 1 user staff 834K Jun  1 15:49 rmol-1.0.5.post1.tar.gz
  ```
  * Updload the RMOL Python extension onto PyPi:
  ```bash
  $ twine upload -u __token__ --repository-url https://upload.pypi.org/legacy/ dist/*
  ```
  * The RMOL Python artifacts may then be browsed on PyyPI:
    https://pypi.org/project/rmol/

  * Launch the Python interpreter:
  ```bash
  $ export PYTHONPATH=${PWD}/_skbuild/macosx-10.15-x86_64-3.8/cmake-install/lib:${PWD}/_skbuild/macosx-10.15-x86_64-3.8/cmake-install/lib/python3.8/site-packages/pyrmol
  $ DYLD_INSERT_LIBRARIES=/Library/Developer/CommandLineTools/usr/lib/clang/11.0.0/lib/darwin/libclang_rt.asan_osx_dynamic.dylib ASAN_OPTIONS=detect_container_overflow=0 /usr/local/Cellar/python@3.8/3.8.3/Frameworks/Python.framework/Versions/3.8/Resources/Python.app/Contents/MacOS/Python
  ```
  * Within the Python interpreter, import, initialize
    and use the RMOL Python extension:
  ```python
  Python 3.8.3 (default, May 27 2020, 20:54:22)
  [Clang 11.0.3 (clang-1103.0.32.59)] on darwin
  Type "help", "copyright", "credits" or "license" for more information.
  >>> import pyrmol
  >>> rmolLibrary = pyrmol.RMOLer()
  >>> rmolLibrary.init('rmol.log', 40, 1, '')
  True
  >>> rmolLibrary.rmol(100, 10, 40.0)
  'RMOL has completed the generation of the booking requests. See the log file for more details.\n'
  >>> quit()
  ```
  * Back to the Shell session, look for the results in the RMOL log file:
  ```bash
  $ cat rmol.log
  Python wrapper initialisation
  [D]${STDAIR_PREFIX}/stdair/command/CmdBomManager.cpp:52: StdAir is building the BOM tree from built-in specifications.
  Python wrapper initialised
  Optimisation for 100 draws, capacity of 40, and with the following method: 10
  [D]${RMOL_PREFIX}/rmol/service/RMOL_Service.cpp:491: Optimisation by Monte-Carlo performed in 0.000321
  [D]${RMOL_PREFIX}/rmol/service/RMOL_Service.cpp:492: Result:
  Yield: 100.00, Protection: 70.48, Booking limit: 100.00
  Yield: 70.00, Protection: 156.19, Booking limit: 29.52
  Yield: 42.00, Protection: -0.00, Booking limit: -56.19
  [D]${RMOL_PREFIX}/rmol/service/RMOL_Service.cpp:505: Bid-Price Vector (BPV): 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 99.00, 99.00, 99.00, 99.00, 99.00, 98.00, 98.00, 97.00, 96.00, 96.00, 96.00, 96.00, 96.00, 95.00, 94.00, 94.00, 90.00, 90.00, 89.00, 88.00, 86.00, 84.00, 82.00, 80.00, 80.00, 79.00, 77.00, 76.00, 75.00, 72.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00
  End of the optimisation.
  RMOL output:
  ```
  * Of course, a few more features could be added to the Python extension API,
    in order not to have to leave the Python interpreter to interact with the
    results of invoking the optimizer. Do not hesitate to contribute
    through [Pull Requests](https://github.com/airsim/rmol/pulls), which are
    always welcome!


pkgId: 720f200504ee7424e4ce5a346698aa6b44843357f55cb845273b48414cb96d9f
name: python-rnc2rng
arch: src
version: 2.6.6
epoch: 0
release: 1
summary: RELAX NG Compact to regular syntax conversion library
url: https://github.com/djc/rnc2rng
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-249c2f23-df55-4514-956e-d4ecb7aee485
location_href: 00004989-python-rnc2rng/python-rnc2rng-2.6.6-1.src.rpm
checksum_type: sha256
description:
  Converts RELAX NG schemata in Compact syntax (`rnc`) to the equivalent schema
  in the XML-based default RELAX NG syntax. Dependencies:
  - Python 3.x (tested with 3.7, 3.8, 3.9)
  - `rply`_
  Feedback welcome on `GitHub`_. Please consider funding continued maintenance of this
  project through `Patreon`_ or `GitHub Sponsors`_.


pkgId: 0cf1c87876eb9bef9f81becd82a0c1d2ddb51def2191f0e0343f074080b366f2
name: python-robloxpy
arch: src
version: 0.2.21
epoch: 0
release: 1
summary: Wrapper for roblox Web API's
url: https://github.com/KristanSmout/RobloxPyOfficial
rpm_license: Attribution Assurance License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-42ee58f9-9519-4c33-bdee-7bc7da60798e
location_href: 00014100-python-robloxpy/python-robloxpy-0.2.21-1.src.rpm
checksum_type: sha256
description:
  RobloxPy is a python API wrapper for roblox. This allows for quick and easy integration of these API's into a python project.
  <sup><center>If you need any help using RobloxPy or want to request an additional please join the discord server at
  	https://www.kristansmout.com/discord
  Accept The Terms & Create a ticket</center></sup>



  * [Getting Started](#Getting-Started)
    * [Prerequisites](#Prerequisites)
    * [Installation](#Installation)
   * [Feature List](#Features)
  	 * [Game](#Game)
  	 * [Group](#Group)
  	 * [Market](#Market)
  	 * [User](#User)
  		 * [User.Friends](#User.Friends)
  		 * [User.Groups](#User.Groups)
   * [Usage Examples](#Usage-Examples)
  	 *  [Utilities](#Utilities)
  	 *  [Game](#Game)



  To use the wrapper you will need to download and import robloxpy into your current project. The project has been designed to not include external requirements that are not included within the base installation of python.


  > None

  ```python
  pip install robloxpy
  ```
  If you wish to update robloxpy in the future you can also do this through pip
  ```python
  pip install robloxpy --upgrade
  ```

  Robloxpy is built on community feedback, if you have a feature you want added please make it known on the discord and we will see if we can implement it for you. Not all features can be added and some are emitted to prevent abuse.



  * GetVersion
  * CheckForUpdate
  * UpdateInstructions
  * SetProxy
  * CheckProxy
  * CheckCookie

  * External
  	* GetUniverseData
  	* GetUniverseVotes
  	* GetUniverseFavourites
  	* GetCurrentUniversePlayers
  	* GetUniverseVisits
  	* GetUniverseLikes
  	* GetUniverseDislikes
  * Internal
  	* GetUniverseID
  	* GetCurrentPlayers
  	* GetGameVisits
  	* GetGameLikes
  	* GetGameDislikes
  	* GetGameFavourites
  	* GetMyGameData

  * External
  	* IsGroupOwned
  	* GetName
  	* GetOwner
  	* GetDescription
  	* GetEmblem
  	* GetRoles
  	* GetAllies
  	* GetEnemies
  	* GetMemberCount
  	* isPublic
  	* isBCOnly
  	* GetMembersList
  	* GetMembersinRoleList


  * External
  	* CanManageAsset
  	* GetLimitedPriceData
  	* GetLimitedRemaining
  	* GetLimitedTotal
  	* GetLimitedSales
  	* GetLimitedRAP
  	* GetLimitedSalePrice
  	* GetLimitedChangePercentage
  	* GetAssetImage
  * Internal
  	* BuyItem

  * External
  	* GetID
  	* GetUserName
  	* UsernameHistory
  	* DoesNameExist
  	* IsOnline
  	* Isbanned
  	* GetDescription
  	* GetAge
  	* CreationDate
  	* GetRAP
  	* GetLimiteds
  	* GetBust
  	* GetHeadshot
  	* GetStatus
  * Internal
  	* SetCookie
  	* GetDetails
  	* isFollowing
  	* FollowUser
  	* UnfollowUser
  	* BlockUser
  	* UnblockUser
  	* GetBlockedUsers
  	* SendMessage
  	* JoinGame

  * External
  	* GetAll
  	* GetCount
  	* GetOnline
  	* GetOffline
  	* GetFollowerCount
  	* GetFollowers
  	* GetFollowingCount
  	* GetFollowing
  * Internal
  	* SendFriendRequest
  	* Unfriend
  	* TotalFriends

  * External
  	* GetGroups
  * Internal
  	* Claim
  	* Join
  	* Leave
  	* GetFunds
  	* Payout
  	* PercentagePayout
  	* SendWallPost
  	* SendGroupShout
  	* ChangeDescription
  	* ChangeRank


  This section will cover the usage of robloxpy, it will provide examples for commands and the expected outputs to help you achieve what you want to achieve with robloxpy.


  The utiliy functions are set to be used more for checking stuff within robloxpy as well as being used a reference point for robloxpy to store values between different areas of the API such as a central place for URL's.

  > Utilities are called by standard as
  > ```
  > robloxpy.Utils.<UTILITYFUNCTION>
  > ```
  > Not all functions require arguments however some do, you will be alerted to this in your IDE providing it supports intellisense.

  * **CheckForUpdate()**
  This function checks to see if an update is available for robloxpy, an internet connection will be required for this to work. If you wish to display this you will need to print it.
  >Example Usage
  >```python
  >robloxpy.Utils.CheckForUpdate()
  >```
  >
  >Example Output
  >```
  >You are up to date!
  >```

  * **GetVersion()**
  This function returns the current version of robloxpy that is being used for the current project.
  >Example Usage
  >```python
  >robloxpy.Utils.GetVersion()
  >```
  >
  >Example Output
  >```
  >0.2.8
  >```

  * **UpdateInstructions(Version)**
  This function returns instructions on how to update robloxpy, this can be used to show users of software how to get to the latest version. Alternatively if your tool was designed for a specific version of robloxpy you can give the user instructions on how to get to that version
  >Example Usage
  >```python
  >robloxpy.Utils.UpdateInstructions()
  >```
  >
  >Example Output
  >```
  >Update robloxpy through pip using following command: 'pip install robloxpy --upgrade'
  >```
  If you wish for your users to use a specific version of robloxpy you can have the instructions given to them on how to reach that specific version using the following.
  >Example Usage
  >```python
  >robloxpy.Utils.UpdateInstructions("0.2.8")
  >```
  >
  >Example Output
  >```
  >This software is intended to work on robloxpy version 0.2.8 please install using the following command
  >'pip install robloxpy==0.2.8'
   >If you get an error with this command the developer of this tool has not provided a valid version
  >```

  * **SetProxy(ProxyIP)**
  This function will set a global proxy to be used within the python program and is not just limited to robloxpy. The expected format is IP:PORT
  >Example Usage
  >```python
  >robloxpy.Utils.SetProxy("144.217.101.245:3129")
  >```
  >
  >Example Output
  >```
  > OUTPUT NOT GIVEN
  >```

  * **CheckProxy(proxyAddress)**
  This function will check the current proxy and provided the IP Shown to external sites.This function does not need an argument, if none is provided then the currently set proxy will be used. The expected format is IP:PORT if an argument is provided
  >Example Usage
  >```python
  >robloxpy.Utils.CheckProxy("144.217.101.245:3129")
  >```
  >
  >Example Output
  >```
  > 144.217.101.245
  >```

  * **CheckCookie(Cookie)**
  This function will check if a cookie is valid, if no cookie is provided it will use the current cookie which has been set using the **SetCookie()** function.
  >Example Usage
  >```python
  >robloxpy.Utils.CheckCookie()
  >```
  >
  >Example Output
  >```
  > Valid Cookie
  >```


  The Game functions are functions geared towards getting data from games/universes. This group of functions has both internal and external commands. The internal commands will utilize the external commands while having an easier way to input data due to the way roblox has locked some API's behind the need to be logged in.


  * **GetUniverseID(PlaceID)**
  This function will convert a placeID to a universe ID to allow it to be used with external functions
  >Example Usage
  >```python
  >robloxpy.Game.Internal.GetUniverseID(164118757)
  >```
  >
  >Example Output
  >```
  > 23476326
  >```

  * **GetCurrentPlayers(PlaceID)**
  This function will return the amount of players in a game
  >Example Usage
  >```python
  >robloxpy.Game.Internal.GetCurrentPlayers(164118757)
  >```
  >
  >Example Output
  >```
  > 52
  >```

  * **GetGameVisits(PlaceID)**
  This function will return the amount of visits a game has
  >Example Usage
  >```python
  >robloxpy.Game.Internal.GetGameVisits(164118757)
  >```
  >
  >Example Output
  >```
  > 97
  >```

  * **GetGameLikes(PlaceID)**
  This function will return the amount of likes a game has
  >Example Usage
  >```python
  >robloxpy.Game.Internal.GetGameLikes(164118757)
  >```
  >
  >Example Output
  >```
  > 6
  >```

  * **GetGameDislikes(PlaceID)**
  This function will return the amount of dislikes a game has
  >Example Usage
  >```python
  >robloxpy.Game.Internal.GetGameDislikes(164118757)
  >```
  >
  >Example Output
  >```
  > 2
  >```

  * **GetGameFavourites(PlaceID)**
  This function will return the amount of favourites a game has
  >Example Usage
  >```python
  >robloxpy.Game.Internal.GetGameFavourites(164118757)
  >```
  >
  >Example Output
  >```
  > 8
  >```

  * **GetMyGameData(PlaceID)**
  This function will return a range of data of a game owned by the current set cookie. The PlaceID must be a game that the current user has permissions for to edit.
  >Example Usage
  >```python
  >robloxpy.Game.Internal.GetMyGameData(164118757)
  >```
  >
  >Example Output
  >```
  > Saved
  >```
  This function will save the games data in a sort of cache to be accessed when needed. This is the data which this function will collect and be used as needed:
  > * maxPlayerCount
  >  * socialSlotType
  >  * customSocialSlotsCount
  >  * allowCopying
  >  * currentSavedVersion
  >  * name
  >  * isRootPlace
  >  * descriptionisRootPlace

  These variables can then be used as needed such as the following
  ```python
  print(robloxpy.Game.Internal.MyGame.maxPlayerCount)
  ```


  * **GetUniverseData(UniverseID)**
  This function will provide a range of data for a game which you can then parse to get what information you need.
  >Example Usage
  >```python
  >robloxpy.Game.External.GetUniverseData(1069201198)
  >```
  >
  >Example Output
  >```
  > {'id': 1069201198, 'rootPlaceId': 2960777560, 'name': '🎄CHRISTMAS🎄Treasure Quest', 'description': '❗ Christmas Event ends on Friday, January 29
  >th! ❗ \r\n\r\n🎉 UPDATE 28!🎉\r\n❄️ New event boss! Team up to defeat Hyperfrost and earn limited time rewards!\r\n🍬 New Candy currency! Earn them from dungeons and quests!\r\n🎄 New Event shop! Limited time items that can be purchased using Candy!\r\n☃️ New Winter Lobby!\r\n🎁 New Orname
  >nt Hunt around the lobby! Find all 6 for a limited time cosmetic!\r\n🏆 New Prize Wheel items!\r\n⚡ New Energy Blade Quest rewards!\r\n🛠️ 4 new
  >crafting recipes!\r\n💀 New Miniboss - Tank!\r\n💥 New Ability - Stomp!\r\n💰 New Mythical Festive Pack!\r\n\r\n⚔️ Welcome to Treasure Quest! Ste
  >al treasure, battle monsters, and complete unique quests as you and your friends become the ultimate treasure hunters! Fight as a Wizard or a Warrior, the choice is yours!\r\n\r\n🎁 Join the group "Nosniy Games" for a Chat tag, Royalty Sword, and the ability to spin the Prize Wheel in the
  >game!\r\nhttps://www.roblox.com/groups/3461453/CLICK-HERE', 'creator': {'id': 3461453, 'name': 'Nosniy Games™', 'type': 'Group'}, 'price': None,
  >'allowedGearGenres': ['RPG'], 'allowedGearCategories': [], 'playing': 1463, 'visits': 247185224, 'maxPlayers': 40, 'created': '2019-03-15T04:27:24.327Z', 'updated': '2021-01-25T05:40:11.4420701Z', 'studioAccessToApisAllowed': False, 'createVipServersAllowed': False, 'universeAvatarType': 'MorphToR15', 'genre': 'RPG'}
  >```

  * **GetUniverseVotes(UniverseID)**
  This function will return data about the votes of a game
  >Example Usage
  >```python
  >robloxpy.Game.External.GetUniverseVotes(1069201198)
  >```
  >
  >Example Output
  >```
  > {'id': 1069201198, 'upVotes': 170780, 'downVotes': 25066}
  >```

  * **GetCurrentUniversePlayers(UniverseID)**
  This function will return the amount of players in a game
  >Example Usage
  >```python
  >robloxpy.Game.External.GetCurrentUniversePlayers(164118757)
  >```
  >
  >Example Output
  >```
  > 52
  >```

  * **GetGameVisits(UniverseID)**
  This function will return the amount of visits a game has
  >Example Usage
  >```python
  >robloxpy.Game.Internal.GetGameVisits(164118757)
  >```
  >
  >Example Output
  >```
  > 97
  >```

  * **GetUniverseFavourites(UniverseID)**
  This function will return the amount of likes a game has
  >Example Usage
  >```python
  >robloxpy.Game.External.GetUniverseFavourites(164118757)
  >```
  >
  >Example Output
  >```
  > 643534
  >```

  * **GetUniverseVisits(UniverseID)**
  This function will return the amount of visits a game has
  >Example Usage
  >```python
  >robloxpy.Game.External.GetUniverseVisits(164118757)
  >```
  >
  >Example Output
  >```
  > 24536342543
  >```

  * **GetCurrentUniversePlayers(UniverseID)**
  This function will return the amount of current players a game has
  >Example Usage
  >```python
  >robloxpy.Game.External.GetCurrentUniversePlayers(164118757)
  >```
  >
  >Example Output
  >```
  > 8535
  >```

  * **GetUniverseLikes(UniverseID)**
  This function will return the amount of likes a game has
  >Example Usage
  >```python
  >robloxpy.Game.External.GetUniverseLikes(164118757)
  >```
  >
  >Example Output
  >```
  > 85
  >```

  * **GetUniverseDislikes(UniverseID)**
  This function will return the amount of dislikes a game has
  >Example Usage
  >```python
  >robloxpy.Game.External.GetUniverseDislikes(164118757)
  >```
  >
  >Example Output
  >```
  > 73
  >```


  The Group functions are aimed towards gathering data from groups. These functions allow you get all the data needed about groups. This section contains bugs which will be fixed shortly.

  **THIS SECTION OF ROBLOXPY IS PLANNED TO CHANGE IN NEAR FUTURE UPDATES**


  _There are currently no Internal functions_

  These functions allow you gather group data without needing an active cookie set
  * **IsGroupOwned(GroupID)**
  This function whether a group is current owned
  >Example Usage
  >```python
  >robloxpy.Group.External.IsGroupOwned(916576)
  >```
  >
  >Example Output
  >```
  > True
  >```

  * **GetName(GroupID)**
  This function returns the name of a group
  >Example Usage
  >```python
  >robloxpy.Group.External.GetName(916576)
  >```
  >
  >Example Output
  >```
  > NEVER WALK ALONE
  >```

  * **GetOwner(GroupID)**
  This function returns the name of an owner of a group
  >Example Usage
  >```python
  >robloxpy.Group.External.GetOwner(916576)
  >```
  >
  >Example Output
  >```
  > kristan99
  >```

  * **GetDescription(GroupID)**
  This function provides the description of a group
  >Example Usage
  >```python
  >robloxpy.Group.External.GetDescription(916576)
  >```
  >
  >Example Output
  >```
  > [NWA]Never Walk Alone
  >NWA is a PMC style group that aims for perfection and are looking for all types of members to join to help us with our goal.
  >
  >We like active members at NWA and have a wide range of bots to help the group function with things such as
  > - Automatic Promotion
   >- Inactivity Detector
  >
  >[Automatic Promotions]
  >{Temp Down Will Be Up Within 1 Week}
  >
  >[Inactivity Kicked]
  >{Online - Set to 30 Days}
  >```

  * **GetEmblem(GroupID)**
  This function will provide a url to a group emblem
  >Example Usage
  >```python
  >robloxpy.Group.External.GetEmblem(916576)
  >```
  >
  >Example Output
  >```
  > http://www.roblox.com/asset/?id=176186568
  >```

  * **GetRoles(GroupID)**
  This function is to generate the roles and a permission value
  >Example Usage
  >```python
  >robloxpy.Group.External.GetRoles(916576)
  >```
  >
  >Example Output
  >```
  > (['[LR I] Recruit', '[LR II] Trooper', '[LR III] Specialist', '[MR I] Squad Leader', '[MR II] Operative', '[OiT] Officer in Training', '[MP]Military Police', '[HR I] Officer', '[HR II] Chief', '[GN I] Lieutenant General', '[GN II] General', '[DP] Diplomat', '[HC] High Command', '[CC] Co -
  >Commander', '[CM] Commander'], [1, 180, 190, 195, 196, 200, 205, 210, 220, 230, 240, 245, 250, 254, 255])
  >```

  * **GetAllies(GroupID)**
  This function to generate a allies list of a group
  >Example Usage
  >```python
  >robloxpy.Group.External.GetAllies(916576)
  >```
  >
  >Example Output
  >```
  > ['Akios', 'Dank']
  >```

  * **GetEnemies(GroupID)**
  This function to generate a enemies list of a group
  >Example Usage
  >```python
  >robloxpy.Group.External.GetEnemies(916576)
  >```
  >
  >Example Output
  >```
  > ["US Military 1940's", 'United Alliance Of Roblox']
  >```

  * **GetMemberCount(GroupID)**
  This function to provide total members in a group
  >Example Usage
  >```python
  >robloxpy.Group.External.GetMemberCount(916576)
  >```
  >
  >Example Output
  >```
  > 2347
  >```

  * **isPublic(GroupID)**
  This function whether a group is availible to join by anyone
  >Example Usage
  >```python
  >robloxpy.Group.External.isPublic(916576)
  >```
  >
  >Example Output
  >```
  > BUG
  >```

  * **isBCOnly(GroupID)**
  This function whether a group is only availible to join by BC members
  >Example Usage
  >```python
  >robloxpy.Group.External.isBCOnly(916576)
  >```
  >
  >Example Output
  >```
  > BUG
  >```

  * **GetMembersList(GroupID,Limit)**
  This function will generate a members list, the limit is optional; if none if provided it will generate a full list from the group
  >Example Usage
  >```python
  >robloxpy.Group.External.GetMemberCount(916576,20)
  >```
  >
  >Example Output
  >```
  > BUG
  >```

  * **GetMembersinRoleList(GroupID,RoleID,Limit)**
  This function will generate a members list from a specifc role, the limit is optional; if none if provided it will generate a full list from the group
  >Example Usage
  >```python
  >robloxpy.Group.External.GetMembersinRoleList(916576,32148,100)
  >```
  >
  >Example Output
  >```
  > BUG
  >```


  The Market functions are based around the roblox market place. These functions allow you to make actions on these items as well retrieve data from each.


  * **BuyItem(MarketID)**
  This function will buy the item denoted by the market id
  >Example Usage
  >```python
  >robloxpy.Market.Internal.BuyItem(363119963)
  >```
  >
  >Example Output
  >```
  > True


  * **CanManageAsset(UserID,AssetID)**
  This function will return if a user can manage a selected asset
  >Example Usage
  >```python
  >robloxpy.Market.External.CanManageAsset(1368140,363119963)
  >```
  >
  >Example Output
  >```
  > Purchased

  * **GetLimitedPriceData(LimitedID)**
  This function will return a set of data points of the limited price over time
  >Example Usage
  >```python
  >robloxpy.Market.External.GetLimitedPriceData(1081300)
  >```
  >
  >Example Output
  >```
  > [{'value': 1826, 'date': '2021-01-25T06:00:00Z'}, {'value': 1648, 'date': '2021-01-24T06:00:00Z'}, {'value': 1767, 'date': '2021-01-23T06:00:00Z'}, {'value': 1984, 'date': '2021-01-22T06:00:00Z'}, {'value': 1786, 'date': '2021-01-21T06:00:00Z'}, {'value': 1599, 'date': '2021-01-20T06:00:00Z'}, {'value': 1604, 'date': '2021-01-19T06:00:00Z'}, {'value': 1736, 'date': '2021-01-18T06:00:00Z'}, {'value': 1889, 'date': '2021-01-17T06:00:00Z'}, {'value': 1798, 'date': '2021-01-16T06:00:00Z'}, {'value': 1892, 'date': '2021-01-15T06:00:00Z'}, {'value': 2041, 'date': '2021-01-14T06:00:00Z'}, {'value': 1796, 'date': '2021-01-13T06:00:00Z'}, {'value': 1843, 'date': '2021-01-12T06:00:00Z'}, {'value': 1834, 'date': '2021-01-11T06:00:00Z'}, {'value': 2081, 'date': '2021-01-10T06:00:00Z'}, {'value': 1931, 'date': '2021-01-09T06:00:00Z'}, {'value': 2110, 'date': '2021-01-08T06:00:00Z'}, {'value': 1871, 'date': '2021-01-07T06:00:00Z'}, {'value': 1983, 'date': '2021-01-06T06:00:00Z'}, {'value': 1971, 'date': '2021-01-05T06:00:00Z'}, {'value': 2048, 'date': '2021-01-04T06:00:00Z'}, {'value': 2055, 'date': '2021-01-03T06:00:00Z'}, {'value': 2251, 'date': '2021-01-02T06:00:00Z'}, {'value': 2458, 'date': '2021-01-01T06:00:00Z'}, {'value': 3541, 'date': '2020-12-31T06:00:00Z'}, {'value': 2239, 'date': '2020-12-30T06:00:00Z'}, {'value': 2041, 'date': '2020-12-29T06:00:00Z'}, {'value': 2519, 'date': '2020-12-28T06:00:00Z'}, {'value': 2224, 'date': '2020-12-27T06:00:00Z'}, {'value': 2570, 'date': '2020-12-26T06:00:00Z'}, {'value': 2725, 'date': '2020-12-25T06:00:00Z'}, {'value': 2137, 'date': '2020-12-24T06:00:00Z'}, {'value': 1781, 'date': '2020-12-23T06:00:00Z'}, {'value': 1611, 'date': '2020-12-22T06:00:00Z'}, {'value': 1819, 'date':
  >'2020-12-21T06:00:00Z'}, {'value': 1727, 'date': '2020-12-20T06:00:00Z'}, {'value': 1508, 'date': '2020-12-19T06:00:00Z'}, {'value': 1555, 'date': '2020-12-18T06:00:00Z'}, {'value': 1558, 'date': '2020-12-17T06:00:00Z'}, {'value': 1647, 'date': '2020-12-16T06:00:00Z'}, {'value': 1337, 'date': '2020-12-15T06:00:00Z'}, {'value': 1842, 'date': '2020-12-14T06:00:00Z'}, {'value': 1570, 'date': '2020-12-13T06:00:00Z'}, {'value': 1435, 'date': '2020-12-12T06:00:00Z'}, {'value': 1649, 'date': '2020-12-11T06:00:00Z'}, {'value': 1402, 'date': '2020-12-10T06:00:00Z'}, {'value': 1538,
  >'date': '2020-12-09T06:00:00Z'}, {'value': 1437, 'date': '2020-12-08T06:00:00Z'}, {'value': 1333, 'date': '2020-12-07T06:00:00Z'}, {'value': 1534, 'date': '2020-12-06T06:00:00Z'}, {'value': 1182, 'date': '2020-12-05T06:00:00Z'}, {'value': 1382, 'date': '2020-12-04T06:00:00Z'}, {'value': 1515, 'date': '2020-12-03T06:00:00Z'}, {'value': 1467, 'date': '2020-12-02T06:00:00Z'}, {'value': 1606, 'date': '2020-12-01T06:00:00Z'}, {'value':
  >1428, 'date': '2020-11-30T06:00:00Z'}, {'value': 1598, 'date': '2020-11-29T06:00:00Z'}, {'value': 1614, 'date': '2020-11-28T06:00:00Z'}, {'value': 3101, 'date': '2020-11-27T06:00:00Z'}, {'value': 1503, 'date': '2020-11-26T06:00:00Z'}, {'value': 1383, 'date': '2020-11-25T06:00:00Z'}, {'value': 1455, 'date': '2020-11-24T06:00:00Z'}, {'value': 1217, 'date': '2020-11-23T06:00:00Z'}, {'value': 1425, 'date': '2020-11-22T06:00:00Z'}, {'value': 1587, 'date': '2020-11-21T06:00:00Z'}, {'value': 2308, 'date': '2020-11-20T06:00:00Z'}, {'value': 1557, 'date': '2020-11-19T06:00:00Z'}, {'value': 1401, 'date': '2020-11-18T06:00:00Z'}, {'value': 1388, 'date': '2020-11-17T06:00:00Z'}, {'value': 1631, 'date': '2020-11-16T06:00:00Z'},
  >{'value': 1811, 'date': '2020-11-15T06:00:00Z'}, {'value': 1583, 'date': '2020-11-14T06:00:00Z'}, {'value': 1366, 'date': '2020-11-13T06:00:00Z'}, {'value': 1197, 'date': '2020-11-12T06:00:00Z'}, {'value': 1426, 'date': '2020-11-11T06:00:00Z'}, {'value': 1494, 'date': '2020-11-10T06:00:00Z'}, {'value': 1594, 'date': '2020-11-09T06:00:00Z'}, {'value': 1526, 'date': '2020-11-08T06:00:00Z'}, {'value': 1347, 'date': '2020-11-07T06:00:00Z'}, {'value': 1355, 'date': '2020-11-06T06:00:00Z'}, {'value': 1315, 'date': '2020-11-05T06:00:00Z'}, {'value': 1204, 'date': '2020-11-04T06:00:00Z'}, {'value': 1016, 'date': '2020-11-03T06:00:00Z'}, {'value': 1332, 'date': '2020-11-02T06:00:00Z'}, {'value': 1274, 'date': '2020-11-01T05:00:00Z'}, {'value': 1407, 'date': '2020-10-31T05:00:00Z'}, {'value': 1270, 'date': '2020-10-30T05:00:00Z'}, {'value': 1205, 'date': '2020-10-29T05:00:00Z'}, {'value': 1216, 'date': '2020-10-28T05:00:00Z'}, {'value': 1246, 'date': '2020-10-27T05:00:00Z'}, {'value': 1124, 'date': '2020-10-26T05:00:00Z'}, {'value': 1338, 'date': '2020-10-25T05:00:00Z'}, {'value': 1107, 'date': '2020-10-24T05:00:00Z'}, {'value': 1164, 'date': '2020-10-23T05:00:00Z'}, {'value': 1089, 'date': '2020-10-22T05:00:00Z'}, {'value': 1041, 'date': '2020-10-21T05:00:00Z'}, {'value': 962, 'date': '2020-10-20T05:00:00Z'}, {'value': 1054, 'date': '2020-10-19T05:00:00Z'}, {'value': 1117, 'date': '2020-10-18T05:00:00Z'}, {'value': 1328, 'date': '2020-10-17T05:00:00Z'}, {'value': 1129, 'date': '2020-10-16T05:00:00Z'}, {'value': 1191, 'date': '2020-10-15T05:00:00Z'}, {'value': 1120, 'date': '2020-10-14T05:00:00Z'}, {'value': 1262, 'date': '2020-10-13T05:00:00Z'}, {'value': 1147, 'date': '2020-10-12T05:00:00Z'}, {'value': 1264, 'date': '2020-10-11T05:00:00Z'}, {'value': 988, 'date': '2020-10-10T05:00:00Z'}, {'value': 1467, 'date': '2020-10-09T05:00:00Z'}, {'value': 2389, 'date': '2020-10-08T05:00:00Z'}, {'value': 1283, 'date': '2020-10-07T05:00:00Z'}, {'value': 1078, 'date': '2020-10-06T05:00:00Z'}, {'value': 1404, 'date': '2020-10-05T05:00:00Z'}, {'value': 1312, 'date': '2020-10-04T05:00:00Z'}, {'value': 1305, 'date': '2020-10-03T05:00:00Z'}, {'value': 1234, 'date': '2020-10-02T05:00:00Z'}, {'value': 1222, 'date': '2020-10-01T05:00:00Z'}, {'value': 1166, 'date': '2020-09-30T05:00:00Z'}, {'value': 1082, 'date': '2020-09-29T05:00:00Z'}, {'value': 1081, 'date': '2020-09-28T05:00:00Z'}, {'value': 1311, 'date': '2020-09-27T05:00:00Z'}, {'value': 1378, 'date': '2020-09-26T05:00:00Z'}, {'value': 1374, 'date': '2020-09-25T05:00:00Z'}, {'value': 1252, 'date': '2020-09-24T05:00:00Z'}, {'value': 1271, 'date': '2020-09-23T05:00:00Z'}, {'value': 1206, 'date': '2020-09-22T05:00:00Z'}, {'value': 1290, 'date': '2020-09-21T05:00:00Z'}, {'value': 1101, 'date': '2020-09-20T05:00:00Z'}, {'value': 1065, 'date': '2020-09-19T05:00:00Z'}, {'value': 1229, 'date': '2020-09-18T05:00:00Z'}, {'value': 945, 'date': '2020-09-17T05:00:00Z'}, {'value': 1053, 'date': '2020-09-16T05:00:00Z'}, {'value': 1192, 'date': '2020-09-15T05:00:00Z'}, {'value':
  >1299, 'date': '2020-09-14T05:00:00Z'}, {'value': 1292, 'date': '2020-09-13T05:00:00Z'}, {'value': 1338, 'date': '2020-09-12T05:00:00Z'}, {'value': 1360, 'date': '2020-09-11T05:00:00Z'}, {'value': 1077, 'date': '2020-09-10T05:00:00Z'}, {'value': 1273, 'date': '2020-09-09T05:00:00Z'}, {'value': 1101, 'date': '2020-09-08T05:00:00Z'}, {'value': 1234, 'date': '2020-09-07T05:00:00Z'}, {'value': 1175, 'date': '2020-09-06T05:00:00Z'}, {'value': 1229, 'date': '2020-09-05T05:00:00Z'}, {'value': 1329, 'date': '2020-09-04T05:00:00Z'}, {'value': 1216, 'date': '2020-09-03T05:00:00Z'}, {'value': 1298, 'date': '2020-09-02T05:00:00Z'}, {'value': 1247, 'date': '2020-09-01T05:00:00Z'}, {'value': 1094, 'date': '2020-08-31T05:00:00Z'},
  >{'value': 1178, 'date': '2020-08-30T05:00:00Z'}, {'value': 1176, 'date': '2020-08-29T05:00:00Z'}, {'value': 1190, 'date': '2020-08-28T05:00:00Z'}, {'value': 1257, 'date': '2020-08-27T05:00:00Z'}, {'value': 1094, 'date': '2020-08-26T05:00:00Z'}, {'value': 1113, 'date': '2020-08-25T05:00:00Z'}, {'value': 1057, 'date': '2020-08-24T05:00:00Z'}, {'value': 1279, 'date': '2020-08-23T05:00:00Z'}, {'value': 1289, 'date': '2020-08-22T05:00:00Z'}, {'value': 1109, 'date': '2020-08-21T05:00:00Z'}, {'value': 1054, 'date': '2020-08-20T05:00:00Z'}, {'value': 981, 'date': '2020-08-19T05:00:00Z'}, {'value': 1088, 'date': '2020-08-18T05:00:00Z'}, {'value': 1003, 'date': '2020-08-17T05:00:00Z'}, {'value': 1088, 'date': '2020-08-16T05:00:00Z'}, {'value': 1070, 'date': '2020-08-15T05:00:00Z'}, {'value': 968, 'date': '2020-08-14T05:00:00Z'}, {'value': 934, 'date': '2020-08-13T05:00:00Z'}, {'value': 919, 'date': '2020-08-12T05:00:00Z'}, {'value': 970, 'date': '2020-08-11T05:00:00Z'}, {'value': 909, 'date': '2020-08-10T05:00:00Z'}, {'value': 1046, 'date': '2020-08-09T05:00:00Z'}, {'value': 1038, 'date': '2020-08-08T05:00:00Z'}, {'value': 1098, 'date': '2020-08-07T05:00:00Z'}, {'value': 1062, 'date': '2020-08-06T05:00:00Z'}, {'value': 1138, 'date': '2020-08-05T05:00:00Z'}, {'value': 1072, 'date': '2020-08-04T05:00:00Z'}, {'value': 1080, 'date': '2020-08-03T05:00:00Z'}, {'value': 1161, 'date': '2020-08-02T05:00:00Z'}, {'value': 1227, 'date': '2020-08-01T05:00:00Z'}, {'value': 1169, 'date': '2020-07-31T05:00:00Z'}, {'value': 1023, 'date': '2020-07-30T05:00:00Z'}, {'value': 1017, 'date': '2020-07-29T05:00:00Z'}]
  > ```

  * **GetLimitedRemaining(LimitedID)**
  This function the reaming limiteds for sale
  >Example Usage
  >```python
  >robloxpy.Market.External.GetLimitedRemaining(1081300)
  >```
  >
  >Example Output
  >```
  > 0
  > ```

  * **GetLimitedTotal(LimitedID)**
  This function returns the total amount of the limited sold. If the item did not use to be limited this function will always return None
  >Example Usage
  >```python
  >robloxpy.Market.External.GetLimitedTotal(1081300)
  >```
  >
  >Example Output
  >```
  > None
  > ```

  * **GetLimitedSales(LimitedID)**
  This function returns the total amount of the limited which are for sale currently.
  >Example Usage
  >```python
  >robloxpy.Market.External.GetLimitedSales(1081300)
  >```
  >
  >Example Output
  >```
  > 37813
  > ```

  * **GetLimitedRAP(LimitedID)**
  This function returns the total recent average price of a limited in robux
  >Example Usage
  >```python
  >robloxpy.Market.External.GetLimitedRAP(1081300)
  >```
  >
  >Example Output
  >```
  > 1707
  > ```

  * **GetLimitedSalePrice(LimitedID)**
  This function returns the price of a limited when it first went on sale, items which were not origionally limited will return None
  >Example Usage
  >```python
  >robloxpy.Market.External.GetLimitedSalePrice(4390890198)
  >```
  >
  >Example Output
  >```
  > 12000
  > ```

  * **GetLimitedChangePercentage(LimitedID)**
  This function returns the price change of a limited price currently to what it origionally sold at
  >Example Usage
  >```python
  >robloxpy.Market.External.GetLimitedChangePercentage(4390890198)
  >```
  >
  >Example Output
  >```
  > 191.3%
  > ```

  * **GetAssetImage(LimitedID,Width,Height)**
  This function returns the a link to the image of an asset
  >Example Usage
  >```python
  >robloxpy.Market.External.GetAssetImage(4390890198,420,420)
  >```
  >
  >Example Output
  >```
  > https://tr.rbxcdn.com/c4f5ec2e849306ebe3cb4dccaf1369f8/420/420/Hat/Png
  > ```


  The user functions are how you interact with specific users to gather data as well as how you interact with roblox as a specific user based on the currently used cookie.


  * **SetCookie(Cookie,Details)**
  This function will set the cookie to be used with any internal commands of robloxpy. The details argument is optional allowing you to pre-fill a wide range of data of the current account as the cookie is set
  >Example Usage
  >```python
  >robloxpy.User.Internal.SetCookie("_WARNING:-DO-NOT-SHARE-THIS.--Sharing-this-will-allow-someone-to-log-in-as-you-and-to-steal-your-ROBUX-and-items._XXXXXXXXXXXXX",True)
  >```
  >
  >Example Output
  >```
  > Cookie Set
  > ```

  The additional data that is set when you set a cookie is as follows:
  > RawCookie
  > UserID
  > Username
  > Robux
  > Thumbnail
  > isBuildersclub
  > isPremium
  > canChangeUsername
  > isAdmin
  > isEmailOnFile
  > isEmailVerified
  > isPhoneFeatureEnabled
  > isSuperSafePrivacyMode
  > IsAppChatSettingEnabled
  > IsGameChatSettingEnabled
  > IsContentRatingsSettingEnabled
  > IsParentalControlsTabEnabled
  > IsSetPasswordNotificationEnabled
  > ChangePasswordRequiresTwoStepVerification
  > ChangeEmailRequiresTwoStepVerification
  > UserEmail
  > UserEmailMasked
  > UserEmailVerified
  > CanHideInventory
  > CanTrade
  > MissingParentEmail
  > IsUpdateEmailSectionShown
  > IsUnder13UpdateEmailMessageSectionShown
  > IsUserConnectedToFacebook
  > IsTwoStepToggleEnabled
  > AgeBracket
  > UserAbove13
  > ClientIpAddress
  > UserAge
  > IsBcRenewalMembership
  > IsAccountPinEnabled
  > IsAccountRestrictionsFeatureEnabled
  > IsAccountRestrictionsSettingEnabled
  > IsAccountSettingsSocialNetworksV2Enabled
  > InApp
  > HasFreeNameChange
  > IsAgeDownEnabled
  > ReceiveNewsletter

  This data can be called as a standard variable as needed such as the following:
  ```python
  print(robloxpy.User.Internal.CanTrade)
  Output > True
  ```
  * **GetDetails(Details)**
  This function will collect the data of the current cookie, this is only useful is you decide not to collec it by default when setting the cookie.
  >Example Usage
  >```python
  >robloxpy.User.Internal.GetDetails(True)
  >```
  >
  >Example Output
  >```
  > Data Gathered
  > ```

  * **isFollowing(targetUserID)**
  This function will check if the user is following a different user
  >Example Usage
  >```python
  >robloxpy.User.Internal.isFollowing(1)
  >```
  >
  >Example Output
  >```
  > True
  > ```

  * **FollowUser(targetUserID)**
  This function will follow the target user
  >Example Usage
  >```python
  >robloxpy.User.Internal.FollowUser(1)
  >```
  >
  >Example Output
  >```
  > success
  > ```

  * **UnfollowUser(targetUserID)**
  This function will unfollow the target user
  >Example Usage
  >```python
  >robloxpy.User.Internal.UnfollowUser(1)
  >```
  >
  >Example Output
  >```
  > success
  > ```

  * **BlockUser(targetUserID)**
  This function will block the target user
  >Example Usage
  >```python
  >robloxpy.User.Internal.BlockUser(1)
  >```
  >
  >Example Output
  >```
  > success
  > ```

  * **UnblockUser(targetUserID)**
  This function will unblock the target user
  >Example Usage
  >```python
  >robloxpy.User.Internal.UnblockUser(1)
  >```
  >
  >Example Output
  >```
  > success
  > ```

  * **GetBlockedUsers()**
  This function will return a list of all blocked users
  >Example Usage
  >```python
  >robloxpy.User.Internal.GetBlockedUsers
  >```
  >
  >Example Output
  >```
  > ['Roblox','Builderman']
  > ```

  * **SendMessage(targetUserID,Subject,Body)**
  This function will send a customised message to the target user
  >Example Usage
  >```python
  >robloxpy.User.Internal.SendMessage(1,"HI THERE","This is a private message sent with robloxpy")
  >```
  >
  >Example Output
  >```
  > Sent
  > ```

  * **JoinGame(PlaceID)**
  This function will make the current user join a game
  >Example Usage
  >```python
  >robloxpy.User.Internal.JoinGame(1762345)
  >```
  >
  >Example Output
  >```
  > The game will open
  > ```


  * **GetID(Username)**
  This function will return the userID of a user based on their name
  >Example Usage
  >```python
  >robloxpy.User.External.GetID("kristan99")
  >```
  >
  >Example Output
  >```
  > 1368140
  > ```

  * **GetUserName(UserID)**
  This function will return the username of a user based on their ID
  >Example Usage
  >```python
  >robloxpy.User.External.GetID(1368140)
  >```
  >
  >Example Output
  >```
  > kristan99
  > ```

  * **UsernameHistory(UserID)**
  This function will return a username history of a user
  >Example Usage
  >```python
  >robloxpy.User.External.UsernameHistory(1368140)
  >```
  >
  >Example Output
  >```
  > ['kristan99']
  > ```

  * **IsOnline(UserID)**
  This function will return if a user is seen as online
  >Example Usage
  >```python
  >robloxpy.User.External.IsOnline(1368140)
  >```
  >
  >Example Output
  >```
  > True
  > ```

  * **Isbanned(UserID)**
  This function will return if a user is banned
  >Example Usage
  >```python
  >robloxpy.User.External.Isbanned(1368140)
  >```
  >
  >Example Output
  >```
  > False
  > ```

  * **GetDescription(UserID)**
  This function will return a users description
  >Example Usage
  >```python
  >robloxpy.User.External.GetDescription(1368140)
  >```
  >
  >Example Output
  >```
  > No longer really play Roblox, I am however working on RobloxPy a python wrapper for Roblox. You can check it out on GitHub @KristanSmout or install through 'pip install robloxpy'
  >
  >I also provide python tutorials and free software on my youtube channel which you can find somewhere here :P
  > ```

  * **GetAge(UserID)**
  This function will return a users age in days
  >Example Usage
  >```python
  >robloxpy.User.External.GetAge(1368140)
  >```
  >
  >Example Output
  >```
  > 4470
  > ```

  * **CreationDate(UserID,Style)**
  This function will return a users creation date, if you use the wrong format and need the month first set the style to 1
  >Example Usage
  >```python
  >robloxpy.User.External.CreationDate(1368140)
  >```
  >
  >Example Output
  >```
  > 30/10/2008
  > ```

  * **GetRAP(UserID)**
  This function will return the RAP of a user in robux
  >Example Usage
  >```python
  >robloxpy.User.External.GetRAP(1368140)
  >```
  >
  >Example Output
  >```
  > 432908
  > ```

  * **GetLimiteds(UserID)**
  This function will return the an array of limiteds of a user and the corresponding item ID's
  >Example Usage
  >```python
  >robloxpy.User.External.GetLimiteds(1368140)
  >```
  >
  >Example Output
  >```
  >(['Racing Helmet', 'Summertime 2009 R&R&R', 'Tee Vee', 'Gobble Gobble', 'Gobble Gobble', 'Clown School Dropout', 'Chrome Egg of Speeding Bullet', 'Norseman', 'Fiery Egg of Egg Testing', 'Brass Top Hat', 'Crocheted Cthulhu', 'Staff of Celestial Light', 'Swordpack', 'Ornate Valkyrie', 'Police Badge', 'Shady Business Hat', 'Rogue Masquerader', "Cupid's Beloved Blade", "Cupid's Beloved Blade", "Cupid's Beloved Blade", "Cupid's Beloved
  >Blade", "Cupid's Beloved Blade", "Cupid's Beloved Blade", "Cupid's Beloved Blade", 'The Last Egg of 2013', 'Deluxe Game Headset', 'Green Starface ', 'Captain Steelshanks Recruiting Staff', 'Fawkes Face', 'Gold Visor', 'Mr X', 'Mr X', 'Egg of Verticality', 'Golden Crown', 'Classy ROBLOX Bow Tie', 'Furry Rock Star Hat', 'Skull of Robloxians Past', 'Halloween Baseball Cap 2014', "Merely's Green Sparkle Time Hoverboard", "St Patrick's
  >Day Fairy", 'Bluesteel Katana', 'Bluesteel Katana', 'Overseer Collar', 'Periastron Crown', 'True Love Smile', "Brighteyes' Top Hat", "Brighteye's Bloxy Cola Hat", 'Valkyrie Helm', 'Neon Green Beautiful Hair', 'Virtual Commando', 'The Crown of Warlords', 'Chiefjustus Gavel', 'ROBLOX Madness Face', "Overseer Warlord's Sword", 'Cursed Korblox Pendant ', 'Purple Wistful Wink', 'Blue Wistful Wink', 'Bacon Face', "DJ Remix's Goldphones", 'Red Goof ', 'Noob Attack: Laser Scythe Scuffle'], [6379764, 13334984, 15857936, 18448414, 18448414, 21392863, 24826640, 24941896, 27345567, 35685137, 35685477, 49491781, 19398258, 23634704, 82358339, 89624140, 93078804, 106064277, 106064277, 106064277, 106064277, 106064277, 106064277, 106064277, 111776247, 100425864, 119812738, 71597060, 134522901, 134087261, 125861676, 125861676, 152980639, 1081300, 162069243, 163496075, 181354245, 184745025, 215392741, 226189871, 243791145, 243791145, 343585127, 343585234, 362051405, 169454280, 24114402, 1365767, 151786902, 362081769, 2264398, 120749528, 130213380, 483308034, 483899424, 583722710, 583721561, 399021751, 102618797, 1191125008, 2566105661])
  > ```

  * **GetBust(UserID,Width,Height)**
  This function will a url to a bust image of a user
  >Example Usage
  >```python
  >robloxpy.User.External.GetBust(1368140)
  >```
  >
  >Example Output
  >```
  > https://tr.rbxcdn.com/d4ff03e82298e804c89de3098e51abe6/420/420/AvatarBust/Png
  > ```

  * **GetHeadshot(UserID,Width,Height)**
  This function will a url to a headshot image of a user
  >Example Usage
  >```python
  >robloxpy.User.External.GetBust(1368140)
  >```
  >
  >Example Output
  >```
  > https://tr.rbxcdn.com/b8864e930fcc0bfd4c3b19a558724841/420/420/AvatarHeadshot/Png
  > ```

  * **GetStatus(UserID)**
  This function will return a users status
  >Example Usage
  >```python
  >robloxpy.User.External.GetBust(1368140)
  >```
  >
  >Example Output
  >```
  > Currently working on RobloxPy a python wrapper of the roblox API
  > ```

  * **DoesNameExist(username)**
  This function will return if a name is being used or not
  >Example Usage
  >```python
  >robloxpy.User.External.DoesNameExist("kristan99")
  >```
  >
  >Example Output
  >```
  > Unavailible
  > ```


  This is the sub category for functions for the user Friends.

  * **SendFriendRequest(UserID)**
  This function will send a friend request to the target user
  >Example Usage
  >```python
  >robloxpy.User.Friend.Internal.SendFriendRequest(1368140)
  >```
  >
  >Example Output
  >```
  > Sent
  > ```

  * **Unfriend(UserID)**
  This function will unfriend the target user
  >Example Usage
  >```python
  >robloxpy.User.Friend.Internal.Unfriend(1368140)
  >```
  >
  >Example Output
  >```
  > Sent
  > ```

  * **TotalFriends()**
  This function will return a full list of a users friends
  >Example Usage
  >```python
  >robloxpy.User.Friend.Internal.TotalFriends()
  >```
  >
  >Example Output
  >```
  > 34
  > ```


  * **GetAll(1368140)**
  This function will return the total list of friends for the current user
  >Example Usage
  >```python
  >robloxpy.User.Friend.External.GetAll(1368140)
  >```
  >
  >Example Output
  >```
  > ['LocalFapper', 'SlimemingPlayz', 'E_xitium', 'Kawaii_Katicorn99', 'KatieeLouisee99', 'Yung_nignogpaddywog', 'BigDDave', 'Nosowl', 'Mirro_rs', 'Gareth1990', 'Voxxes', 'matantheman', 'ItzDishan', 'KioshiShimano', 'CinnabonNinja', 'roxo_pl', 'GlowwLikeThat', 'BritishP0litics', 'Nicolas9970', 'YunPlant', 'sirjoshh', 'iMistifye', 'Scorp1x', 'Fribbzdaman', 'xMcKenziee', 'AjinKovac', 'Angels_Develop', 'RonerRehnskiold', 'agnen', 'RocketValkyrie', 'methanshacked', 'GingyWyven', 'KingsmanSS', 'glitch19']
  > ```

  * **GetCount(UserID)**
  This function will return the total number of friends for the current user
  >Example Usage
  >```python
  >robloxpy.User.Friend.External.GetCount(1368140)
  >```
  >
  >Example Output
  >```
  > 34
  > ```

  * **GetOnline(UserID)**
  This function will return the total list of online friends for the current user
  >Example Usage
  >```python
  >robloxpy.User.Friend.External.GetOnline(1368140)
  >```
  >
  >Example Output
  >```
  > ['Mirro_rs', 'Angels_Develop']
  > ```

  * **GetOffline(UserID)**
  This function will return the total list of offline friends for the current user
  >Example Usage
  >```python
  >robloxpy.User.Friend.External.GetOffline(1368140)
  >```
  >
  >Example Output
  >```
  > ['LocalFapper', 'SlimemingPlayz', 'E_xitium', 'Kawaii_Katicorn99', 'KatieeLouisee99', 'Yung_nignogpaddywog', 'BigDDave', 'Nosowl', 'Gareth1990',
  >'Voxxes', 'matantheman', 'ItzDishan', 'KioshiShimano', 'CinnabonNinja', 'roxo_pl', 'GlowwLikeThat', 'BritishP0litics', 'Nicolas9970', 'YunPlant', 'sirjoshh', 'iMistifye', 'Scorp1x', 'Fribbzdaman', 'xMcKenziee', 'AjinKovac', 'RonerRehnskiold', 'agnen', 'RocketValkyrie', 'methanshacked', 'GingyWyven', 'KingsmanSS', 'glitch19']
  > ```

  * **GetFollowerCount(UserID)**
  This function will return the total follower count friends for the current user
  >Example Usage
  >```python
  >robloxpy.User.Friend.External.GetOnline(1368140)
  >```
  >
  >Example Output
  >```
  > 12607
  > ```

  * **GetFollowers(UserID,Amount)**
  This function will return a list of users following a user, limit the list size using the amount variable. This function also provides the user ID's of the followers
  >Example Usage
  >```python
  >robloxpy.User.Friend.External.GetOnline(1368140,10)
  >```
  >
  >Example Output
  >```
  > (['builderman', 'Gaming112', 'snowbeat54321', 'BobHag', 'lilmigithunter', 'UchihaSasukePat', 'Alessi7953', 'GarraSabakuno', 'jangofettt', 'Garty983chub'], [156, 1359952, 2918062, 3149494, 2899616, 2937573, 2754369, 2982496, 20169, 169558])
  > ```

  * **GetFollowingCount(UserID)**
  This function will return the total amount of users followed by the current user
  >Example Usage
  >```python
  >robloxpy.User.Friend.External.GetFollowingCount(1368140)
  >```
  >
  >Example Output
  >```
  > 16
  > ```

  * **GetFollowing(UserID,Amount)**
  This function will return a list of users being followed by the user, limit the list size using the amount variable. This function also provides the user ID's of the followers
  >Example Usage
  >```python
  >robloxpy.User.Friend.External.GetFollowing(1368140,10)
  >```
  >
  >Example Output
  >```
  > (['takeovertom', 'dino5aur', 'iClanTech', '1waffle1', 'ForyxeV', 'Imaginze', 'StoryBased', 'LoneTraveler', 'beanme100', 'enyahs7'], [1096520, 649206, 65797433, 75323, 9622035, 17256624, 27572897, 3304627, 485933, 336048])
  > ```


  This is the sub category for functions for the user Groups.

  * **Claim(GroupID)**
  This function will attempt to claim an unowned group
  >Example Usage
  >```python
  >robloxpy.User.Groups.Internal.Claim(916576)
  >```
  >
  >Example Output
  >```
  > Sent
  > ```

  * **Join(GroupID)**
  This function will attempt to Join a group
  >Example Usage
  >```python
  >robloxpy.User.Groups.Internal.Join(916576)
  >```
  >
  >Example Output
  >```
  > Join request sent
  > ```

  * **Leave(GroupID)**
  This function will attempt to Leave a group
  >Example Usage
  >```python
  >robloxpy.User.Groups.Internal.Leave(916576)
  >```
  >
  >Example Output
  >```
  > Sent
  > ```

  * **GetFunds(GroupID)**
  This function will attempt to get the group funds (You need permission to see them)
  >Example Usage
  >```python
  >robloxpy.User.Groups.Internal.GetFunds(916576)
  >```
  >
  >Example Output
  >```
  > 17290
  > ```

  * **Payout(GroupID,targetUserID,RobuxAmount)**
  This function will attempt to payout a specific amount of the group funds (You need permission to do so)
  >Example Usage
  >```python
  >robloxpy.User.Groups.Internal.Payout(916576,1368140,1000)
  >```
  >
  >Example Output
  >```
  > Sent
  > ```

  * **PercentagePayout(GroupID,targetUserID,Percentage)**
  This function will attempt to payout a specific percentage of the group funds (You need permission to do so)
  >Example Usage
  >```python
  >robloxpy.User.Groups.Internal.Payout(916576,1368140,5)
  >```
  >
  >Example Output
  >```
  > Sent
  > ```

  * **SendWallPost(GroupID,PostText)**
  This function will attempt to post on the group wall
  >Example Usage
  >```python
  >robloxpy.User.Groups.Internal.SendWallPost(916576,"Hello World")
  >```
  >
  >Example Output
  >```
  > Sent
  > ```

  * **SendGroupShout(GroupID,ShoutText)**
  This function will attempt to post on the group wall
  >Example Usage
  >```python
  >robloxpy.User.Groups.Internal.SendGroupShout(916576,"Hello World")
  >```
  >
  >Example Output
  >```
  > Sent
  > ```

  * **ChangeDescription(GroupID,DescriptionText)**
  This function will attempt to post on the group wall
  >Example Usage
  >```python
  >robloxpy.User.Groups.Internal.ChangeDescription(916576,"Hello World")
  >```
  >
  >Example Output
  >```
  > Sent
  > ```

  * **ChangeRank(GroupID,targetUserID,RoleID)**
  This function will attempt to post on the group wall
  >Example Usage
  >```python
  >robloxpy.User.Groups.Internal.ChangeDescription(916576,1368140,15728)
  >```
  >
  >Example Output
  >```
  > Sent
  > ```




  * **GetGroups(UserID)**
  This function will Returnsthe list of groups a user is in with the group ID's
  >Example Usage
  >```python
  >robloxpy.User.Groups.External.GetGroups(1368140)
  >```
  >
  >Example Output
  >```
  > (['Simple Studio', 'BlackRock Studio', 'White Wolf Hounds', '🌶️Hot Pepper Clothes', 'Twisted Murder er Official Group', 'StarCraft®', 'United Alliance Of Roblox', 'NEVER WALK ALONE'], [3297855, 847360, 1201505, 3206677, 1225381, 1132763, 14195, 916576])
  > ```


  These docs should be complete, if you find something that is not included in the documentation please let me know and I will add it when I get a chance. If you see anything in the documentation that is incorrect please also make me aware and I resolve it ASAP.


pkgId: 4e52c3642a41536f729faace7903065685da7d48119f45348bac5021c9a63198
name: python-robotframework-appiumlibrary-help
arch: noarch
version: 2.0.0
epoch: 0
release: 1
summary: Development documents and examples for robotframework-appiumlibrary
url: https://github.com/serhatbolsu/robotframework-appiumlibrary
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-555363f9-ffcb-431f-ad48-5fe16548ef25
rpm_sourcerpm: python-robotframework-appiumlibrary-2.0.0-1.src.rpm
checksum_type: sha256
location_href:
  00012949-python-robotframework-appiumlibrary/python-robotframework-appiumlibrary-help-2.0.0-1.noarch.rpm


pkgId: f3065d23b47a50d68d3d345e61ae31ffc7de16514f62c6511d6dba4fa32c1593
name: python-robotframework-debuglibrary-help
arch: noarch
version: 2.3.0
epoch: 0
release: 1
summary: Development documents and examples for robotframework-debuglibrary
url: https://github.com/xyb/robotframework-debuglibrary/
rpm_license: New BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-11124755-0471-4c17-9611-ebb79c4ef3a6
rpm_sourcerpm: python-robotframework-debuglibrary-2.3.0-1.src.rpm
checksum_type: sha256
location_href:
  00012951-python-robotframework-debuglibrary/python-robotframework-debuglibrary-help-2.3.0-1.noarch.rpm


pkgId: c5f41d145bc1e36cbd2e4d2218a5edb7403563487fa6721f7effc2f0dff71388
name: python-robotframework-lint
arch: src
version: 1.1
epoch: 0
release: 1
summary: Static analysis tool for robotframework plain text files
url: https://github.com/boakley/robotframework-lint/
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-728217a5-7ca9-4564-bde2-b3275a13579a
location_href: 00013489-python-robotframework-lint/python-robotframework-lint-1.1-1.src.rpm
checksum_type: sha256
description:
  Static analysis for robot framework plain text files.
  This is a static analysis tool for robot framework plain text files.


pkgId: 45e4cd737aa8319e03bd5edc02cb580e080502d05772db9bfb2e58d5129491f7
name: python-robotframework-pabot
arch: src
version: 2.15.0
epoch: 0
release: 1
summary: Parallel test runner for Robot Framework
url: https://pabot.org
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-848442ad-f05f-4e2d-9bea-1e598055d25c
location_href: 00010919-python-robotframework-pabot/python-robotframework-pabot-2.15.0-1.src.rpm
checksum_type: sha256
description:
  A parallel executor for Robot Framework tests. With Pabot you can split one execution into multiple and save test execution time.


pkgId: 9109d1885f589adf190c2346eae20a8d14c2b1167410552af37a4f72513a5bda
name: python-robotframework-pythonlibcore
arch: src
version: 4.1.2
epoch: 0
release: 1
summary: Tools to ease creating larger test libraries for Robot Framework using Python.
url: https://github.com/robotframework/PythonLibCore
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c74c7d23-0334-44cc-a575-b04396944f2a
location_href: 00010605-python-robotframework-pythonlibcore/python-robotframework-pythonlibcore-4.1.2-1.src.rpm
checksum_type: sha256
description:
  Tools to ease creating larger test libraries for `Robot Framework`_ using
  Python. The Robot Framework `hybrid`_ and `dynamic library API`_ gives more
  flexibility for library than the static library API, but they also sets requirements
  for libraries which needs to be implemented in the library side. PythonLibCore
  eases the problem by providing simpler interface and handling all the requirements
  towards the Robot Framework library APIs.
  Code is stable and version 1.0 is already used by SeleniumLibrary_ and
  WhiteLibrary_. The version 2.0 support changes in the Robot Framework
  3.2.


pkgId: bef4e3be9c2fd32f04745f83c87cd876449d99d4b74ec7fb6ce8dee6e2175692
name: python-robotframework-pythonlibcore-help
arch: noarch
version: 4.1.2
epoch: 0
release: 1
summary: Development documents and examples for robotframework-pythonlibcore
url: https://github.com/robotframework/PythonLibCore
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c74c7d23-0334-44cc-a575-b04396944f2a
rpm_sourcerpm: python-robotframework-pythonlibcore-4.1.2-1.src.rpm
checksum_type: sha256
description:
  Tools to ease creating larger test libraries for `Robot Framework`_ using
  Python. The Robot Framework `hybrid`_ and `dynamic library API`_ gives more
  flexibility for library than the static library API, but they also sets requirements
  for libraries which needs to be implemented in the library side. PythonLibCore
  eases the problem by providing simpler interface and handling all the requirements
  towards the Robot Framework library APIs.
  Code is stable and version 1.0 is already used by SeleniumLibrary_ and
  WhiteLibrary_. The version 2.0 support changes in the Robot Framework
  3.2.

location_href:
  00010605-python-robotframework-pythonlibcore/python-robotframework-pythonlibcore-help-4.1.2-1.noarch.rpm


pkgId: e3174b21ed8a7d1c69d0c48fff7ffdcb519df4c5f4f31fafc51fdcc29784d8b4
name: python-robotframework-requests
arch: src
version: 0.9.4
epoch: 0
release: 1
summary: Robot Framework keyword library wrapper around requests
url: https://github.com/MarketSquare/robotframework-requests
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-73acd8fe-0fc9-4ec1-a318-9b3747efd834
location_href: 00010353-python-robotframework-requests/python-robotframework-requests-0.9.4-1.src.rpm
checksum_type: sha256
description:
  ![Python application](https://github.com/MarketSquare/robotframework-requests/workflows/Python%20application/badge.svg?branch=master)
  [![codecov](https://codecov.io/gh/MarketSquare/robotframework-requests/branch/master/graph/badge.svg)](https://codecov.io/gh/MarketSquare/robotframework-requests)
  [![PyPi downloads](https://img.shields.io/pypi/dm/robotframework-requests)](https://pypi.python.org/pypi/robotframework-requests)
  [![Latest Version](https://img.shields.io/pypi/v/robotframework-requests)](https://pypi.python.org/pypi/robotframework-requests)

  🏠 ``RequestsLibrary`` is a [Robot Framework](https://robotframework.org/) library
  aimed to provide HTTP api testing functionalities by wrapping the well known [Python Requests Library](https://github.com/kennethreitz/requests).


  ```sh
  pip install robotframework-requests
  ```


  ```robotframework
  *** Settings ***
  Library               RequestsLibrary

  *** Test Cases ***

  Quick Get Request Test
      ${response}=    GET  https://www.google.com

  Quick Get Request With Parameters Test
      ${response}=    GET  https://www.google.com/search  params=query=ciao  expected_status=200

  Quick Get A JSON Body Test
      ${response}=    GET  https://jsonplaceholder.typicode.com/posts/1
      Should Be Equal As Strings    1  ${response.json()}[id]
  ```


  Sessionless keywords are now available, you can just `GET`, `POST`, etc.. no need to create a session anymore!
  ```robotframework
  ${resp}=  GET  https://www.google.com
  ```

  `Status Should Be` and `Request Should Be Successfull` can use the last response, no need to pass the response anymore!
  ```robotframework
  GET  https://www.google.com
  Status Should Be  200
  ```



  **New keywords structure:**
  All requests keywords have been rewritten because of many not backward compatible changes
  and to allow in the near future requests keywords without a session.
  Example `Get Request` become `GET On Session` and soon there will be also just `GET`
  when a session is not needed.
  Old keywords `* Request` are now deprecated and will be removed in 1.0.0 version.

  **Implicit assert on status code:**
  `* On Session` keywords automatically fail if an error status code is returned.
  `expect_status=` could be used to specify a status code (`201`, `OK`, `Bad request`)
  or `any` if you want to evaluate the response in any case.

  **Closer to the original Requests library:**
  New keywords have the same parameter orders and structure as the original.
  Lot of pre-parsing / encoding has been removed to have a more accurate and unchanged behaviour.

  **Cleaner project architecture:**
  Main keywords file has been split with a more logic division to allow better and faster maintenance.


  ```robotframework
  *** Settings ***
  Library    Collections
  Library    RequestsLibrary

  Suite Setup    Create Session  jsonplaceholder  https://jsonplaceholder.typicode.com

  *** Test Cases ***

  Get Request Test
      Create Session    google  http://www.google.com

      ${resp_google}=   GET On Session  google  /  expected_status=200
      ${resp_json}=     GET On Session  jsonplaceholder  /posts/1

      Should Be Equal As Strings          ${resp_google.reason}  OK
      Dictionary Should Contain Value     ${resp_json.json()}  sunt aut facere repellat provident

  Post Request Test
      &{data}=    Create dictionary  title=Robotframework requests  body=This is a test!  userId=1
      ${resp}=    POST On Session    jsonplaceholder  /posts  json=${data}  expected_status=anything

      Status Should Be                 201  ${resp}
  ```


  Robotframework-requests offers a wide set of keywords which can be found in the [Keywords documentation](http://marketsquare.github.io/robotframework-requests/doc/RequestsLibrary.html)


  You can find many test examples inside the `atests` folder.


  Feel free to contribute and open an issue in order to discuss it. Before doing it take a look at the [contribution guidelines](CONTRIBUTING.md).

  📢 Get in touch with the community via slack and Users group
  - [Robot Framework Slack #requests channel](https://robotframework-slack-invite.herokuapp.com/)
  - [Robot Framework Users Group](https://groups.google.com/forum/#!forum/robotframework-users)


pkgId: e98a9301e6dfa2b05ae5f981db804876ee50f8c2dbdc187aa397daac08676251
name: python-robotframework-robocop
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Static code analysis tool (linter) for Robot Framework
url: https://github.com/MarketSquare/robotframework-robocop
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5193a6fe-39e5-46a3-b40c-b02e516c936a
location_href: 00013575-python-robotframework-robocop/python-robotframework-robocop-3.0.0-1.src.rpm
checksum_type: sha256
description:
  <img style="float:right" src="https://raw.githubusercontent.com/MarketSquare/robotframework-robocop/master/docs/images/robocop_logo_small.png">


pkgId: 0fd05674f750d941cfad582f3fbacd8d378e36350ae4509fb6209315e278a5fd
name: python-robotframework-selenium2library
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Web testing library for Robot Framework
url: https://github.com/robotframework/Selenium2Library
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d5f73a87-cc7c-4879-9e92-83d57f6e5866
checksum_type: sha256
description:
  Selenium2Library is a web testing library for `Robot Framework`_
  that uses the Selenium_ tool internally. The project is hosted on
  GitHub_ and downloads can be found from PyPI_.
  Starting from version 3.0, Selenium2Library is renamed to SeleniumLibrary_
  and this project exists mainly to help with transitioning.

location_href:
  00011563-python-robotframework-selenium2library/python-robotframework-selenium2library-3.0.0-1.src.rpm


pkgId: a379e365bb729e24c88b95100594f550a1ac4151838689688a9c1e0b002453bf
name: python-robotframework-selenium2library-help
arch: noarch
version: 3.0.0
epoch: 0
release: 1
summary: Development documents and examples for robotframework-selenium2library
url: https://github.com/robotframework/Selenium2Library
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d5f73a87-cc7c-4879-9e92-83d57f6e5866
rpm_sourcerpm: python-robotframework-selenium2library-3.0.0-1.src.rpm
checksum_type: sha256
description:
  Selenium2Library is a web testing library for `Robot Framework`_
  that uses the Selenium_ tool internally. The project is hosted on
  GitHub_ and downloads can be found from PyPI_.
  Starting from version 3.0, Selenium2Library is renamed to SeleniumLibrary_
  and this project exists mainly to help with transitioning.

location_href:
  00011563-python-robotframework-selenium2library/python-robotframework-selenium2library-help-3.0.0-1.noarch.rpm


pkgId: f215016d35a2db9ac2e015dbf1831252ff40e30e1bed15ee2d2e3d8d43c2d916
name: python-robotframework-seleniumlibrary
arch: src
version: 6.0.0
epoch: 0
release: 1
summary: Web testing library for Robot Framework
url: https://github.com/robotframework/SeleniumLibrary
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-694af16e-146f-4d97-9d46-d1fdc1b14a94
checksum_type: sha256
location_href:
  00009974-python-robotframework-seleniumlibrary/python-robotframework-seleniumlibrary-6.0.0-1.src.rpm


pkgId: 205eb55ff4b2bc5b978050ba6b0e7218af3ed339c658760db14ab0c7e23c7a8b
name: python-robotframework-seleniumlibrary-help
arch: noarch
version: 6.0.0
epoch: 0
release: 1
summary: Development documents and examples for robotframework-seleniumlibrary
url: https://github.com/robotframework/SeleniumLibrary
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-694af16e-146f-4d97-9d46-d1fdc1b14a94
rpm_sourcerpm: python-robotframework-seleniumlibrary-6.0.0-1.src.rpm
checksum_type: sha256
location_href:
  00009974-python-robotframework-seleniumlibrary/python-robotframework-seleniumlibrary-help-6.0.0-1.noarch.rpm


pkgId: e6cc73b7e1d3ef074b24757d3124d9f54fc7a20180a6c27c61ebae475969ca2a
name: python-robotframework-seleniumtestability
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: SeleniumTestability library that helps speed up tests withasyncronous evens
url: https://github.com/marketsquare/robotframework-seleniumtestability
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3408e515-76e8-4680-b484-db789c56a460
checksum_type: sha256
description:
  SeleniumTestability is a plugin to Robot Framework's SeleniumLibrary that adds
  functionality to it doesn't fit into its mission. These new features are archived
  by SL's plugin api that then automatically instrumentents the web application via
  javascript calls and provides  keywords to bridge those into Robot Framework.
  Plugin provides automatic detection of asyncronous events happening within
  the web application. For example, if a rest api is called from the application,
  testcase can automatically wait for that call to finish before doing any
  interaction in the UI. There's also a bunch of functionality like fetching of
  browser logs,  keywords to interact with local and session storage.  See the
  keyword documentation [here](https://marketsquare.github.io/robotframework-seleniumtestability/index.html?tag=plugin)
  for more details.
  SeleniumTestability relies on core Selenium's feature EventFiringWebdriver
  and provides it's own listener interface that takes care of waiting in right
  places and instrumenting the SUT whenever it is needed.
  In the future, its also possible to extend the javascript parts of
  SeleniumTestability to incorporate more state inspections.
  Monitoring of the asyncronous events is archived with help of [Testability.js](https://github.com/alfonso-presa/testability.js)
  and its [bindings](https://github.com/alfonso-presa/testability-browser-bindings)

  "Official" support channel available in [Gitter.im](https://gitter.im/robotframework-seleniumtestability/community)

  ```
  pip install robotframework-seleniumtestability
  ```


  ```
  Library         SeleniumLibrary     plugins=SeleniumTestability;True;30 Seconds;True
  ```
  For parameter descriptions, refer to keyword docmentation.

  ```robotframework
    Click Element             id:button_that_triggers_ajax_request
    Click Element             id:some_other_element
    Log To Console            This will happen right after clicking
  ```
  In here, if automatic_wait has been enabled, second `Click Element` keyword wont
  be executed before action triggered by the first button is finished.
  If automatic_wait is not enabled, test case can request the wait itself and previous
  example would look something like this.
  ```
    Click Element               id:button_that_triggers_ajax_request
    Wait For Testability Ready
    Click Element               id:some_other_element
    Wait For Testability Ready
    Log To Console              This would show after events triggered by second click are done.
  ```

  * setTimeout & setImmediate calls and wait for them.
  * fetch() call and wait for it to finish
  * XHR requests and wait for them to finish
  * CSS Animations and wait form them to finish
  * CSS Transitions and wait form them to finish
  * Viewport scrolling.
  Do note that catching css animations and transitions is browser dependant. In the past
  certain browsers did not implement these features as "the standard" would require.

  SeleniumTestability also provides other conveniance keywords that do not make sense to incorporate into
  SeleniumLibrary itself, mainly due to functionality not being in scope of SeleniumLibrary and Selenium
  python bindings. Do check the keyword documentation for up to date list of keywords.

  Keyword documentation [here](https://marketsquare.github.io/robotframework-seleniumtestability/index.html?tag=plugin) and if you need to create one for offline usage:
  ```
  python -m robot.libdoc SeleniumLibrary::plugins=SeleniumTestability
  ```

  [CONTRIBUTING.md](https://github.com/marketsquare/robotframework-seleniumtestability/blob/master/CONTRIBUTING.md) documents how to setup the environment for further development of SeleniumTestability.

location_href:
  00013395-python-robotframework-seleniumtestability/python-robotframework-seleniumtestability-2.1.0-1.src.rpm


pkgId: 91345b999289f7ea30c899e7ef0ced5e598a7a1d2b6369362f5cbe89b8c95e0a
name: python-robotframework-seleniumtestability-help
arch: noarch
version: 2.1.0
epoch: 0
release: 1
summary: Development documents and examples for robotframework-seleniumtestability
url: https://github.com/marketsquare/robotframework-seleniumtestability
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3408e515-76e8-4680-b484-db789c56a460
rpm_sourcerpm: python-robotframework-seleniumtestability-2.1.0-1.src.rpm
checksum_type: sha256
description:
  SeleniumTestability is a plugin to Robot Framework's SeleniumLibrary that adds
  functionality to it doesn't fit into its mission. These new features are archived
  by SL's plugin api that then automatically instrumentents the web application via
  javascript calls and provides  keywords to bridge those into Robot Framework.
  Plugin provides automatic detection of asyncronous events happening within
  the web application. For example, if a rest api is called from the application,
  testcase can automatically wait for that call to finish before doing any
  interaction in the UI. There's also a bunch of functionality like fetching of
  browser logs,  keywords to interact with local and session storage.  See the
  keyword documentation [here](https://marketsquare.github.io/robotframework-seleniumtestability/index.html?tag=plugin)
  for more details.
  SeleniumTestability relies on core Selenium's feature EventFiringWebdriver
  and provides it's own listener interface that takes care of waiting in right
  places and instrumenting the SUT whenever it is needed.
  In the future, its also possible to extend the javascript parts of
  SeleniumTestability to incorporate more state inspections.
  Monitoring of the asyncronous events is archived with help of [Testability.js](https://github.com/alfonso-presa/testability.js)
  and its [bindings](https://github.com/alfonso-presa/testability-browser-bindings)

  "Official" support channel available in [Gitter.im](https://gitter.im/robotframework-seleniumtestability/community)

  ```
  pip install robotframework-seleniumtestability
  ```


  ```
  Library         SeleniumLibrary     plugins=SeleniumTestability;True;30 Seconds;True
  ```
  For parameter descriptions, refer to keyword docmentation.

  ```robotframework
    Click Element             id:button_that_triggers_ajax_request
    Click Element             id:some_other_element
    Log To Console            This will happen right after clicking
  ```
  In here, if automatic_wait has been enabled, second `Click Element` keyword wont
  be executed before action triggered by the first button is finished.
  If automatic_wait is not enabled, test case can request the wait itself and previous
  example would look something like this.
  ```
    Click Element               id:button_that_triggers_ajax_request
    Wait For Testability Ready
    Click Element               id:some_other_element
    Wait For Testability Ready
    Log To Console              This would show after events triggered by second click are done.
  ```

  * setTimeout & setImmediate calls and wait for them.
  * fetch() call and wait for it to finish
  * XHR requests and wait for them to finish
  * CSS Animations and wait form them to finish
  * CSS Transitions and wait form them to finish
  * Viewport scrolling.
  Do note that catching css animations and transitions is browser dependant. In the past
  certain browsers did not implement these features as "the standard" would require.

  SeleniumTestability also provides other conveniance keywords that do not make sense to incorporate into
  SeleniumLibrary itself, mainly due to functionality not being in scope of SeleniumLibrary and Selenium
  python bindings. Do check the keyword documentation for up to date list of keywords.

  Keyword documentation [here](https://marketsquare.github.io/robotframework-seleniumtestability/index.html?tag=plugin) and if you need to create one for offline usage:
  ```
  python -m robot.libdoc SeleniumLibrary::plugins=SeleniumTestability
  ```

  [CONTRIBUTING.md](https://github.com/marketsquare/robotframework-seleniumtestability/blob/master/CONTRIBUTING.md) documents how to setup the environment for further development of SeleniumTestability.

location_href:
  00013395-python-robotframework-seleniumtestability/python-robotframework-seleniumtestability-help-2.1.0-1.noarch.rpm


pkgId: e276cf32b52731b285a72fd19bf2204cfcf5d033580e79ee624275977a961beb
name: python-robotframework-stacktrace
arch: src
version: 0.4.1
epoch: 0
release: 1
url: https://github.com/MarketSquare/robotframework-stacktrace
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1dd980b7-e928-4048-957a-2c20d4eefa04
location_href: 00012495-python-robotframework-stacktrace/python-robotframework-stacktrace-0.4.1-1.src.rpm
checksum_type: sha256
summary:
  A listener that prints a Stack Trace to console to faster find the code section where the failure appears.


pkgId: 82309ed5d2fa3961ceee59911d7781088de815188fe0cbf5ef7ca9f51f061b50
name: python-robotremoteserver
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Robot Framework remote server implemented with Python
url: https://github.com/robotframework/PythonRemoteServer
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3f067aae-eefb-4de4-8447-9060137e4fc9
location_href: 00013790-python-robotremoteserver/python-robotremoteserver-1.1.1-1.src.rpm
checksum_type: sha256
description:
  `Robot Framework`_ remote servers allow hosting test libraries on different
  processes or machines than Robot Framework itself is running on. This project
  implements a generic remote server using the Python_ programming language.
  See the `remote library interface documentation`_ for more information about
  the remote interface in general as well as for a list of remote server
  implementations in other programming languages.
  This project is hosted on GitHub_ and downloads are available on PyPI_.


pkgId: af9243a26b55918fc60591409f9efd14c0bd5d7e9b28db5469b6f6616c5c4fde
name: python-rollbar
arch: src
version: 0.16.3
epoch: 0
release: 1
url: http://github.com/rollbar/pyrollbar
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5d57d44d-d7ed-42fe-94b2-46c601c6508d
location_href: 00010401-python-rollbar/python-rollbar-0.16.3-1.src.rpm
checksum_type: sha256
summary:
  Easy and powerful exception tracking with Rollbar. Send messages and exceptions with arbitrary context, get back aggregates, and debug production issues quickly.

description:
  ![Build Status](https://github.com/rollbar/pyrollbar/workflows/Pyrollbar%20CI/badge.svg?tag=latest)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/rollbar)

  Python notifier for reporting exceptions, errors, and log messages to [Rollbar](https://rollbar.com).



  1. [Sign up for a Rollbar account](https://rollbar.com/signup)
  2. Follow the [Quick Start](https://docs.rollbar.com/docs/python#section-quick-start) instructions in our [Python SDK docs](https://docs.rollbar.com/docs/python) to install pyrollbar and configure it for your platform.



  For complete usage instructions and configuration reference, see our [Python SDK docs](https://docs.rollbar.com/docs/python).



  See our [Releases](https://github.com/rollbar/pyrollbar/releases) page for a list of all releases, including changes.



  If you run into any issues, please email us at [support@rollbar.com](mailto:support@rollbar.com)

  For bug reports, please [open an issue on GitHub](https://github.com/rollbar/pyrollbar/issues/new).




  1. Fork it
  2. Create your feature branch (```git checkout -b my-new-feature```).
  3. Commit your changes (```git commit -am 'Added some feature'```)
  4. Push to the branch (```git push origin my-new-feature```)
  5. Create new Pull Request

  Tests are in `rollbar/test`. To run the tests: `python setup.py test`


pkgId: 594e4c846836e02f7983cc039e073862dac8a6a254f6fa80a4b0267951dfe6cf
name: python-roman
arch: src
version: 4.0
epoch: 0
release: 1
summary: Integer to Roman numerals converter
url: https://github.com/zopefoundation/roman
rpm_license: Python 2.1.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-72b5095d-fb2a-416d-8b5b-d9e5e2a77f8f
location_href: 00004991-python-roman/python-roman-4.0-1.src.rpm
checksum_type: sha256
description:
  Small helper library to convert arabic to roman numerals.
  There are two ways to use this library.
  1. Importing it into your application
      import roman
      
      number = int(input('> ')) # 10
      print(roman.toRoman(number))
      
      number = input('> ') # X
      print(roman.fromRoman(number))
  2. ``roman`` CLI command
      ~$ roman 972
      CMLXXII
      
      ~$ roman -r CMLXXII
      972
      
      ~$ roman -r cMlxxii
      972


pkgId: e1f087c3b3c5619a0b9248b29e5c0986141a546116dba6e8508ca0c860a07432
name: python-ropwr
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: RoPWR: Robust Piecewise Regression
url: https://github.com/guillermo-navas-palencia/ropwr
rpm_license: Apache Licence 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1f528cc7-3ec3-4d04-87af-a52b5b9dc3a1
location_href: 00010435-python-ropwr/python-ropwr-1.0.0-1.src.rpm
checksum_type: sha256
description:
  **RoPWR** is a library written in Python implementing several mathematical
  programming formulations to compute the optimal continuous/discontinuous
  piecewise polynomial regression given a list of split points.

  Read the documentation at: http://gnpalencia.org/ropwr/

  RoPWR is distributed under the Apache Software License (Apache 2.0).


pkgId: a9301c76a00aa0613392c8bd4771b7c6a494014a13d827521a38d2349e152d2d
name: python-roundrobin
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: Collection of roundrobin utilities
url: https://github.com/linnik/roundrobin
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b54d7ba8-4e84-4cd8-8751-5796862262ca
location_href: 00011189-python-roundrobin/python-roundrobin-0.0.4-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/linnik/roundrobin.svg?branch=master)](https://travis-ci.org/linnik/roundrobin)
  [![PyPI install](https://img.shields.io/badge/pip%20install-roundrobin-informational)](https://pypi.org/project/roundrobin/)
  ![versions](https://img.shields.io/pypi/pyversions/roundrobin.svg)



  This is rather small collection of round robin utilites

  ```python
  >>> import roundrobin
  >>> get_roundrobin = roundrobin.basic(["A", "B", "C"])
  >>> ''.join([get_roundrobin() for _ in range(7)])
  'ABCABCA'
  >>> # weighted round-robin balancing algorithm as seen in LVS
  >>> get_weighted = roundrobin.weighted([("A", 5), ("B", 1), ("C", 1)])
  >>> ''.join([get_weighted() for _ in range(7)])
  'AAAAABC'
  >>> # smooth weighted round-robin balancing algorithm as seen in Nginx
  >>> get_weighted_smooth = roundrobin.smooth([("A", 5), ("B", 1), ("C", 1)])
  >>> ''.join([get_weighted_smooth() for _ in range(7)])
  'AABACAA'
  ```


pkgId: 9d29c8be0b306acd4bfed0baaabc77f3678ba30d2223cc36bbde532721ca79e4
name: python-rpdb
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: pdb wrapper with remote access via tcp socket
url: http://tamentis.com/projects/rpdb
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d46e5509-d4fe-4f8d-888c-e4a1e121e9d7
location_href: 00005000-python-rpdb/python-rpdb-0.1.6-1.src.rpm
checksum_type: sha256
description:
  rpdb is a wrapper around pdb that re-routes stdin and stdout to a socket
  handler. By default it opens the debugger on port 4444::
      import rpdb; rpdb.set_trace()
  But you can change that by simply instantiating Rpdb manually::
      import rpdb
      debugger = rpdb.Rpdb(port=12345)
      debugger.set_trace()
  It is known to work on Jython 2.5 to 2.7, Python 2.5 to 3.1. It was written
  originally for Jython since this is pretty much the only way to debug it when
  running it on Tomcat.
  Upon reaching `set_trace()`, your script will "hang" and the only way to get it
  to continue is to access rpdb using telnet, netcat, etc..::
      nc 127.0.0.1 4444


pkgId: e5ad99fb3d4bcd8d321e6cdd2bf6cafe75e310385510a30f85572d1a26be7bff
name: python-rpkg
arch: src
version: 1.66
epoch: 0
release: 1
summary: A python library and runtime script for managing RPMpackage sources in a git repository
url: https://pagure.io/rpkg
rpm_license: GPLv2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bc3f650f-0002-42d1-a43b-2c1f5c78709e
location_href: 00005001-python-rpkg/python-rpkg-1.66-1.src.rpm
checksum_type: sha256
description:
  This is the rpkg project, which mostly is a python library for dealing with
  rpm packaging in a git source control.  pyrpkg is the base library that sites
  can subclass to create useful tools.
  rpkg works with Python 2.7, 3.6, 3.9, 3.10 and 3.11.


pkgId: e6904f3aea12141feb59efb70bdd257a357ead4dbdc95b92ab9ed9c868fc7a7b
name: python-rply
arch: src
version: 0.7.8
epoch: 0
release: 1
summary: A pure Python Lex/Yacc that works with RPython
url: https://pypi.org/project/rply/
rpm_license: BSD 3-Clause License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7e79b080-9d26-4b41-911b-1233ff0bd4e9
location_href: 00005002-python-rply/python-rply-0.7.8-1.src.rpm
checksum_type: sha256
description:
  Welcome to RPLY! A pure Python parser generator, that also works with RPython.
  It is a more-or-less direct port of David Beazley's awesome PLY, with a new
  public API, and RPython support.
  You can find the documentation `online`_.
  Basic API:
      from rply import ParserGenerator, LexerGenerator
      from rply.token import BaseBox
      lg = LexerGenerator()
      
      lg.add("PLUS", r"\+")
      lg.add("MINUS", r"-")
      lg.add("NUMBER", r"\d+")
      lg.ignore(r"\s+")
      
      
      
      
      
      
      
      pg = ParserGenerator(["NUMBER", "PLUS", "MINUS"],
              precedence=[("left", ['PLUS', 'MINUS'])], cache_id="myparser")
      @pg.production("main : expr")
      def main(p):
          
          
          return p[0]
      @pg.production("expr : expr PLUS expr")
      @pg.production("expr : expr MINUS expr")
      def expr_op(p):
          lhs = p[0].getint()
          rhs = p[2].getint()
          if p[1].gettokentype() == "PLUS":
              return BoxInt(lhs + rhs)
          elif p[1].gettokentype() == "MINUS":
              return BoxInt(lhs - rhs)
          else:
              raise AssertionError("This is impossible, abort the time machine!")
      @pg.production("expr : NUMBER")
      def expr_num(p):
          return BoxInt(int(p[0].getstr()))
      lexer = lg.build()
      parser = pg.build()
      class BoxInt(BaseBox):
          def __init__(self, value):
              self.value = value
          def getint(self):
              return self.value
  Then you can do:
      parser.parse(lexer.lex("1 + 3 - 2+12-32"))
  You can also substitute your own lexer. A lexer is an object with a ``next()``
  method that returns either the next token in sequence, or ``None`` if the token
  stream has been exhausted.


pkgId: ec184bb01cf9894003fa4acda8a3c544f0b7d2d4b4c80e36fc9be68559997abe
name: python-rpmfluff
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: Lightweight way of building RPMs, and sabotaging them
url: https://pagure.io/rpmfluff
rpm_license: GPL-2.0+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6ed23ffb-b4ae-4ddc-99e4-4f3b00a1a10b
location_href: 00005008-python-rpmfluff/python-rpmfluff-0.6.2-1.src.rpm
checksum_type: sha256
description:
  rpmfluff provides a python library for building RPM packages, and
  sabotaging them so they are broken in controlled ways.

  It is intended for use when validating package analysis tools such as RPM lint.
  It can also be used to construct test cases for package management software
  such as RPM, YUM, and DNF.


pkgId: ebe60c4d14bd0c2c267be54f8b2544b1de26558a2c97c5ce28ad6b531cf10713
name: python-rpyc
arch: src
version: 5.3.1
epoch: 0
release: 1
summary: Remote Python Call (RPyC) is a transparent and symmetric distributed computing library
url: https://rpyc.readthedocs.org
rpm_license: None
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0f8a9bf1-a70b-4d6f-a1d3-aad3ddac1675
location_href: 00005010-python-rpyc/python-rpyc-5.3.1-1.src.rpm
checksum_type: sha256
description:
  |Version| |Python| |Tests| |License|

  RPyC_ (pronounced like *are-pie-see*), or *Remote Python Call*, is a
  **transparent** library for **symmetrical** `remote procedure calls`_,
  clustering_, and distributed-computing_.  RPyC makes use of object-proxying_,
  a technique that employs python's dynamic nature, to overcome the physical
  boundaries between processes and computers, so that remote objects can be
  manipulated as if they were local.

  Documentation can be found at https://rpyc.readthedocs.io

  .. figure:: http://rpyc.readthedocs.org/en/latest/_images/screenshot.png
     :align: center

     A screenshot of a Windows client connecting to a Linux server.

     Note that text written to the server's ``stdout`` is actually printed on
     the server's console.


  .. References:

  .. _RPyC:                   https://github.com/tomerfiliba-org/rpyc
  .. _remote procedure calls: http://en.wikipedia.org/wiki/Remote_procedure_calls
  .. _clustering:             http://en.wikipedia.org/wiki/Clustering
  .. _distributed-computing:  http://en.wikipedia.org/wiki/Distributed_computing
  .. _object-proxying:        http://en.wikipedia.org/wiki/Proxy_pattern

  .. Badges:

  .. |Version| image::   https://img.shields.io/pypi/v/rpyc.svg?style=flat
     :target:            https://pypi.python.org/pypi/rpyc
     :alt:               Version

  .. |Python| image::    https://img.shields.io/pypi/pyversions/rpyc.svg?style=flat
     :target:            https://pypi.python.org/pypi/rpyc#downloads
     :alt:               Python Versions

  .. |Tests| image::     https://github.com/tomerfiliba-org/rpyc/actions/workflows/python-app.yml/badge.svg
     :target:            https://github.com/tomerfiliba-org/rpyc/actions/workflows/python-app.yml
     :alt:               Build Status

  .. |License| image::   https://img.shields.io/pypi/l/rpyc.svg?style=flat
     :target:            https://github.com/tomerfiliba-org/rpyc/blob/master/LICENSE
     :alt:               License: MIT


pkgId: 594d364e29bba33547bd41655ab84d9915ef8b9a261e5e9836eef00c0e94a0ba
name: python-rq-dashboard
arch: src
version: 0.6.1
epoch: 0
release: 1
url: https://github.com/Parallels/rq-dashboard
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2a73d179-f6f1-4bb8-8cfd-02f4c55e1bf2
location_href: 00013482-python-rq-dashboard/python-rq-dashboard-0.6.1-1.src.rpm
checksum_type: sha256
summary:
  rq-dashboard is a general purpose, lightweight, web interface to monitor your RQ queues, jobs, and workers in realtime.

description:
  `rq-dashboard` is a general purpose, lightweight,
  [Flask](https://flask.palletsprojects.com/)-based web front-end to monitor your
  [RQ](http://python-rq.org/) queues, jobs, and workers in realtime.
  [![Build
  Status](https://travis-ci.org/Parallels/rq-dashboard.svg?branch=master)](https://travis-ci.org/Parallels/rq-dashboard)
  [![Python
  Support](https://img.shields.io/pypi/pyversions/rq-dashboard.svg)](https://pypi.python.org/pypi/rq-dashboard)
  ![PyPI Downloads](https://img.shields.io/pypi/dw/rq-dashboard)


pkgId: 18ab02e6af270df45937521ac1cea7359dc28540d8cc96b59c1a519e1e5b088e
name: python-rsa
arch: src
version: 4.9
epoch: 0
release: 1
summary: Pure-Python RSA implementation
url: https://stuvel.eu/rsa
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1df32723-343b-49be-b3a5-c8e0c6085eea
location_href: 00008892-python-rsa/python-rsa-4.9-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/rsa.svg)](https://pypi.org/project/rsa/)
  [![Build Status](https://travis-ci.org/sybrenstuvel/python-rsa.svg?branch=master)](https://travis-ci.org/sybrenstuvel/python-rsa)
  [![Coverage Status](https://coveralls.io/repos/github/sybrenstuvel/python-rsa/badge.svg?branch=master)](https://coveralls.io/github/sybrenstuvel/python-rsa?branch=master)
  [![Code Climate](https://api.codeclimate.com/v1/badges/a99a88d28ad37a79dbf6/maintainability)](https://codeclimate.com/github/codeclimate/codeclimate/maintainability)

  [Python-RSA](https://stuvel.eu/rsa) is a pure-Python RSA implementation. It supports
  encryption and decryption, signing and verifying signatures, and key
  generation according to PKCS#1 version 1.5. It can be used as a Python
  library as well as on the commandline. The code was mostly written by
  Sybren A.  Stüvel.

  Documentation can be found at the [Python-RSA homepage](https://stuvel.eu/rsa). For all changes, check [the changelog](https://github.com/sybrenstuvel/python-rsa/blob/master/CHANGELOG.md).

  Download and install using:

      pip install rsa

  or download it from the [Python Package Index](https://pypi.org/project/rsa/).

  The source code is maintained at [GitHub](https://github.com/sybrenstuvel/python-rsa/) and is
  licensed under the [Apache License, version 2.0](https://www.apache.org/licenses/LICENSE-2.0)



  Because of how Python internally stores numbers, it is very hard (if not impossible) to make a pure-Python program secure against timing attacks. This library is no exception, so use it with care. See https://securitypitfalls.wordpress.com/2018/08/03/constant-time-compare-in-python/ for more info.



  ```
  python3 -m venv .venv
  . ./.venv/bin/activate
  pip install poetry
  poetry install
  ```



  Since this project is considered critical on the Python Package Index,
  two-factor authentication is required. For uploading packages to PyPi, an API
  key is required; username+password will not work.

  First, generate an API token at https://pypi.org/manage/account/token/. Then,
  use this token when publishing instead of your username and password.

  As username, use `__token__`.
  As password, use the token itself, including the `pypi-` prefix.

  See https://pypi.org/help/#apitoken for help using API tokens to publish. This
  is what I have in `~/.pypirc`:

  ```
  [distutils]
  index-servers =
      rsa


  [rsa]
    repository = https://upload.pypi.org/legacy/
    username = __token__
    password = pypi-token
  ```

  ```
  . ./.venv/bin/activate
  pip install twine

  poetry build
  twine check dist/rsa-4.9.tar.gz dist/rsa-4.9-*.whl
  twine upload -r rsa dist/rsa-4.9.tar.gz dist/rsa-4.9-*.whl
  ```

  The `pip install twine` is necessary as Python-RSA requires Python >= 3.6, and
  Twine requires at least version 3.7. This means Poetry refuses to add it as
  dependency.


pkgId: bdf2f4f0228197e92119fa59fc5e61f332e8c3f2ff5fc1ea91d555b2f4de88f6
name: python-rst2ansi
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: A rst converter to ansi-decorated console output
url: https://github.com/Snaipe/python-rst-to-ansi
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5a81f7b3-eb5f-414d-826a-79af1d5c0951
location_href: 00013098-python-rst2ansi/python-rst2ansi-0.1.5-1.src.rpm
checksum_type: sha256
description:
  |build| |downloads| |pyversions| |format|
  A python module dedicated to rendering RST (reStructuredText) documents
  to ansi-escaped strings suitable for display in a terminal.
  |asciicast|


pkgId: 9bb3515d4d14e33c90dae7dd7f0fcc3c70edfcb8520ef32db27514836b193584
name: python-ruamel.yaml
arch: src
version: 0.17.21
epoch: 0
release: 1
url: https://sourceforge.net/p/ruamel-yaml/code/ci/default/tree
rpm_license: MIT license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c24a39df-1c89-4ee9-95e5-2a7125d4a7f1
location_href: 00005020-python-ruamel-yaml/python-ruamel.yaml-0.17.21-1.src.rpm
checksum_type: sha256
summary:
  ruamel.yaml is a YAML parser/emitter that supports roundtrip preservation of comments, seq/map flow style, and map key order

description:
  ``ruamel.yaml`` is a YAML 1.2 loader/dumper package for Python.
  *The 0.16.13 release was the last that was tested to be working on Python 2.7.
  The 0.17.21 is the last one tested to be working on Python 3.5,
  that is also the last release supporting old PyYAML functions, you'll have to create a
  `YAML()` instance and use its `.load()` and `.dump()` methods.*
  *Please adjust your dependencies accordingly if necessary. (`ruamel.yaml<0.18`)*
  Starting with version 0.15.0 the way YAML files are loaded and dumped
  has been changing, see the API doc for details.  Currently existing
  functionality will throw a warning before being changed/removed.
  **For production systems already using a pre 0.16 version, you should
  pin the version being used with ``ruamel.yaml<=0.15``** if you cannot
  fully test upgrading to a newer version. For new usage
  pin to the minor version tested ( ``ruamel.yaml<=0.17``) or even to the
  exact version used.
  New functionality is usually only available via the new API, so
  make sure you use it and stop using the `ruamel.yaml.safe_load()`,
  `ruamel.yaml.round_trip_load()` and `ruamel.yaml.load()` functions
  (and their `....dump()` counterparts).
  If your package uses ``ruamel.yaml`` and is not listed on PyPI, drop
  me an email, preferably with some information on how you use the
  package (or a link to the repository) and I'll keep you informed
  when the status of the API is stable enough to make the transition.
  * `Overview <http://yaml.readthedocs.org/en/latest/overview.html>`_
  * `Installing <http://yaml.readthedocs.org/en/latest/install.html>`_
  * `Basic Usage <http://yaml.readthedocs.org/en/latest/basicuse.html>`_
  * `Details <http://yaml.readthedocs.org/en/latest/detail.html>`_
  * `Examples <http://yaml.readthedocs.org/en/latest/example.html>`_
  * `API <http://yaml.readthedocs.org/en/latest/api.html>`_
  * `Differences with PyYAML <http://yaml.readthedocs.org/en/latest/pyyaml.html>`_


pkgId: 429b8b03c7cb07fb6b01e345fcdcdb2e1ad231bd0f05c9f0e93dbd39c8d41c97
name: python-rubymarshal
arch: src
version: 1.2.7
epoch: 0
release: 1
summary: Read and write Ruby-marshalled data
url: https://github.com/d9pouces/RubyMarshal
rpm_license: WTFPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a89117a4-346d-41b5-90a6-6bebad3745fc
location_href: 00011745-python-rubymarshal/python-rubymarshal-1.2.7-1.src.rpm
checksum_type: sha256
description:
  Read and write Ruby-marshalled data.
  Only basics Ruby data types can be directly read and written, but you can use any custom Python and Ruby types:
    * `float`,
    * `bool`,
    * `int`,
    * `str` (mapped to `rubymarshal.classes.RubyString` if dumped with instance variables),
    * `nil` (mapped to `None` in Python),
    * `array` (mapped to `list`),
    * `hash` (mapped to `dict`),
    * symbols and other classes are mapped to specific Python classes.


pkgId: ff44f3a5dd8a347975b5fe73c57c488371b114bddb6836dfca3c9e00f6643117
name: python-ruffus
arch: src
version: 2.8.4
epoch: 0
release: 1
summary: Light-weight Python Computational Pipeline Management
url: http://www.ruffus.org.uk
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-763b4685-497e-4c78-a3e6-c653592a4628
location_href: 00005021-python-ruffus/python-ruffus-2.8.4-1.src.rpm
checksum_type: sha256
description:
  ***************************************
  Overview
  ***************************************


      The Ruffus module is a lightweight way to add support
      for running computational pipelines.

      Computational pipelines are often conceptually quite simple, especially
      if we breakdown the process into simple stages, or separate **tasks**.

      Each stage or **task** in a computational pipeline is represented by a python function
      Each python function can be called in parallel to run multiple **jobs**.

      Ruffus was originally designed for use in bioinformatics to analyse multiple genome
      data sets.

  ***************************************
  Documentation
  ***************************************

      Ruffus documentation can be found `here <http://www.ruffus.org.uk>`__ ,
      with `download notes <http://www.ruffus.org.uk/installation.html>`__ ,
      a `tutorial <http://www.ruffus.org.uk/tutorials/new_tutorial/introduction.html>`__ and
      an `in-depth manual <http://www.ruffus.org.uk/tutorials/new_tutorial/manual_contents.html>`__ .


  ***************************************
  Background
  ***************************************

      The purpose of a pipeline is to determine automatically which parts of a multi-stage
      process needs to be run and in what order in order to reach an objective ("targets")

      Computational pipelines, especially for analysing large scientific datasets are
      in widespread use.
      However, even a conceptually simple series of steps can be difficult to set up and
      maintain.

  ***************************************
  Design
  ***************************************
      The ruffus module has the following design goals:

          * Lightweight
          * Scalable / Flexible / Powerful
          * Standard Python
          * Unintrusive
          * As simple as possible

  ***************************************
  Features
  ***************************************

      Automatic support for

          * Managing dependencies
          * Parallel jobs, including dispatching work to computational clusters
          * Re-starting from arbitrary points, especially after errors (checkpointing)
          * Display of the pipeline as a flowchart
          * Managing complex pipeline topologies


  ***************************************
  A Simple example
  ***************************************

          Use the **@follows(...)** python decorator before the function definitions::

              from ruffus import *
              import sys

              def first_task():
                  print "First task"

              @follows(first_task)
              def second_task():
                  print "Second task"

              @follows(second_task)
              def final_task():
                  print "Final task"




          the ``@follows`` decorator indicate that the ``first_task`` function precedes ``second_task`` in
          the pipeline.

          The canonical Ruffus decorator is ``@transform`` which **transforms** data flowing down a
          computational pipeline from one stage to teh next.

  ********
  Usage
  ********

      Each stage or **task** in a computational pipeline is represented by a python function
      Each python function can be called in parallel to run multiple **jobs**.

      1. Import module::

              import ruffus


      1. Annotate functions with python decorators

      2. Print dependency graph if you necessary

          - For a graphical flowchart in ``jpg``, ``svg``, ``dot``, ``png``, ``ps``, ``gif`` formats::

              pipeline_printout_graph ("flowchart.svg")

          This requires ``dot`` to be installed

          - For a text printout of all jobs ::

              pipeline_printout(sys.stdout)


      3. Run the pipeline::

          pipeline_run()


pkgId: 9a6f72f15e30afc0c2c91297bb92d75e964e43b0112d15484c6a4b3876fbe123
name: python-rules
arch: src
version: 3.3
epoch: 0
release: 1
summary: Awesome Django authorization, without the database
url: http://github.com/dfunckt/django-rules
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-487cd715-247a-41e8-8c66-992a94891bf8
location_href: 00011481-python-rules/python-rules-3.3-1.src.rpm
checksum_type: sha256
description:
  ``rules`` has got you covered. ``rules`` is:
  -   **Documented**, **tested**, **reliable** and **easy to use**.
  -   **Versatile**. Decorate callables to build complex graphs of predicates.
      Predicates can be any type of callable -- simple functions, lambdas,
      methods, callable class objects, partial functions, decorated functions,
      anything really.
  -   **A good Django citizen**. Seamless integration with Django views,
      templates and the Admin for testing for object-level permissions.
  -   **Efficient** and **smart**. No need to mess around with a database to figure
      out whether John really wrote that book.
  -   **Simple**. Dive in the code. You'll need 10 minutes to figure out how it
      works.
  -   **Powerful**. ``rules`` comes complete with advanced features, such as
      invocation context and storage for arbitrary data, skipping evaluation of
      predicates under specific conditions, logging of evaluated predicates and more!


pkgId: 855b9e10a273aabaa4b7edb17d7577647b8995b4d718425d5ed99512af7487ff
name: python-rustcfg
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Rust cfg expression parser in python
url: https://pagure.io/fedora-rust/python-rustcfg
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b763557b-0de7-4714-9469-2f493c301425
location_href: 00005022-python-rustcfg/python-rustcfg-0.0.2-1.src.rpm
checksum_type: sha256
description:
  - https://doc.rust-lang.org/reference/attributes.html#conditional-compilation
  - https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html
  - https://gitlab.com/kornelski/parse_cfg
  - https://pagure.io/fedora-rust/rust2rpm


pkgId: 663d51f83befca30e2e27b0cd6f4628c6b26756f2edff33d953ff25e36a9261f
name: python-rxjson
arch: src
version: 0.3
epoch: 0
release: 1
summary: JSON RX Schema validation tool
url: https://github.com/spiral-project/rxjson
rpm_license: GPLv2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2d8735e3-6221-430f-9f2f-bd6c14acfa4d
location_href: 00005025-python-rxjson/python-rxjson-0.3-1.src.rpm
checksum_type: sha256
description:
  When adding an API to your web service, you have to choose how to encode the
  data you send across the line. XML is one common choice for this, but it can
  grow arcane and cumbersome pretty quickly. Lots of webservice authors want to
  avoid thinking about XML, and instead choose formats that provide a few simple
  data types that correspond to common data structures in modern programming
  languages. In other words, JSON and YAML.
  Unfortunately, while these formats make it easy to pass around complex data
  structures, they lack a system for validation. XML has XML Schemas and RELAX
  NG, but these are complicated and sometimes confusing standards. They're not
  very portable to the kind of data structure provided by JSON, and if you wanted
  to avoid XML as a data encoding, writing more XML to validate the first XML is
  probably even less appealing.
  Rx is meant to provide a system for data validation that matches up with
  JSON-style data structures and is as easy to work with as JSON itself.


pkgId: 9e5a20bab1dfe995d40daacd7c12b6407249c5f1b5211d0ea755f54618c1af5b
name: python-ryu
arch: src
version: 4.34
epoch: 0
release: 1
summary: Component-based Software-defined Networking Framework
url: http://osrg.github.io/ryu/
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3f1bf48b-9c61-42ba-839f-b3e7c6558532
location_href: 00005026-python-ryu/python-ryu-4.34-1.src.rpm
checksum_type: sha256
description:
  Ryu is a component-based software defined networking framework.
  Ryu provides software components with well defined API's that make it
  easy for developers to create new network management and control
  applications. Ryu supports various protocols for managing network
  devices, such as OpenFlow, Netconf, OF-config, etc. About OpenFlow,
  Ryu supports fully 1.0, 1.2, 1.3, 1.4, 1.5 and Nicira Extensions.
  All of the code is freely available under the Apache 2.0 license. Ryu
  is fully written in Python.


pkgId: 1e007824b908edd53de881ed43ea12bf8792532dab2209783fe54165870295db
name: python-s2sphere
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: Python implementation of the S2 Geometry Library
url: http://s2sphere.readthedocs.io
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c3992021-4157-4a7c-bfbc-331f8729950d
location_href: 00010691-python-s2sphere/python-s2sphere-0.2.5-1.src.rpm
checksum_type: sha256
description:
  Python implementation of a part of the C++ `S2 geometry library <https://code.google.com/p/s2-geometry-library/>`_.
  Links: `Documentation <http://s2sphere.readthedocs.io>`_,
  `GitHub <https://github.com/sidewalklabs/s2sphere>`_,
  `Issue Tracker <https://github.com/sidewalklabs/s2sphere/issues>`_
  Install with:
      pip install s2sphere
  Quick set up for development (see the `Developing section in the docs <http://s2sphere.readthedocs.io/en/latest/dev.html>`_ for more details):
      pip install .[tests]
      nosetests -vv


pkgId: 8620af5e505e40c370eb720030684cff275cb0685e523423d7b592b7303acbfd
name: python-s3cmd
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: Command line tool for managing Amazon S3 and CloudFront services
url: http://s3tools.org
rpm_license: GNU GPL v2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-22d0ed16-f236-4142-9861-aaf7e96f90f0
location_href: 00009460-python-s3cmd/python-s3cmd-2.3.0-1.src.rpm
checksum_type: sha256
description:
      Florent Viard <florent@sodria.com>
      Michal Ludvig  <michal@logix.cz>
      Matt Domsch (github.com/mdomsch)


pkgId: aa83ce6494a54869e39ba9f0c2298789b57f6368220ba7d7c30be3ce9633026c
name: python-s3path
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/liormizr/s3path
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6f0a6193-8b0b-4503-9b63-f45eee41a11c
location_href: 00013635-python-s3path/python-s3path-0.4.1-1.src.rpm
checksum_type: sha256
description:
  S3Path provide a Python convenient File-System/Path like interface for AWS S3 Service using boto3 S3 resource as a driver.
  Like pathlib, but for S3 Buckets
  ________________________________
  AWS S3 is among the most popular cloud storage solutions. It's object storage, is built to store and retrieve various amounts of data from anywhere.
  Currently, Python developers use Boto3 as the default API to connect / put / get / list / delete files from S3.
  S3Path blends Boto3's ease of use and the familiarity of pathlib api.


pkgId: 1e4a3cb40f387e9a0f602925132445c570f3d5b75d0e7010cf0cca9ba6f2aec6
name: python-sacred
arch: src
version: 0.8.4
epoch: 0
release: 1
summary: Facilitates automated and reproducible experimental research
url: https://github.com/IDSIA/sacred
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-df81fc79-5f95-4cc8-896c-9f57ed711fdd
location_href: 00013603-python-sacred/python-sacred-0.8.4-1.src.rpm
checksum_type: sha256
description:
      | *Every experiment is sacred*
      | *Every experiment is great*
      | *If an experiment is wasted*
      | *God gets quite irate*
  |pypi| |py_versions| |license| |rtfd| |doi|
  |build| |coverage| |code_quality| |black|
  Sacred is a tool to help you configure, organize, log and reproduce experiments.
  It is designed to do all the tedious overhead work that you need to do around
  your actual experiment in order to:
  - keep track of all the parameters of your experiment
  - easily run your experiment for different settings
  - save configurations for individual runs in a database
  - reproduce your results
  Sacred achieves this through the following main mechanisms:
  -  **Config Scopes** A very convenient way of the local variables in a function
     to define the parameters your experiment uses.
  -  **Config Injection**: You can access all parameters of your configuration
     from every function. They are automatically injected by name.
  -  **Command-line interface**: You get a powerful command-line interface for each
     experiment that you can use to change parameters and run different variants.
  -  **Observers**: Sacred provides Observers that log all kinds of information
     about your experiment, its dependencies, the configuration you used,
     the machine it is run on, and of course the result. These can be saved
     to a MongoDB, for easy access later.
  -  **Automatic seeding** helps controlling the randomness in your experiments,
     such that the results remain reproducible.


pkgId: 5ff32424c5efefee808dd434ee64a2ff79fc568489f89f190394033045aa6027
name: python-sailthru-client
arch: src
version: 2.3.5
epoch: 0
release: 1
summary: Python client for Sailthru API
url: https://github.com/sailthru/sailthru-python-client
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-19bff1ef-6d7e-411a-9fe2-98e9b4deb9f8
location_href: 00011508-python-sailthru-client/python-sailthru-client-2.3.5-1.src.rpm
checksum_type: sha256
description:
  For installation instructions, documentation, and examples please visit:
  [http://getstarted.sailthru.com/new-for-developers-overview/api-client-library/python](http://getstarted.sailthru.com/new-for-developers-overview/api-client-library/python)
  A simple client library to remotely access the `Sailthru REST API` as per [http://getstarted.sailthru.com/api](http://getstarted.sailthru.com/developers/api)
  Python binding for [Sailthru API](http://getstarted.sailthru.com/api) based on [Requests](http://docs.python-requests.org/en/latest/)
  It will make requests in `JSON` format.
  Supports Python 2.6, 2.7, 3.3+

  Installing with [pip](http://www.pip-installer.org/):
      pip install sailthru-client

  Install tox and then type:
      tox

  Here is an example how to check rate limiting and throttle API calls based on that. For more information about Rate Limiting, see [Sailthru Documentation](https://getstarted.sailthru.com/new-for-developers-overview/api/api-technical-details/#Rate_Limiting)
  ```python
  sailthru_client = SailthruClient(api_key, api_secret)

  rate_limit_info = sailthru_client.get_last_rate_limit_info('user', 'POST')

  if rate_limit_info is not None:
      limit = rate_limit_info['limit'];
      remaining = rate_limit_info['remaining'];
      reset_timestamp = rate_limit_info['reset'];
      
      if remaining <= 0:
           seconds_till_reset = reset_timestamp - time.time()
           
           time.sleep(seconds_till_reset);
  ```


pkgId: 47eddd253df45f3293dd2c9518dd565401580055612c0e6c40de0d5871281731
name: python-salesforce-api
arch: src
version: 0.1.45
epoch: 0
release: 1
summary: Salesforce API wrapper
url: https://github.com/felixlindstrom/python-salesforce-api
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-19e7230a-2478-41bb-82b7-16be026d3699
location_href: 00012575-python-salesforce-api/python-salesforce-api-0.1.45-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/felixlindstrom/python-salesforce-api.svg?branch=master)](https://travis-ci.org/felixlindstrom/python-salesforce-api)
  This project aims to provide an easy to use, highly flexible and testable solution for communicating with Salesforce
  through its REST and SOAP api.


pkgId: 65be202ce2e23bdb16dd42e92b1976cc23fb4920b22eb456923cd55ea983924e
name: python-salt
arch: src
version: 3005.1
epoch: 0
release: 1
summary: Portable, distributed, remote execution and configuration management system
url: https://saltproject.io
rpm_license: Apache Software License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6b5e5109-b4ec-4c75-a4ae-226a32f5cd9c
location_href: 00011640-python-salt/python-salt-3005.1-1.src.rpm
checksum_type: sha256
description:
  Built on python, Salt uses simple and human-readable YAML combined with
  event-driven automation to deploy and configure complex IT systems. In addition
  to leveling-up `vRealize Automation SaltStack Config`_, Salt can be found under
  the hood of products from Juniper, Cisco, Cloudflare, Nutanix, SUSE, and Tieto,
  to name a few.


pkgId: c530addfebb564cabc2babf4ba4fa3b6c9d1c66b926f781e4ea84ba34ec0f1f2
name: python-samba
arch: src
version: 0.0.0
epoch: 0
release: 1
summary: A very small PaaS to do git push app deployments to your own servers, similar to Heroku
url: https://github.com/mardix/samba/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9a12c8de-5329-48ae-9d18-a5ce08ed2a57
location_href: 00005028-python-samba/python-samba-0.0.0-1.src.rpm
checksum_type: sha256
description:
  Samba

  A small PAAS to deploy Flask/Django, Node, PHP and Static HTML sites using GIT, similar to Heroku

  https://github.com/mardix/samba/


pkgId: 0e5d47a99ca8c5610e0deaef096d498711a47ba745a1317604f10ffcda58dbd2
name: python-sanic
arch: src
version: 23.3.0
epoch: 0
release: 1
summary: A web server and web framework that's written to go fast. Build fast. Run fast.
url: http://github.com/sanic-org/sanic/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a0de9d74-7589-43aa-b4db-09370e7ac58b
location_href: 00009237-python-sanic/python-sanic-23.3.0-1.src.rpm
checksum_type: sha256
description:
      * - Build
        - | |Py310Test| |Py39Test| |Py38Test| |Py37Test|
      * - Docs
        - | |UserGuide| |Documentation|
      * - Package
        - | |PyPI| |PyPI version| |Wheel| |Supported implementations| |Code style black|
      * - Support
        - | |Forums| |Discord| |Awesome|
      * - Stats
        - | |Downloads| |WkDownloads| |Conda downloads|
  Sanic is a **Python 3.7+** web server and web framework that's written to go fast. It allows the usage of the ``async/await`` syntax added in Python 3.5, which makes your code non-blocking and speedy.
  Sanic is also ASGI compliant, so you can deploy it with an `alternative ASGI webserver <https://sanicframework.org/en/guide/deployment/running.html#asgi>`_.
  `Source code on GitHub <https://github.com/sanic-org/sanic/>`_ | `Help and discussion board <https://community.sanicframework.org/>`_ | `User Guide <https://sanicframework.org>`_ | `Chat on Discord <https://discord.gg/FARQzAEMAA>`_
  The project is maintained by the community, for the community. **Contributions are welcome!**
  The goal of the project is to provide a simple way to get up and running a highly performant HTTP server that is easy to build, to expand, and ultimately to scale.


pkgId: 0e4b8f38e64944050c6f4bd256b842065e9ff76d4cc9e99e65f1660f144a849e
name: python-sanic-jwt
arch: src
version: 1.8.0
epoch: 0
release: 1
summary: JWT oauth flow for Sanic
url: https://github.com/ahopkins/sanic-jwt
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-908301aa-a9bb-4bcb-9608-0af8217ef25b
location_href: 00012180-python-sanic-jwt/python-sanic-jwt-1.8.0-1.src.rpm
checksum_type: sha256
description:
  **What do I do?**
  It's easy: (1) install, (2) initialize, and (3) authenticate.
  **Install:**
  ```
  pip install sanic-jwt
  ```
    [Sanic]: http://sanic.readthedocs.io
    [JWT]: https://jwt.io
  **Initialize:**
  ```python
  from sanic import Sanic
  from sanic_jwt import Initialize
  def my_authenticate(request, *args, **kwargs):
  app = Sanic()
  Initialize(
      app,
      authenticate=my_authenticate
  )
  ```
  **Authenticate:**


pkgId: 2ac75ee851b0e484289b01a98b75d7e14eb5c410111421a59f13b4d149849550
name: python-sanic-openapi
arch: src
version: 21.12.0
epoch: 0
release: 1
summary: Easily document your Sanic API with a UI.
url: http://github.com/sanic-org/sanic-openapi/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5694c888-a641-471a-8c62-8de0563fb8ad
location_href: 00012885-python-sanic-openapi/python-sanic-openapi-21.12.0-1.src.rpm
checksum_type: sha256
description:
  ⚠️ This package is being replaced by [Sanic Extensions](https://sanicframework.org/en/plugins/sanic-ext/getting-started.html). The project will continue to be monitored, but no new features or major development is anticipated. Sanic Extensions contains a near 1:1 upgrade if you are using Sanic OpenAPI with OAS3. Ask in the [forums](https://community.sanicframework.org/) or [discord server](https://discord.gg/FARQzAEMAA) for questions about upgrading.



  [![Build Status](https://travis-ci.com/sanic-org/sanic-openapi.svg?branch=master)](https://travis-ci.com/sanic-org/sanic-openapi)
  [![PyPI](https://img.shields.io/pypi/v/sanic-openapi.svg)](https://pypi.python.org/pypi/sanic-openapi/)
  [![PyPI](https://img.shields.io/pypi/pyversions/sanic-openapi.svg)](https://pypi.python.org/pypi/sanic-openapi/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/python/black)
  [![codecov](https://codecov.io/gh/sanic-org/sanic-openapi/branch/master/graph/badge.svg)](https://codecov.io/gh/sanic-org/sanic-openapi)

  Give your Sanic API a UI and OpenAPI documentation, all for the price of free!

  ![Example Swagger UI](docs/_static/images/code-to-ui.png?raw=true "Swagger UI")

  Check out [open collective](https://opencollective.com/sanic-org) to learn more about helping to fund Sanic.




  ```shell
  pip install sanic-openapi
  ```

  Add Swagger UI with the OpenAPI spec:

  ```python
  from sanic_openapi import swagger_blueprint

  app.blueprint(swagger_blueprint)
  ```

  You'll now have a Swagger UI at the URL `/swagger/` and an OpenAPI 2.0 spec at `/swagger/swagger.json`.
  Your routes will be automatically categorized by their blueprints.



  Here is an example to use Sanic-OpenAPI 2:

  ```python
  from sanic import Sanic
  from sanic.response import json
  from sanic_openapi import openapi2_blueprint

  app = Sanic(name="AwesomeApi")
  app.blueprint(openapi2_blueprint)


  @app.route("/")
  async def test(request):
      return json({"hello": "world"})


  if __name__ == "__main__":
      app.run(host="0.0.0.0", port=8000)

  ```

  And you can get your Swagger document at <http://localhost:8000/swagger> like this:
  ![](docs/_static/images/hello_world_example.png)




  Here is an example to use Sanic-OpenAPI 3:

  ```python
  from sanic import Sanic
  from sanic.response import json
  from sanic_openapi import openapi3_blueprint

  app = Sanic(name="AwesomeApi")
  app.blueprint(openapi3_blueprint)


  @app.route("/")
  async def test(request):
      return json({"hello": "world"})


  if __name__ == "__main__":
      app.run(host="0.0.0.0", port=8000)

  ```

  And you can get your Swagger document at <http://localhost:8000/swagger> like this:
  ![](docs/_static/images3/hello_world_example.png)



  Please check the documentation on [Readthedocs](https://sanic-openapi.readthedocs.io)



  Any contribution is welcome. If you don't know how to getting started, please check issues first and check our [Contributing Guide](CONTRIBUTING.md) to start you contribution.


pkgId: 4c1230583a1eaa86a582d96dcf5bc09dbe7e6c5d1eea95e9e63bda2ce2444522
name: python-sanic-routing
arch: src
version: 22.8.0
epoch: 0
release: 1
summary: Core routing component for Sanic
url: https://github.com/sanic-org/sanic-routing/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8603c01f-dc89-4bcd-8c44-0a8e0888e12d
location_href: 00009317-python-sanic-routing/python-sanic-routing-22.8.0-1.src.rpm
checksum_type: sha256
description:
  Beginning in v21.3, Sanic makes use of this new AST-style router in two use cases:

  1. Routing paths; and
  2. Routing signals.

  Therefore, this package comes with a `BaseRouter` that needs to be subclassed in order to be used for its specific needs.

  Most Sanic users should never need to concern themselves with the details here.



  A simple implementation:

  ```python
  import logging

  from sanic_routing import BaseRouter

  logging.basicConfig(level=logging.DEBUG)


  class Router(BaseRouter):
      def get(self, path, *args, **kwargs):
          return self.resolve(path, *args, **kwargs)


  router = Router()

  router.add("/<foo>", lambda: ...)
  router.finalize()
  router.tree.display()
  logging.info(router.find_route_src)

  route, handler, params = router.get("/matchme", method="BASE", extra=None)
  ```

  The above snippet uses `router.tree.display()` to show how the router has decided to arrange the routes into a tree. In this simple example:

  ```
  <Node: level=0>
      <Node: part=__dynamic__:str, level=1, groups=[<RouteGroup: path=<foo:str> len=1>], dynamic=True>
  ```

  We can can see the code that the router has generated for us. It is available as a string at `router.find_route_src`.

  ```python
  def find_route(path, method, router, basket, extra):
      parts = tuple(path[1:].split(router.delimiter))
      num = len(parts)

      
      if num == 1:  # CHECK 1
          try:
              basket['__matches__'][0] = str(parts[0])
          except ValueError:
              pass
          else:
              
              return router.dynamic_routes[('<__dynamic__:str>',)][0], basket
      raise NotFound
  ```

  _FYI: If you are on Python 3.9, you can see a representation of the source after compilation at `router.find_route_src_compiled`_



  Therefore, in general implementation requires you to:

  1. Define a router with a `get` method;
  2. Add one or more routes;
  3. Finalize the router (`router.finalize()`); and
  4. Call the router's `get` method.

  _NOTE: You can call `router.finalize(False)` if you do not want to compile the source code into executable form. This is useful if you only intend to review the generated output._

  Every time you call `router.add` you create one (1) new `Route` instance. Even if that one route is created with multiple methods, it generates a single instance. If you `add()` another `Route` that has a similar path structure (but, perhaps has differen methods) they will be grouped together into a `RouteGroup`. It is worth also noting that a `RouteGroup` is created the first time you call `add()`, but subsequent similar routes will reuse the existing grouping instance.


  When you call `finalize()`, it is taking the defined route groups and arranging them into "nodes" in a hierarchical tree. A single node is a path segment. A `Node` instance can have one or more `RouteGroup` on it where the `Node` is the termination point for that path.

  Perhaps an example is easier:

  ```python
  router.add("/path/to/<foo>", lambda: ...)
  router.add("/path/to/<foo:int>", lambda: ...)
  router.add("/path/to/different/<foo>", lambda: ...)
  router.add("/path/to/different/<foo>", lambda: ..., methods=["one", "two"])
  ```

  The generated `RouteGroup` instances (3):

  ```
  <RouteGroup: path=path/to/<foo:str> len=1>
  <RouteGroup: path=path/to/<foo:int> len=1>
  <RouteGroup: path=path/to/different/<foo:str> len=2>
  ```

  The generated `Route` instances (4):

  ```
  <Route: path=path/to/<foo:str>>
  <Route: path=path/to/<foo:int>>
  <Route: path=path/to/different/<foo:str>>
  <Route: path=path/to/different/<foo:str>>
  ```

  The Node Tree:

  ```
  <Node: level=0>
      <Node: part=path, level=1>
          <Node: part=to, level=2>
              <Node: part=different, level=3>
                  <Node: part=__dynamic__:str, level=4, groups=[<RouteGroup: path=path/to/different/<foo:str> len=2>], dynamic=True>
              <Node: part=__dynamic__:int, level=3, groups=[<RouteGroup: path=path/to/<foo:int> len=1>], dynamic=True>
              <Node: part=__dynamic__:str, level=3, groups=[<RouteGroup: path=path/to/<foo:str> len=1>], dynamic=True>
  ```

  And, the generated source code:

  ```python
  def find_route(path, method, router, basket, extra):
      parts = tuple(path[1:].split(router.delimiter))
      num = len(parts)

      
      if num > 1:  # CHECK 1
          if parts[0] == "path":  # CHECK 4

              
              if num > 2:  # CHECK 1
                  if parts[1] == "to":  # CHECK 4

                      
                      if num > 3:  # CHECK 1
                          if parts[2] == "different":  # CHECK 4

                              
                              if num == 4:  # CHECK 1
                                  try:
                                      basket['__matches__'][3] = str(parts[3])
                                  except ValueError:
                                      pass
                                  else:
                                      if method in frozenset({'one', 'two'}):
                                          route_idx = 0
                                      elif method in frozenset({'BASE'}):
                                          route_idx = 1
                                      else:
                                          raise NoMethod
                                      
                                      return router.dynamic_routes[('path', 'to', 'different', '<__dynamic__:str>')][route_idx], basket

                      
                      if num >= 3:  # CHECK 1
                          try:
                              basket['__matches__'][2] = int(parts[2])
                          except ValueError:
                              pass
                          else:
                              if num == 3:  # CHECK 5
                                  
                                  return router.dynamic_routes[('path', 'to', '<__dynamic__:int>')][0], basket

                      
                      if num >= 3:  # CHECK 1
                          try:
                              basket['__matches__'][2] = str(parts[2])
                          except ValueError:
                              pass
                          else:
                              if num == 3:  # CHECK 5
                                  
                                  return router.dynamic_routes[('path', 'to', '<__dynamic__:str>')][0], basket
      raise NotFound
  ```



  The above example only shows routes that have a dynamic path segment in them (example: `<foo>`). But, there are other use cases that are covered differently:

  1. *fully static paths* - These are paths with no parameters (example: `/user/login`). These are basically matched against a key/value store.
  2. *regex paths* - If a route as a single regular expression match, then the whole route will be matched via regex. In general, this happens inline not too dissimilar than what we see in the above example.
  3. *special regex paths* - The router comes with a special `path` type (example: `<foo:path>`) that can match on an expanded delimiter. This is also true for any regex that uses the path delimiter in it. These cannot be matched in the normal course since they are of unknown length.


pkgId: 619a7e5966af4355955549ebe5ef39cbadaa45b2a2bc8ae1557c1510cc859ad7
name: python-saspy
arch: src
version: 5.0.2
epoch: 0
release: 1
summary: A Python interface to SAS
url: https://github.com/sassoftware/saspy
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a4398284-8d7f-4f8c-aa6e-d52ee20a0466
location_href: 00013163-python-saspy/python-saspy-5.0.2-1.src.rpm
checksum_type: sha256
description:
  ![224493-SASPy-logo-OL-01](https://user-images.githubusercontent.com/17710182/171252212-4af121a6-72d9-4234-b6cf-2a0d31eb8bf7.png)


  This package provides interfaces between Python and SAS. This package enables a Python developer to create mixed Python/SAS workflows to leverage the
  powers of both SAS and Python, by connecting a Python process to any of a variety of SAS deployments, where it will run SAS code. The SAS code is
  generated by the SASPy object and methods or explicitly user written. Results from SAS are returned as text, HTML5 documents (via SAS ODS), or as
  Pandas Data Frames. This package supports running analytics and returning the resulting graphics and result data to the Python process. It can convert
  data representations between SAS Data Sets and Pandas Data Frames.

  This package has multiple access methods which allow it to connect to local or remote Linux SAS, IOM SAS on Windows, Linux (Including Grid Manager),
  or MVS, and local PC SAS. It can run within various Notebooks platforms, or IDE's/UI's or in interactive line mode Python or in Python batch scripts.

  It is expected that the user community can, and will, contribute enhancements.


  [![OpenSSF Best Practices](https://bestpractices.coreinfrastructure.org/projects/6716/badge)](https://bestpractices.coreinfrastructure.org/projects/6716)


  - Python3.x or above
  - SAS 9.4 or above
  - SAS Viya 3 or above


  - Linux SAS: local or remote, including Grid Manager
  - Windows SAS: local or remote
  - MVS SAS: remote
  - Jupyter, Databricks and/or Zeppelin Notebooks
  - Interactive Line mode, Python IDE's or other UI's
  - Batch Python scripts



  This package can be installed via pip or Conda. This will pull down the latest PyPI package and install it.

      pip install saspy

  However, if that's too easy, you can also download a specific release from
  [SASpy project releases page](https://github.com/sassoftware/saspy/releases), or just clone
  the repo and and instll from that. To install a given release, use the following,
  where the X.X.X is the release version you want.

      pip install https://github.com/sassoftware/saspy/archive/vX.X.X.tar.gz



  All of the doc, including install and configuration information can be found at
  [sassoftware.github.io/saspy](https://sassoftware.github.io/saspy/).

  Also, example Notebooks and use cases can be found at
  [sassoftware/saspy-examples](https://github.com/sassoftware/saspy-examples/).


  The [Contributing](https://github.com/sassoftware/saspy/blob/main/CONTRIBUTING.md) file explains the rules and conventions to follow while
  Contributing to this project. It also contains the **Contributor Agreement** instructions.


  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of
  the License at [LICENSE.txt](https://github.com/sassoftware/saspy/blob/main/LICENSE.md)

  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES
  OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


  - [Python Website](http://www.python.org/)
  - [SASPy Documentation](https://sassoftware.github.io/saspy/).
  - [SASPy Examples](https://github.com/sassoftware/saspy-examples)


pkgId: 465e99067ceb6d79baaa5a2344c5c7a1de513eaf467563d5bf928392f4252577
name: python-sbvirtualdisplay
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: A customized pyvirtualdisplay for SeleniumBase.
url: https://github.com/mdmintz/sbVirtualDisplay
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f6d7a846-f49e-406e-92fc-bd2e7e181e44
location_href: 00012368-python-sbvirtualdisplay/python-sbvirtualdisplay-1.2.0-1.src.rpm
checksum_type: sha256
description:
  A customized [pyvirtualdisplay](https://github.com/ponty/PyVirtualDisplay) for use with [SeleniumBase](https://github.com/seleniumbase/SeleniumBase) automation.



  ```python
  from sbvirtualdisplay import Display

  display = Display(visible=0, size=(1440, 1880))
  display.start()



  display.stop()
  ```



  ```python
  with Display(visible=0, size=(1440, 1880)):
      
      ...
  ```



  If you need to run browser tests on a headless machine (such as a Linux backend), and you can't use a browser's headless mode (such as Chrome's headless mode), then this may help. For example, Chrome does not allow extensions in headless mode, so if you need to run automated tests on a headless Linux machine and you need to use Chrome extensions, then this will let you run those tests using a virtual display.




  * [Xvfb](https://en.wikipedia.org/wiki/Xvfb) is required for this to work.


pkgId: 1b127ff35fe7fdbb948cea991306aa9f294290046752643c8453e319a0c09fcd
name: python-scalesec-gcp-workload-identity
arch: src
version: 1.0.7
epoch: 0
release: 1
summary: This package enables AWS->GCP federation with two lines of code
url: https://github.com/ScaleSec/gcp-workload-identity-federation
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6e59764b-36c9-4fcf-b966-1f6c61fef645
checksum_type: sha256
description:
  [![.github/workflows/python-linter.yml](https://github.com/ScaleSec/gcp-workload-identity-federation/actions/workflows/python-linter.yml/badge.svg)](https://github.com/ScaleSec/gcp-workload-identity-federation/actions/workflows/python-linter.yml) [![CodeQL](https://github.com/ScaleSec/gcp-workload-identity-federation/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/ScaleSec/gcp-workload-identity-federation/actions/workflows/codeql-analysis.yml)

  This package provides a python module to federate access from AWS to GCP using Workload Identity. View our [blog](https://scalesec.com/blog/access-gcp-from-aws-using-workload-identity-federation/) for additional details.


  * A GCP service account (environment variable "GCP_SERVICE_ACCOUNT_EMAIL")
  * An AWS IAM role (environment variable "AWS_ROLE_NAME")
  * AWS credentials (environment variable "AWS_PROFILE")
  * python3.x



  ```bash

  make setup
  source .venv/bin/activate
  pip install scalesec-gcp-workload-identity
  ```

  ```bash

  mv .env.example .env
  ```

  ```bash

  cat <<EOF >.env

  export GCP_PROJECT_NUMBER=
  export GCP_PROJECT_ID=


  export GCP_WORKLOAD_ID=
  export GCP_WORKLOAD_PROVIDER=
  export GCP_SERVICE_ACCOUNT_EMAIL=


  export AWS_REGION=
  export AWS_ACCOUNT_ID=
  export AWS_ROLE_NAME=


  export TOKEN_LIFETIME=
  export TOKEN_SCOPES=
  EOF
  ```

  ```bash

  source .env
  ```

  ```bash

  gcloud auth login


  gcloud config set project $GCP_PROJECT_ID


  gcloud services enable sts.googleapis.com


  gcloud services enable iamcredentials.googleapis.com




  gcloud beta iam workload-identity-pools create "$GCP_WORKLOAD_ID" \
    --location="global" \
    --description="$GCP_WORKLOAD_ID" \
    --display-name="$GCP_WORKLOAD_ID"


  gcloud beta iam workload-identity-pools providers create-aws "$GCP_WORKLOAD_PROVIDER" \
    --location="global" \
    --workload-identity-pool="$GCP_WORKLOAD_ID" \
    --account-id="$AWS_ACCOUNT_ID"


  gcloud iam service-accounts add-iam-policy-binding $GCP_SERVICE_ACCOUNT_EMAIL \
    --role roles/iam.workloadIdentityUser \
    --member "principalSet://iam.googleapis.com/projects/$GCP_PROJECT_NUMBER/locations/global/workloadIdentityPools/$GCP_WORKLOAD_ID/attribute.aws_role/arn:aws:sts::${AWS_ACCOUNT_ID}:assumed-role/$AWS_ROLE_NAME"
  ```



  Set your AWS credentials

  ```bash
  export AWS_PROFILE=xyz
  ```

  Getting a Service Account token is now simple:

  ```python
  from scalesec_gcp_workload_identity.main import TokenService
  from os import getenv





  token_service = TokenService(
    gcp_project_number=getenv('GCP_PROJECT_NUMBER'),
    gcp_workload_id=getenv('GCP_WORKLOAD_ID'),
    gcp_workload_provider=getenv('GCP_WORKLOAD_PROVIDER'),
    gcp_service_account_email=getenv('GCP_SERVICE_ACCOUNT_EMAIL'),
    aws_account_id=getenv('AWS_ACCOUNT_ID'),
    aws_role_name=getenv('AWS_ROLE_NAME'),
    aws_region=getenv('AWS_REGION'),
    gcp_token_lifetime=getenv('TOKEN_LIFETIME'), # Not required
    gcp_token_scopes=getenv('TOKEN_SCOPES') # Not required
  )

  sa_token, expiry_date = token_service.get_token()
  ```



  The default expiration for a service account token is 1h in GCP. This behavior can be changed by overriding the environment variable `TOKEN_LIFETIME` in the `.env` file. By default, GCP does not allow tokens to have an expiry over 1 hour and an organization policy __must__ be updated for this change to take affect. The organization policy is called `iam.allowServiceAccountCredentialLifetimeExtension` and it accepts a list of service accounts that are allowed to have an > 1 hr token.

  ```bash

  gcloud org-policies set-policy policy.yaml


  name: projects/1234567890/policies/iam.allowServiceAccountCredentialLifetimeExtension
  spec:
    etag: BwXBMNmIrQg=
    rules:
    - values:
        allowedValues:
        - your-sa@yourproject.iam.gserviceaccount.com
  ```



  The default scope for the service account token is `https://www.googleapis.com/auth/cloud-platform`. This behaviour can be overridden to enable a different set of scopes by using the environment variable `TOKEN_SCOPES` in the `.env` file with a comma-separated list of GCP scopes.



  ```shell

  make setup
  ```

  Edit `.env` with your values

  ```shell

  make dev


  make test
  ```



  To test that your code will pass the lint and code quality GitHub action:

  * Clone the repository locally
  * Make your updates
  * From the root of the repository, execute:
  ```bash
  pylint --rcfile .github/workflows/configs/.pylintrc scalesec_gcp_workload_identity tests examples
  ```



  We have provided [examples](./examples) on how to use the service account access token generated by this module. Access tokens are mainly used via an API call or using `curl` on the CLI.



  By default, any GCP user with the `roles/iam.workloadIdentityPoolAdmin` or `roles/owner` role is able to create a workload identity pool in your GCP organization. There are two organization policies available to help you lockdown which outside providers can have pools in your organization.

  * `constraints/iam.workloadIdentityPoolProviders ` - Accepts a list of URIs such as `https://sts.amazonaws.com` or `https://sts.windows.net/$AZURE_TENANT_ID`. For example:

  ```bash

  gcloud beta resource-manager org-policies allow constraints/iam.workloadIdentityPoolProviders \
       https://sts.amazonaws.com --organization=$ORG_ID


  gcloud beta resource-manager org-policies allow constraints/iam.workloadIdentityPoolProviders \
       https://sts.windows.net/$AZURE_TENANT_ID --organization=$ORG_ID
  ```

  * `constraints/iam.workloadIdentityPoolAwsAccounts` - Specifically focused on AWS, this constraint accepts a list of AWS account IDs. If this orgnanization policy is used, `constraints/iam.workloadIdentityPoolProviders` must either allow `https://sts.amazonaws.com` or be set to default (allow all). For example:

  ```bash

  gcloud beta resource-manager org-policies allow constraints/iam.workloadIdentityPoolAwsAccounts \
      $AWS_ACCOUNT_ID --organization=$ORG_ID
  ```



  Set your token/credentials in ~/.pypirc

  `make dist VERSION=1.x.x`



  Feedback is welcome and encouraged via a GitHub issue. Please open an issue for any bugs, feature requests, or general improvements you would like to see. Thank you in advance!

location_href:
  00012287-python-scalesec-gcp-workload-identity/python-scalesec-gcp-workload-identity-1.0.7-1.src.rpm


pkgId: e14b67a2484edaf3893757b9bb1da9d901b357c82d44d0e22635a58671fe32b9
name: python-scalesec-gcp-workload-identity-help
arch: noarch
version: 1.0.7
epoch: 0
release: 1
summary: Development documents and examples for scalesec-gcp-workload-identity
url: https://github.com/ScaleSec/gcp-workload-identity-federation
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6e59764b-36c9-4fcf-b966-1f6c61fef645
rpm_sourcerpm: python-scalesec-gcp-workload-identity-1.0.7-1.src.rpm
checksum_type: sha256
description:
  [![.github/workflows/python-linter.yml](https://github.com/ScaleSec/gcp-workload-identity-federation/actions/workflows/python-linter.yml/badge.svg)](https://github.com/ScaleSec/gcp-workload-identity-federation/actions/workflows/python-linter.yml) [![CodeQL](https://github.com/ScaleSec/gcp-workload-identity-federation/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/ScaleSec/gcp-workload-identity-federation/actions/workflows/codeql-analysis.yml)

  This package provides a python module to federate access from AWS to GCP using Workload Identity. View our [blog](https://scalesec.com/blog/access-gcp-from-aws-using-workload-identity-federation/) for additional details.


  * A GCP service account (environment variable "GCP_SERVICE_ACCOUNT_EMAIL")
  * An AWS IAM role (environment variable "AWS_ROLE_NAME")
  * AWS credentials (environment variable "AWS_PROFILE")
  * python3.x



  ```bash

  make setup
  source .venv/bin/activate
  pip install scalesec-gcp-workload-identity
  ```

  ```bash

  mv .env.example .env
  ```

  ```bash

  cat <<EOF >.env

  export GCP_PROJECT_NUMBER=
  export GCP_PROJECT_ID=


  export GCP_WORKLOAD_ID=
  export GCP_WORKLOAD_PROVIDER=
  export GCP_SERVICE_ACCOUNT_EMAIL=


  export AWS_REGION=
  export AWS_ACCOUNT_ID=
  export AWS_ROLE_NAME=


  export TOKEN_LIFETIME=
  export TOKEN_SCOPES=
  EOF
  ```

  ```bash

  source .env
  ```

  ```bash

  gcloud auth login


  gcloud config set project $GCP_PROJECT_ID


  gcloud services enable sts.googleapis.com


  gcloud services enable iamcredentials.googleapis.com




  gcloud beta iam workload-identity-pools create "$GCP_WORKLOAD_ID" \
    --location="global" \
    --description="$GCP_WORKLOAD_ID" \
    --display-name="$GCP_WORKLOAD_ID"


  gcloud beta iam workload-identity-pools providers create-aws "$GCP_WORKLOAD_PROVIDER" \
    --location="global" \
    --workload-identity-pool="$GCP_WORKLOAD_ID" \
    --account-id="$AWS_ACCOUNT_ID"


  gcloud iam service-accounts add-iam-policy-binding $GCP_SERVICE_ACCOUNT_EMAIL \
    --role roles/iam.workloadIdentityUser \
    --member "principalSet://iam.googleapis.com/projects/$GCP_PROJECT_NUMBER/locations/global/workloadIdentityPools/$GCP_WORKLOAD_ID/attribute.aws_role/arn:aws:sts::${AWS_ACCOUNT_ID}:assumed-role/$AWS_ROLE_NAME"
  ```



  Set your AWS credentials

  ```bash
  export AWS_PROFILE=xyz
  ```

  Getting a Service Account token is now simple:

  ```python
  from scalesec_gcp_workload_identity.main import TokenService
  from os import getenv





  token_service = TokenService(
    gcp_project_number=getenv('GCP_PROJECT_NUMBER'),
    gcp_workload_id=getenv('GCP_WORKLOAD_ID'),
    gcp_workload_provider=getenv('GCP_WORKLOAD_PROVIDER'),
    gcp_service_account_email=getenv('GCP_SERVICE_ACCOUNT_EMAIL'),
    aws_account_id=getenv('AWS_ACCOUNT_ID'),
    aws_role_name=getenv('AWS_ROLE_NAME'),
    aws_region=getenv('AWS_REGION'),
    gcp_token_lifetime=getenv('TOKEN_LIFETIME'), # Not required
    gcp_token_scopes=getenv('TOKEN_SCOPES') # Not required
  )

  sa_token, expiry_date = token_service.get_token()
  ```



  The default expiration for a service account token is 1h in GCP. This behavior can be changed by overriding the environment variable `TOKEN_LIFETIME` in the `.env` file. By default, GCP does not allow tokens to have an expiry over 1 hour and an organization policy __must__ be updated for this change to take affect. The organization policy is called `iam.allowServiceAccountCredentialLifetimeExtension` and it accepts a list of service accounts that are allowed to have an > 1 hr token.

  ```bash

  gcloud org-policies set-policy policy.yaml


  name: projects/1234567890/policies/iam.allowServiceAccountCredentialLifetimeExtension
  spec:
    etag: BwXBMNmIrQg=
    rules:
    - values:
        allowedValues:
        - your-sa@yourproject.iam.gserviceaccount.com
  ```



  The default scope for the service account token is `https://www.googleapis.com/auth/cloud-platform`. This behaviour can be overridden to enable a different set of scopes by using the environment variable `TOKEN_SCOPES` in the `.env` file with a comma-separated list of GCP scopes.



  ```shell

  make setup
  ```

  Edit `.env` with your values

  ```shell

  make dev


  make test
  ```



  To test that your code will pass the lint and code quality GitHub action:

  * Clone the repository locally
  * Make your updates
  * From the root of the repository, execute:
  ```bash
  pylint --rcfile .github/workflows/configs/.pylintrc scalesec_gcp_workload_identity tests examples
  ```



  We have provided [examples](./examples) on how to use the service account access token generated by this module. Access tokens are mainly used via an API call or using `curl` on the CLI.



  By default, any GCP user with the `roles/iam.workloadIdentityPoolAdmin` or `roles/owner` role is able to create a workload identity pool in your GCP organization. There are two organization policies available to help you lockdown which outside providers can have pools in your organization.

  * `constraints/iam.workloadIdentityPoolProviders ` - Accepts a list of URIs such as `https://sts.amazonaws.com` or `https://sts.windows.net/$AZURE_TENANT_ID`. For example:

  ```bash

  gcloud beta resource-manager org-policies allow constraints/iam.workloadIdentityPoolProviders \
       https://sts.amazonaws.com --organization=$ORG_ID


  gcloud beta resource-manager org-policies allow constraints/iam.workloadIdentityPoolProviders \
       https://sts.windows.net/$AZURE_TENANT_ID --organization=$ORG_ID
  ```

  * `constraints/iam.workloadIdentityPoolAwsAccounts` - Specifically focused on AWS, this constraint accepts a list of AWS account IDs. If this orgnanization policy is used, `constraints/iam.workloadIdentityPoolProviders` must either allow `https://sts.amazonaws.com` or be set to default (allow all). For example:

  ```bash

  gcloud beta resource-manager org-policies allow constraints/iam.workloadIdentityPoolAwsAccounts \
      $AWS_ACCOUNT_ID --organization=$ORG_ID
  ```



  Set your token/credentials in ~/.pypirc

  `make dist VERSION=1.x.x`



  Feedback is welcome and encouraged via a GitHub issue. Please open an issue for any bugs, feature requests, or general improvements you would like to see. Thank you in advance!

location_href:
  00012287-python-scalesec-gcp-workload-identity/python-scalesec-gcp-workload-identity-help-1.0.7-1.noarch.rpm


pkgId: 745add5c215ba9cbb41b9ac22959043d8ea24e642132b77bdb3335566b8c31c3
name: python-scan-build
arch: src
version: 2.0.20
epoch: 0
release: 1
summary: static code analyzer wrapper for Clang.
url: https://github.com/rizsotto/scan-build
rpm_license: LICENSE.txt
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-96a47fd0-de79-4742-a75a-b5824e2136d3
location_href: 00010988-python-scan-build/python-scan-build-2.0.20-1.src.rpm
checksum_type: sha256
description:
  A package designed to wrap a build so that all calls to gcc/clang are
  intercepted and logged into a `compilation database`_ and/or piped to
  the clang static analyzer. Includes intercept-build tool, which logs
  the build, as well as scan-build tool, which logs the build and runs
  the clang static analyzer on it.


pkgId: a3fae15c175a64820aef1ec9d2a34f4618dd45dbd82aa30406fcff48c5998a14
name: python-scandir
arch: src
version: 1.10.0
epoch: 0
release: 1
summary: scandir, a better directory iterator and faster os.walk()
url: https://github.com/benhoyt/scandir
rpm_license: New BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e878ff57-b70f-4431-9626-1b74591cc03f
location_href: 00009227-python-scandir/python-scandir-1.10.0-1.src.rpm
checksum_type: sha256
description:
  ``scandir()`` is a directory iteration function like ``os.listdir()``,
  except that instead of returning a list of bare filenames, it yields
  ``DirEntry`` objects that include file type and stat information along
  with the name. Using ``scandir()`` increases the speed of ``os.walk()``
  by 2-20 times (depending on the platform and file system) by avoiding
  unnecessary calls to ``os.stat()`` in most cases.


pkgId: 4c5cefda0165e96de7637eca8981298ef97bb6d4fcc59ba47bb33d5af614d5e9
name: python-scandir-debuginfo
arch: aarch64
version: 1.10.0
epoch: 0
release: 1
summary: Debug information for package python-scandir
url: https://github.com/benhoyt/scandir
rpm_license: New BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-e878ff57-b70f-4431-9626-1b74591cc03f
rpm_sourcerpm: python-scandir-1.10.0-1.src.rpm
location_href: 00009227-python-scandir/python-scandir-debuginfo-1.10.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-scandir.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: da2b35863c1fd6c1b04f75e5041f3d6bd8b6b1bfe8f717bbf95cc3950b9f16c5
name: python-scandir-debugsource
arch: aarch64
version: 1.10.0
epoch: 0
release: 1
summary: Debug sources for package python-scandir
url: https://github.com/benhoyt/scandir
rpm_license: New BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-e878ff57-b70f-4431-9626-1b74591cc03f
rpm_sourcerpm: python-scandir-1.10.0-1.src.rpm
location_href: 00009227-python-scandir/python-scandir-debugsource-1.10.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-scandir.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 405d725862cf23854cb32973191b9071d3ae6c54947c8848865e6154bfb077d9
name: python-scanless
arch: src
version: 2.1.6
epoch: 0
release: 1
summary: An online port scan scraper.
url: https://github.com/vesche/scanless
rpm_license: Unlicense
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b33f4033-91ba-4153-9733-8ddab96ffcb6
location_href: 00005036-python-scanless/python-scanless-2.1.6-1.src.rpm
checksum_type: sha256
description:
  This is a Python 3 command-line utility and library for using websites that can perform port scans on your behalf.



  * [hackertarget](https://hackertarget.com/nmap-online-port-scanner/)
  * [ipfingerprints](http://www.ipfingerprints.com/portscan.php)
  * [spiderip](https://spiderip.com/online-port-scan.php)
  * [standingtech](https://portscanner.standingtech.com/)
  * [viewdns](http://viewdns.info/)
  * [yougetsignal](http://www.yougetsignal.com/tools/open-ports/)



  Do it up:
  ```
  $ pip install scanless --user
  ```



  ```
  $ scanless --help
  usage: scanless [-h] [-v] [-t TARGET] [-s SCANNER] [-r] [-l] [-a]

  scanless, an online port scan scraper.

  optional arguments:
    -h, --help            show this help message and exit
    -v, --version         display the current version
    -t TARGET, --target TARGET
                          ip or domain to scan
    -s SCANNER, --scanner SCANNER
                          scanner to use (default: hackertarget)
    -r, --random          use a random scanner
    -l, --list            list scanners
    -a, --all             use all the scanners
    -d, --debug           debug mode (cli mode off & show network errors)

  $ scanless --list
  +----------------+--------------------------------------+
  | Scanner Name   | Website                              |
  +----------------+--------------------------------------+
  | hackertarget   | https://hackertarget.com             |
  | ipfingerprints | https://www.ipfingerprints.com       |
  | spiderip       | https://spiderip.com                 |
  | standingtech   | https://portscanner.standingtech.com |
  | viewdns        | https://viewdns.info                 |
  | yougetsignal   | https://www.yougetsignal.com         |
  +----------------+--------------------------------------+

  $ scanless -t scanme.nmap.org -s spiderip
  Running scanless v2.1.6...

  spiderip:
  PORT      STATE  SERVICE
  21/tcp    closed ftp
  22/tcp    open   ssh
  25/tcp    closed smtp
  80/tcp    open   http
  110/tcp   closed pop3
  143/tcp   closed imap
  443/tcp   closed https
  465/tcp   closed smtps
  993/tcp   closed imaps
  995/tcp   closed pop3s
  1433/tcp  closed ms-sql-s
  3306/tcp  closed mysql
  3389/tcp  closed ms-wbt-server
  5900/tcp  closed vnc
  8080/tcp  closed http-proxy
  8443/tcp  closed https-alt
  ```



  ```
  >>> import scanless
  >>> sl = scanless.Scanless()
  >>> output = sl.scan('scanme.nmap.org', scanner='hackertarget')
  >>> print(output['raw'])
  Starting Nmap 7.70 ( https://nmap.org ) at 2020-05-12 21:39 UTC
  Nmap scan report for scanme.nmap.org (45.33.32.156)
  Host is up (0.065s latency).
  Other addresses for scanme.nmap.org (not scanned): 2600:3c01::f03c:91ff:fe18:bb2f

  PORT    STATE  SERVICE
  21/tcp  closed ftp
  22/tcp  open   ssh
  80/tcp  open   http
  443/tcp closed https

  Nmap done: 1 IP address (1 host up) scanned in 0.11 seconds
  >>> import json
  >>> print(json.dumps(output['parsed'], indent=2))
  [
    {
      "port": "21",
      "state": "closed",
      "service": "ftp",
      "protocol": "tcp"
    },
    {
      "port": "22",
      "state": "open",
      "service": "ssh",
      "protocol": "tcp"
    },
    {
      "port": "80",
      "state": "open",
      "service": "http",
      "protocol": "tcp"
    },
    {
      "port": "443",
      "state": "closed",
      "service": "https",
      "protocol": "tcp"
    }
  ]
  ```


pkgId: dec19d8ca201d95ab7df6db6423da5436b27610dc64ec7e56289b14a88c6c1ec
name: python-scanless
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: An online port scan scraper.
url: https://github.com/vesche/scanless
rpm_license: Unlicense
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f8ba663d-a131-4d8e-8b5d-f4fa36561876
location_href: 00008365-python-scanless/python-scanless-2.2.1-1.src.rpm
checksum_type: sha256
description:
  This is a Python command-line utility and library for using websites that can perform port scans on your behalf.



  * [ipfingerprints](http://www.ipfingerprints.com/portscan.php)
  * [spiderip](https://spiderip.com/online-port-scan.php)
  * [standingtech](https://portscanner.standingtech.com/)
  * [viewdns](http://viewdns.info/)
  * [yougetsignal](http://www.yougetsignal.com/tools/open-ports/)



  Do it up:
  ```
  $ pip install scanless --user
  ```



  ```
  $ scanless --help
  usage: scanless [-h] [-v] [-t TARGET] [-s SCANNER] [-r] [-l] [-a] [-d]

  scanless, an online port scan scraper.

  options:
    -h, --help            show this help message and exit
    -v, --version         display the current version
    -t TARGET, --target TARGET
                          ip or domain to scan
    -s SCANNER, --scanner SCANNER
                          scanner to use (default: yougetsignal)
    -r, --random          use a random scanner
    -l, --list            list scanners
    -a, --all             use all the scanners
    -d, --debug           debug mode (cli mode off & show network errors)

  $ scanless --list
  +----------------+--------------------------------------+
  | Scanner Name   | Website                              |
  +----------------+--------------------------------------+
  | ipfingerprints | https://www.ipfingerprints.com       |
  | spiderip       | https://spiderip.com                 |
  | standingtech   | https://portscanner.standingtech.com |
  | viewdns        | https://viewdns.info                 |
  | yougetsignal   | https://www.yougetsignal.com         |
  +----------------+--------------------------------------+

  $ scanless -t scanme.nmap.org -s spiderip
  Running scanless v2.2.1 ...

  spiderip:
  PORT      STATE  SERVICE
  21/tcp    closed ftp
  22/tcp    open   ssh
  25/tcp    closed smtp
  80/tcp    open   http
  110/tcp   closed pop3
  143/tcp   closed imap
  443/tcp   closed https
  465/tcp   closed smtps
  993/tcp   closed imaps
  995/tcp   closed pop3s
  1433/tcp  closed ms-sql-s
  3306/tcp  closed mysql
  3389/tcp  closed ms-wbt-server
  5900/tcp  closed vnc
  8080/tcp  closed http-proxy
  8443/tcp  closed https-alt
  ```



  ```
  >>> import scanless
  >>> sl = scanless.Scanless()
  >>> output = sl.scan('scanme.nmap.org', scanner='yougetsignal')
  >>> print(output['raw'])
  PORT      STATE  SERVICE
  21/tcp    closed ftp
  22/tcp    open   ssh
  23/tcp    closed telnet
  25/tcp    closed smtp
  53/tcp    closed domain
  80/tcp    open   http
  110/tcp   closed pop3
  115/tcp   closed sftp
  135/tcp   closed msrpc
  139/tcp   closed netbios-ssn
  143/tcp   closed imap
  194/tcp   closed irc
  443/tcp   closed https
  445/tcp   closed microsoft-ds
  1433/tcp  closed ms-sql-s
  3306/tcp  closed mysql
  3389/tcp  closed ms-wbt-server
  5632/tcp  closed pcanywherestat
  5900/tcp  closed vnc
  6112/tcp  closed dtspc
  >>> import json
  >>> print(json.dumps(output['parsed'], indent=2))
  [
    {
      "port": "21",
      "state": "closed",
      "service": "ftp",
      "protocol": "tcp"
    },
    {
      "port": "22",
      "state": "open",
      "service": "ssh",
      "protocol": "tcp"
    },
    {
      "port": "23",
      "state": "closed",
      "service": "telnet",
      "protocol": "tcp"
    },
    {
      "port": "25",
      "state": "closed",
      "service": "smtp",
      "protocol": "tcp"
    },
    {
      "port": "53",
      "state": "closed",
      "service": "domain",
      "protocol": "tcp"
    },
    {
      "port": "80",
      "state": "open",
      "service": "http",
      "protocol": "tcp"
    },
    ...
  ]
  ```


pkgId: 887f5fa4119f75b6a342ba0a2420aee51777f798267fe11d6f606a3f99f81caa
name: python-scapy
arch: src
version: 2.5.0
epoch: 0
release: 1
summary: Scapy: interactive packet manipulation tool
url: https://scapy.net
rpm_license: GPL-2.0-only
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-849a6608-7a5b-44d9-891b-1f2599cc33cd
location_href: 00005037-python-scapy/python-scapy-2.5.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI Version](https://img.shields.io/pypi/v/scapy.svg)](https://pypi.python.org/pypi/scapy/)
  [![License: GPL v2](https://img.shields.io/badge/License-GPL%20v2-blue.svg)](LICENSE)

  Scapy is a powerful Python-based interactive packet manipulation program and
  library.

  It is able to forge or decode packets of a wide number of protocols, send them
  on the wire, capture them, store or read them using pcap files, match requests
  and replies, and much more. It is designed to allow fast packet prototyping by
  using default values that work.

  It can easily handle most classical tasks like scanning, tracerouting, probing,
  unit tests, attacks or network discovery (it can replace `hping`, 85% of `nmap`,
  `arpspoof`, `arp-sk`, `arping`, `tcpdump`, `wireshark`, `p0f`, etc.). It also
  performs very well at a lot of other specific tasks that most other tools can't
  handle, like sending invalid frames, injecting your own 802.11 frames, combining
  techniques (VLAN hopping+ARP cache poisoning, VoIP decoding on WEP protected
  channel, ...), etc.

  Scapy supports Python 2.7 and Python 3 (3.4 to 3.9). It's intended to
  be cross platform, and runs on many different platforms (Linux, OSX,
  \*BSD, and Windows).



  Scapy is usable either as a **shell** or as a **library**.
  For further details, please head over to [Getting started with Scapy](https://scapy.readthedocs.io/en/latest/introduction.html), which is part of the documentation.



  ![Scapy install demo](https://secdev.github.io/files/doc/animation-scapy-install.svg)

  Scapy can easily be used as an interactive shell to interact with the network.
  The following example shows how to send an ICMP Echo Request message to
  `github.com`, then display the reply source IP address:

  ```python
  sudo ./run_scapy
  Welcome to Scapy
  >>> p = IP(dst="github.com")/ICMP()
  >>> r = sr1(p)
  Begin emission:
  .Finished to send 1 packets.
  *
  Received 2 packets, got 1 answers, remaining 0 packets
  >>> r[IP].src
  '192.30.253.113'
  ```



  The [documentation](https://scapy.readthedocs.io/en/latest/) contains more
  advanced use cases, and examples.

  Other useful resources:

  -   [Scapy in 20 minutes](https://github.com/secdev/scapy/blob/master/doc/notebooks/Scapy%20in%2015%20minutes.ipynb)
  -   [Interactive tutorial](https://scapy.readthedocs.io/en/latest/usage.html#interactive-tutorial) (part of the documentation)
  -   [The quick demo: an interactive session](https://scapy.readthedocs.io/en/latest/introduction.html#quick-demo)
  (some examples may be outdated)
  -   [HTTP/2 notebook](https://github.com/secdev/scapy/blob/master/doc/notebooks/HTTP_2_Tuto.ipynb)
  -   [TLS notebooks](https://github.com/secdev/scapy/blob/master/doc/notebooks/tls)



  Scapy works without any external Python modules on Linux and BSD like operating
  systems. On Windows, you need to install some mandatory dependencies as
  described in [the
  documentation](http://scapy.readthedocs.io/en/latest/installation.html#windows).

  On most systems, using Scapy is as simple as running the following commands:

  ```bash
  git clone https://github.com/secdev/scapy
  cd scapy
  ./run_scapy
  ```

  To benefit from all Scapy features, such as plotting, you might want to install
  Python modules, such as `matplotlib` or `cryptography`. See the
  [documentation](http://scapy.readthedocs.io/en/latest/installation.html) and
  follow the instructions to install them.


