# packages

pkgId: 1410aa9ed6f660c45785116c6e3ef73b30c9bdb5cd1c6fb954ea634fe4115245
name: python-pythreejs
arch: src
version: 2.4.2
epoch: 0
release: 1
url: https://github.com/jupyter-widgets/pythreejs
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-031f0df6-c913-404b-8d91-6c69f8791c1b
location_href: 00013523-python-pythreejs/python-pythreejs-2.4.2-1.src.rpm
checksum_type: sha256
summary:
  Interactive 3D graphics for the Jupyter Notebook and JupyterLab, using Three.js and Jupyter Widgets.

description:
  [![Interactive demo on Binder][binder-badge]][binder]
  [![Install from PyPI][pypi-badge]][pypi]
  [![Install from conda-forge][cf-badge]][cf]
  [![Reuse from npm][npm-badge]][npm]
  [![Documentation Status][docs-badge]][docs]
  [![Build Status][ci-badge]][ci]

  A Python / ThreeJS bridge for [Jupyter Widgets][widgets].

  ![Screencast]

  [binder-badge]: https://mybinder.org/badge_logo.svg
  [binder]: https://mybinder.org/v2/gh/jupyter-widgets/pythreejs/HEAD?urlpath=lab%2Ftree%2Fexamples%2FExamples.ipynb
  [pypi-badge]: https://img.shields.io/pypi/v/pythreejs?logo=pypi
  [pypi]: https://pypi.org/project/pythreejs
  [cf-badge]: https://img.shields.io/conda/vn/conda-forge/pythreejs?logo=conda-forge
  [cf]: https://anaconda.org/conda-forge/pythreejs
  [npm-badge]: https://img.shields.io/npm/v/jupyter-threejs?logo=npm
  [npm]: https://www.npmjs.com/package/jupyter-threejs
  [docs-badge]: https://readthedocs.org/projects/pythreejs/badge/?version=stable
  [docs]: https://pythreejs.readthedocs.io/en/stable
  [ci-badge]: https://github.com/jupyter-widgets/pythreejs/actions/workflows/ci.yml/badge.svg
  [ci]: https://github.com/jupyter-widgets/pythreejs/actions/workflows/ci.yml?query=branch%3Amaster
  [widgets]: https://jupyter.org/widgets
  [screencast]: https://raw.githubusercontent.com/jupyter-widgets/pythreejs/master/screencast.gif



  Using `pip`:

  ```bash
  pip install pythreejs
  ```

  or `conda`:

  ```bash
  conda install -c conda-forge pythreejs
  ```

  > For a development install, see the [contributing guide][contributing].

  The extension should then be installed automatically for your Jupyter client.

  > For JupyterLab `<3`, you may also need to ensure `nodejs` is installed, and
  > rebuild the application:
  >
  > ```bash
  > # conda install -c cond-forge 'nodejs>=12'
  > jupyter lab build
  > ```

  [contributing]: https://github.com/jupyter-widgets/pythreejs/blob/master/CONTRIBUTING.md



  If the extension is not automatically installed, you can manually enable it



  ```bash
  jupyter nbextension list
  jupyter nbextension install --py --symlink --sys-prefix pythreejs
  jupyter nbextension enable --py --sys-prefix pythreejs
  jupyter nbextension list
  ```

  You should see:

  ```bash
  Known nbextensions:
    ...
    jupyter-js-widgets/extension  enabled
      - Validating: OK
  ```

  > Note for developers: the `--symlink` argument on Linux or MacOS allows one to
  > modify the JavaScript code in-place. This feature is not available on Windows.



  To perform a _source installation_:

  ```bash


  jupyter labextension list
  jupyter labextension install --no-build @jupyter-widgets/jupyterlab-manager
  jupyter labextension install --no-build jupyter-datawidgets/extension
  jupyter labextension install jupyter-threejs
  jupyter labextension list
  ```

  You should see:

  ```bash
  JupyterLab v...
    ...
      jupyterlab-datawidgets v... enabled OK
      @jupyter-widgets/jupyterlab-manager v... enabled OK
      jupyter-threejs v... enabled OK

  ```

  > This approach is _not recommended_ for JupyterLab 3, which enables
  > _federated modules_, installed via `pip`, `conda` or other package managers,
  > and does not require rebuilding the entire application.



  Using `pip`:

  ```bash
  pip uninstall pythreejs
  ```

  or `conda`:

  ```bash
  conda uninstall pythreejs
  ```

  > If you applied any manual steps above, it may be necessary to remove the



  ```bash
  jupyter nbextension disable --py --sys-prefix pythreejs
  ```



  ```bash
  jupyter labextension uninstall jupyter-threejs
  ```



  This software is licensed under the [BSD-3-Clause][] License.

  [bsd-3-clause]: https://github.com/jupyter-widgets/pythreejs/blob/master/LICENSE


pkgId: 43cd3ce47831a087539d8c309177e0ccb90f8295dfad48077d0e6f32a7da135f
name: python-pytile
arch: src
version: 2022.10.0
epoch: 0
release: 1
summary: A simple Python API for Tile® Bluetooth trackers
url: https://github.com/bachya/pytile
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-13f61460-0255-4d31-a674-f7a33146bd74
location_href: 00004875-python-pytile/python-pytile-2022.10.0-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/bachya/pytile/workflows/CI/badge.svg)](https://github.com/bachya/pytile/actions)
  [![PyPi](https://img.shields.io/pypi/v/pytile.svg)](https://pypi.python.org/pypi/pytile)
  [![Version](https://img.shields.io/pypi/pyversions/pytile.svg)](https://pypi.python.org/pypi/pytile)
  [![License](https://img.shields.io/pypi/l/pytile.svg)](https://github.com/bachya/pytile/blob/main/LICENSE)
  [![Code Coverage](https://codecov.io/gh/bachya/pytile/branch/dev/graph/badge.svg)](https://codecov.io/gh/bachya/pytile)
  [![Maintainability](https://api.codeclimate.com/v1/badges/71eb642c735e33adcdfc/maintainability)](https://codeclimate.com/github/bachya/pytile/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>

  `pytile` is a simple Python library for retrieving information on
  [Tile® Bluetooth trackers](https://www.thetileapp.com/en-us/) (including last
  location and more).

  This library is built on an unpublished, unofficial Tile API; it may alter or
  cease operation at any point.

  - [Python Versions](#python-versions)
  - [Installation](#installation)
  - [Usage](#usage)
  - [Contributing](#contributing)



  Version 5.0.0 is a complete re-architecture of `pytile` – as such, the API has changed.
  Please read the documentation carefully!



  `pytile` is currently supported on:

  - Python 3.9
  - Python 3.10
  - Python 3.11



  ```bash
  pip install pytile
  ```





  `pytile` usage starts with an [`aiohttp`](https://github.com/aio-libs/aiohttp) `ClientSession` –
  note that this ClientSession is required to properly authenticate the library:

  ```python
  import asyncio

  from aiohttp import ClientSession

  from pytile import async_login


  async def main() -> None:
      """Run!"""
      async with ClientSession() as session:
          api = await async_login("<EMAIL>", "<PASSWORD>", session)


  asyncio.run(main())
  ```

  If for some reason you need to use a specific client UUID (to, say, ensure that the
  Tile API sees you as a client it's seen before) or a specific locale, you can do
  so easily:

  ```python
  import asyncio

  from aiohttp import ClientSession

  from pytile import async_login


  async def main() -> None:
      """Run!"""
      async with ClientSession() as session:
          api = await async_login(
              "<EMAIL>", "<PASSWORD>", session, client_uuid="MY_UUID", locale="en-GB"
          )


  asyncio.run(main())
  ```



  ```python
  import asyncio

  from aiohttp import ClientSession

  from pytile import async_login


  async def main() -> None:
      """Run!"""
      async with ClientSession() as session:
          api = await async_login("<EMAIL>", "<PASSWORD>", session)

          tiles = await api.async_get_tiles()


  asyncio.run(main())
  ```

  The `async_get_tiles` coroutine returns a dict with Tile UUIDs as the keys and `Tile`
  objects as the values.



  The Tile object comes with several properties:

  - `accuracy`: the location accuracy of the Tile
  - `altitude`: the altitude of the Tile
  - `archetype`: the internal reference string that describes the Tile's "family"
  - `dead`: whether the Tile is inactive
  - `firmware_version`: the Tile's firmware version
  - `hardware_version`: the Tile's hardware version
  - `kind`: the kind of Tile (e.g., `TILE`, `PHONE`)
  - `last_timestamp`: the timestamp at which the current attributes were received
  - `latitude`: the latitude of the Tile
  - `longitude`: the latitude of the Tile
  - `lost`: whether the Tile has been marked as "lost"
  - `lost_timestamp`: the timestamp at which the Tile was last marked as "lost"
  - `name`: the name of the Tile
  - `uuid`: the Tile UUID
  - `visible`: whether the Tile is visible in the mobile app

  ```python
  import asyncio

  from aiohttp import ClientSession

  from pytile import async_login


  async def main() -> None:
      """Run!"""
      async with ClientSession() as session:
          api = await async_login("<EMAIL>", "<PASSWORD>", session)

          tiles = await api.async_get_tiles()

          for tile_uuid, tile in tiles.items():
              print(f"The Tile's name is {tile.name}")
              


  asyncio.run(main())
  ```

  In addition to these properties, the `Tile` object comes with an `async_update` coroutine
  which requests new data from the Tile cloud API for this Tile:

  ```python
  import asyncio

  from aiohttp import ClientSession

  from pytile import async_login


  async def main() -> None:
      """Run!"""
      async with ClientSession() as session:
          api = await async_login("<EMAIL>", "<PASSWORD>", session)

          tiles = await api.async_get_tiles()

          for tile_uuid, tile in tiles.items():
              await tile.async_update()


  asyncio.run(main())
  ```



  1. [Check for open features/bugs](https://github.com/bachya/pytile/issues)
     or [initiate a discussion on one](https://github.com/bachya/pytile/issues/new).
  2. [Fork the repository](https://github.com/bachya/pytile/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 pytile tests`
  9. Update `README.md` with any new documentation.
  10. Add yourself to `AUTHORS.md`.
  11. Submit a pull request!


pkgId: 812651c5725fe13f96b40ae5d32cd60370cc6ea98cde024f2aae98d03425f7b2
name: python-pytoml
arch: src
version: 0.1.21
epoch: 0
release: 1
summary: A parser for TOML-0.4.0
url: https://github.com/avakar/pytoml
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-33f0dfdb-7c5e-466b-8711-77e9a8f092d6
location_href: 00010103-python-pytoml/python-pytoml-0.1.21-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/pytoml.svg)](https://pypi.python.org/pypi/pytoml)
  [![Build Status](https://travis-ci.org/avakar/pytoml.svg?branch=master)](https://travis-ci.org/avakar/pytoml)



  The pytoml project is no longer being actively maintained. Consider using the
  [toml](https://github.com/uiri/toml) package instead.



  This project aims at being a specs-conforming and strict parser and writer for [TOML][1] files.
  The library currently supports [version 0.4.0][2] of the specs and runs with Python 2.7+ and 3.5+.

  Install:

      pip install pytoml

  The interface is the same as for the standard `json` package.

      >>> import pytoml as toml
      >>> toml.loads('a = 1')
      {'a': 1}
      >>> with open('file.toml', 'rb') as fin:
      ...     obj = toml.load(fin)
      >>> obj
      {'a': 1}

  The `loads` function accepts either a bytes object
  (that gets decoded as UTF-8 with no BOM allowed),
  or a unicode object.

  Use `dump` or `dumps` to serialize a dict into TOML.

      >>> print toml.dumps(obj)
      a = 1



  To run the tests update the `toml-test` submodule:

      git submodule update --init --recursive

  Then run the tests:

      python test/test.py

    [1]: https://github.com/toml-lang/toml
    [2]: https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.4.0.md


pkgId: 822b2ab65b940a4bbccac76730fa2b8125b5421d78701356801955d5bf222a23
name: python-pytools
arch: src
version: 2022.1.14
epoch: 0
release: 1
summary: A collection of tools for Python
url: http://pypi.python.org/pypi/pytools
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5833d597-19b8-4e3c-9244-3beaae84aac9
location_href: 00004877-python-pytools/python-pytools-2022.1.14-1.src.rpm
checksum_type: sha256
description:
  Pytools is a big bag of things that are "missing" from the Python standard
  library. This is mainly a dependency of my other software packages, and is
  probably of little interest to you unless you use those. If you're curious
  nonetheless, here's what's on offer:
  * A ton of small tool functions such as `len_iterable`, `argmin`,
    tuple generation, permutation generation, ASCII table pretty printing,
    GvR's monkeypatch_xxx() hack, the elusive `flatten`, and much more.
  * A time-series logging module, `pytools.log`.
  * Batch job submission, `pytools.batchjob`.
  * A lexer, `pytools.lex`.
  Links:
  * `Documentation <https://documen.tician.de/pytools>`_
  * `Github <https://github.com/inducer/pytools>`_
  * ``pytools.log`` has been spun out into a separate project,
    `logpyle <https://github.com/illinois-ceesd/logpyle>`__.


pkgId: 2e989571dd81787b7d83e4c231d2e41f54eaa1aaa77ade488fd48fae54ba47ad
name: python-pytorch-ignite
arch: src
version: 0.4.11
epoch: 0
release: 1
summary: A lightweight library to help with training neural networks in PyTorch.
url: https://github.com/pytorch/ignite
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7c8d371f-f483-411a-b379-be6939030ce8
location_href: 00011212-python-pytorch-ignite/python-pytorch-ignite-0.4.11-1.src.rpm
checksum_type: sha256
description:
  <div align="center">

  <!-- ![Ignite Logo](assets/logo/ignite_logo_mixed.svg) -->

  <img src="https://raw.githubusercontent.com/pytorch/ignite/master/assets/logo/ignite_logo_mixed.svg" width=512>

  <!-- [![image](https://travis-ci.com/pytorch/ignite.svg?branch=master)](https://travis-ci.com/pytorch/ignite) -->

  | ![image](https://img.shields.io/badge/-Tests:-black?style=flat-square) [![image](https://github.com/pytorch/ignite/workflows/Run%20unit%20tests/badge.svg)](https://github.com/pytorch/ignite/actions) [![image](https://img.shields.io/badge/-GPU%20tests-black?style=flat-square)](https://app.circleci.com/pipelines/github/pytorch/ignite?branch=master)[![image](https://circleci.com/gh/pytorch/ignite.svg?style=svg)](https://app.circleci.com/pipelines/github/pytorch/ignite?branch=master) [![image](https://codecov.io/gh/pytorch/ignite/branch/master/graph/badge.svg)](https://codecov.io/gh/pytorch/ignite) [![image](https://img.shields.io/badge/dynamic/json.svg?label=docs&url=https%3A%2F%2Fpypi.org%2Fpypi%2Fpytorch-ignite%2Fjson&query=%24.info.version&colorB=brightgreen&prefix=v)](https://pytorch.org/ignite/index.html) |
  |:---
  | ![image](https://img.shields.io/badge/-Stable%20Releases:-black?style=flat-square) [![image](https://anaconda.org/pytorch/ignite/badges/version.svg)](https://anaconda.org/pytorch/ignite) [![image](https://anaconda.org/pytorch/ignite/badges/downloads.svg)](https://anaconda.org/pytorch/ignite) [![image](https://img.shields.io/badge/dynamic/json.svg?label=PyPI&url=https%3A%2F%2Fpypi.org%2Fpypi%2Fpytorch-ignite%2Fjson&query=%24.info.version&colorB=brightgreen&prefix=v)](https://pypi.org/project/pytorch-ignite/) [![image](https://pepy.tech/badge/pytorch-ignite)](https://pepy.tech/project/pytorch-ignite) |
  | ![image](https://img.shields.io/badge/-Nightly%20Releases:-black?style=flat-square) [![image](https://anaconda.org/pytorch-nightly/ignite/badges/version.svg)](https://anaconda.org/pytorch-nightly/ignite) [![image](https://img.shields.io/badge/PyPI-pre%20releases-brightgreen)](https://pypi.org/project/pytorch-ignite/#history)|
  | ![image](https://img.shields.io/badge/-Features:-black?style=flat-square) [![image](https://img.shields.io/badge/docker-hub-blue)](https://hub.docker.com/u/pytorchignite) [![image](https://img.shields.io/badge/Optuna-integrated-blue)](https://optuna.org) [![image](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) |
  | ![image](https://img.shields.io/badge/-Community:-black?style=flat-square) [![Twitter](https://img.shields.io/badge/news-twitter-blue)](https://twitter.com/pytorch_ignite) [![facebook](https://img.shields.io/badge/news-facebook-blue)](https://www.facebook.com/PyTorch-Ignite-Community-105837321694508) [![numfocus](https://img.shields.io/badge/NumFOCUS-affiliated%20project-green)](https://numfocus.org/sponsored-projects/affiliated-projects) [![discord](https://img.shields.io/badge/chat-discord-blue?logo=discord)](https://discord.gg/djZtm3EmKj) |
  | ![image](https://img.shields.io/badge/-Supported_PyTorch/Python_versions:-black?style=flat-square) [![link](https://img.shields.io/badge/-check_here-blue)](https://github.com/pytorch/ignite/actions?query=workflow%3A%22PyTorch+version+tests%22)|

  </div>



  Ignite is a high-level library to help with training and evaluating neural networks in PyTorch flexibly and transparently.

  <div align="center">

  <a href="https://colab.research.google.com/github/pytorch/ignite/blob/master/assets/tldr/teaser.ipynb">
   <img alt="PyTorch-Ignite teaser"
        src="https://raw.githubusercontent.com/pytorch/ignite/master/assets/tldr/pytorch-ignite-teaser.gif"
        width=532>
  </a>

  _Click on the image to see complete code_

  </div>



  - [Less code than pure PyTorch](https://raw.githubusercontent.com/pytorch/ignite/master/assets/ignite_vs_bare_pytorch.png)
    while ensuring maximum control and simplicity

  - Library approach and no program's control inversion - _Use ignite where and when you need_

  - Extensible API for metrics, experiment managers, and other components

  <!-- ############################################################################################################### -->



  - [Table of Contents](#table-of-contents)
  - [Why Ignite?](#why-ignite)
    - [Simplified training and validation loop](#simplified-training-and-validation-loop)
    - [Power of Events & Handlers](#power-of-events--handlers)
      - [Execute any number of functions whenever you wish](#execute-any-number-of-functions-whenever-you-wish)
      - [Built-in events filtering](#built-in-events-filtering)
      - [Stack events to share some actions](#stack-events-to-share-some-actions)
      - [Custom events to go beyond standard events](#custom-events-to-go-beyond-standard-events)
    - [Out-of-the-box metrics](#out-of-the-box-metrics)
  - [Installation](#installation)
    - [Nightly releases](#nightly-releases)
    - [Docker Images](#docker-images)
      - [Using pre-built images](#using-pre-built-images)
  - [Getting Started](#getting-started)
  - [Documentation](#documentation)
    - [Additional Materials](#additional-materials)
  - [Examples](#examples)
    - [Tutorials](#tutorials)
    - [Reproducible Training Examples](#reproducible-training-examples)
  - [Communication](#communication)
    - [User feedback](#user-feedback)
  - [Contributing](#contributing)
  - [Projects using Ignite](#projects-using-ignite)
  - [Citing Ignite](#citing-ignite)
  - [About the team & Disclaimer](#about-the-team--disclaimer)

  <!-- ############################################################################################################### -->



  Ignite is a **library** that provides three high-level features:

  - Extremely simple engine and event system
  - Out-of-the-box metrics to easily evaluate models
  - Built-in handlers to compose training pipeline, save artifacts and log parameters and metrics



  No more coding `for/while` loops on epochs and iterations. Users instantiate engines and run them.

  <details>
  <summary>
  Example
  </summary>

  ```python
  from ignite.engine import Engine, Events, create_supervised_evaluator
  from ignite.metrics import Accuracy



  def train_step(engine, batch):
      
      
      

  trainer = Engine(train_step)


  evaluator = create_supervised_evaluator(model, metrics={"accuracy": Accuracy()})

  def validation():
      state = evaluator.run(validation_data_loader)
      
      print(trainer.state.epoch, state.metrics)


  trainer.add_event_handler(Events.EPOCH_COMPLETED, validation)


  trainer.run(training_data_loader, max_epochs=100)
  ```

  </details>



  The cool thing with handlers is that they offer unparalleled flexibility (compared to, for example, callbacks). Handlers can be any function: e.g. lambda, simple function, class method, etc. Thus, we do not require to inherit from an interface and override its abstract methods which could unnecessarily bulk up your code and its complexity.



  <details>
  <summary>
  Examples
  </summary>

  ```python
  trainer.add_event_handler(Events.STARTED, lambda _: print("Start training"))


  mydata = [1, 2, 3, 4]
  logger = ...

  def on_training_ended(data):
      print(f"Training is ended. mydata={data}")
      
      logger.info("Training is ended")


  trainer.add_event_handler(Events.COMPLETED, on_training_ended, mydata)

  trainer.add_event_handler(Events.COMPLETED, lambda engine: print(engine.state.times))

  @trainer.on(Events.ITERATION_COMPLETED)
  def log_something(engine):
      print(engine.state.output)
  ```

  </details>



  <details>
  <summary>
  Examples
  </summary>

  ```python

  @trainer.on(Events.EPOCH_COMPLETED(every=5))
  def run_validation():
      


  @trainer.on(Events.EPOCH_STARTED(once=20))
  def change_training_variable():
      


  @trainer.on(Events.ITERATION_COMPLETED(event_filter=first_x_iters))
  def log_gradients():
      
  ```

  </details>



  <details>
  <summary>
  Examples
  </summary>

  Events can be stacked together to enable multiple calls:

  ```python
  @trainer.on(Events.COMPLETED | Events.EPOCH_COMPLETED(every=10))
  def run_validation():
      
  ```

  </details>



  <details>
  <summary>
  Examples
  </summary>

  Custom events related to backward and optimizer step calls:

  ```python
  from ignite.engine import EventEnum


  class BackpropEvents(EventEnum):
      BACKWARD_STARTED = 'backward_started'
      BACKWARD_COMPLETED = 'backward_completed'
      OPTIM_STEP_COMPLETED = 'optim_step_completed'

  def update(engine, batch):
      
      loss = criterion(y_pred, y)
      engine.fire_event(BackpropEvents.BACKWARD_STARTED)
      loss.backward()
      engine.fire_event(BackpropEvents.BACKWARD_COMPLETED)
      optimizer.step()
      engine.fire_event(BackpropEvents.OPTIM_STEP_COMPLETED)
      

  trainer = Engine(update)
  trainer.register_events(*BackpropEvents)

  @trainer.on(BackpropEvents.BACKWARD_STARTED)
  def function_before_backprop(engine):
      
  ```

  - Complete snippet is found [here](https://pytorch.org/ignite/faq.html#creating-custom-events-based-on-forward-backward-pass).
  - Another use-case of custom events: [trainer for Truncated Backprop Through Time](https://pytorch.org/ignite/contrib/engines.html#ignite.contrib.engines.create_supervised_tbptt_trainer).

  </details>



  - [Metrics](https://pytorch.org/ignite/metrics.html#complete-list-of-metrics) for various tasks:
    Precision, Recall, Accuracy, Confusion Matrix, IoU etc, ~20 [regression metrics](https://pytorch.org/ignite/contrib/metrics.html#regression-metrics).

  - Users can also [compose their metrics](https://pytorch.org/ignite/metrics.html#metric-arithmetics) with ease from
    existing ones using arithmetic operations or torch methods.

  <details>
  <summary>
  Example
  </summary>

  ```python
  precision = Precision(average=False)
  recall = Recall(average=False)
  F1_per_class = (precision * recall * 2 / (precision + recall))
  F1_mean = F1_per_class.mean()  # torch mean method
  F1_mean.attach(engine, "F1")
  ```

  </details>

  <!-- ############################################################################################################### -->



  From [pip](https://pypi.org/project/pytorch-ignite/):

  ```bash
  pip install pytorch-ignite
  ```

  From [conda](https://anaconda.org/pytorch/ignite):

  ```bash
  conda install ignite -c pytorch
  ```

  From source:

  ```bash
  pip install git+https://github.com/pytorch/ignite
  ```



  From pip:

  ```bash
  pip install --pre pytorch-ignite
  ```

  From conda (this suggests to install [pytorch nightly release](https://anaconda.org/pytorch-nightly/pytorch) instead of stable
  version as dependency):

  ```bash
  conda install ignite -c pytorch-nightly
  ```





  Pull a pre-built docker image from [our Docker Hub](https://hub.docker.com/u/pytorchignite) and run it with docker v19.03+.

  ```bash
  docker run --gpus all -it -v $PWD:/workspace/project --network=host --shm-size 16G pytorchignite/base:latest /bin/bash
  ```

  <details>

  <summary>
  List of available pre-built images
  </summary>

  Base
  - `pytorchignite/base:latest`
  - `pytorchignite/apex:latest`
  - `pytorchignite/hvd-base:latest`
  - `pytorchignite/hvd-apex:latest`
  - `pytorchignite/msdp-apex:latest`

  Vision:
  - `pytorchignite/vision:latest`
  - `pytorchignite/hvd-vision:latest`
  - `pytorchignite/apex-vision:latest`
  - `pytorchignite/hvd-apex-vision:latest`
  - `pytorchignite/msdp-apex-vision:latest`

  NLP:
  - `pytorchignite/nlp:latest`
  - `pytorchignite/hvd-nlp:latest`
  - `pytorchignite/apex-nlp:latest`
  - `pytorchignite/hvd-apex-nlp:latest`
  - `pytorchignite/msdp-apex-nlp:latest`

  </details>

  For more details, see [here](docker).

  <!-- ############################################################################################################### -->



  Few pointers to get you started:

  - [Quick Start Guide: Essentials of getting a project up and running](https://pytorch.org/ignite/quickstart.html)
  - [Concepts of the library: Engine, Events & Handlers, State, Metrics](https://pytorch.org/ignite/concepts.html)
  - Full-featured template examples (coming soon)

  <!-- ############################################################################################################### -->



  - Stable API documentation and an overview of the library: https://pytorch.org/ignite/
  - Development version API documentation: https://pytorch.org/ignite/master/
  - [FAQ](https://pytorch.org/ignite/faq.html),
    ["Questions on Github"](https://github.com/pytorch/ignite/issues?q=is%3Aissue+label%3Aquestion+) and
    ["Questions on Discuss.PyTorch"](https://discuss.pytorch.org/c/ignite).
  - [Project's Roadmap](https://github.com/pytorch/ignite/wiki/Roadmap)



  - [Distributed Training Made Easy with PyTorch-Ignite](https://labs.quansight.org/blog/2021/06/distributed-made-easy-with-ignite/)
  - [PyTorch Ecosystem Day 2021 Breakout session presentation](https://colab.research.google.com/drive/1qhUgWQ0N2U71IVShLpocyeY4AhlDCPRd)
  - [Tutorial blog post about PyTorch-Ignite](https://labs.quansight.org/blog/2020/09/pytorch-ignite/)
  - [8 Creators and Core Contributors Talk About Their Model Training Libraries From PyTorch Ecosystem](https://neptune.ai/blog/model-training-libraries-pytorch-ecosystem?utm_source=reddit&utm_medium=post&utm_campaign=blog-model-training-libraries-pytorch-ecosystem)
  - Ignite Posters from Pytorch Developer Conferences:
    - [2021](https://drive.google.com/file/d/1YXrkJIepPk_KltSG1ZfWRtA5IRgPFz_U)
    - [2019](https://drive.google.com/open?id=1bqIl-EM6GCCCoSixFZxhIbuF25F2qTZg)
    - [2018](https://drive.google.com/open?id=1_2vzBJ0KeCjGv1srojMHiJRvceSVbVR5)

  <!-- ############################################################################################################### -->





  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/TextCNN.ipynb) [Text Classification using Convolutional Neural
    Networks](https://github.com/pytorch/ignite/blob/master/examples/notebooks/TextCNN.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/VAE.ipynb) [Variational Auto
    Encoders](https://github.com/pytorch/ignite/blob/master/examples/notebooks/VAE.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/FashionMNIST.ipynb) [Convolutional Neural Networks for Classifying Fashion-MNIST
    Dataset](https://github.com/pytorch/ignite/blob/master/examples/notebooks/FashionMNIST.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/CycleGAN_with_nvidia_apex.ipynb) [Training Cycle-GAN on Horses to
    Zebras with Nvidia/Apex](https://github.com/pytorch/ignite/blob/master/examples/notebooks/CycleGAN_with_nvidia_apex.ipynb) - [ logs on W&B](https://app.wandb.ai/vfdev-5/ignite-cyclegan-apex)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/CycleGAN_with_torch_cuda_amp.ipynb) [Another training Cycle-GAN on Horses to
    Zebras with Native Torch CUDA AMP](https://github.com/pytorch/ignite/blob/master/examples/notebooks/CycleGAN_with_torch_cuda_amp.ipynb) - [logs on W&B](https://app.wandb.ai/vfdev-5/ignite-cyclegan-torch-amp)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/EfficientNet_Cifar100_finetuning.ipynb) [Finetuning EfficientNet-B0 on
    CIFAR100](https://github.com/pytorch/ignite/blob/master/examples/notebooks/EfficientNet_Cifar100_finetuning.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/Cifar10_Ax_hyperparam_tuning.ipynb) [Hyperparameters tuning with
    Ax](https://github.com/pytorch/ignite/blob/master/examples/notebooks/Cifar10_Ax_hyperparam_tuning.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/FastaiLRFinder_MNIST.ipynb) [Basic example of LR finder on
    MNIST](https://github.com/pytorch/ignite/blob/master/examples/notebooks/FastaiLRFinder_MNIST.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/Cifar100_bench_amp.ipynb) [Benchmark mixed precision training on Cifar100:
    torch.cuda.amp vs nvidia/apex](https://github.com/pytorch/ignite/blob/master/examples/notebooks/Cifar100_bench_amp.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/MNIST_on_TPU.ipynb) [MNIST training on a single
    TPU](https://github.com/pytorch/ignite/blob/master/examples/notebooks/MNIST_on_TPU.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1E9zJrptnLJ_PKhmaP5Vhb6DTVRvyrKHx) [CIFAR10 Training on multiple TPUs](https://github.com/pytorch/ignite/tree/master/examples/contrib/cifar10)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/HandlersTimeProfiler_MNIST.ipynb) [Basic example of handlers
    time profiling on MNIST training example](https://github.com/pytorch/ignite/blob/master/examples/notebooks/HandlersTimeProfiler_MNIST.ipynb)



  Inspired by [torchvision/references](https://github.com/pytorch/vision/tree/master/references),
  we provide several reproducible baselines for vision tasks:

  - [ImageNet](examples/references/classification/imagenet) - logs on Ignite Trains server coming soon ...
  - [Pascal VOC2012](examples/references/segmentation/pascal_voc2012) - logs on Ignite Trains server coming soon ...

  Features:

  - Distributed training: native or horovod and using [PyTorch native AMP](https://pytorch.org/docs/stable/notes/amp_examples.html)



  The easiest way to create your training scripts with PyTorch-Ignite:
  - https://code-generator.pytorch-ignite.ai/


  <!-- ############################################################################################################### -->



  - [GitHub issues](https://github.com/pytorch/ignite/issues): questions, bug reports, feature requests, etc.

  - [Discuss.PyTorch](https://discuss.pytorch.org/c/ignite), category "Ignite".

  - [PyTorch-Ignite Discord Server](https://discord.gg/djZtm3EmKj): to chat with the community

  - [GitHub Discussions](https://github.com/pytorch/ignite/discussions): general library-related discussions, ideas, Q&A, etc.



  We have created a form for ["user feedback"](https://github.com/pytorch/ignite/issues/new/choose). We
  appreciate any type of feedback, and this is how we would like to see our
  community:

  - If you like the project and want to say thanks, this the right
    place.
  - If you do not like something, please, share it with us, and we can
    see how to improve it.

  Thank you!

  <!-- ############################################################################################################### -->



  Please see the [contribution guidelines](https://github.com/pytorch/ignite/blob/master/CONTRIBUTING.md) for more information.

  As always, PRs are welcome :)

  <!-- ############################################################################################################### -->



  <details>

  <summary>
  Research papers
  </summary>

  - [BatchBALD: Efficient and Diverse Batch Acquisition for Deep Bayesian Active Learning](https://github.com/BlackHC/BatchBALD)
  - [A Model to Search for Synthesizable Molecules](https://github.com/john-bradshaw/molecule-chef)
  - [Localised Generative Flows](https://github.com/jrmcornish/lgf)
  - [Extracting T Cell Function and Differentiation Characteristics from the Biomedical Literature](https://github.com/hammerlab/t-cell-relation-extraction)
  - [Variational Information Distillation for Knowledge Transfer](https://github.com/amzn/xfer/tree/master/var_info_distil)
  - [XPersona: Evaluating Multilingual Personalized Chatbot](https://github.com/HLTCHKUST/Xpersona)
  - [CNN-CASS: CNN for Classification of Coronary Artery Stenosis Score in MPR Images](https://github.com/ucuapps/CoronaryArteryStenosisScoreClassification)
  - [Bridging Text and Video: A Universal Multimodal Transformer for Video-Audio Scene-Aware Dialog](https://github.com/ictnlp/DSTC8-AVSD)
  - [Adversarial Decomposition of Text Representation](https://github.com/text-machine-lab/adversarial_decomposition)
  - [Uncertainty Estimation Using a Single Deep Deterministic Neural Network](https://github.com/y0ast/deterministic-uncertainty-quantification)
  - [DeepSphere: a graph-based spherical CNN](https://github.com/deepsphere/deepsphere-pytorch)
  - [Norm-in-Norm Loss with Faster Convergence and Better Performance for Image Quality Assessment](https://github.com/lidq92/LinearityIQA)
  - [Unified Quality Assessment of In-the-Wild Videos with Mixed Datasets Training](https://github.com/lidq92/MDTVSFA)
  - [Deep Signature Transforms](https://github.com/patrick-kidger/Deep-Signature-Transforms)
  - [Neural CDEs for Long Time-Series via the Log-ODE Method](https://github.com/jambo6/neuralCDEs-via-logODEs)
  - [Volumetric Grasping Network](https://github.com/ethz-asl/vgn)
  - [Mood Classification using Listening Data](https://github.com/fdlm/listening-moods)
  - [Deterministic Uncertainty Estimation (DUE)](https://github.com/y0ast/DUE)
  - [PyTorch-Hebbian: facilitating local learning in a deep learning framework](https://github.com/Joxis/pytorch-hebbian)
  - [Stochastic Weight Matrix-Based Regularization Methods for Deep Neural Networks](https://github.com/rpatrik96/lod-wmm-2019)
  - [Learning explanations that are hard to vary](https://github.com/gibipara92/learning-explanations-hard-to-vary)
  - [The role of disentanglement in generalisation](https://github.com/mmrl/disent-and-gen)
  - [A Probabilistic Programming Approach to Protein Structure Superposition](https://github.com/LysSanzMoreta/Theseus-PP)
  - [PadChest: A large chest x-ray image dataset with multi-label annotated reports](https://github.com/auriml/Rx-thorax-automatic-captioning)

  </details>

  <details>

  <summary>
  Blog articles, tutorials, books
  </summary>

  - [State-of-the-Art Conversational AI with Transfer Learning](https://github.com/huggingface/transfer-learning-conv-ai)
  - [Tutorial on Transfer Learning in NLP held at NAACL 2019](https://github.com/huggingface/naacl_transfer_learning_tutorial)
  - [Deep-Reinforcement-Learning-Hands-On-Second-Edition, published by Packt](https://github.com/PacktPublishing/Deep-Reinforcement-Learning-Hands-On-Second-Edition)
  - [Once Upon a Repository: How to Write Readable, Maintainable Code with PyTorch](https://towardsdatascience.com/once-upon-a-repository-how-to-write-readable-maintainable-code-with-pytorch-951f03f6a829)
  - [The Hero Rises: Build Your Own SSD](https://allegro.ai/blog/the-hero-rises-build-your-own-ssd/)
  - [Using Optuna to Optimize PyTorch Ignite Hyperparameters](https://medium.com/pytorch/using-optuna-to-optimize-pytorch-ignite-hyperparameters-626ffe6d4783)
  - [PyTorch Ignite - Classifying Tiny ImageNet with EfficientNet](https://towardsdatascience.com/pytorch-ignite-classifying-tiny-imagenet-with-efficientnet-e5b1768e5e8f)

  </details>

  <details>

  <summary>
  Toolkits
  </summary>

  - [Project MONAI - AI Toolkit for Healthcare Imaging](https://github.com/Project-MONAI/MONAI)
  - [DeepSeismic - Deep Learning for Seismic Imaging and Interpretation](https://github.com/microsoft/seismic-deeplearning)
  - [Nussl - a flexible, object-oriented Python audio source separation library](https://github.com/nussl/nussl)
  - [PyTorch Adapt - A fully featured and modular domain adaptation library](https://github.com/KevinMusgrave/pytorch-adapt)
  - [gnina-torch: PyTorch implementation of GNINA scoring function](https://github.com/RMeli/gnina-torch)

  </details>

  <details>

  <summary>
  Others
  </summary>

  - [Implementation of "Attention is All You Need" paper](https://github.com/akurniawan/pytorch-transformer)
  - [Implementation of DropBlock: A regularization method for convolutional networks in PyTorch](https://github.com/miguelvr/dropblock)
  - [Kaggle Kuzushiji Recognition: 2nd place solution](https://github.com/lopuhin/kaggle-kuzushiji-2019)
  - [Unsupervised Data Augmentation experiments in PyTorch](https://github.com/vfdev-5/UDA-pytorch)
  - [Hyperparameters tuning with Optuna](https://github.com/optuna/optuna-examples/blob/main/pytorch/pytorch_ignite_simple.py)
  - [Logging with ChainerUI](https://chainerui.readthedocs.io/en/latest/reference/module.html#external-library-support)
  - [FixMatch experiments in PyTorch and Ignite (CTA dataaug policy)](https://github.com/vfdev-5/FixMatch-pytorch)
  - [Kaggle Birdcall Identification Competition: 1st place solution](https://github.com/ryanwongsa/kaggle-birdsong-recognition)
  - [Logging with Aim - An open-source experiment tracker](https://aimstack.readthedocs.io/en/latest/quick_start/integrations.html#integration-with-pytorch-ignite)

  </details>

  See other projects at ["Used by"](https://github.com/pytorch/ignite/network/dependents?package_id=UGFja2FnZS02NzI5ODEwNA%3D%3D)

  If your project implements a paper, represents other use-cases not
  covered in our official tutorials, Kaggle competition's code, or just
  your code presents interesting results and uses Ignite. We would like to
  add your project to this list, so please send a PR with brief
  description of the project.

  <!-- ############################################################################################################### -->



  If you use PyTorch-Ignite in a scientific publication, we would appreciate citations to our project.

  ```
  @misc{pytorch-ignite,
    author = {V. Fomin and J. Anmol and S. Desroziers and J. Kriss and A. Tejani},
    title = {High-level library to help with training neural networks in PyTorch},
    year = {2020},
    publisher = {GitHub},
    journal = {GitHub repository},
    howpublished = {\url{https://github.com/pytorch/ignite}},
  }
  ```

  <!-- ############################################################################################################### -->



  PyTorch-Ignite is a [NumFOCUS Affiliated Project](https://www.numfocus.org/), operated and maintained by volunteers in the PyTorch community in their capacities as individuals
  (and not as representatives of their employers). See the ["About us"](https://pytorch-ignite.ai/about/community/#about-us)
  page for a list of core contributors. For usage questions and issues, please see the various channels
  [here](#communication). For all other questions and inquiries, please send an email
  to contact@pytorch-ignite.ai.


pkgId: a34f2a3f2e60e5b181d379256d17785cebb14fed7c2d743cc93a0578c2d14419
name: python-pytorch-lightning
arch: src
version: 2.0.1
epoch: 0
release: 1
url: https://github.com/Lightning-AI/lightning
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-45491569-7a6a-47ea-9f92-d0649c86ddb5
location_href: 00009713-python-pytorch-lightning/python-pytorch-lightning-2.0.1-1.src.rpm
checksum_type: sha256
summary:
  PyTorch Lightning is the lightweight PyTorch wrapper for ML researchers. Scale your models. Write less boilerplate.

description:
  <div align="center">

  <img src="https://pl-public-data.s3.amazonaws.com/assets_lightning/pytorch-lightning.png" width="400px">

  **The lightweight PyTorch wrapper for high-performance AI research.
  Scale your models, not the boilerplate.**

  ______________________________________________________________________

  <p align="center">
    <a href="https://www.pytorchlightning.ai/">Website</a> •
    <a href="#key-features">Key Features</a> •
    <a href="#how-to-use">How To Use</a> •
    <a href="https://lightning.ai/docs/pytorch/stable/">Docs</a> •
    <a href="#examples">Examples</a> •
    <a href="#community">Community</a> •
    <a href="https://lightning.ai/">Lightning AI</a> •
    <a href="https://github.com/Lightning-AI/lightning/blob/master/LICENSE">License</a>
  </p>

  <!-- DO NOT ADD CONDA DOWNLOADS... README CHANGES MUST BE APPROVED BY EDEN OR WILL -->

  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pytorch-lightning)](https://pypi.org/project/pytorch-lightning/)
  [![PyPI Status](https://badge.fury.io/py/pytorch-lightning.svg)](https://badge.fury.io/py/pytorch-lightning)
  [![PyPI Status](https://pepy.tech/badge/pytorch-lightning)](https://pepy.tech/project/pytorch-lightning)
  [![Conda](https://img.shields.io/conda/v/conda-forge/pytorch-lightning?label=conda&color=success)](https://anaconda.org/conda-forge/pytorch-lightning)
  [![DockerHub](https://img.shields.io/docker/pulls/pytorchlightning/pytorch_lightning.svg)](https://hub.docker.com/r/pytorchlightning/pytorch_lightning)
  [![codecov](https://codecov.io/gh/Lightning-AI/lightning/release/2.0.1/graph/badge.svg)](https://codecov.io/gh/Lightning-AI/lightning)

  [![ReadTheDocs](https://readthedocs.org/projects/pytorch-lightning/badge/?version=2.0.1)](https://lightning.ai/docs/pytorch/stable/)[![Discord](https://img.shields.io/discord/1077906959069626439?style=plastic)](https://discord.gg/VptPCZkGNa)
  [![license](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/Lightning-AI/lightning/blob/master/LICENSE)

  <!--
  [![CodeFactor](https://www.codefactor.io/repository/github/Lightning-AI/lightning/badge)](https://www.codefactor.io/repository/github/Lightning-AI/lightning)
  -->

  </div>



  ______________________________________________________________________



  Lightning disentangles PyTorch code to decouple the science from the engineering.
  ![PT to PL](../../https://github.com/Lightning-AI/lightning/raw/2.0.1/docs/source-app/_static/images/general/pl_quick_start_full_compressed.gif)

  ______________________________________________________________________



  Lightning structures PyTorch code with these principles:

  <div align="center">
    <img src="https://pl-bolts-doc-images.s3.us-east-2.amazonaws.com/philosophies.jpg" max-height="250px">
  </div>

  Lightning forces the following structure to your code which makes it reusable and shareable:

  - Research code (the LightningModule).
  - Engineering code (you delete, and is handled by the Trainer).
  - Non-essential research code (logging, etc... this goes in Callbacks).
  - Data (use PyTorch DataLoaders or organize them into a LightningDataModule).

  Once you do this, you can train on multiple-GPUs, TPUs, CPUs, IPUs, HPUs and even in 16-bit precision without changing your code!

  [Get started in just 15 minutes](https://lightning.ai/docs/pytorch/latest/starter/introduction.html)

  ______________________________________________________________________



  Lightning is rigorously tested across multiple CPUs, GPUs, TPUs, IPUs, and HPUs and against major Python and PyTorch versions.

  <details>
    <summary>Current build statuses</summary>

  <center>

  |       System / PyTorch ver.        |                                                                                              1.11                                                                                               |                                                                                                              1.12                                                                                                               | 1.13                                                                                                                                                                                                                            | 2.0  |
  | :--------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---- |
  |        Linux py3.9 \[GPUs\]        |                                                                                                -                                                                                                | [![Build Status](<https://dev.azure.com/Lightning-AI/lightning/_apis/build/status/pytorch-lightning%20(GPUs)?branchName=refs%2Ftags%2F2.0.1>)](https://dev.azure.com/Lightning-AI/lightning/_build/latest?definitionId=24&branchName=master) | [![Build Status](<https://dev.azure.com/Lightning-AI/lightning/_apis/build/status/pytorch-lightning%20(GPUs)?branchName=refs%2Ftags%2F2.0.1>)](https://dev.azure.com/Lightning-AI/lightning/_build/latest?definitionId=24&branchName=master) | Soon |
  |        Linux py3.9 \[TPUs\]        |                                                                                                -                                                                                                |                     [![Test PyTorch - TPU](https://github.com/Lightning-AI/lightning/actions/workflows/tpu-tests.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/tpu-tests.yml)                     |                                                                                                                                                                                                                                 | Soon |
  |        Linux py3.8 \[IPUs\]        |                                                                                                -                                                                                                |                                                                                                                -                                                                                                                | [![Build Status](<https://dev.azure.com/Lightning-AI/lightning/_apis/build/status/pytorch-lightning%20(IPUs)?branchName=refs%2Ftags%2F2.0.1>)](https://dev.azure.com/Lightning-AI/lightning/_build/latest?definitionId=25&branchName=master) | Soon |
  |        Linux py3.8 \[HPUs\]        |                                                                                                -                                                                                                |                                                                                                                -                                                                                                                | [![Build Status](<https://dev.azure.com/Lightning-AI/lightning/_apis/build/status/pytorch-lightning%20(HPUs)?branchName=refs%2Ftags%2F2.0.1>)](https://dev.azure.com/Lightning-AI/lightning/_build/latest?definitionId=26&branchName=master) | Soon |
  |  Linux (multiple Python versions)  | [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml) |                 [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml)                 | [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml)                                 | Soon |
  |   OSX (multiple Python versions)   | [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml) |                 [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml)                 | [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml)                                 | Soon |
  | Windows (multiple Python versions) | [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml) |                 [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml)                 | [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml)                                 | Soon |

  </center>
  </details>

  ______________________________________________________________________





  Simple installation from PyPI

  ```bash
  pip install pytorch-lightning
  ```

  <!--  -->



  ```python
  import os
  import torch
  from torch import nn
  import torch.nn.functional as F
  from torchvision.datasets import MNIST
  from torch.utils.data import DataLoader, random_split
  from torchvision import transforms
  import pytorch_lightning as pl
  ```



  A LightningModule defines a full *system* (ie: a GAN, autoencoder, BERT or a simple Image Classifier).

  ```python
  class LitAutoEncoder(pl.LightningModule):
      def __init__(self):
          super().__init__()
          self.encoder = nn.Sequential(nn.Linear(28 * 28, 128), nn.ReLU(), nn.Linear(128, 3))
          self.decoder = nn.Sequential(nn.Linear(3, 128), nn.ReLU(), nn.Linear(128, 28 * 28))

      def forward(self, x):
          
          embedding = self.encoder(x)
          return embedding

      def training_step(self, batch, batch_idx):
          
          x, y = batch
          x = x.view(x.size(0), -1)
          z = self.encoder(x)
          x_hat = self.decoder(z)
          loss = F.mse_loss(x_hat, x)
          self.log("train_loss", loss)
          return loss

      def configure_optimizers(self):
          optimizer = torch.optim.Adam(self.parameters(), lr=1e-3)
          return optimizer
  ```

  **Note: Training_step defines the training loop. Forward defines how the LightningModule behaves during inference/prediction.**



  ```python
  dataset = MNIST(os.getcwd(), download=True, transform=transforms.ToTensor())
  train, val = random_split(dataset, [55000, 5000])

  autoencoder = LitAutoEncoder()
  trainer = pl.Trainer()
  trainer.fit(autoencoder, DataLoader(train), DataLoader(val))
  ```



  Lightning has over [40+ advanced features](https://lightning.ai/docs/pytorch/latest/common/trainer.html#trainer-flags) designed for professional AI research at scale.

  Here are some examples:

  <div align="center">
    <img src="https://pl-bolts-doc-images.s3.us-east-2.amazonaws.com/features_2.jpg" max-height="600px">
  </div>

  <details>
    <summary>Highlighted feature code snippets</summary>

  ```python


  trainer = Trainer(max_epochs=1, accelerator="gpu", devices=8)


  trainer = Trainer(max_epochs=1, accelerator="gpu", devices=8, num_nodes=32)
  ```

  <summary>Train on TPUs without code changes</summary>

  ```python

  trainer = Trainer(accelerator="tpu", devices=8)
  ```

  <summary>16-bit precision</summary>

  ```python

  trainer = Trainer(precision=16)
  ```

  <summary>Experiment managers</summary>

  ```python
  from pytorch_lightning import loggers


  trainer = Trainer(logger=TensorBoardLogger("logs/"))


  trainer = Trainer(logger=loggers.WandbLogger())


  trainer = Trainer(logger=loggers.CometLogger())


  trainer = Trainer(logger=loggers.MLFlowLogger())


  trainer = Trainer(logger=loggers.NeptuneLogger())


  ```

  <summary>EarlyStopping</summary>

  ```python
  es = EarlyStopping(monitor="val_loss")
  trainer = Trainer(callbacks=[es])
  ```

  <summary>Checkpointing</summary>

  ```python
  checkpointing = ModelCheckpoint(monitor="val_loss")
  trainer = Trainer(callbacks=[checkpointing])
  ```

  <summary>Export to torchscript (JIT) (production use)</summary>

  ```python

  autoencoder = LitAutoEncoder()
  torch.jit.save(autoencoder.to_torchscript(), "model.pt")
  ```

  <summary>Export to ONNX (production use)</summary>

  ```python
  autoencoder = LitAutoEncoder()
  input_sample = torch.randn((1, 64))
  with tempfile.NamedTemporaryFile(suffix=".onnx", delete=False) as tmpfile:
      autoencoder.to_onnx(tmpfile.name, input_sample, export_params=True)
  ```

  </details>



  For complex/professional level work, you have optional full control of the optimizers.

  ```python
  class LitAutoEncoder(pl.LightningModule):
      def __init__(self):
          super().__init__()
          self.automatic_optimization = False

      def training_step(self, batch, batch_idx):
          
          opt_a, opt_b = self.optimizers(use_pl_optimizer=True)

          loss_a = ...
          self.manual_backward(loss_a, opt_a)
          opt_a.step()
          opt_a.zero_grad()

          loss_b = ...
          self.manual_backward(loss_b, opt_b, retain_graph=True)
          self.manual_backward(loss_b, opt_b)
          opt_b.step()
          opt_b.zero_grad()
  ```

  ______________________________________________________________________



  - Models become hardware agnostic
  - Code is clear to read because engineering code is abstracted away
  - Easier to reproduce
  - Make fewer mistakes because lightning handles the tricky engineering
  - Keeps all the flexibility (LightningModules are still PyTorch modules), but removes a ton of boilerplate
  - Lightning has dozens of integrations with popular machine learning tools.
  - [Tested rigorously with every new PR](https://github.com/Lightning-AI/lightning/tree/master/tests). We test every combination of PyTorch and Python supported versions, every OS, multi GPUs and even TPUs.
  - Minimal running speed overhead (about 300 ms per epoch compared with pure PyTorch).

  ______________________________________________________________________





  - [CPC transforms](https://lightning-bolts.readthedocs.io/en/stable/transforms/self_supervised.html#cpc-transforms)
  - [Moco v2 tranforms](https://lightning-bolts.readthedocs.io/en/stable/transforms/self_supervised.html#moco-v2-transforms)
  - [SimCLR transforms](https://lightning-bolts.readthedocs.io/en/stable/transforms/self_supervised.html#simclr-transforms)



  - [GPT-2](https://lightning-bolts.readthedocs.io/en/stable/models/convolutional.html#gpt-2)
  - [UNet](https://lightning-bolts.readthedocs.io/en/stable/models/convolutional.html#unet)



  - [DQN Loss](https://lightning-bolts.readthedocs.io/en/stable/losses.html#dqn-loss)
  - [Double DQN Loss](https://lightning-bolts.readthedocs.io/en/stable/losses.html#double-dqn-loss)
  - [Per DQN Loss](https://lightning-bolts.readthedocs.io/en/stable/losses.html#per-dqn-loss)



  - [Basic GAN](https://lightning-bolts.readthedocs.io/en/stable/models/gans.html#basic-gan)
  - [DCGAN](https://lightning-bolts.readthedocs.io/en/stable/models/gans.html#dcgan)



  - [Logistic Regression](https://lightning-bolts.readthedocs.io/en/stable/models/classic_ml.html#logistic-regression)
  - [Linear Regression](https://lightning-bolts.readthedocs.io/en/stable/models/classic_ml.html#linear-regression)

  ______________________________________________________________________



  The PyTorch Lightning community is maintained by

  - [10+ core contributors](https://lightning.ai/docs/pytorch/latest/governance.html) who are all a mix of professional engineers, Research Scientists, and Ph.D. students from top AI labs.
  - 680+ active community contributors.

  Want to help us build Lightning and reduce boilerplate for thousands of researchers? [Learn how to make your first contribution here](https://devblog.pytorchlightning.ai/quick-contribution-guide-86d977171b3a)

  PyTorch Lightning is also part of the [PyTorch ecosystem](https://pytorch.org/ecosystem/) which requires projects to have solid testing, documentation and support.



  If you have any questions please:

  1. [Read the docs](https://lightning.ai/docs/pytorch/latest).
  1. [Search through existing Discussions](https://github.com/Lightning-AI/lightning/discussions), or [add a new question](https://github.com/Lightning-AI/lightning/discussions/new)
  1. [Join our Discord community](https://discord.gg/VptPCZkGNa).


pkgId: deaa6c457785c1ae2f662f32e4b718c09fef21abbaee09efaff798ca736f1744
name: python-pytorch-metric-learning
arch: src
version: 2.1.0
epoch: 0
release: 1
url: https://github.com/KevinMusgrave/pytorch-metric-learning
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f00e9bc3-d669-4876-a76c-977d74541a29
location_href: 00011443-python-pytorch-metric-learning/python-pytorch-metric-learning-2.1.0-1.src.rpm
checksum_type: sha256
summary:
  The easiest way to use deep metric learning in your application. Modular, flexible, and extensible. Written in PyTorch.

description:
  <h1>
  <a href="https://github.com/KevinMusgrave/pytorch-metric-learning">
  <img alt="PyTorch Metric Learning" src="https://github.com/KevinMusgrave/pytorch-metric-learning/blob/master/docs/imgs/Logo2.png">
  </a>
  </h1>

  <p align="center">
   <a href="https://pypi.org/project/pytorch-metric-learning">
       <img alt="PyPi version" src="https://img.shields.io/pypi/v/pytorch-metric-learning?color=bright-green">
   </a>



   <a href="https://anaconda.org/conda-forge/pytorch-metric-learning">
       <img alt="Anaconda version" src="https://img.shields.io/conda/v/conda-forge/pytorch-metric-learning?color=bright-green">
   </a>
  </p>



  **January 16**: v1.7.0
  - Fixes an edge case in ArcFaceLoss. See the [release notes](https://github.com/KevinMusgrave/pytorch-metric-learning/releases/tag/v1.7.0).
  - Thanks to contributor [ElisonSherton](https://github.com/ElisonSherton).

  **September 3**: v1.6.0
  - `DistributedLossWrapper` and `DistributedMinerWrapper` now support `ref_emb` and `ref_labels`.
  - Thanks to contributor [NoTody](https://github.com/NoTody).


  - [**View the documentation here**](https://kevinmusgrave.github.io/pytorch-metric-learning/)
  - [**View the installation instructions here**](https://github.com/KevinMusgrave/pytorch-metric-learning#installation)
  - [**View the available losses, miners etc. here**](https://github.com/KevinMusgrave/pytorch-metric-learning/blob/master/CONTENTS.md)



  See the [examples folder](https://github.com/KevinMusgrave/pytorch-metric-learning/blob/master/examples/README.md) for notebooks you can download or run on Google Colab.



  This library contains 9 modules, each of which can be used independently within your existing codebase, or combined together for a complete train/test workflow.

  ![high_level_module_overview](docs/imgs/high_level_module_overview.png)






  Let’s initialize a plain [TripletMarginLoss](https://kevinmusgrave.github.io/pytorch-metric-learning/losses/#tripletmarginloss):
  ```python
  from pytorch_metric_learning import losses
  loss_func = losses.TripletMarginLoss()
  ```

  To compute the loss in your training loop, pass in the embeddings computed by your model, and the corresponding labels. The embeddings should have size (N, embedding_size), and the labels should have size (N), where N is the batch size.

  ```python

  for i, (data, labels) in enumerate(dataloader):
  	optimizer.zero_grad()
  	embeddings = model(data)
  	loss = loss_func(embeddings, labels)
  	loss.backward()
  	optimizer.step()
  ```

  The TripletMarginLoss computes all possible triplets within the batch, based on the labels you pass into it. Anchor-positive pairs are formed by embeddings that share the same label, and anchor-negative pairs are formed by embeddings that have different labels.

  Sometimes it can help to add a mining function:
  ```python
  from pytorch_metric_learning import miners, losses
  miner = miners.MultiSimilarityMiner()
  loss_func = losses.TripletMarginLoss()


  for i, (data, labels) in enumerate(dataloader):
  	optimizer.zero_grad()
  	embeddings = model(data)
  	hard_pairs = miner(embeddings, labels)
  	loss = loss_func(embeddings, labels, hard_pairs)
  	loss.backward()
  	optimizer.step()
  ```
  In the above code, the miner finds positive and negative pairs that it thinks are particularly difficult. Note that even though the TripletMarginLoss operates on triplets, it’s still possible to pass in pairs. This is because the library automatically converts pairs to triplets and triplets to pairs, when necessary.


  Loss functions can be customized using [distances](https://kevinmusgrave.github.io/pytorch-metric-learning/distances/), [reducers](https://kevinmusgrave.github.io/pytorch-metric-learning/reducers/), and [regularizers](https://kevinmusgrave.github.io/pytorch-metric-learning/regularizers/). In the diagram below, a miner finds the indices of hard pairs within a batch. These are used to index into the distance matrix, computed by the distance object. For this diagram, the loss function is pair-based, so it computes a loss per pair. In addition, a regularizer has been supplied, so a regularization loss is computed for each embedding in the batch. The per-pair and per-element losses are passed to the reducer, which (in this diagram) only keeps losses with a high value. The averages are computed for the high-valued pair and element losses, and are then added together to obtain the final loss.

  ![high_level_loss_function_overview](docs/imgs/high_level_loss_function_overview.png)

  Now here's an example of a customized TripletMarginLoss:
  ```python
  from pytorch_metric_learning.distances import CosineSimilarity
  from pytorch_metric_learning.reducers import ThresholdReducer
  from pytorch_metric_learning.regularizers import LpRegularizer
  from pytorch_metric_learning import losses
  loss_func = losses.TripletMarginLoss(distance = CosineSimilarity(),
  				     reducer = ThresholdReducer(high=0.3),
  			 	     embedding_regularizer = LpRegularizer())
  ```
  This customized triplet loss has the following properties:

   - The loss will be computed using cosine similarity instead of Euclidean distance.
   - All triplet losses that are higher than 0.3 will be discarded.
   - The embeddings will be L2 regularized.



  The TripletMarginLoss is an embedding-based or tuple-based loss. This means that internally, there is no real notion of "classes". Tuples (pairs or triplets) are formed at each iteration, based on the labels it receives. The labels don't have to represent classes. They simply need to indicate the positive and negative relationships between the embeddings. Thus, it is easy to use these loss functions for unsupervised or self-supervised learning.

  For example, the code below is a simplified version of the augmentation strategy commonly used in self-supervision. The dataset does not come with any labels. Instead, the labels are created in the training loop, solely to indicate which embeddings are positive pairs.

  ```python

  for i, data in enumerate(dataloader):
  	optimizer.zero_grad()
  	embeddings = your_model(data)
  	augmented = your_model(your_augmentation(data))
  	labels = torch.arange(embeddings.size(0))

  	embeddings = torch.cat([embeddings, augmented], dim=0)
  	labels = torch.cat([labels, labels], dim=0)

  	loss = loss_func(embeddings, labels)
  	loss.backward()
  	optimizer.step()
  ```

  If you're interested in [MoCo](https://arxiv.org/pdf/1911.05722.pdf)-style self-supervision, take a look at the [MoCo on CIFAR10](https://github.com/KevinMusgrave/pytorch-metric-learning/tree/master/examples#simple-examples) notebook. It uses CrossBatchMemory to implement the momentum encoder queue, which means you can use any tuple loss, and any tuple miner to extract hard samples from the queue.




  - For a convenient way to train your model, take a look at the [trainers](https://kevinmusgrave.github.io/pytorch-metric-learning/trainers/).
  - Want to test your model's accuracy on a dataset? Try the [testers](https://kevinmusgrave.github.io/pytorch-metric-learning/testers/).
  - To compute the accuracy of an embedding space directly, use [AccuracyCalculator](https://kevinmusgrave.github.io/pytorch-metric-learning/accuracy_calculation/).

  If you're short of time and want a complete train/test workflow, check out the [example Google Colab notebooks](https://github.com/KevinMusgrave/pytorch-metric-learning/tree/master/examples).

  To learn more about all of the above, [see the documentation](https://kevinmusgrave.github.io/pytorch-metric-learning).





   - ```pytorch-metric-learning >= v0.9.90``` requires ```torch >= 1.6```
   - ```pytorch-metric-learning < v0.9.90``` doesn't have a version requirement, but was tested with ```torch >= 1.2```

  Other dependencies: ```numpy, scikit-learn, tqdm, torchvision```


  ```
  pip install pytorch-metric-learning
  ```

  **To get the latest dev version**:
  ```
  pip install pytorch-metric-learning --pre
  ```

  **To install on Windows**:
  ```
  pip install torch===1.6.0 torchvision===0.7.0 -f https://download.pytorch.org/whl/torch_stable.html
  pip install pytorch-metric-learning
  ```

  **To install with evaluation and logging capabilities**

  (This will install the unofficial pypi version of faiss-gpu, plus record-keeper and tensorboard):
  ```
  pip install pytorch-metric-learning[with-hooks]
  ```

  **To install with evaluation and logging capabilities (CPU)**

  (This will install the unofficial pypi version of faiss-cpu, plus record-keeper and tensorboard):
  ```
  pip install pytorch-metric-learning[with-hooks-cpu]
  ```


  ```
  conda install -c conda-forge pytorch-metric-learning
  ```

  **To use the testing module, you'll need faiss, which can be installed via conda as well. See the [installation instructions for faiss](https://github.com/facebookresearch/faiss/blob/master/INSTALL.md).**

  </details>




  See [powerful-benchmarker](https://github.com/KevinMusgrave/powerful-benchmarker/) to view benchmark results and to use the benchmarking tool.



  Development is done on the ```dev``` branch:
  ```
  git checkout dev
  ```

  Unit tests can be run with the default ```unittest``` library:
  ```bash
  python -m unittest discover
  ```

  You can specify the test datatypes and test device as environment variables. For example, to test using float32 and float64 on the CPU:
  ```bash
  TEST_DTYPES=float32,float64 TEST_DEVICE=cpu python -m unittest discover
  ```

  To run a single test file instead of the entire test suite, specify the file name:
  ```bash
  python -m unittest tests/losses/test_angular_loss.py
  ```

  Code is formatted using ```black``` and ```isort```:
  ```bash
  pip install black isort
  ./format_code.sh
  ```





  Thanks to the contributors who made pull requests!

  | Contributor | Highlights |
  | -- | -- |
  |[mlopezantequera](https://github.com/mlopezantequera) | - Made the [testers](https://kevinmusgrave.github.io/pytorch-metric-learning/testers) work on any combination of query and reference sets <br/> - Made [AccuracyCalculator](https://kevinmusgrave.github.io/pytorch-metric-learning/accuracy_calculation/) work with arbitrary label comparisons |
  |[cwkeam](https://github.com/cwkeam) | - [VICRegLoss](https://kevinmusgrave.github.io/pytorch-metric-learning/losses/#vicregloss) <br/> - Added mean reciprocal rank accuracy to [AccuracyCalculator](https://kevinmusgrave.github.io/pytorch-metric-learning/accuracy_calculation/) |
  |[marijnl](https://github.com/marijnl)| - [BatchEasyHardMiner](https://kevinmusgrave.github.io/pytorch-metric-learning/miners/#batcheasyhardminer) <br/> - [TwoStreamMetricLoss](https://kevinmusgrave.github.io/pytorch-metric-learning/trainers/#twostreammetricloss) <br/> - [GlobalTwoStreamEmbeddingSpaceTester](https://kevinmusgrave.github.io/pytorch-metric-learning/testers/#globaltwostreamembeddingspacetester) <br/> - [Example using trainers.TwoStreamMetricLoss](https://github.com/KevinMusgrave/pytorch-metric-learning/blob/master/examples/notebooks/TwoStreamMetricLoss.ipynb) |
  | [chingisooinar](https://github.com/chingisooinar) | [SubCenterArcFaceLoss](https://kevinmusgrave.github.io/pytorch-metric-learning/losses/#subcenterarcfaceloss) |
  | [elias-ramzi](https://github.com/elias-ramzi) | [HierarchicalSampler](https://kevinmusgrave.github.io/pytorch-metric-learning/samplers/#hierarchicalsampler) |
  | [fjsj](https://github.com/fjsj) | [SupConLoss](https://kevinmusgrave.github.io/pytorch-metric-learning/losses/#supconloss) |
  | [AlenUbuntu](https://github.com/AlenUbuntu) | [CircleLoss](https://kevinmusgrave.github.io/pytorch-metric-learning/losses/#circleloss) |
  | [interestingzhuo](https://github.com/interestingzhuo) | [**PNPLoss**](https://kevinmusgrave.github.io/pytorch-metric-learning/losses/#pnploss) |
  | [wconnell](https://github.com/wconnell) | [Learning a scRNAseq Metric Embedding](https://github.com/KevinMusgrave/pytorch-metric-learning/blob/master/examples/notebooks/scRNAseq_MetricEmbedding.ipynb) |
  | [AlexSchuy](https://github.com/AlexSchuy) | optimized ```utils.loss_and_miner_utils.get_random_triplet_indices``` |
  | [JohnGiorgi](https://github.com/JohnGiorgi) | ```all_gather``` in [utils.distributed](https://kevinmusgrave.github.io/pytorch-metric-learning/distributed) |
  | [Hummer12007](https://github.com/Hummer12007) | ```utils.key_checker``` |
  | [vltanh](https://github.com/vltanh) | Made ```InferenceModel.train_indexer``` accept datasets |
  | [btseytlin](https://github.com/btseytlin) | ```get_nearest_neighbors``` in [InferenceModel](https://kevinmusgrave.github.io/pytorch-metric-learning/inference_models) |
  | [mlw214](https://github.com/mlw214) | Added ```return_per_class``` to [AccuracyCalculator](https://kevinmusgrave.github.io/pytorch-metric-learning/accuracy_calculation/) |
  | [layumi](https://github.com/layumi) | [InstanceLoss](https://kevinmusgrave.github.io/pytorch-metric-learning/losses/#instanceloss) |
  | [NoTody](https://github.com/NoTody) | Helped add `ref_emb` and `ref_labels` to the distributed wrappers. |
  | [ElisonSherton](https://github.com/ElisonSherton) | Fixed an edge case in ArcFaceLoss. |
  | [z1w](https://github.com/z1w) | |
  | [thinline72](https://github.com/thinline72) | |
  | [tpanum](https://github.com/tpanum) | |
  | [fralik](https://github.com/fralik) | |
  | [joaqo](https://github.com/joaqo) | |
  | [JoOkuma](https://github.com/JoOkuma) | |
  | [gkouros](https://github.com/gkouros) | |
  | [yutanakamura-tky](https://github.com/yutanakamura-tky) | |
  | [KinglittleQ](https://github.com/KinglittleQ) | |
  | [martin0258](https://github.com/martin0258) | |
  | [michaeldeyzel](https://github.com/michaeldeyzel) | |




  Thank you to [Ser-Nam Lim](https://research.fb.com/people/lim-ser-nam/) at [Facebook AI](https://ai.facebook.com/), and my research advisor, [Professor Serge Belongie](https://vision.cornell.edu/se3/people/serge-belongie/). This project began during my internship at Facebook AI where I received valuable feedback from Ser-Nam, and his team of computer vision and machine learning engineers and research scientists. In particular, thanks to [Ashish Shah](https://www.linkedin.com/in/ashish217/) and [Austin Reiter](https://www.linkedin.com/in/austin-reiter-3962aa7/) for reviewing my code during its early stages of development.


  This library contains code that has been adapted and modified from the following great open-source repos:
  - https://github.com/bnu-wangxun/Deep_Metric
  - https://github.com/chaoyuaw/incubator-mxnet/blob/master/example/gluon/embedding_learning
  - https://github.com/facebookresearch/deepcluster
  - https://github.com/geonm/proxy-anchor-loss
  - https://github.com/idstcv/SoftTriple
  - https://github.com/kunhe/FastAP-metric-learning
  - https://github.com/ronekko/deep_metric_learning
  - https://github.com/tjddus9597/Proxy-Anchor-CVPR2020
  - http://kaizhao.net/regularface


  Thanks to [Jeff Musgrave](https://www.designgenius.ca/) for designing the logo.


  If you'd like to cite pytorch-metric-learning in your paper, you can use this bibtex:
  ```latex
  @article{Musgrave2020PyTorchML,
    title={PyTorch Metric Learning},
    author={Kevin Musgrave and Serge J. Belongie and Ser-Nam Lim},
    journal={ArXiv},
    year={2020},
    volume={abs/2008.09164}
  }
  ```


pkgId: f65de20591b5bb3cf2230c389f77cbc31111048587847693a8382fb4c0014cce
name: python-pytube
arch: src
version: 12.1.3
epoch: 0
release: 1
summary: Python 3 library for downloading YouTube Videos.
url: https://github.com/pytube/pytube
rpm_license: The Unlicense (Unlicense)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3823dca5-2294-46aa-beca-1273c2594fd5
location_href: 00010659-python-pytube/python-pytube-12.1.3-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <p>
      <a href="#"><img src="https://assets.nickficano.com/gh-pytube.min.svg" width="456" height="143" alt="pytube logo" /></a>
    </p>
    <p align="center">
  	<a href="https://pypi.org/project/pytube/"><img src="https://img.shields.io/pypi/dm/pytube?style=flat-square" alt="pypi"/></a>
  	<a href="https://pytube.io/en/latest/"><img src="https://readthedocs.org/projects/python-pytube/badge/?version=latest&style=flat-square" /></a>
  	<a href="https://pypi.org/project/pytube/"><img src="https://img.shields.io/pypi/v/pytube?style=flat-square" /></a>
    </p>
  </div>



  Have ideas for how pytube can be improved? Feel free to open an issue or a pull request!



  *pytube* is a genuine, lightweight, dependency-free Python library (and command-line utility) for downloading YouTube videos.



  Detailed documentation about the usage of the library can be found at [pytube.io](https://pytube.io). This is recommended for most cases. If you want to hastily download a single video, the [quick start](#Quickstart) guide below might be what you're looking for.



  YouTube is the most popular video-sharing platform in the world and as a hacker, you may encounter a situation where you want to script something to download videos. For this, I present to you: *pytube*.

  *pytube* is a lightweight library written in Python. It has no third-party
  dependencies and aims to be highly reliable.

  *pytube* also makes pipelining easy, allowing you to specify callback functions for different download events, such as  ``on progress`` or ``on complete``.

  Furthermore, *pytube* includes a command-line utility, allowing you to download videos right from the terminal.



  - Support for both progressive & DASH streams
  - Support for downloading the complete playlist
  - Easily register ``on_download_progress`` & ``on_download_complete`` callbacks
  - Command-line interfaced included
  - Caption track support
  - Outputs caption tracks to .srt format (SubRip Subtitle)
  - Ability to capture thumbnail URL
  - Extensively documented source code
  - No third-party dependencies



  This guide covers the most basic usage of the library. For more detailed information, please refer to [pytube.io](https://pytube.io).



  Pytube requires an installation of Python 3.6 or greater, as well as pip. (Pip is typically bundled with Python [installations](https://python.org/downloads).)

  To install from PyPI with pip:

  ```bash
  $ python -m pip install pytube
  ```

  Sometimes, the PyPI release becomes slightly outdated. To install from the source with pip:

  ```bash
  $ python -m pip install git+https://github.com/pytube/pytube
  ```



  To download a video using the library in a script, you'll need to import the YouTube class from the library and pass an argument of the video URL. From there, you can access the streams and download them.

  ```python
   >>> from pytube import YouTube
   >>> YouTube('https://youtu.be/2lAe1cqCOXo').streams.first().download()
   >>> yt = YouTube('http://youtube.com/watch?v=2lAe1cqCOXo')
   >>> yt.streams
    ... .filter(progressive=True, file_extension='mp4')
    ... .order_by('resolution')
    ... .desc()
    ... .first()
    ... .download()
  ```



  Using the CLI is remarkably straightforward as well. To download a video at the highest progressive quality, you can use the following command:
  ```bash
  $ pytube https://youtube.com/watch?v=2lAe1cqCOXo
  ```

  You can also do the same for a playlist:
  ```bash
  $ pytube https://www.youtube.com/playlist?list=PLS1QulWo1RIaJECMeUT4LFwJ-ghgoSH6n
  ```


pkgId: 5dce93501431c8b077d30b860566ac1cc1b99aeb6a23e62367969573b47a2a75
name: python-pytz
arch: src
version: 2023.3
epoch: 0
release: 1
summary: World timezone definitions, modern and historical
url: http://pythonhosted.org/pytz
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ea158e51-9ecb-41b2-8a18-cdf225d0e91f
location_href: 00008903-python-pytz/python-pytz-2023.3-1.src.rpm
checksum_type: sha256
description:
  Introduction
  ~~~~~~~~~~~~
  pytz brings the Olson tz database into Python. This library allows
  accurate and cross platform timezone calculations using Python 2.4
  or higher. It also solves the issue of ambiguous times at the end
  of daylight saving time, which you can read more about in the Python
  Library Reference (``datetime.tzinfo``).
  Almost all of the Olson timezones are supported.
      Projects using Python 3.9 or later should be using the support
      now included as part of the standard library, and third party
      packages work with it such as `tzdata <https://pypi.org/project/tzdata/>`_.
      pytz offers no advantages beyond backwards compatibility with
      code written for earlier versions of Python.
      This library differs from the documented Python API for
      tzinfo implementations; if you want to create local wallclock
      times you need to use the ``localize()`` method documented in this
      document. In addition, if you perform date arithmetic on local
      times that cross DST boundaries, the result may be in an incorrect
      timezone (ie. subtract 1 minute from 2002-10-27 1:00 EST and you get
      2002-10-27 0:59 EST instead of the correct 2002-10-27 1:59 EDT). A
      ``normalize()`` method is provided to correct this. Unfortunately these
      issues cannot be resolved without modifying the Python datetime
      implementation (see PEP-431).
  Installation
  ~~~~~~~~~~~~
  This package can either be installed using ``pip`` or from a tarball using the
  standard Python distutils.
  If you are installing using ``pip``, you don't need to download anything as the
  latest version will be downloaded for you from PyPI::
      pip install pytz
  If you are installing from a tarball, run the following command as an
  administrative user::
      python setup.py install
  pytz for Enterprise
  ~~~~~~~~~~~~~~~~~~~
  Available as part of the Tidelift Subscription.
  The maintainers of pytz and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. `Learn more. <https://tidelift.com/subscription/pkg/pypi-pytz?utm_source=pypi-pytz&utm_medium=referral&utm_campaign=enterprise&utm_term=repo>`_.
  Example & Usage
  ~~~~~~~~~~~~~~~


pkgId: 235ca672de0df2153a3db20a49eee48c1f9d4f68b14ce55579037ef61425e685
name: python-pyu2f
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: U2F host library for interacting with a U2F device over USB.
url: https://github.com/google/pyu2f/
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b2563386-83e1-4bbb-99a8-43ef655b40a0
location_href: 00010479-python-pyu2f/python-pyu2f-0.1.5-1.src.rpm
checksum_type: sha256
description:
  pyu2f is a python based U2F host library for Linux, Windows, and MacOS. It provides functionality for interacting with a U2F device over USB.


pkgId: 80fd557600a89a5a2c73333805ab3ea562e57ca7586d2b7824b998dd84ae3a35
name: python-pyudev
arch: src
version: 0.24.0
epoch: 0
release: 1
summary: A libudev binding
url: http://pyudev.readthedocs.org/
rpm_license: LGPL 2.1+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-057ec85c-1055-44ae-9f16-5746351d9690
location_href: 00010025-python-pyudev/python-pyudev-0.24.0-1.src.rpm
checksum_type: sha256
description:
  Usage of pyudev is quite simply thanks to the power of the underlying udev
  library. Getting the labels of all partitions just takes a few lines:
  >>> import pyudev
  >>> context = pyudev.Context()
  >>> for device in context.list_devices(subsystem='block', DEVTYPE='partition'):
  boot
  swap
  system
  The website_ provides a detailed `user guide`_ and a complete `API reference`_.


pkgId: 5f3106062263b8113a90e61b3cb5a6d18ca301921e6a85dd1a8303f08722cb48
name: python-pyutil
arch: src
version: 3.3.6
epoch: 0
release: 1
summary: a collection of utilities for Python programmers
url: https://github.com/tpltnt/pyutil
rpm_license: GPL-2.0-or-later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eae1d843-2c5c-4762-a503-7c03912e32d3
location_href: 00004881-python-pyutil/python-pyutil-3.3.6-1.src.rpm
checksum_type: sha256
description:
  Many of these utilities (or their ancestors) were developed originally
  by Zooko Wilcox-O'Hearn for the Mojo Nation, Mnet, Allmydata.com "Mountain View",
  Tahoe-LAFS, or SimpleGeo's products. Please note that version 2.X is based
  on Python 2. Version 3.X will has support for Python 3.


pkgId: 0e0b6821165c3505cec762dd425fd5ea8407a9ee76c986c29b738d0a16f9bfb4
name: python-pyvex
arch: src
version: 9.2.41
epoch: 0
release: 1
summary: A Python interface to libVEX and VEX IR
url: https://github.com/angr/pyvex
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7498c1d0-4282-4010-b728-f4e7f191670b
location_href: 00004882-python-pyvex/python-pyvex-9.2.41-1.src.rpm
checksum_type: sha256
description:
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)



  PyVEX can be pip-installed:

  ```bash
  pip install pyvex
  ```



  If you use PyVEX in an academic work, please cite the paper for which it was developed:

  ```bibtex
  @article{shoshitaishvili2015firmalice,
    title={Firmalice - Automatic Detection of Authentication Bypass Vulnerabilities in Binary Firmware},
    author={Shoshitaishvili, Yan and Wang, Ruoyu and Hauser, Christophe and Kruegel, Christopher and Vigna, Giovanni},
    booktitle={NDSS},
    year={2015}
  }
  ```



  PyVEX exposes VEX into Python. To understand VEX, read the "VEX Intermediate Representation" section below.

  ```python
  import pyvex
  import archinfo


  irsb = pyvex.lift(b"\x90\x90\x90\x90\x90", 0x400400, archinfo.ArchAMD64())


  irsb.pp()


  print(irsb.next)


  print(irsb.jumpkind)


  irsb.next.pp()


  for stmt in irsb.statements:
      stmt.pp()


  import pyvex
  for stmt in irsb.statements:
      if isinstance(stmt, pyvex.IRStmt.Store):
          print("Data:", end="")
          stmt.data.pp()
          print("")

          print("Type:", end="")
          print(stmt.data.result_type)
          print("")


  for stmt in irsb.statements:
      if isinstance(stmt, pyvex.IRStmt.Exit):
          print("Condition:", end="")
          stmt.guard.pp()
          print("")

          print("Target:", end="")
          stmt.dst.pp()
          print("")


  print(irsb.tyenv.types)


  print(irsb.tyenv.types[0])
  ```

  Keep in mind that this is a *syntactic* respresentation of a basic block. That is, it'll tell you what the block means, but you don't have any context to say, for example, what *actual* data is written by a store instruction.



  To deal with widely diverse architectures, it is useful to carry out analyses on an intermediate representation.
  An IR abstracts away several architecture differences when dealing with different architectures, allowing a single analysis to be run on all of them:

  - **Register names.** The quantity and names of registers differ between architectures, but modern CPU designs hold to a common theme: each CPU contains several general purpose registers, a register to hold the stack pointer, a set of registers to store condition flags, and so forth. The IR provides a consistent, abstracted interface to registers on different platforms. Specifically, VEX models the registers as a separate memory space, with integer offsets (i.e., AMD64's `rax` is stored starting at address 16 in this memory space).
  - **Memory access.** Different architectures access memory in different ways. For example, ARM can access memory in both little-endian and big-endian modes. The IR must abstracts away these differences.
  - **Memory segmentation.** Some architectures, such as x86, support memory segmentation through the use of special segment registers. The IR understands such memory access mechanisms.
  - **Instruction side-effects.** Most instructions have side-effects. For example, most operations in Thumb mode on ARM update the condition flags, and stack push/pop instructions update the stack pointer. Tracking these side-effects in an *ad hoc* manner in the analysis would be crazy, so the IR makes these effects explicit.

  There are lots of choices for an IR. We use VEX, since the uplifting of binary code into VEX is quite well supported.
  VEX is an architecture-agnostic, side-effects-free representation of a number of target machine languages.
  It abstracts machine code into a representation designed to make program analysis easier.
  This representation has five main classes of objects:

  - **Expressions.** IR Expressions represent a calculated or constant value. This includes memory loads, register reads, and results of arithmetic operations.
  - **Operations.** IR Operations describe a *modification* of IR Expressions. This includes integer arithmetic, floating-point arithmetic, bit operations, and so forth. An IR Operation applied to IR Expressions yields an IR Expression as a result.
  - **Temporary variables.** VEX uses temporary variables as internal registers: IR Expressions are stored in temporary variables between use. The content of a temporary variable can be retrieved using an IR Expression. These temporaries are numbered, starting at `t0`. These temporaries are strongly typed (i.e., "64-bit integer" or "32-bit float").
  - **Statements.** IR Statements model changes in the state of the target machine, such as the effect of memory stores and register writes. IR Statements use IR Expressions for values they may need. For example, a memory store *IR Statement* uses an *IR Expression* for the target address of the write, and another *IR Expression* for the content.
  - **Blocks.** An IR Block is a collection of IR Statements, representing an extended basic block (termed "IR Super Block" or "IRSB") in the target architecture. A block can have several exits. For conditional exits from the middle of a basic block, a special *Exit* IR Statement is used. An IR Expression is used to represent the target of the unconditional exit at the end of the block.

  VEX IR is actually quite well documented in the `libvex_ir.h` file (https://github.com/angr/vex/blob/dev/pub/libvex_ir.h) in the VEX repository. For the lazy, we'll detail some parts of VEX that you'll likely interact with fairly frequently. To begin with, here are some IR Expressions:

  | IR Expression | Evaluated Value | VEX Output Example |
  | ------------- | --------------- | ------- |
  | Constant | A constant value. | 0x4:I32 |
  | Read Temp | The value stored in a VEX temporary variable. | RdTmp(t10) |
  | Get Register | The value stored in a register. | GET:I32(16) |
  | Load Memory | The value stored at a memory address, with the address specified by another IR Expression. | LDle:I32 / LDbe:I64 |
  | Operation | A result of a specified IR Operation, applied to specified IR Expression arguments. | Add32 |
  | If-Then-Else | If a given IR Expression evaluates to 0, return one IR Expression. Otherwise, return another. | ITE |
  | Helper Function | VEX uses C helper functions for certain operations, such as computing the conditional flags registers of certain architectures. These functions return IR Expressions. | function\_name() |

  These expressions are then, in turn, used in IR Statements. Here are some common ones:

  | IR Statement | Meaning | VEX Output Example |
  | ------------ | ------- | ------------------ |
  Write Temp | Set a VEX temporary variable to the value of the given IR Expression. | WrTmp(t1) = (IR Expression) |
  Put Register | Update a register with the value of the given IR Expression. | PUT(16) = (IR Expression) |
  Store Memory | Update a location in memory, given as an IR Expression, with a value, also given as an IR Expression. | STle(0x1000) = (IR Expression) |
  Exit | A conditional exit from a basic block, with the jump target specified by an IR Expression. The condition is specified by an IR Expression. | if (condition) goto (Boring) 0x4000A00:I32 |

  An example of an IR translation, on ARM, is produced below. In the example, the subtraction operation is translated into a single IR block comprising 5 IR Statements, each of which contains at least one IR Expression (although, in real life, an IR block would typically consist of more than one instruction). Register names are translated into numerical indices given to the *GET* Expression and *PUT* Statement.
  The astute reader will observe that the actual subtraction is modeled by the first 4 IR Statements of the block, and the incrementing of the program counter to point to the next instruction (which, in this case, is located at `0x59FC8`) is modeled by the last statement.

  The following ARM instruction:

      subs R2, R2, #8

  Becomes this VEX IR:

      t0 = GET:I32(16)
      t1 = 0x8:I32
      t3 = Sub32(t0,t1)
      PUT(16) = t3
      PUT(68) = 0x59FC8:I32

  Cool stuff!


pkgId: 5fed561eb6a8e1103472af51bf909981b283508f3618e85c01fd6b3f547f19ee
name: python-pyvlx
arch: src
version: 0.2.20
epoch: 0
release: 1
url: https://github.com/Julius2342/pyvlx
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ecc5f4ae-f777-4780-a561-4f8323f36ffe
location_href: 00004885-python-pyvlx/python-pyvlx-0.2.20-1.src.rpm
checksum_type: sha256
summary:
  PyVLX is a wrapper for the Velux KLF 200 API. PyVLX enables you to run scenes and or open and close velux windows.

description:
  [![CI](https://github.com/Julius2342/pyvlx/actions/workflows/ci.yml/badge.svg)](https://github.com/Julius2342/pyvlx/actions/workflows/ci.yml)
  PyVLX uses the Velux KLF 200 interface to control io-Homecontrol devices, e.g. Velux Windows.


pkgId: e422c91f6c9c1b43dd5a618853e14f186eeb9f4875e60e44a77a6666f18fba9e
name: python-pyvmomi
arch: src
version: 8.0.0.1.2
epoch: 0
release: 1
summary: VMware vSphere Python SDK
url: https://github.com/vmware/pyvmomi
rpm_license: License :: OSI Approved :: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4d05377b-d8fb-4226-a1a8-f9909fa8baf9
location_href: 00009626-python-pyvmomi/python-pyvmomi-8.0.0.1.2-1.src.rpm
checksum_type: sha256
description:
  To get started, see the
  `getting started guide <http://vmware.github.io/pyvmomi-community-samples/#getting-started>`_.
  You'll need `Python <https://www.python.org/downloads/>`_,
  `pip <https://pip.pypa.io/en/latest/installation/>`_, and the
  `samples project <http://vmware.github.io/pyvmomi-community-samples/>`_.


pkgId: 952c707f9c5cfa80ef47ac737f56cf5efd6d487f2ff8e2385f4ace197caaa3c3
name: python-pyvo
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: Astropy affiliated package for accessing Virtual Observatory data and services
url: https://github.com/astropy/pyvo
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-38787d92-a4ee-4b66-adc1-364742d6fd18
location_href: 00004886-python-pyvo/python-pyvo-1.4.1-1.src.rpm
checksum_type: sha256
description:
  PyVO is a package providing access to remote data and services of the
  Virtual observatory (VO) using Python.
  Its development was launched by the NSF/NASA-funded Virtual Astronomical
  Observatory (VAO, www.usvao.org) project (formerly under the name
  VAOpy) as part of its initiative to bring VO capabilities to desktop.
  Its goal is to allow astronomers and tool developers to access data and
  services from remote archives and other web resources.  It takes
  advantage of VO standards to give access to thousands of catalogs,
  data archives, information services, and analysis tools.  It also
  takes advantage of the general capabilities of Astopy (and numpy), and
  so a secondary goal is to provide a development platform for migrating
  more VO capabilities into Astropy.
  Source code can be found `on GitHub <http://github.com/astropy/pyvo>`_


pkgId: 16cebf91bed63f1f65df7046b40e278a2b6b5e5be048707060b80aff03273a12
name: python-pywebpush
arch: src
version: 1.14.0
epoch: 0
release: 1
summary: WebPush publication library
url: https://github.com/web-push-libs/pywebpush
rpm_license: MPL2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d5fc9512-c4a1-4bbb-b532-f310b52c3767
location_href: 00011190-python-pywebpush/python-pywebpush-1.14.0-1.src.rpm
checksum_type: sha256
description:
  This is a work in progress. This library is available on `pypi as
  pywebpush <https://pypi.python.org/pypi/pywebpush>`__. Source is
  available on `github <https://github.com/mozilla-services/pywebpush>`__.


pkgId: f9530fe6bda2fd78ea24007536d92c91e342a20f2553c6cb78805ded9f4ad836
name: python-pywinauto
arch: src
version: 0.6.8
epoch: 0
release: 1
summary: A set of Python modules to automate the Microsoft Windows GUI
url: http://pywinauto.github.io/
rpm_license: BSD 3-clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3575a151-9fb5-4285-876c-3ae7a492fdb3
location_href: 00010260-python-pywinauto/python-pywinauto-0.6.8-1.src.rpm
checksum_type: sha256
description:
  - Home page: http://pywinauto.github.io/
  - Docs Intro: https://pywinauto.readthedocs.io/en/latest/
  - Getting Started Guide: https://pywinauto.readthedocs.io/en/latest/getting_started.html
  - StackOverflow tag: https://stackoverflow.com/questions/tagged/pywinauto


pkgId: 7006a7ae21fcdcc3b31e6027504736fb0cdffc2254d65508fa57a127168f0c66
name: python-pywinrm
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: Python library for Windows Remote Management
url: http://github.com/diyan/pywinrm/
rpm_license: MIT license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c1d5099e-c319-4363-b054-7f2eaa717fd4
location_href: 00010046-python-pywinrm/python-pywinrm-0.4.3-1.src.rpm
checksum_type: sha256
description:
  pywinrm is a Python client for the Windows Remote Management (WinRM)
  service. It allows you to invoke commands on target Windows machines
  from any machine that can run Python.
  |License| |Test workflow| |Coverage| |PyPI|
  WinRM allows you to perform various management tasks remotely. These
  include, but are not limited to: running batch scripts, powershell
  scripts, and fetching WMI variables.
  Used by `Ansible <https://www.ansible.com/>`__ for Windows support.
  For more information on WinRM, please visit `Microsoft’s WinRM
  site <http://msdn.microsoft.com/en-us/library/aa384426.aspx>`__.


pkgId: 371277fda74fab9638afe8183f77887346652bb4322cf6b73c51412ff7b98922
name: python-pywizlight
arch: src
version: 0.5.14
epoch: 0
release: 1
summary: A python connector for WiZ light bulbs (e.g SLV Play)
url: https://github.com/sbidy/pywizlight
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2ef0a409-50bd-4e39-9d34-68e71d73273e
location_href: 00004889-python-pywizlight/python-pywizlight-0.5.14-1.src.rpm
checksum_type: sha256
description:
  ![Upload Python Package](https://github.com/sbidy/pywizlight/workflows/Upload%20Python%20Package/badge.svg)

  <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
  [![All Contributors](https://img.shields.io/badge/all_contributors-18-orange.svg?style=flat-square)](#contributors-)
  <!-- ALL-CONTRIBUTORS-BADGE:END -->

  ![Update Docs](https://github.com/sbidy/pywizlight/workflows/Update%20Docs/badge.svg)
  [![Lint](https://github.com/sbidy/pywizlight/actions/workflows/lint.yml/badge.svg)](https://github.com/sbidy/pywizlight/actions/workflows/lint.yml)
  [![codecov][code-cover-shield]][code-coverage]




  A Python connector for [WiZ](https://www.wizconnected.com/en/consumer/) devices.



  ```bash
  pip install pywizlight
  ```

  **Note:** Requires Python version `>=3.7`.



  On a Fedora-based system or on a CentOS/RHEL 8 machine which has EPEL enabled, as
  [`pywizlight`](https://src.fedoraproject.org/rpms/python-pywizlight) is present in the
  Fedora Package Collection.

  ```bash
  sudo dnf -y install python3-pywizlight
  ```



  For NixOS and Nix the latest release of `pywizlight` is usually available in the [`unstable`](https://search.nixos.org/packages?channel=unstable&query=pywizlight)
  channel. Stable releases might ship older versions of `pywizlight`.

  ```bash
  nix-env -iA nixos.python37Packages.pywizlight
  ```



  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tr>
      <td align="center"><a href="http://mtnspring.org"><img src="https://avatars.githubusercontent.com/u/223277?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Seth Nickell</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=snickell" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/daanzu"><img src="https://avatars.githubusercontent.com/u/4319503?v=4?s=100" width="100px;" alt=""/><br /><sub><b>David Zurow</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=daanzu" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/eibanez"><img src="https://avatars.githubusercontent.com/u/438494?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Eduardo Ibanez</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=eibanez" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/angadsingh"><img src="https://avatars.githubusercontent.com/u/1623026?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Angad Singh</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=angadsingh" title="Code">💻</a></td>
      <td align="center"><a href="http://fabian-affolter.ch/blog/"><img src="https://avatars.githubusercontent.com/u/116184?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Fabian Affolter</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=fabaff" title="Documentation">📖</a> <a href="https://github.com/sbidy/pywizlight/commits?author=fabaff" title="Code">💻</a></td>
      <td align="center"><a href="https://redaxmedia.com"><img src="https://avatars.githubusercontent.com/u/1835397?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Henry Ruhs</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=redaxmedia" title="Code">💻</a></td>
      <td align="center"><a href="https://www.panu.it/"><img src="https://avatars.githubusercontent.com/u/2248402?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Alberto Panu</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=bigjohnson" title="Code">💻</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/skitterrusty"><img src="https://avatars.githubusercontent.com/u/71942600?v=4?s=100" width="100px;" alt=""/><br /><sub><b>skitterrusty</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=skitterrusty" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/mots"><img src="https://avatars.githubusercontent.com/u/26517?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Mathias Roth</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=mots" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/durnezj"><img src="https://avatars.githubusercontent.com/u/11504333?v=4?s=100" width="100px;" alt=""/><br /><sub><b>durnezj</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=durnezj" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/Dirty-No"><img src="https://avatars.githubusercontent.com/u/54525684?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Noëlle</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=Dirty-No" title="Documentation">📖</a></td>
      <td align="center"><a href="https://linkedin.com/in/scriptsrc"><img src="https://avatars.githubusercontent.com/u/8009126?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Patrick Kelley</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=scriptsrc" title="Documentation">📖</a></td>
      <td align="center"><a href="http://ellismichael.com"><img src="https://avatars.githubusercontent.com/u/1312141?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Ellis Michael</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=emichael" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/SvbZ3r0"><img src="https://avatars.githubusercontent.com/u/57280279?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Gughan Ravikumar</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=SvbZ3r0" title="Code">💻</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/CharlotteCross1998"><img src="https://avatars.githubusercontent.com/u/29734551?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Charlotte</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=CharlotteCross1998" title="Code">💻</a></td>
      <td align="center"><a href="https://akx.github.io/"><img src="https://avatars.githubusercontent.com/u/58669?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Aarni Koskela</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=akx" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/UH-60"><img src="https://avatars.githubusercontent.com/u/4968133?v=4?s=100" width="100px;" alt=""/><br /><sub><b>UH-60</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=UH-60" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/bdraco"><img src="https://avatars.githubusercontent.com/u/663432?v=4?s=100" width="100px;" alt=""/><br /><sub><b>J. Nick Koston</b></sub></a><br /><a href="https://github.com/sbidy/pywizlight/commits?author=bdraco" title="Code">💻</a></td>
    </tr>
  </table>

  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->

  <!-- ALL-CONTRIBUTORS-LIST:END -->



  To find bulbs via cli you can use the following:
  ```bash
  python -m pywizlight.cli discover
  ```



  ```python
  import asyncio

  from pywizlight import wizlight, PilotBuilder, discovery

  async def main():
      """Sample code to work with bulbs."""
      
      
      bulbs = await discovery.discover_lights(broadcast_space="192.168.1.255")
      
      print(f"Bulb IP address: {bulbs[0].ip}")

      
      for bulb in bulbs:
          print(bulb.__dict__)
          
          

      
      light = wizlight("192.168.1.27")
      
      

      
      
      

      
      await light.turn_on(PilotBuilder())
      
      await light.turn_on(PilotBuilder(brightness = 255))

      
      timeout = 10
      await asyncio.wait_for(light.turn_on(PilotBuilder(brightness = 255)), timeout)

      
      await light.turn_on(PilotBuilder(warm_white = 255))

      
      
      await light.turn_on(PilotBuilder(rgb = (0, 128, 255)))

      
      state = await light.updateState()
      print(state.get_colortemp())
      red, green, blue = state.get_rgb()
      print(f"red {red}, green {green}, blue {blue}")

      
      await light.turn_on(PilotBuilder(scene = 4)) # party

      
      state = await light.updateState()
      print(state.get_scene())

      
      bulb_type = await bulbs[0].get_bulbtype()
      print(bulb_type.features.brightness) # returns True if brightness is supported
      print(bulb_type.features.color) # returns True if color is supported
      print(bulb_type.features.color_tmp) # returns True if color temperatures are supported
      print(bulb_type.features.effect) # returns True if effects are supported
      print(bulb_type.kelvin_range.max) # returns max kelvin in INT
      print(bulb_type.kelvin_range.min) # returns min kelvin in INT
      print(bulb_type.name) # returns the module name of the bulb

      
      await light.turn_off()

      
      
      
      
      
      
      
      
      
      
      

  loop = asyncio.get_event_loop()
  loop.run_until_complete(main())
  ```



  `wizlight` is a command-line tool to perform basic interactions with bulbs.

  ```console
  $ wizlight
  Usage: wizlight [OPTIONS] COMMAND [ARGS]...

    Simple command-line tool to interact with Wizlight bulbs.

  Options:
    --version  Show the version and exit.
    --help     Show this message and exit.

  Commands:
    discover  Discover bulb in the local network.
    off       Turn the bulb off.
    on        Turn the bulb on.
    state     Get the current state from the given bulb.
  ```



  The discovery works with a UDP Broadcast request and collects all bulbs in the network.



  - **sceneId** - calls one of the predefined scenes (int from 1 to 32) [List of names in code](https://github.com/sbidy/pywizlight/blob/master/pywizlight/scenes.py)
  - **speed** - sets the color changing speed in percent
  - **dimming** - sets the dimmer of the bulb in percent
  - **temp** - sets the color temperature in kelvins
  - **r** - red color range 0-255
  - **g** - green color range 0-255
  - **b** - blue color range 0-255
  - **c** - cold white range 0-255
  - **w** - warm white range 0-255
  - **id** - the bulb id
  - **state** - whether it's on or off
  - **schdPsetId** - rhythm id of the room



  For async I/O this component uses Python's built-in asyncio DatagramTransport, which allows completely non-blocking UDP transport.



  `wizlight(ip)`: Creates an instance of a WiZ Light Bulb. Constructed with the IP addCancel changesress of the bulb.



  First you need to fetch the state by calling `light.updateState()`.
  After that all states can be fetched from `light.state`, which is a `PilotParser` object.

  `PilotParser.get_brightness()`gets the value of the brightness 0-255

  `PilotParser.get_rgb()` gets the rgbW color state of the bulb

  `PilotParser.get_colortemp()` gets the color temperature of the bulb

  `PilotParser.get_warm_white/get_cold_white()` gets the current warm/cold setting (not supported by original Philips Wiz bulbs)

  `PilotParser.get_scene()` gets the current scene name

  `PilotParser.get_state()` returns True/False. True = on, False = off



  `getBulbConfig(self)` returns the hardware configuration of the bulb

  `updateState(self)` gets the current bulb state from the light using `sendUDPMessage` and sets it to `self.state`

  `lightSwitch(self)` toggles the light bulb on or off like a switch

  `getMAC(self)` returns the MAC address of the bulb. Can be used as a unique ID

  `sendUDPMessage(self, message, timeout = 60, send_interval = 0.5, max_send_datagrams = 100):` sends the UDP message to the bulb. Since UDP can lose packets, and your light might be a long distance away from the router, we continuously keep sending the UDP command datagram until there is a response from the bulb. In tests this worked way better than just sending once and waiting for a timeout. You can set the async operation timeout using `timeout`, set the time interval to sleep between continuous UDP sends using `send_interval` and the maximum number of continuous pings to send using `max_send_datagrams`. It is already hardcoded to a lower value for `setPilot` (set light state) vs `getPilot` (fetch light state) to avoid flickering the light.

  `turn_off(self)` turns the light off

  `turn_on(PilotBuilder)` turns the light on. This takes a `PilotBuilder` object, which can be used to set all the parameters programmatically - rgb, color temperature, brightness, etc. To set the light to rhythm mode, create an empty `PilotBuilder`.



  - **getSystemConfig** - gets the current system configuration - no parameters required
  - **syncPilot** - sent by the bulb as heartbeats
  - **getPilot** - gets the current bulb state - no parameters required
  - **setPilot** - used to tell the bulb to change color/temp/state
  - **Pulse** - uncertain of purpose
  - **Registration** - used to "register" with the bulb: This notifies the bulb if you want it to send you heartbeat sync packets



  - syncUserConfig
  - syncPilot - {"method":"syncPilot","env":"pro","params":{"mac":"ABCABCABC","rssi":-71,"src":"udp","state":true,"sceneId":0,"temp":6500,"dimming":62}}
  - syncSchdPset
  - syncBroadcastPilot
  - syncSystemConfig
  - syncConfig
  - syncAlarm



  - pulse - {"method":"pulse", "params":{"delta":-15,"duration":300}}
  - registration - {"method":"registration","id":105, "params":{"phoneIp":"10.0.0.0","phoneMac":"aaaaaaaaaaaa","register":true}}
  - setUserConfig
  - setSystemConfig
  - setDevInfo
  - setSchd
  - setSchdPset
  - setWifiConfig
  - reset
  - setFavs
  - setState
  - setPilot



  - getPilot
  - getUserConfig
  - getSystemConfig
  - getWifiConfig
  - reboot
  - getDevInfo



  - Parse error
  - Invalid Request
  - Method not found
  - Invalid params
  - Internal error
  - Success



  Send message to the bulb:
  `{"method":"setPilot","params":{"r":255,"g":255,"b":255,"dimming":50}}`
  Response: `{"method":"setPilot","env":"pro","result":{"success":true}}`

  Get state of the bulb:
  `{"method":"getPilot","params":{}}`
  Responses:

  custom color mode:

  `{'method': 'getPilot', 'env': 'pro', 'result': {'mac': 'a8bb50a4f94d', 'rssi': -60, 'src': '', 'state': True, 'sceneId': 0, 'temp': 5075, 'dimming': 47}}`

  scene mode:

  `{'method': 'getPilot', 'env': 'pro', 'result': {'mac': 'a8bb50a4f94d', 'rssi': -65, 'src': '', 'state': True, 'sceneId': 12, 'speed': 100, 'temp': 4200, 'dimming': 47}}`

  rhythm mode:

  `{'method': 'getPilot', 'env': 'pro', 'result': {'mac': 'a8bb50a4f94d', 'rssi': -63, 'src': '', 'state': True, 'sceneId': 14, 'speed': 100, 'dimming': 100, 'schdPsetId': 9}}`

  [code-coverage]: https://codecov.io/gh/sbidy/pywizlight
  [code-cover-shield]: https://codecov.io/gh/sbidy/pywizlight/branch/master/graph/badge.svg


pkgId: 10e57b6054f1f5f92cdf9a5176e8f8e577a9af47c3c6e9ab5abefbc380d6a40c
name: python-pyxero
arch: src
version: 0.9.3
epoch: 0
release: 1
summary: Python API for accessing the REST API of the Xero accounting tool.
url: http://github.com/freakboy3742/pyxero
rpm_license: New BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-771e45ed-68a6-4f63-905b-c80c06454b45
location_href: 00013036-python-pyxero/python-pyxero-0.9.3-1.src.rpm
checksum_type: sha256
description:
  [![Python Versions](https://img.shields.io/pypi/pyversions/pyxero.svg)](https://pypi.python.org/pypi/pyxero) [![PyPI Version](https://img.shields.io/pypi/v/pyxero.svg)](https://pypi.python.org/pypi/pyxero) [![Maturity](https://img.shields.io/pypi/status/pyxero.svg)](https://pypi.python.org/pypi/pyxero) [![BSD License](https://img.shields.io/pypi/l/pyxero.svg)](https://github.com/freakboy3742/pyxero/blob/master/LICENSE) [![Build Status](https://github.com/freakboy3742/pyxero/workflows/Build%20status/badge.svg)](https://github.com/freakboy3742/pyxero/actions)
  PyXero is a Python API for accessing the REST API provided by the [Xero](https://developer.xero.com)
  accounting tool. It allows access to both Public, Private and Partner applications.

  Install this library using the python package manager:
  ```
  pip install pyxero
  ```
  You'll need to follow the [Xero Developer documentation](https://developer.xero.com/documentation/) to register your application. Do that as follows:

  Public applications use a 3-step OAuth process.
  When you [register your public application with Xero](https://developer.xero.com/documentation/auth-and-limits/public-applications/), you'll be given a
  **Consumer Key** and a **Consumer secret**. These are both strings.
  To access the Xero API you must first create some credentials:
  ```python
  >>> from xero.auth import PublicCredentials
  >>> credentials = PublicCredentials(<consumer_key>, <consumer_secret>)
  >>> print credentials.url
  'http://my.xero.com/.....'
  ```
  You now direct the user to visit the URL described by `credentials.url`. They
  will be asked to log into their Xero account, and then shown a request to
  authenticate your request to access the user's account. When the allow access,
  they will be directed to a page that gives them a 6-digit verification number.
  Put this verifier number into a string, and call `verify()` on the credentials
  object::
  ```python
  >>> credentials.verify(<verifier string>)
  ```
  This will verify your credentials, and retrieve an access token. You can
  then use your credentials to instantiate an instance of the Xero API::
  ```python
  >>> from xero import Xero
  >>> xero = Xero(credentials)
  ```

  Public applications can also be validated using a callback URI. If this
  approach is used, the user won't be given a verification number. Instead,
  when they authorize the OAuth request, their browser will be redirected to
  a pre-configured callback URI, which will deliver the validation token
  directly to your application.
  To use a callback, you must provide a domain as part of your Xero application
  registration; then, you provide a URL under that domain as the third argument
  when creating the credentials::
  ```python
  >>> credentials = PublicCredentials(<consumer_key>, <consumer_secret>, <callback_uri>)
  >>> print credentials.url
  'http://my.xero.com/.....'
  ```
  When the user authorizes access to their Xero account, the `callback_url`
  will be called with three GET arguments:
  * `oauth_token`: The oauth_token that this request belongs to
  * `oauth_verifier`: The verifier string
  * `org`: An identifier for the organization that is allowing access.
  The verifier can then be used to verify the credentials, as with the manual
  process.

  Public Applications use a 3-step OAuth process, and if you're doing this in a
  web application, you will usually lose the credentials object over the
  verification step. This means you need to be able to restore the credentials
  object when verification has been provided.
  The `state` attribute of a credentials object contains all the details needed
  to reconstruct an instance of the credentials::
  ```python
  >>> saved_state = credentials.state
  >>> print saved_state
  {'consumer_key': '...', 'consumer_secret': '...', ...}
  >>> new_credentials = PublicCredentials(**saved_state)
  ```

  *Private Applications are deprecated by Xero*. An alternative is to use the machine-to-machine method. This is fundamentally an OAuth2 flow, but Xero provides a helper executable to get tokens from a local machine without needing a server to host a callback. See [Xero Machine to Machine authentication](https://developer.xero.com/documentation/api-guides/machine-2-machine)
  If using a Private application, you will need to install `PyCrypto`, a pure
  Python cryptographic module. You'll also need to generate an signed RSA
  certificate, and submit that certificate as part of registering your
  application with Xero. See the [Xero Developer documentation](https://developer.xero.com/) for more
  details.
  When you [register your private application with Xero](https://developer.xero.com/documentation/auth-and-limits/private-applications/), you'll be given a
  **Consumer Key**. You'll also be given a **Consumer secret** - this can be
  ignored.
  Using the Private credentials is much simpler than the Public credentials,
  because there's no verification step -- verification is managed using RSA
  signed API requests::
  ```python
  >>> from xero import Xero
  >>> from xero.auth import PrivateCredentials
  >>> with open(<path to rsa key file>) as keyfile:
  >>> credentials = PrivateCredentials(<consumer_key>, rsa_key)
  >>> xero = Xero(credentials)
  ```
  [Follow these steps](https://developer.xero.com/documentation/api-guides/create-publicprivate-key/) to generate a public/private key pair to sign your requests.  You'll upload your public key when you create your Xero Private app at https://app.xero.com.  You'll use the private key (aka RSA key) to generate your oAuth signature.


pkgId: 129b57350ddfa69e0e43f0316d47651b7863db48d49d5c97f400555b0b203e9c
name: python-pyxid
arch: src
version: 1.0
epoch: 0
release: 1
summary: Pure python library for communicating with Cedrus XID and StimTracker devices.
url: http://www.github.com/cedrus-opensource/pyxid/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5e7ab254-67f7-4d2c-adc0-1403ca4f34d7
location_href: 00004891-python-pyxid/python-pyxid-1.0-1.src.rpm
checksum_type: sha256
description:
  Python library for interfacing with Cedrus XID and StimTracker devices

  XID (eXperiment Interface Device) devices are used in software such as
  SuperLab, Presentation, and ePrime for receiving input as part of
  stimulus/response testing experiments.

  This handles all of the low level device handling for XID devices in
  python projects.  The developer using this library must poll the
  attached device(s) for responses.  Here's an example of how to do so:

      import pyxid

      
      devices = pyxid.get_xid_devices()

      dev = devices[0] # get the first device to use
      if dev.is_response_device():
          dev.reset_base_timer()
          dev.reset_rt_timer()

          while True:
              dev.poll_for_response()
              if dev.response_queue_size() > 0:
                  response = dev.get_next_response()
                  


  The response is a python dict with the following keys:

      pressed: True if the key was pressed, False if it was released
      key: Response pad key pressed by the subject
      port: Device port the response was from (typically 0)
      time: value of the Response Time timer when the key was hit/released


  StimTracker

  Support for Cedrus StimTracker devices is now included.  On StimTracker
  devices, there are the following methods:

      set_pulse_duration()
      activate_line()
      clear_line()

  See the docstring for activate_line() for documentation on how to use it.

  These methods are not available if the device is a response pad.

  StimTracker is used in software such as SuperLab, Presentation and ePrime
  for sending event markers.


  Timers

  Each Cedrus XID device has an internal timer a Base Timer and a
  Response Time Timer.  The Base Timer should be reset at the start of
  an experiment.  The Response Time timer should be reset whenever a
  stimulus is presented.

  At the time of this library release, there is a known issue with clock
  drift in XID devices.  Our hardware/firmware developer is currently
  looking into the issue.

  Given the issue, use of the response timer built into the response
  pads is optional.  If you wish to use the time reported from the
  response pads, do the following after importing the pyxid library:

      import pyxid
      pyxid.use_response_pad_timer = True

  This will return the time in the 'time' field of the dict returned by
  XidDevice.get_next_response(), otherwise, the 'time' field will
  contain 0.

  Windows Specific Issues

  Sometimes, windows fails at detecting XID devices.  Running
  detect_xid_devices() a second time should result in finding the
  devices.


pkgId: 0c2359de126a893485bed92419bc1555a22456e366ad0d736b04b3c118f42379
name: python-pyxlsb
arch: src
version: 1.0.10
epoch: 0
release: 1
summary: Excel 2007-2010 Binary Workbook (xlsb) parser
url: https://github.com/willtrnr/pyxlsb
rpm_license: LGPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7a34a6f2-5c4c-46f4-94d3-244e00117060
location_href: 00010371-python-pyxlsb/python-pyxlsb-1.0.10-1.src.rpm
checksum_type: sha256
description:
  |PyPI|
  ``pyxlsb`` is an Excel 2007-2010 Binary Workbook (xlsb) parser for
  Python. The library is currently extremely limited, but functional
  enough for basic data extraction.


pkgId: 331f8d6b6f4f882fe75b749985efa3cea93270232c51d4018134721242b68d14
name: python-pyxlsx
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/fortfall/pyxlsx
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7962076b-6ce4-4fcb-93e4-c970f64f4d5e
location_href: 00009624-python-pyxlsx/python-pyxlsx-1.1.3-1.src.rpm
checksum_type: sha256
description:
  A package to read/write xlsx worksheet like dictionary, based on openpyxl.


  * from pip
  ```python
  pip install pyxlsx
  ```
  * download package and run setup.py
  ```python
  python setup.py install
  ```


  * Create a new xlsx file and write to it
  ```python
  from pyxlsx import new_xlsx

  with new_xlsx(filename) as wb:
      ws = wb.create_sheet('sheet1')
      


  wb = new_xlsx()
  ws = wb.creat_sheet('sheet1')  # create a new sheet with name 'sheet1'

  wb.save(filename)
  ```
  * Open an existing xlsx file
  ```python
  from pyxlsx import open_xlsx

  with open_xlsx(filename) as wb:
      ws1 = wb.active  # get active sheet
      ws2 = wb['sheet2']
      


  wb = open_xlsx(filename)
  ws = wb['sheet2']

  wb.save()

  wb.save(another_filename)
  ```
  * Append rows to a worksheet
  ```python
  ws = wb['sheet1']
  ws.append(
      ["", "", "str('Unknown')", "float(4.5)", "int(500)"]
  )

  content1 = {
      'id': '001',
      'productName': 'pork',
      'productType': 'meat',
      'price': 2.5,
      'weight': 1000,
  }
  content2 = {
      'id': '002',
      'productName': 'beef',
      'productType': 'meat',
      'price': 4.5,
      'weight': 1000,
      'origin': 'Australia'
  }

  ws.append_by_header(content1)

  ws.append_by_header(content2)

  ```
  ||A|B|C|D|E|F|
  |:---:|:---:|:---:|:---:|:---:|:---:|:---|
  |1|||str('Unknown')|float(30)|int(0)|
  |2|id|productName|productType|price|weight|origin
  |3|001|pork|meat|2.5|1000|
  |4|002|beef|meat|4.5|1000|Australia
  * Read from / write to a worksheet by row
    Note: if there are duplicate header names, only the first would be used.
  ```python
  ws = wb['sheet1']
  assert ws.header is None
  ws.header_row = 2  # set the second row as worksheet header row
  assert ws.header is not None

  for row in ws.content_rows:  # starting from row just below header row
      print(row[1])  # row cell value can accessed by column number, if key is of type int
      print(row['productName'])  # row cell value can be accessed by header name, if key is of type of str
      print(row['price'])
      if row['productName'] == 'pork':
          row[1] = '003'  # change pork id to '003'
          row['price'] = 3.5  # change pork price to 3.5







  ```
  * Read from a worksheet by column
  ```python
  ws = wb['sheet1']
  ws.header_row = 2

  column_cells = ws['B']
  for c in column_cells:
      print(c.data)  # 'pork', 'beef'



  name_column = ws.get_content_column('productName')
  for c in name_column:
      print(c.data)  # 'pork', 'beef'



  name_column = ws.get_content_column(2)
  for c in name_column:
      print(c.data)  # 'pork', 'beef'
  ```
  * Read cell directly from Worksheet, Header, ContentRow
  ```python
  ws = wb['sheet1']
  ws.header_row = 2

  cell = ws.cell(2, 2)
  print(cell.data)  # 'productName'


  cell = ws.header.cell('productName')
  print(cell.data)  # 'productName'

  cell = ws.header.cell(1)
  print(cell.data)  # 'id'

  for row in ws.content_rows:
      cell = row.cell(1)  # '001', '002'
      print(cell.data)
      cell = row.cell('productName')
      print(cell.data)  # 'pork', 'beef'
  ```

  * Read adjacent cells of a certain cell
  ```python
  cell = ws.cell(2, 2)
  print(cell.top.data)  # "str('Unknown')"
  print(cell.left.data)  # 'id'
  print(cell.right.data)  # 'productType'
  print(cell.bottom.data)  # 'pork'

  for c in cell.vertical:
      print(c.data)  # 'productName', 'pork', 'beef'

  for c in cell.horizontal:
      print(c.data)  # 'productName', 'productType', 'price', 'weigth', 'origin'
  ```


pkgId: f0a0b7cabbfff4551634ab11fb4b14142358d7e831f08da46242171740309562
name: python-pyxs
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Pure Python bindings to XenStore.
url: https://github.com/selectel/pyxs
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d40e669c-4097-4e02-82a2-d7c84fd58bc1
location_href: 00004892-python-pyxs/python-pyxs-0.4.1-1.src.rpm
checksum_type: sha256
description:
  It's a pure Python XenStore client implementation, which covers all of
  the ``libxs`` features and adds some nice Pythonic sugar on top. Here's
  a shortlist:
  * ``pyxs`` supports both Python 2 and 3,
  * works over a Unix socket or XenBus,
  * has a clean and well-documented API,
  * is writen in easy to understand Python,
  * can be used with `gevent <http://www.gevent.org>`_ or
    `eventlet <http://eventlet.net>`_.


pkgId: cdf5e103c9e25f8b670351b385b87a61e9515fa3f42bf734611026d13d0ff35e
name: python-pyyaml_env_tag
arch: src
version: 0.1
epoch: 0
release: 1
summary: A custom YAML tag for referencing environment variables in YAML files.
url: https://github.com/waylan/pyyaml-env-tag
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2894b261-39b0-4b19-9e89-3313c6544166
location_href: 00009994-python-pyyaml-env-tag/python-pyyaml_env_tag-0.1-1.src.rpm
checksum_type: sha256
description:
  A custom YAML tag for referencing environment variables in YAML files.



  Install `PyYAML` and the `pyyaml_env_tag` package with pip:

  ```bash
  pip install pyyaml pyyaml_env_tag
  ```



  To enable the tag, import and add the `construct_env_tag` constructor to your YAML
  loader of choice.

  ```python
  import yaml
  from yaml_env_tag import construct_env_tag

  yaml.Loader.add_constructor('!ENV', construct_env_tag)
  ```

  Then you may use the loader as per usual. For example:

  ```python
  yaml.load(data, Loader=yaml.Loader)
  ```



  Include the tag `!ENV` followed by the name of an environment variable in a YAML
  file and the value of the environment variable will be used in its place.

  ```yaml
  key: !ENV SOME_VARIABLE
  ```

  If `SOME_VARIABLE` is set to `A string!`, then the above YAML would result in the
  following Python object:

  ```python
  {'key': 'A string!'}
  ```

  The content of the variable is parsed using YAML's implicit scalar types, such as
  string, bool, integer, float, datestamp and null. More complex types are not
  recognized and simply passed through as a string. For example, if `SOME_VARIABLE`
  was set to the string `true`, then the above YAML would result in the following:

  ```python
  {'key': True}
  ```

  If the variable specified is not set, then a `null` value is assigned as a default.
  You may define your own default as the last item in a sequence.

  ```yaml
  key: !ENV [SOME_VARIABLE, default]
  ```

  In the above example, if `SOME_VARIABLE` is not defined, the string `default` would
  be used instead, as follows:

  ```python
  {'key': 'default'}
  ```

  You may list multiple variables as fallbacks. The first variable which is set is
  used. In any sequance with more than one item, the last item must always be a
  default value and will not be resolved as an environment variable.

  ```yaml
  key: !ENV [SOME_VARIABLE, FALLBACK, default]
  ```

  As with variable contents, the default is resolved to a Python object of the
  implied type (string, bool, integer, float, datestamp and null).

  When `SOME_VARIABLE` is not set, all four of the following items will resolve to
  the same value (`None`):

  ```yaml
  - !ENV SOME_VARIABLE
  - !ENV [SOME_VARIABLE]
  - !ENV [SOME_VARIABLE, ~]
  - !ENV [SOME_VARIABLE, null]
  ```



  pyyaml_env_tag was inspired by the Ruby package [yaml-env-tag].

  An alternate method of referencing environment variables in YAML files is
  implemented by [pyyaml-tags] and [python_yaml_environment_variables].
  Each of those libraries use a template string and replace the template tag with
  the content of the variable. While this allows a single value to reference
  multiple variables and to contain additional content, it restricts all values
  to strings only and does not provide a way to define defaults.

  [yaml-env-tag]: https://github.com/jirutka/yaml-env-tag
  [pyyaml-tags]: https://github.com/meiblorn/pyyaml-tags
  [python_yaml_environment_variables]: https://gist.github.com/mkaranasou/ba83e25c835a8f7629e34dd7ede01931



  pyyaml_env_tag is licensed under the [MIT License] as defined in `LICENSE`.

  [MIT License]: https://opensource.org/licenses/MIT





  The initial release.


pkgId: cff453c4d07f5e7e86fc0183193722eab7ef5d74bda741b47acb6a4b5115bf5c
name: python-pyyml
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Use python in yaml
url: https://github.com/q1394168335/pyyml
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0d3a405f-94a4-498a-926a-f4896260d4ee
location_href: 00010153-python-pyyml/python-pyyml-0.0.2-1.src.rpm
checksum_type: sha256
description:
  Use python in yaml

  在python中使用：
  ```python
  from pyyml import load

  with open('conf.yml') as f:
      raw_conf = f.read()
  config = load(raw_conf)
  print(config)
  ```
  在yaml中 `${...}` 中的内容将会被python执行：

  yaml内容
  ```yaml
  sum: ${1 + 1}
  ```
  实际解析内容
  ```python
  {'sum': 2}
  ```
  通过在文件开头第一行注释来导入所需的包：

  ```yaml

  ```
  通过 [包名]:[别名] 取别名导入包

  `'os.path:path' 等同于 python 中的 from os import path`

  例如yaml文件内容
  ```yaml

  os_name: ${os.name}
  base_dir: ${path.abspath(path.dirname(__file__))}
  ```


pkgId: 77f8488340dc82a15382f2e0a8029318d01686832bd98d337d9487e903dbae44
name: python-pyzabbix
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: Zabbix API Python interface
url: http://github.com/lukecyca/pyzabbix
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5df849b2-0eff-4f6d-b800-9296a05c947d
location_href: 00004893-python-pyzabbix/python-pyzabbix-1.2.1-1.src.rpm
checksum_type: sha256
description:
  **PyZabbix** is a Python module for working with the [Zabbix API](https://www.zabbix.com/documentation/current/manual/api/reference).

  [![CI](https://github.com/lukecyca/pyzabbix/actions/workflows/ci.yml/badge.svg)](https://github.com/lukecyca/pyzabbix/actions/workflows/ci.yml)
  [![PyPI Package Version](https://img.shields.io/pypi/v/pyzabbix.svg)](https://pypi.org/project/pyzabbix/)
  [![PyPI Python Versions](https://img.shields.io/pypi/pyversions/pyzabbix.svg)](https://pypi.org/project/pyzabbix/)



  - Tested against Zabbix 4.0 LTS, 5.0 LTS, 6.0 LTS and 6.2.





  Install PyZabbix using pip:

  ```bash
  $ pip install pyzabbix
  ```

  You can now import and use pyzabbix like so:

  ```python
  from pyzabbix import ZabbixAPI

  zapi = ZabbixAPI("http://zabbixserver.example.com")
  zapi.login("zabbix user", "zabbix pass")


  print("Connected to Zabbix API Version %s" % zapi.api_version())

  for h in zapi.host.get(output="extend"):
      print(h['hostid'])
  ```

  Refer to the [Zabbix API Documentation](https://www.zabbix.com/documentation/current/manual/api/reference) and the [PyZabbix Examples](https://github.com/lukecyca/pyzabbix/tree/master/examples) for more information.



  PyZabbix uses the [requests](https://requests.readthedocs.io/en/master/) library for HTTP. You can customize the request parameters by configuring the [requests Session](https://requests.readthedocs.io/en/master/user/advanced/#session-objects) object used by PyZabbix.

  This is useful for:

  - Customizing headers
  - Enabling HTTP authentication
  - Enabling Keep-Alive
  - Disabling SSL certificate verification

  ```python
  from pyzabbix import ZabbixAPI

  zapi = ZabbixAPI("http://zabbixserver.example.com")


  zapi.session.auth = ("http user", "http password")


  zapi.session.verify = False


  zapi.timeout = 5.1


  zapi.login("http user", "http password")



  ```



  If you need to debug some issue with the Zabbix API, you can enable the output of logging, pyzabbix already uses the default python logging facility but by default, it logs to "Null", you can change this behavior on your program, here's an example:

  ```python
  import sys
  import logging
  from pyzabbix import ZabbixAPI

  stream = logging.StreamHandler(sys.stdout)
  stream.setLevel(logging.DEBUG)
  log = logging.getLogger('pyzabbix')
  log.addHandler(stream)
  log.setLevel(logging.DEBUG)


  zapi = ZabbixAPI("http://zabbixserver.example.com")
  zapi.login('admin','password')




  ```

  The expected output is as following:

  ```
  Sending: {
      "params": {
          "password": "password",
          "user": "admin"
      },
      "jsonrpc": "2.0",
      "method": "user.login",
      "id": 2
  }
  Response Code: 200
  Response Body: {
      "jsonrpc": "2.0",
      "result": ".................",
      "id": 2
  }
  >>>
  ```



  To develop this project, start by reading the `Makefile` to have a basic understanding of the possible tasks.

  Install the project and the dependencies in a virtual environment:

  ```sh
  make install
  source .venv/bin/activate
  ```



  To release a new version, first bump the version number in `setup.py` by hand and run the release target:

  ```sh
  make release
  ```

  Finally, push the release commit and tag to publish them to Pypi:

  ```sh
  git push --follow-tags
  ```



  LGPL 2.1 http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html

  Zabbix API Python Library.

  Original Ruby Library is Copyright (C) 2009 Andrew Nelson nelsonab(at)red-tux(dot)net

  Original Python Library is Copyright (C) 2009 Brett Lentz brett.lentz(at)gmail(dot)com

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA


pkgId: 19a9a27394598dcb0c29c0f2ae7dc8bf44954fccd261ad558d9d40ced6d2bc7a
name: python-pyzipcode
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: query zip codes and location data
url: https://github.com/vangheem/pyzipcode
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9b0843f9-b694-47fc-a2ac-59bd76a1cdbc
location_href: 00012205-python-pyzipcode/python-pyzipcode-3.0.1-1.src.rpm
checksum_type: sha256
description:
  This package will allow you to get zip code information. The data used in this
  package can be retrieved from
  https://web.archive.org/web/20101126192032/http://pablotron.org/files/zipcodes-csv-10-Aug-2004.zip
  `pyzipcode` uses a local sqlite database to run. You can replace it with your
  own other storage mechanism with a little effort.
  Here is some basic usage...
  ```pycon
  >>> from pyzipcode import ZipCodeDatabase
  >>> zcdb = ZipCodeDatabase()
  >>> zcdb[54115]
  ZipCode(zip='54115', city='De Pere', state='WI', longitude=-88.07896, latitude=44.42042, timezone=-6, dst=1)
  >>> zcdb[210]
  ZipCode(zip='00210', city='Portsmouth', state='NH', longitude=-71.013202, latitude=43.005895, timezone=-5, dst=1)
  ```
  Search zip codes...
  ```pycon
  >>> from pyzipcode import ZipCodeDatabase
  >>> zcdb = ZipCodeDatabase()
  >>> len(zcdb.find_zip(city="Oshkosh"))
  7
  >>> len(zcdb.find_zip(city="O%"))  # all cities starting with "O" using SQL wildcard
  60
  >>> len(zcdb.find_zip(city="Doesn't Exist"))  # returns None
  >>>
  ```
  Get a list of zipcodes around a radius of a zipcode (this actually searches a square area)
  ```pycon
  >>> from pyzipcode import ZipCodeDatabase
  >>> zcdb = ZipCodeDatabase()
  >>> [z.zip for z in zcdb.get_zipcodes_around_radius('54901', 10)]
  ['54901', '54902', '54903', '54904', '54906', '54927', '54952', '54956', '54957', '54979', '54985']
  ```


pkgId: 8e73271f7093401eee638e534df00b7586873eb36b0ab96298245006aaf27339
name: python-pyzipper
arch: src
version: 0.3.6
epoch: 0
release: 1
summary: AES encryption for zipfile.
url: https://github.com/danifus/pyzipper
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-50486b3d-09e5-4c11-8a95-32aa198425c9
location_href: 00010852-python-pyzipper/python-pyzipper-0.3.6-1.src.rpm
checksum_type: sha256
description:
  A replacement for Python's ``zipfile`` that can read and write AES encrypted
  zip files. Forked from Python 3.7's ``zipfile`` module, it features the same
  ``zipfile`` API from that time (most notably, lacking support for
  ``pathlib``-compatible wrappers that were introduced in Python 3.8).


pkgId: bd3549abda22e593dd3dee1af613388d93dd6341efc9e93463cb4371a92d8d1b
name: python-pyzolib
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: Utilities for the Pyzo environment.
url: http://bitbucket.org/pyzo/pyzolib
rpm_license: (new) BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-76a35fd5-2eec-4a29-b6d0-5bcb4d4978d2
location_href: 00004894-python-pyzolib/python-pyzolib-0.3.4-1.src.rpm
checksum_type: sha256
description:
  Package pyzolib

  The pyzolib package provides basic functionality for the Pyzo environment.
  It contains a collection of modules and small packages that should be
  imported as "from pyzolib import xxx"

  The packages currently are:
    * path - object oriented path processing (no more os.path.x)
    * paths - Get paths to useful directories in a cross platform manner.
    * qt - Proxy for importing QtCore et al. from PySide or PyQt4
    * ssdf - the Simple Structured Data Format (for config files and
      scientific databases)
    * insertdocs - a sphynx pre-processor to include docstrings in the text,
      allowing readthedocs.org to host the docs without requiring importing code.
    * pyximport - for easy on the fly compilation of Cython, using the Pyzo
      environment to establish the location of a gcc compiler.
    * gccutils - used by the above to manage the gcc compiler.
    * interprerers - list the Python interpreters available on this system.
    * dllutils - utilities to set the RPATH in dynamic libararies and
      remove depndencies on the MSVCR from the embedded manifest.
    * shebang - for making shebangs in pyzo distro absolute.


pkgId: ab30c809c281fa6c6877f01de4d8bd473b8bbfe89a23a1c19a04bf91a2a13d6b
name: python-pyzstd
arch: src
version: 0.15.6
epoch: 0
release: 1
url: https://github.com/animalize/pyzstd
rpm_license: The 3-Clause BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-840ae91b-44b7-4624-af62-f210c3005345
location_href: 00010467-python-pyzstd/python-pyzstd-0.15.6-1.src.rpm
checksum_type: sha256
summary:
  Python bindings to Zstandard (zstd) compression library, the API style is similar to Python's bz2/lzma/zlib modules.

description:
  Pyzstd module provides classes and functions for compressing and decompressing data, using Facebook's `Zstandard <http://www.zstd.net>`_ (or zstd as short name) algorithm.
  The API style is similar to Python's bz2/lzma/zlib modules.
  * Includes zstd v1.5.5 source code
  * Can also dynamically link to zstd library provided by system, see `this note <https://pyzstd.readthedocs.io/en/latest/#build-pyzstd>`_.
  * Has a CFFI implementation that can work with PyPy
  * Has a command line interface: ``python -m pyzstd --help``


pkgId: abf37f1246cb94aabfaf979932078d55e1068b123ba352d0f4e1c2bb4852dac2
name: python-pyzstd-debuginfo
arch: aarch64
version: 0.15.6
epoch: 0
release: 1
summary: Debug information for package python-pyzstd
url: https://github.com/animalize/pyzstd
rpm_license: The 3-Clause BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-840ae91b-44b7-4624-af62-f210c3005345
rpm_sourcerpm: python-pyzstd-0.15.6-1.src.rpm
location_href: 00010467-python-pyzstd/python-pyzstd-debuginfo-0.15.6-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pyzstd.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 8f81adc3de6e6b02d3763142be83ae5cb5651cd54e8701258e66e9eb121126a0
name: python-pyzstd-debugsource
arch: aarch64
version: 0.15.6
epoch: 0
release: 1
summary: Debug sources for package python-pyzstd
url: https://github.com/animalize/pyzstd
rpm_license: The 3-Clause BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-840ae91b-44b7-4624-af62-f210c3005345
rpm_sourcerpm: python-pyzstd-0.15.6-1.src.rpm
location_href: 00010467-python-pyzstd/python-pyzstd-debugsource-0.15.6-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pyzstd.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: e56e9b61b7710fd83f6a873adb4888537ec76e7ced47cd75f08307be6f977cb1
name: python-qcelemental
arch: src
version: 0.25.1
epoch: 0
release: 1
summary: Essentials for Quantum Chemistry.
url: https://github.com/MolSSI/QCElemental
rpm_license: BSD-3C
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-07181aa9-66a3-406c-a81b-d0f98893c057
location_href: 00004896-python-qcelemental/python-qcelemental-0.25.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/MolSSI/QCElemental/workflows/CI/badge.svg?branch=master)](https://github.com/MolSSI/QCElemental/actions?query=workflow%3ACI)
  [![codecov](https://img.shields.io/codecov/c/github/MolSSI/QCElemental.svg?logo=Codecov&logoColor=white)](https://codecov.io/gh/MolSSI/QCElemental)
  [![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/MolSSI/QCElemental.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/MolSSI/QCElemental/context:python)
  [![Documentation Status](https://img.shields.io/github/workflow/status/MolSSI/QCElemental/CI/master?label=docs&logo=readthedocs&logoColor=white)](http://docs.qcarchive.molssi.org/projects/qcelemental/en/latest/)
  [![Chat on Slack](https://img.shields.io/badge/chat-on_slack-green.svg?longCache=true&style=flat&logo=slack)](https://join.slack.com/t/qcarchive/shared_invite/enQtNDIzNTQ2OTExODk0LTE3MWI0YzBjNzVhNzczNDM0ZTA5MmQ1ODcxYTc0YTA1ZDQ2MTk1NDhlMjhjMmQ0YWYwOGMzYzJkZTM2NDlmOGM)
  ![python](https://img.shields.io/badge/python-3.6+-blue.svg)

  QCElemental is a resource module for quantum chemistry containing physical
  constants and periodic table data from NIST and molecule handlers.

  Periodic Table and Physical Constants data are pulled from NIST srd144 and
  srd121, respectively ([details](raw_data/README.md)) in a renewable manner
  (class around NIST-published JSON file).

  This project also contains a generator, validator, and translator for [Molecule
  QCSchema](https://molssi-qc-schema.readthedocs.io/en/latest/auto_topology.html).

  It is intended to keep the QCElemental code compatible with Python 3.6+
  as long as dependencies allow. Packages are assured for Python 3.8+.




  A variety of periodic table quantities are available using virtually any alias:

  ```python
  >>> import qcelemental as qcel
  >>> qcel.periodictable.to_E('KRYPTON')
  'Kr'
  >>> qcel.periodictable.to_element(36)
  'Krypton'
  >>> qcel.periodictable.to_Z('kr84')
  36
  >>> qcel.periodictable.to_A('Kr')
  84
  >>> qcel.periodictable.to_A('D')
  2
  >>> qcel.periodictable.to_mass('kr', return_decimal=True)
  Decimal('83.9114977282')
  >>> qcel.periodictable.to_mass('kr84')
  83.9114977282
  >>> qcel.periodictable.to_mass('Kr86')
  85.9106106269
  ```



  Physical constants can be acquired directly from the [NIST CODATA](https://physics.nist.gov/cuu/Constants/Table/allascii.txt):

  ```python
  >>> import qcelemental as qcel
  >>> qcel.constants.Hartree_energy_in_eV
  27.21138602
  >>> qcel.constants.get('hartree ENERGY in ev')
  27.21138602
  >>> pc = qcel.constants.get('hartree ENERGY in ev', return_tuple=True)
  >>> pc.label
  'Hartree energy in eV'
  >>> pc.data
  Decimal('27.21138602')
  >>> pc.units
  'eV'
  >>> pc.comment
  'uncertainty=0.000 000 17'
  ```

  Alternatively, with the use of the [Pint unit conversion package](https://pint.readthedocs.io/en/latest/), arbitrary
  conversion factors can be obtained:

  ```python
  >>> qcel.constants.conversion_factor("bohr", "miles")
  3.2881547429884475e-14
  ```



  Covalent radii are accessible for most of the periodic table from [Alvarez, Dalton Transactions (2008) doi:10.1039/b801115j](https://doi.org/10.1039/b801115j) ([details](qcelemental/data/alvarez_2008_covalent_radii.py.py)).
  ```python
  >>> import qcelemental as qcel
  >>> qcel.covalentradii.get('I')
  2.626719314386381
  >>> qcel.covalentradii.get('I', units='angstrom')
  1.39
  >>> qcel.covalentradii.get(116)
  Traceback (most recent call last):
  ...
  qcelemental.exceptions.DataUnavailableError: ('covalent radius', 'Lv')
  >>> qcel.covalentradii.get(116, missing=4.0)
  4.0
  >>> qcel.covalentradii.get('iodine', return_tuple=True).dict()
  {'numeric': True, 'label': 'I', 'units': 'angstrom', 'data': Decimal('1.39'), 'comment': 'e.s.d.=3 n=451', 'doi': 'DOI: 10.1039/b801115j'}
  ```



  Van der Waals radii are accessible for tmost of the periodic table from [Mantina, J. Phys. Chem. A (2009) doi: 10.1021/jp8111556](https://pubs.acs.org/doi/10.1021/jp8111556) ([details](qcelemental/data/mantina_2009_vanderwaals_radii.py)).
  ```python
  >>> import qcelemental as qcel
  >>> qcel.vdwradii.get('I')
  3.7416577284064996
  >>> qcel.vdwradii.get('I', units='angstrom')
  1.98
  >>> qcel.vdwradii.get(116)
  Traceback (most recent call last):
  ...
  qcelemental.exceptions.DataUnavailableError: ('vanderwaals radius', 'Lv')
  >>> qcel.vdwradii.get('iodine', return_tuple=True).dict()
  {'numeric': True, 'label': 'I', 'units': 'angstrom', 'data': Decimal('1.98'), 'doi': 'DOI: 10.1021/jp8111556'}
  ```


pkgId: 41ebb293c0b0d5f6cb237dd71d5409410d96b63bcf68414585557db141c3bfd3
name: python-qiskit
arch: src
version: 0.42.1
epoch: 0
release: 1
summary: Software for developing quantum computing programs
url: https://qiskit.org/
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6b9d868b-045d-448e-a4c9-01455dfb2ff1
location_href: 00012445-python-qiskit/python-qiskit-0.42.1-1.src.rpm
checksum_type: sha256
description:
  ![Image](https://raw.githubusercontent.com/Qiskit/qiskit/master/images/qiskit_header.png)

  [![License](https://img.shields.io/github/license/Qiskit/qiskit.svg?)](https://opensource.org/licenses/Apache-2.0)
  ![Build Status](https://github.com/Qiskit/qiskit/actions/workflows/main.yml/badge.svg?branch=master)
  ![Build Status](https://github.com/Qiskit/qiskit/actions/workflows/docs.yml/badge.svg?branch=master)
  [![](https://img.shields.io/github/release/Qiskit/qiskit.svg)](https://github.com/Qiskit/qiskit/releases)
  [![Downloads](https://pepy.tech/badge/qiskit)](https://pypi.org/project/qiskit/)
  [![DOI](https://zenodo.org/badge/161550823.svg)](https://zenodo.org/badge/latestdoi/161550823)

  **Qiskit** is an open-source SDK for working with quantum computers at the level of circuits, algorithms, and application modules.

  Qiskit is made up of elements that work together to enable quantum computing. This is a simple meta-package to install the elements of Qiskit altogether.



  The best way of installing `qiskit` is by using `pip`:

  ```bash
  $ pip install qiskit
  ```

  See [install](https://qiskit.org/documentation/getting_started.html) Qiskit for detailed instructions, how to use virtual environments, and
  build from source standalone versions of the individual Qiskit elements and components.



  The Qiskit project used to be made up of many components. However, in the future the Qiskit metapackage will only install [**Qiskit Terra**](https://github.com/Qiskit/qiskit-terra):

  | Build   | Version | Contribute |
  | ---     | --- | --- |
  | [**Qiskit Terra**](https://github.com/Qiskit/qiskit-terra) | [![](https://img.shields.io/github/release/Qiskit/qiskit-terra.svg?)](https://github.com/Qiskit/qiskit-terra/releases)  | [![](https://img.shields.io/github/forks/Qiskit/qiskit-terra.svg?)](https://github.com/Qiskit/qiskit-terra) |

  <table>
    <tr>
      <td colspan="3" align="center">:warning: WARNING :warning:</br> <b>For the time being, two other packages are installed, but these components will be removed from the metapackage in a future release.</b></td>
    </tr>
  <tr>
  <th>Build</th>
  <th>Version</th>
  <th>Contribute</th>
  </tr>
  <tr>
  <td><a href="https://github.com/Qiskit/qiskit-aer"><strong>Qiskit Aer</strong></a></td>
  <td><a href="https://github.com/Qiskit/qiskit-aer/releases"><img src="https://camo.githubusercontent.com/7b4ebed2975693dc2d18233e49b7f9141838c1e86f22ac36f465fcd3886821b6/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f72656c656173652f5169736b69742f7169736b69742d6165722e7376673f" alt="" data-canonical-src="https://img.shields.io/github/release/Qiskit/qiskit-aer.svg?"></a></td>
  <td><a href="https://github.com/Qiskit/qiskit-aer"><img src="https://camo.githubusercontent.com/ced831707852701ae4c21b1455d6c2d2a03fa54dffe09fcf5208970112023a05/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f666f726b732f5169736b69742f7169736b69742d6165722e7376673f" alt="" data-canonical-src="https://img.shields.io/github/forks/Qiskit/qiskit-aer.svg?"></a></td>
  </tr>
  <tr>
  <td><a href="https://github.com/Qiskit/qiskit-ibmq-provider"><strong>Qiskit IBM Quantum Provider</strong></a></td>
  <td><a href="https://github.com/Qiskit/qiskit-ibmq-provider/releases"><img src="https://camo.githubusercontent.com/daa12aee2f03d2d310bd6ad1a5c5babe99b038fc08ad9f0309f5e1c7420c9ffe/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f72656c656173652f5169736b69742f7169736b69742d69626d712d70726f76696465722e7376673f" alt="" data-canonical-src="https://img.shields.io/github/release/Qiskit/qiskit-ibmq-provider.svg?"></a></td>
  <td><a href="https://github.com/Qiskit/qiskit-ibmq-provider"><img src="https://camo.githubusercontent.com/49f1938883f91358a594feeddecdd59b3188a353a9a20721a6fefcd64c32f6ce/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f666f726b732f5169736b69742f7169736b69742d69626d712d70726f76696465722e7376673f" alt="" data-canonical-src="https://img.shields.io/github/forks/Qiskit/qiskit-ibmq-provider.svg?"></a></td>
  </tr>
  </table>



  These components are part of the Qiskit ecosystem but are built on top of
  `qiskit` and are not installed by default with the meta-package. You can either
  install them manually, as an optional extra
  (ie `pip install "qiskit[finance,experiments]"`), or all together with
  `pip install "qiskit[all]"`.

  | Build | Version | Contribute |
  | ---   | --- | --- |
  | [**Qiskit Optimization**](https://github.com/Qiskit/qiskit-optimization) | [![](https://img.shields.io/github/release/Qiskit/qiskit-optimization.svg?)](https://github.com/Qiskit/qiskit-optimization/releases) | [![](https://img.shields.io/github/forks/Qiskit/qiskit-optimization.svg?)](https://github.com/Qiskit/qiskit-optimization) |
  | [**Qiskit Finance**](https://github.com/Qiskit/qiskit-finance) |  [![](https://img.shields.io/github/release/Qiskit/qiskit-finance.svg?)](https://github.com/Qiskit/qiskit-finance/releases) | [![](https://img.shields.io/github/forks/Qiskit/qiskit-finance.svg?)](https://github.com/Qiskit/qiskit-finance) |
  | [**Qiskit Machine Learning**](https://github.com/Qiskit/qiskit-machine-learning) | [![](https://img.shields.io/github/release/Qiskit/qiskit-machine-learning.svg?)](https://github.com/Qiskit/qiskit-machine-learning/releases) | [![](https://img.shields.io/github/forks/Qiskit/qiskit-machine-learning.svg?)](https://github.com/Qiskit/qiskit-machine-learning) |
  | [**Qiskit Nature**](https://github.com/Qiskit/qiskit-nature) |  [![](https://img.shields.io/github/release/Qiskit/qiskit-nature.svg?)](https://github.com/Qiskit/qiskit-nature/releases) | [![](https://img.shields.io/github/forks/Qiskit/qiskit-nature.svg?)](https://github.com/Qiskit/qiskit-nature) |
  | [**Qiskit Experiments**](https://github.com/Qiskit/qiskit-experiments) |  [![](https://img.shields.io/github/release/Qiskit/qiskit-experiments.svg?)](https://github.com/Qiskit/qiskit-experiments/releases) | [![](https://img.shields.io/github/forks/Qiskit/qiskit-experiments.svg?)](https://github.com/Qiskit/qiskit-experiments) |



  If you are interested in using quantum services (i.e. using a real quantum
  computer, not a simulator) you can look at the Qiskit Partners program for
  partner organizations that have provider packages available for their offerings:

  https://qiskit.org/documentation/partners/



  If you'd like to contribute to Qiskit, please take a look at our
  [contribution guidelines](https://qiskit.org/documentation/contributing_to_qiskit.html). This project adheres to Qiskit's [code of conduct](CODE_OF_CONDUCT.md). By participating, you are expected to uphold this code.

  We use [GitHub issues](https://github.com/Qiskit/qiskit/issues) for tracking requests and bugs. Please use our [Slack](https://qisk.it/join-slack) for discussion and simple questions. For questions that are more suited for a forum we use the Qiskit tag in the [Stack Exchange](https://quantumcomputing.stackexchange.com/questions/tagged/qiskit).



  Now you're set up and ready to check out our
  [Qiskit Tutorials](https://github.com/Qiskit/qiskit-tutorials) repository.



  Qiskit is the work of [many people](AUTHORS) who contribute to the project at
  different levels. If you use Qiskit, please cite as per the included
  [BibTeX file](Qiskit.bib).



  [Apache License 2.0](LICENSE.txt)


pkgId: 5b2d5d6aee4ce4afdfce2d4ddca517add87ac539dcc1be69e1fa81b3787ba421
name: python-qiskit-ibmq-provider
arch: src
version: 0.20.2
epoch: 0
release: 1
summary: Qiskit provider for accessing the quantum devices and simulators at IBMQ
url: https://github.com/Qiskit/qiskit-ibmq-provider
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f8a61671-6453-4c92-be90-f4f088ba0069
location_href: 00012813-python-qiskit-ibmq-provider/python-qiskit-ibmq-provider-0.20.2-1.src.rpm
checksum_type: sha256
description:
  **_PLEASE NOTE:_** _As of version 0.20.0, released in January 2023, `qiskit-ibmq-provider` has been deprecated
  with its support ending and eventual archival being no sooner than 3 months from that date. The
  function provided by `qiskit-ibmq-provider` is not going away rather it has being split out to separate repositories.
  Please see the [Migration Guides](#migration-guides) section below for more detail. We encourage you


pkgId: becfddb8fa132426b2efaedb80ff4170b16c78965718c51050e57b939cdbcf87
name: python-qiskit-ignis
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: Qiskit tools for quantum information science
url: https://github.com/Qiskit/qiskit-ignis
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6d1c7b7e-10dc-44f6-89a2-2381b57123a2
location_href: 00013531-python-qiskit-ignis/python-qiskit-ignis-0.7.1-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/github/license/Qiskit/qiskit-ignis.svg?style=popout-square)](https://opensource.org/licenses/Apache-2.0)[![Build Status](https://img.shields.io/travis/com/Qiskit/qiskit-ignis/master.svg?style=popout-square)](https://travis-ci.com/Qiskit/qiskit-ignis)[![](https://img.shields.io/github/release/Qiskit/qiskit-ignis.svg?style=popout-square)](https://github.com/Qiskit/qiskit-ignis/releases)[![](https://img.shields.io/pypi/dm/qiskit-ignis.svg?style=popout-square)](https://pypi.org/project/qiskit-ignis/)

  **_NOTE_** _As of the version 0.7.0 Qiskit Ignis is deprecated and has been
  superseded by the
  [Qiskit Experiments](https://github.com/Qiskit/qiskit-experiments) project.
  Active development on the project has stopped and only compatibility fixes
  and other critical bugfixes will be accepted until the project is officially
  retired and archived._

  **Qiskit** is an open-source framework for working with noisy quantum computers at the level of pulses, circuits, and algorithms.

  Qiskit is made up of elements that each work together to enable quantum computing. This element is **Ignis**, which provides tools for quantum hardware verification, noise characterization, and error correction.



  As of version 0.7.0, Qiskit Ignis has been deprecated and some of its functionality
  was migrated into the `qiskit-experiments` package and into `qiskit-terra`.

  * Ignis characterization module

    * This module was partly migrated to [`qiskit-experiments`](https://github.com/Qiskit/qiskit-experiments) and split into two different modules:
    `qiskit_experiments.library.calibration`
    `qiskit_experiments.library.characterization`
    * `AmpCal` is now replaced by `FineAmplitude`.
    * `ZZFitter` was not migrated yet.

  * Ignis discriminator module

    * This module is in the process of migration to [`qiskit-experiments`](https://github.com/Qiskit/qiskit-experiments)

  * Ignis mitigation module

    * The readout mitigator will be soon added to [`qiskit-terra`](https://github.com/Qiskit/qiskit-terra).
    * Experiments for generating the readout mitigators will be added to [`qiskit-experiments`](https://github.com/Qiskit/qiskit-experiments)
    * For use of mitigators with `qiskit.algorithms` and the [`QuantumInstance` class](https://qiskit.org/documentation/stubs/qiskit.utils.QuantumInstance.html?highlight=quantuminstance#qiskit.utils.QuantumInstance)
      this has been integrated into `qiskit-terra` directly with the `QuantumInstance`.

  * Ignis verification module

    * Randomized benchmarking, Quantum Volume and State and Process Tomography were migrated to [`qiskit-experiments`](https://github.com/Qiskit/qiskit-experiments).
    * Migration of Gate-set tomography to [`qiskit-experiments`](https://github.com/Qiskit/qiskit-experiments) is in progress.
    * `topological_codes` will continue development under [NCCR-SPIN](https://github.com/NCCR-SPIN/topological_codes/blob/master/README.md), while the functionality is reintegrated into Qiskit. Some additional functionality can also be found in the offshoot project [qtcodes](https://github.com/yaleqc/qtcodes).
    * Currently the Accredition and Entanglement modules have not been migrated.
  The following table gives a more detailed breakdown that relates the function, as it existed in Ignis,
  to where it now lives after this move.

  | Old | New | Library |
  | :---: | :---: | :---: |
  | qiskit.ignis.characterization.calibrations | qiskit_experiments.library.calibration | qiskit-experiments |
  | qiskit.ignis.characterization.coherence | qiskit_experiments.library.characterization | qiskit-experiments |
  | qiskit.ignis.mitigation | qiskit_terra.mitigation | qiskit-terra |
  | qiskit.ignis.verification.quantum_volume | qiskit_experiments.library.quantum_volume | qiskit-experiments |
  | qiskit.ignis.verification.randomized_benchmarking | qiskit_experiments.library.randomized_benchmarking | qiskit-experiments |
  | qiskit.ignis.verification.tomography | qiskit_experiments.library.tomography | qiskit-experiments |



  We encourage installing Qiskit via the pip tool (a python package manager). The following command installs the core Qiskit components, including Ignis.

  ```bash
  pip install qiskit
  ```

  Pip will handle all dependencies automatically for us and you will always install the latest (and well-tested) version.

  To install from source, follow the instructions in the [contribution guidelines](./CONTRIBUTING.md).



  Some functionality has extra optional requirements. If you're going to use any
  visualization functions for fitters you'll need to install matplotlib. You
  can do this with `pip install matplotlib` or when you install ignis with
  `pip install qiskit-ignis[visualization]`. If you're going to use a cvx fitter
  for running tomogography you'll need to install cvxpy. You can do this with
  `pip install cvxpy` or when you install ignis with
  `pip install qiskit-ignis[cvx]`. When performing expectation value measurement
  error mitigation using the CTMP method performance can be improved using
  just-in-time compiling if Numbda is installed. You can do this with
  `pip install numba` or when you install ignis with
  `pip install qiskit-ignis[jit]`. For using the discriminator classes in
  `qiskit.ignis.measurement` scikit-learn needs to be installed. You can do this with
  `pip install scikit-learn` or when you install ignis with
  `pip install qiskit-ignis[iq]`. If you want to install all extra requirements
  when you install ignis you can run `pip install qiskit-ignis[visualization,cvx,jit,iq]`.


  Now that you have Qiskit Ignis installed, you can start creating experiments, to reveal information about the device quality. Here is a basic example:

  ```
  $ python
  ```

  ```python

  import qiskit
  from qiskit import QuantumRegister, QuantumCircuit, ClassicalRegister
  from qiskit.providers.aer import noise # import AER noise model


  from qiskit.ignis.mitigation.measurement import (complete_meas_cal,
                                                   CompleteMeasFitter,
                                                   MeasurementFilter)


  noise_model = noise.NoiseModel()
  for qi in range(5):
      read_err = noise.errors.readout_error.ReadoutError([[0.75, 0.25],[0.1, 0.9]])
      noise_model.add_readout_error(read_err, [qi])



  qr = QuantumRegister(5)
  meas_cals, state_labels = complete_meas_cal(qubit_list=[2,3,4], qr=qr)


  backend = qiskit.Aer.get_backend('qasm_simulator')
  job = qiskit.execute(meas_cals, backend=backend, shots=1000, noise_model=noise_model)
  cal_results = job.result()


  meas_fitter = CompleteMeasFitter(cal_results, state_labels)


  cr = ClassicalRegister(3)
  ghz = QuantumCircuit(qr, cr)
  ghz.h(qr[2])
  ghz.cx(qr[2], qr[3])
  ghz.cx(qr[3], qr[4])
  ghz.measure(qr[2],cr[0])
  ghz.measure(qr[3],cr[1])
  ghz.measure(qr[4],cr[2])


  job = qiskit.execute(ghz, backend=backend, shots=1000, noise_model=noise_model)
  results = job.result()


  raw_counts = results.get_counts()
  print("Results without mitigation:", raw_counts)


  meas_filter = meas_fitter.filter


  mitigated_counts = meas_filter.apply(raw_counts)
  print("Results with mitigation:", {l:int(mitigated_counts[l]) for l in mitigated_counts})
  ```

  ```
  Results without mitigation: {'000': 181, '001': 83, '010': 59, '011': 65, '100': 101, '101': 48, '110': 72, '111': 391}

  Results with mitigation: {'000': 421, '001': 2, '011': 1, '100': 53, '110': 13, '111': 510}
  ```



  If you'd like to contribute to Qiskit Ignis, please take a look at our
  [contribution guidelines](./CONTRIBUTING.md). This project adheres to Qiskit's [code of conduct](./CODE_OF_CONDUCT.md). By participating, you are expect to uphold to this code.

  We use [GitHub issues](https://github.com/Qiskit/qiskit-ignis/issues) for tracking requests and bugs. Please use our [slack](https://qiskit.slack.com) for discussion and simple questions. To join our Slack community use the [link](https://join.slack.com/t/qiskit/shared_invite/enQtNDc2NjUzMjE4Mzc0LTMwZmE0YTM4ZThiNGJmODkzN2Y2NTNlMDIwYWNjYzA2ZmM1YTRlZGQ3OGM0NjcwMjZkZGE0MTA4MGQ1ZTVmYzk). For questions that are more suited for a forum we use the Qiskit tag in the [Stack Exchange](https://quantumcomputing.stackexchange.com/questions/tagged/qiskit).



  Now you're set up and ready to check out some of the other examples from our
  [Qiskit Tutorials](https://github.com/Qiskit/qiskit-iqx-tutorials/tree/master/qiskit/advanced/ignis) repository.



  Qiskit Ignis is the work of [many people](https://github.com/Qiskit/qiskit-ignis/graphs/contributors) who contribute
  to the project at different levels. If you use Qiskit, please cite as per the included [BibTeX file](https://github.com/Qiskit/qiskit/blob/master/Qiskit.bib).



  [Apache License 2.0](LICENSE.txt)


pkgId: 745de1e8352fe8f3e30d155f8f8c63447abb9e32ae9e2cc9e42e900346464c50
name: python-qmp
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: QEMU Monitor Protocol client
url: https://gitlab.com/abogdanenko/qmp
rpm_license: GNU General Public License v2 (GPLv2)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-aab289fa-8751-4462-8a79-0b32a00899a3
location_href: 00011804-python-qmp/python-qmp-0.0.1-1.src.rpm
checksum_type: sha256
description:
  QEMU Monitor Protocol (QMP) is a JSON-based protocol that allows applications to
  communicate with a QEMU instance.
  This project packages an exact copy of `python/qemu/qmp.py` from the QEMU source
  tree.
  For a brief introduction to QMP, see
  <https://github.com/qemu/qemu/blob/master/docs/interop/qmp-intro.txt>.
  For detailed information about the protocol, see
  <https://github.com/qemu/qemu/blob/master/docs/interop/qmp-spec.txt>.
  For the full list of commands supported by QMP see *qemu-qmp-ref* man page,
  which is available at
  <https://manpages.debian.org/unstable/qemu-system-common/qemu-qmp-ref.7.en.html>.


pkgId: b21326b50c301794f10586576604eafbd962039454f7455d44df0ec432c3c38b
name: python-qtconsole
arch: src
version: 5.4.0
epoch: 0
release: 1
summary: Jupyter Qt console
url: http://jupyter.org
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9f7a9d30-a8ce-465f-b7c3-e7861298aa53
location_href: 00004914-python-qtconsole/python-qtconsole-5.4.0-1.src.rpm
checksum_type: sha256
description:
  ![Windows tests](https://github.com/jupyter/qtconsole/workflows/Windows%20tests/badge.svg)
  ![Macos tests](https://github.com/jupyter/qtconsole/workflows/Macos%20tests/badge.svg)
  ![Linux tests](https://github.com/jupyter/qtconsole/workflows/Linux%20tests/badge.svg)
  [![Coverage Status](https://coveralls.io/repos/github/jupyter/qtconsole/badge.svg?branch=master)](https://coveralls.io/github/jupyter/qtconsole?branch=master)
  [![Documentation Status](https://readthedocs.org/projects/qtconsole/badge/?version=stable)](https://qtconsole.readthedocs.io/en/stable/)
  [![Google Group](https://img.shields.io/badge/-Google%20Group-lightgrey.svg)](https://groups.google.com/forum/#!forum/jupyter)

  A rich Qt-based console for working with Jupyter kernels,
  supporting rich media output, session export, and more.

  The Qtconsole is a very lightweight application that largely feels like a terminal, but
  provides a number of enhancements only possible in a GUI, such as inline
  figures, proper multiline editing with syntax highlighting, graphical calltips,
  and more.

  ![qtconsole](https://raw.githubusercontent.com/jupyter/qtconsole/master/docs/source/_images/qtconsole.png)


  The Qtconsole requires Python bindings for Qt, such as [PyQt5](http://www.riverbankcomputing.com/software/pyqt/intro),
  [PyQt4](https://www.riverbankcomputing.com/software/pyqt/download),
  or [PySide](http://pyside.github.io/docs/pyside).

  Although [pip](https://pypi.python.org/pypi/pip) and
  [conda](http://conda.pydata.org/docs) may be used to install the Qtconsole, conda
  is simpler to use since it automatically installs PyQt5. Alternatively,
  the Qtconsole installation with pip needs additional steps since pip doesn't install
  the Qt requirement.


  To install:

      conda install qtconsole

  **Note:** If the Qtconsole is installed using conda, it will **automatically**
  install the Qt requirement as well.


  To install:

      pip install qtconsole

  **Note:** Make sure that Qt is installed. Unfortunately, Qt is not
  installed when using pip. The next section gives instructions on doing it.


  You can install PyQt5 with pip using the following command:

      pip install pyqt5

  or with a system package manager on Linux. For Windows, PyQt binary packages may be
  used.

  **Note:** Additional information about using a system package manager may be
  found in the [qtconsole documentation](https://qtconsole.readthedocs.io).

  More installation instructions for PyQt can be found in the [PyQt5 documentation](http://pyqt.sourceforge.net/Docs/PyQt5/installation.html) and [PyQt4 documentation](http://pyqt.sourceforge.net/Docs/PyQt4/installation.html)

  Source packages for Windows/Linux/MacOS can be found here: [PyQt5](https://www.riverbankcomputing.com/software/pyqt/download5) and [PyQt4](https://riverbankcomputing.com/software/pyqt/download).



  To run the Qtconsole:

      jupyter qtconsole


  - [Project Jupyter website](https://jupyter.org)
  - Documentation for the Qtconsole
    * [latest version](https://qtconsole.readthedocs.io/en/latest/) [[PDF](https://media.readthedocs.org/pdf/qtconsole/latest/qtconsole.pdf)]
    * [stable version](https://qtconsole.readthedocs.io/en/stable/) [[PDF](https://media.readthedocs.org/pdf/qtconsole/stable/qtconsole.pdf)]
  - [Documentation for Project Jupyter](https://jupyter.readthedocs.io/en/latest/index.html) [[PDF](https://media.readthedocs.org/pdf/jupyter/latest/jupyter.pdf)]
  - [Issues](https://github.com/jupyter/qtconsole/issues)
  - [Technical support - Jupyter Google Group](https://groups.google.com/forum/#!forum/jupyter)


pkgId: a442254f613c510abaaa9572431e66bb9a5d65dcc266c853cb3c155950eddfb4
name: python-qtsass
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Compile SCSS files to valid Qt stylesheets.
url: https://github.com/spyder-ide/qtsass
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-39e51460-3bc1-426d-8b26-41f7b6f7117b
location_href: 00004915-python-qtsass/python-qtsass-0.3.2-1.src.rpm
checksum_type: sha256
description:
  [![License - MIT](https://img.shields.io/github/license/spyder-ide/qtsass.svg)](./LICENSE.txt)
  [![OpenCollective Backers](https://opencollective.com/spyder/backers/badge.svg?color=blue)](#backers)
  [![Join the chat at https://gitter.im/spyder-ide/public](https://badges.gitter.im/spyder-ide/spyder.svg)](https://gitter.im/spyder-ide/public)<br>
  [![Github build status](https://github.com/spyder-ide/qtsass/workflows/Tests/badge.svg)](https://github.com/spyder-ide/qtsass/actions)
  [![Codecov coverage](https://img.shields.io/codecov/c/github/spyder-ide/qtsass/master.svg)](https://codecov.io/gh/spyder-ide/qtsass)
  [![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/spyder-ide/qtsass/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/spyder-ide/qtsass/?branch=master)

  *Copyright © 2015 Yann Lanthony*

  *Copyright © 2017–2018 Spyder Project Contributors*




  [SASS](http://sass-lang.com/) brings countless amazing features to CSS.
  Besides being used in web development, CSS is also the way to stylize Qt-based desktop applications.
  However, Qt's CSS has a few variations that prevent the direct use of SASS compiler.

  The purpose of this tool is to fill the gap between SASS and Qt-CSS by handling those variations.




  The goal of QtSASS is to be able to generate a Qt-CSS stylesheet based on a 100% valid SASS file.
  This is how it deals with Qt's specifics and how you should modify your CSS stylesheet to use QtSASS.


  Qt allows to define the style of a widget according to its states, like this:

  ```css
  QLineEdit:enabled {
  ...
  }
  ```

  However, a "not" state is problematic because it introduces an exclamation mark in the selector's name, which is not valid SASS/CSS:

  ```css
  QLineEdit:!editable {
  ...
  }
  ```

  QtSASS allows "!" in selectors' names; the SASS file is preprocessed and any occurence of `:!` is replaced by `:_qnot_` (for "Qt not").
  However, using this feature prevents from having a 100% valid SASS file, so this support of `!` might change in the future.
  This can be replaced by the direct use of the `_qnot_` keyword in your SASS file:

  ```css
  QLineEdit:_qnot_editable { /* will generate QLineEdit:!editable { */
  ...
  }
  ```


  The qlineargradient function also has a non-valid CSS syntax.

  ```css
  qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0.1 blue, stop: 0.8 green)
  ```

  To support qlineargradient QtSASS provides a preprocessor and a SASS implementation of the qlineargradient function. The above QSS syntax will be replaced with the following:

  ```css
  qlineargradient(0, 0, 0, 1, (0.1 blue, 0.8 green))
  ```

  You may also use this syntax directly in your QtSASS.

  ```
  qlineargradient(0, 0, 0, 1, (0.1 blue, 0.8 green))

  $stops = 0.1 blue, 0.8 green
  qlineargradient(0, 0, 0, 0, $stops)
  ```


  Qt's rgba:

  ```css
  rgba(255, 128, 128, 50%)
  ```

  is replaced by CSS rgba:

  ```css
  rgba(255, 128, 128, 0.5)
  ```




  To compile your SASS stylesheet to a Qt compliant CSS file:

  ```bash

  qtsass style.scss -o style.css
  ```

  To use the watch mode and get your stylesheet auto recompiled on each file save:

  ```bash

  qtsass style.scss -o style.css -w
  ```

  To compile a directory containing SASS stylesheets to Qt compliant CSS files:

  ```bash
  qtsass ./static/scss -o ./static/css
  ```

  You can also use watch mode to watch the entire directory for changes.

  ```bash
  qtsass ./static/scss -o ./static/css -w
  ```

  Set the Environment Variable QTSASS_DEBUG to 1 or pass the --debug flag to enable logging.

  ```bash
  qtsass ./static/scss -o ./static/css --debug
  ```





  Conform and Compile QtSASS source code to CSS.

  This function conforms QtSASS to valid SCSS before passing it to
  sass.compile. Any keyword arguments you provide will be combined with
  qtsass's default keyword arguments and passed to sass.compile.

  Examples:

  ```bash
  >>> import qtsass
  >>> qtsass.compile("QWidget {background: rgb(0, 0, 0);}")
  QWidget {background:black;}
  ```

  Arguments:
  - string: QtSASS source code to conform and compile.
  - kwargs: Keyword arguments to pass to sass.compile

  Returns:
  - Qt compliant CSS string



  Compile and save QtSASS file as Qt compliant CSS.

  Examples:

  ```bash
  >>> import qtsass
  >>> qtsass.compile_filename('dummy.scss', 'dummy.css')
  ```

  Arguments:
  - input_file: Path to QtSass file.
  - dest_file: Path to destination Qt compliant CSS file.
  - kwargs: Keyword arguments to pass to sass.compile



  Compile and save QtSASS file as Qt compliant CSS.

  Examples:

  ```bash
  >>> import qtsass
  >>> qtsass.compile_filename('dummy.scss', 'dummy.css')
  ```

  Arguments:
  - input_file: Path to QtSass file.
  - output_file: Path to write Qt compliant CSS.
  - kwargs: Keyword arguments to pass to sass.compile



  Compiles QtSASS files in a directory including subdirectories.

  ```bash
  >>> import qtsass
  >>> qtsass.compile_dirname("./scss", "./css")
  ```

  Arguments:
  - input_dir: Path to directory containing QtSass files.
  - output_dir: Directory to write compiled Qt compliant CSS files to.
  - kwargs: Keyword arguments to pass to sass.compile


  Enable logging for qtsass.

  Sets the qtsass logger's level to:
      1. the provided logging level
      2. logging.DEBUG if the QTSASS_DEBUG envvar is a True value
      3. logging.WARNING

  ```bash
  >>> import logging
  >>> import qtsass
  >>> handler = logging.StreamHandler()
  >>> formatter = logging.Formatter('-8s: s> s')
  >>> handler.setFormatter(formatter)
  >>> qtsass.enable_logging(level=logging.DEBUG, handler=handler)
  ```

  Arguments:
  - level: Optional logging level
  - handler: Optional handler to add


  Watches a source file or directory, compiling QtSass files when modified.

  The compiler function defaults to compile_filename when source is a file
  and compile_dirname when source is a directory.

  Arguments:
  - source: Path to source QtSass file or directory.
  - destination: Path to output css file or directory.
  - compiler: Compile function (optional)
  - Watcher: Defaults to qtsass.watchers.Watcher (optional)

  Returns:
  - qtsass.watchers.Watcher instance



  Everyone is welcome to contribute!




  Spyder and its subprojects are funded thanks to the generous support of

  [![Quansight](https://static.wixstatic.com/media/095d2c_2508c560e87d436ea00357abc404cf1d~mv2.png/v1/crop/x_0,y_9,w_915,h_329/fill/w_380,h_128,al_c,usm_0.66_1.00_0.01/095d2c_2508c560e87d436ea00357abc404cf1d~mv2.png)](https://www.quansight.com/)[![Numfocus](https://i2.wp.com/numfocus.org/wp-content/uploads/2017/07/NumFocus_LRG.png?fit=320%2C148&ssl=1)](https://numfocus.org/)


  and the donations we have received from our users around the world through [Open Collective](https://opencollective.com/spyder/):

  [![Sponsors](https://opencollective.com/spyder/sponsors.svg)](https://opencollective.com/spyder#support)

  Please consider becoming a sponsor!


pkgId: 840ae4b60c3c590ada67cdb7d0971a341c4adf52cd694ecf5b97f3f15542ece7
name: python-qtsass
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Compile SCSS files to valid Qt stylesheets.
url: https://github.com/spyder-ide/qtsass
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-91bda14e-e306-4b6a-a604-ae56f89ed0d4
location_href: 00008245-python-qtsass/python-qtsass-0.4.0-1.src.rpm
checksum_type: sha256
description:
  [![License - MIT](https://img.shields.io/github/license/spyder-ide/qtsass.svg)](./LICENSE.txt)
  [![OpenCollective Backers](https://opencollective.com/spyder/backers/badge.svg?color=blue)](#backers)
  [![Join the chat at https://gitter.im/spyder-ide/public](https://badges.gitter.im/spyder-ide/spyder.svg)](https://gitter.im/spyder-ide/public)<br>
  [![Github build status](https://github.com/spyder-ide/qtsass/workflows/Tests/badge.svg)](https://github.com/spyder-ide/qtsass/actions)
  [![Codecov coverage](https://img.shields.io/codecov/c/github/spyder-ide/qtsass/master.svg)](https://codecov.io/gh/spyder-ide/qtsass)
  [![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/spyder-ide/qtsass/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/spyder-ide/qtsass/?branch=master)

  *Copyright © 2015 Yann Lanthony*

  *Copyright © 2017–2018 Spyder Project Contributors*




  [SASS](http://sass-lang.com/) brings countless amazing features to CSS.
  Besides being used in web development, CSS is also the way to stylize Qt-based desktop applications.
  However, Qt's CSS has a few variations that prevent the direct use of SASS compiler.

  The purpose of this tool is to fill the gap between SASS and Qt-CSS by handling those variations.




  The goal of QtSASS is to be able to generate a Qt-CSS stylesheet based on a 100% valid SASS file.
  This is how it deals with Qt's specifics and how you should modify your CSS stylesheet to use QtSASS.


  Qt allows to define the style of a widget according to its states, like this:

  ```css
  QLineEdit:enabled {
  ...
  }
  ```

  However, a "not" state is problematic because it introduces an exclamation mark in the selector's name, which is not valid SASS/CSS:

  ```css
  QLineEdit:!editable {
  ...
  }
  ```

  QtSASS allows "!" in selectors' names; the SASS file is preprocessed and any occurence of `:!` is replaced by `:_qnot_` (for "Qt not").
  However, using this feature prevents from having a 100% valid SASS file, so this support of `!` might change in the future.
  This can be replaced by the direct use of the `_qnot_` keyword in your SASS file:

  ```css
  QLineEdit:_qnot_editable { /* will generate QLineEdit:!editable { */
  ...
  }
  ```


  The qlineargradient function also has a non-valid CSS syntax.

  ```css
  qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0.1 blue, stop: 0.8 green)
  ```

  To support qlineargradient QtSASS provides a preprocessor and a SASS implementation of the qlineargradient function. The above QSS syntax will be replaced with the following:

  ```css
  qlineargradient(0, 0, 0, 1, (0.1 blue, 0.8 green))
  ```

  You may also use this syntax directly in your QtSASS.

  ```
  qlineargradient(0, 0, 0, 1, (0.1 blue, 0.8 green))

  $stops = 0.1 blue, 0.8 green
  qlineargradient(0, 0, 0, 0, $stops)
  ```


  Qt's rgba:

  ```css
  rgba(255, 128, 128, 50%)
  ```

  is replaced by CSS rgba:

  ```css
  rgba(255, 128, 128, 0.5)
  ```




  To compile your SASS stylesheet to a Qt compliant CSS file:

  ```bash

  qtsass style.scss -o style.css
  ```

  To use the watch mode and get your stylesheet auto recompiled on each file save:

  ```bash

  qtsass style.scss -o style.css -w
  ```

  To compile a directory containing SASS stylesheets to Qt compliant CSS files:

  ```bash
  qtsass ./static/scss -o ./static/css
  ```

  You can also use watch mode to watch the entire directory for changes.

  ```bash
  qtsass ./static/scss -o ./static/css -w
  ```

  Set the Environment Variable QTSASS_DEBUG to 1 or pass the --debug flag to enable logging.

  ```bash
  qtsass ./static/scss -o ./static/css --debug
  ```





  Conform and Compile QtSASS source code to CSS.

  This function conforms QtSASS to valid SCSS before passing it to
  sass.compile. Any keyword arguments you provide will be combined with
  qtsass's default keyword arguments and passed to sass.compile.

  Examples:

  ```bash
  >>> import qtsass
  >>> qtsass.compile("QWidget {background: rgb(0, 0, 0);}")
  QWidget {background:black;}
  ```

  Arguments:
  - string: QtSASS source code to conform and compile.
  - kwargs: Keyword arguments to pass to sass.compile

  Returns:
  - Qt compliant CSS string



  Compile and return a QtSASS file as Qt compliant CSS. Optionally save to a file.

  Examples:

  ```bash
  >>> import qtsass
  >>> qtsass.compile_filename("dummy.scss", "dummy.css")
  >>> css = qtsass.compile_filename("dummy.scss")
  ```

  Arguments:
  - input_file: Path to QtSass file.
  - output_file: Path to write Qt compliant CSS.
  - kwargs: Keyword arguments to pass to sass.compile

  Returns:
  - Qt compliant CSS string



  Compiles QtSASS files in a directory including subdirectories.

  ```bash
  >>> import qtsass
  >>> qtsass.compile_dirname("./scss", "./css")
  ```

  Arguments:
  - input_dir: Path to directory containing QtSass files.
  - output_dir: Directory to write compiled Qt compliant CSS files to.
  - kwargs: Keyword arguments to pass to sass.compile


  Enable logging for qtsass.

  Sets the qtsass logger's level to:
      1. the provided logging level
      2. logging.DEBUG if the QTSASS_DEBUG envvar is a True value
      3. logging.WARNING

  ```bash
  >>> import logging
  >>> import qtsass
  >>> handler = logging.StreamHandler()
  >>> formatter = logging.Formatter('-8s: s> s')
  >>> handler.setFormatter(formatter)
  >>> qtsass.enable_logging(level=logging.DEBUG, handler=handler)
  ```

  Arguments:
  - level: Optional logging level
  - handler: Optional handler to add


  Watches a source file or directory, compiling QtSass files when modified.

  The compiler function defaults to compile_filename when source is a file
  and compile_dirname when source is a directory.

  Arguments:
  - source: Path to source QtSass file or directory.
  - destination: Path to output css file or directory.
  - compiler: Compile function (optional)
  - Watcher: Defaults to qtsass.watchers.Watcher (optional)

  Returns:
  - qtsass.watchers.Watcher instance



  Everyone is welcome to contribute!




  Spyder and its subprojects are funded thanks to the generous support of

  [![Quansight](https://static.wixstatic.com/media/095d2c_2508c560e87d436ea00357abc404cf1d~mv2.png/v1/crop/x_0,y_9,w_915,h_329/fill/w_380,h_128,al_c,usm_0.66_1.00_0.01/095d2c_2508c560e87d436ea00357abc404cf1d~mv2.png)](https://www.quansight.com/)[![Numfocus](https://i2.wp.com/numfocus.org/wp-content/uploads/2017/07/NumFocus_LRG.png?fit=320%2C148&ssl=1)](https://numfocus.org/)


  and the donations we have received from our users around the world through [Open Collective](https://opencollective.com/spyder/):

  [![Sponsors](https://opencollective.com/spyder/sponsors.svg)](https://opencollective.com/spyder#support)

  Please consider becoming a sponsor!


pkgId: e6838189d0d4dcde6a7637010d948fb9b119e9e3fc1f7645821334f083681eee
name: python-quantconnect-stubs
arch: src
version: 15366
epoch: 0
release: 1
summary: Type stubs for QuantConnect's Lean
url: https://github.com/QuantConnect/quantconnect-stubs-generator
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-60680e97-9b05-4cf5-b604-dd453d65a8ab
location_href: 00012074-python-quantconnect-stubs/python-quantconnect-stubs-15366-1.src.rpm
checksum_type: sha256
description:
  This package contains type stubs for QuantConnect's [Lean](https://github.com/QuantConnect/Lean) algorithmic trading engine and for parts of the .NET library that are used by Lean.

  These stubs can be used by editors to provide type-aware features like autocomplete and auto-imports in QuantConnect strategies written in Python.

  After installing the stubs, you can copy the following line to the top of every Python file to have the same imports as the ones that are added by default in the cloud:
  ```py
  from AlgorithmImports import *
  ```

  This line imports [all common QuantConnect members](https://github.com/QuantConnect/Lean/blob/master/Common/AlgorithmImports.py) and provides autocomplete for them.


pkgId: d2ed8ddfc1c7539de8caa4ea33f0fb3dd0e942c98c4d92d0881ff51e7f8c5fa8
name: python-quantities
arch: src
version: 0.14.1
epoch: 0
release: 1
summary: Support for physical quantities with units, based on numpy
url: https://pypi.org/project/quantities/
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1dd06250-7807-4c08-b450-d4617d823c08
location_href: 00004916-python-quantities/python-quantities-0.14.1-1.src.rpm
checksum_type: sha256
rpm_license:
  .. _license:  *********************************************** License ***********************************************   Quantities only uses BSD compatible code.  See the Open Source Initiative `licenses page <http://www.opensource.org/licenses>`_ for details on individual licenses.  License Agreement for Quantities ================================  Copyright (c) 2012, Darren Dale <dsdale24@gmail.com> All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the University nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.   License Agreement for Scimath =============================  This software is OSI Certified Open Source Software. OSI Certified is a certification mark of the Open Source Initiative.  Copyright (c) 2006, Enthought, Inc. All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Enthought, Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 20a9a68ccfe698379c31b50ef0ac5d25603d2c0ed8090042910dc1cd0ad9c8df
name: python-quart
arch: src
version: 0.18.4
epoch: 0
release: 1
summary: A Python ASGI web microframework with the same API as Flask
url: https://github.com/pallets/quart/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-aebd8db3-e527-42bc-8b73-e14cd5f823f0
location_href: 00009158-python-quart/python-quart-0.18.4-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |docs| |pypi| |python| |license| |chat|
  Quart is an async Python web microframework. Using Quart you can,
  * render and serve HTML templates,
  * write (RESTful) JSON APIs,
  * serve WebSockets,
  * stream request and response data,
  * do pretty much anything over the HTTP or WebSocket protocols.


pkgId: 172084d493bee0bd905ec5c86b4757ea960660b25aa45d8f172cd3f612259f1c
name: python-query-string
arch: src
version: 2020.12.3
epoch: 0
release: 1
summary: get url query string dict
url: https://github.com/andrewp-as-is/query-string.py
rpm_license: Unlicense
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2acbf1e4-8a92-42ef-888f-0ed395b11eff
location_href: 00013279-python-query-string/python-query-string-2020.12.3-1.src.rpm
checksum_type: sha256
description:
  <!--
  https://readme42.com
  -->


  [![](https://img.shields.io/pypi/v/query-string.svg?maxAge=3600)](https://pypi.org/project/query-string/)
  [![](https://img.shields.io/badge/License-Unlicense-blue.svg?longCache=True)](https://unlicense.org/)


  ```bash
  $ [sudo] pip install query-string
  ```


  +   Python 2/3 compatible


  ```python
  >>> import query_string

  >>> query_string.parse('https://site.org/index.php?k=v&k2=v2&k3=v3#anchor')
  {'k': 'v','k2': 'v2', 'k3': 'v3'}

  >>> query_string.parse('k=v&k2=v2&k3=v3')
  {'k': 'v','k2': 'v2', 'k3': 'v3'}
  ```


  +   [Query string - Wikipedia](https://en.wikipedia.org/wiki/Query_string)

  <p align="center">
      <a href="https://readme42.com/">readme42.com</a>
  </p>


pkgId: d451a9b08462e727e48c4d8cbc8799f8230a42cc1492b76671baeb45d2ffff62
name: python-questionary
arch: src
version: 1.10.0
epoch: 0
release: 1
summary: Python library to build pretty command line user prompts ⭐️
url: https://github.com/tmbo/questionary
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4fa389a4-7b3a-4173-9b31-9d56d46d39d0
location_href: 00009997-python-questionary/python-questionary-1.10.0-1.src.rpm
checksum_type: sha256
description:
  [![Version](https://img.shields.io/pypi/v/questionary.svg)](https://pypi.org/project/questionary/)
  [![License](https://img.shields.io/pypi/l/questionary.svg)](#)
  [![Continuous Integration](https://github.com/tmbo/questionary/workflows/Continuous%20Integration/badge.svg)](#)
  [![Coverage](https://coveralls.io/repos/github/tmbo/questionary/badge.svg?branch=master)](https://coveralls.io/github/tmbo/questionary?branch=master)
  [![Supported Python Versions](https://img.shields.io/pypi/pyversions/questionary.svg)](https://pypi.python.org/pypi/questionary)
  [![Documentation](https://readthedocs.org/projects/questionary/badge/?version=latest)](https://questionary.readthedocs.io/en/latest/?badge=latest)

  ✨ Questionary is a Python library for effortlessly building pretty command line interfaces ✨

  * [Features](#features)
  * [Installation](#installation)
  * [Usage](#usage)
  * [Documentation](#documentation)
  * [Support](#support)


  ![Example](https://raw.githubusercontent.com/tmbo/questionary/master/docs/images/example.gif)

  ```python3
  import questionary

  questionary.text("What's your first name").ask()
  questionary.password("What's your secret?").ask()
  questionary.confirm("Are you amazed?").ask()

  questionary.select(
      "What do you want to do?",
      choices=["Order a pizza", "Make a reservation", "Ask for opening hours"],
  ).ask()

  questionary.rawselect(
      "What do you want to do?",
      choices=["Order a pizza", "Make a reservation", "Ask for opening hours"],
  ).ask()

  questionary.checkbox(
      "Select toppings", choices=["foo", "bar", "bazz"]
  ).ask()

  questionary.path("Path to the projects version file").ask()
  ```

  Used and supported by

  [<img src="https://raw.githubusercontent.com/tmbo/questionary/master/docs/images/rasa-logo.svg" width="200">](https://github.com/RasaHQ/rasa)



  Questionary supports the following input prompts:

   * [Text](https://questionary.readthedocs.io/en/stable/pages/types.html#text)
   * [Password](https://questionary.readthedocs.io/en/stable/pages/types.html#password)
   * [File Path](https://questionary.readthedocs.io/en/stable/pages/types.html#file-path)
   * [Confirmation](https://questionary.readthedocs.io/en/stable/pages/types.html#confirmation)
   * [Select](https://questionary.readthedocs.io/en/stable/pages/types.html#select)
   * [Raw select](https://questionary.readthedocs.io/en/stable/pages/types.html#raw-select)
   * [Checkbox](https://questionary.readthedocs.io/en/stable/pages/types.html#checkbox)
   * [Autocomplete](https://questionary.readthedocs.io/en/stable/pages/types.html#autocomplete)

  There is also a helper to [print formatted text](https://questionary.readthedocs.io/en/stable/pages/types.html#printing-formatted-text)
  for when you want to spice up your printed messages a bit.



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

  ```bash
  $ pip install questionary
  ✨🎂✨
  ```



  ```python
  import questionary

  questionary.select(
      "What do you want to do?",
      choices=[
          'Order a pizza',
          'Make a reservation',
          'Ask for opening hours'
      ]).ask()  # returns value of selection
  ```

  That's all it takes to create a prompt! Have a [look at the documentation](https://questionary.readthedocs.io/)
  for some more examples.



  Documentation for Questionary is available [here](https://questionary.readthedocs.io/).



  Please [open an issue](https://github.com/tmbo/questionary/issues/new)
  with enough information for us to reproduce your problem.
  A [minimal, reproducible example](https://stackoverflow.com/help/minimal-reproducible-example)
  would be very helpful.



  Contributions are very much welcomed and appreciated. Head over to the documentation on [how to contribute](https://questionary.readthedocs.io/en/stable/pages/contributors.html#steps-for-submitting-code).



  Questionary is written and maintained by Tom Bocklisch and Kian Cross.

  It is based on the great work by [Oyetoke Toby](https://github.com/CITGuru/PyInquirer)
  and [Mark Fink](https://github.com/finklabs/whaaaaat).


  Licensed under the [MIT License](https://github.com/tmbo/questionary/blob/master/LICENSE). Copyright 2021 Tom Bocklisch.


pkgId: 16b166da66fec1492a697de4ed5a994c53896a1bc1647af4d771ecccb429e7d4
name: python-queueman
arch: src
version: 0.5
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/ludeeus/queueman
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-01c56f73-11bd-4b2a-a853-ce1fcb32b826
location_href: 00010209-python-queueman/python-queueman-0.5-1.src.rpm
checksum_type: sha256
description:
  [![codecov][codecov_img]][codecov_url]
  [![Test action][github_action_test]][github_actions]

  WIP

  ```bash
  python3 -m pip install queueman
  ```

  <!-- LINKS -->
  [codecov_url]: https://codecov.io/gh/ludeeus/queueman
  [codecov_img]: https://codecov.io/gh/ludeeus/queueman/branch/master/graph/badge.svg
  [github_actions]: https://github.com/ludeeus/queueman/actions
  [github_action_test]: https://github.com/ludeeus/queueman/workflows/Test/badge.svg
  <!-- LINKS -->


pkgId: 7aef0eab8fb52e7dd8bae67aa72bf3f0715c013e216f35b5d3320cc885455615
name: python-quilt3
arch: src
version: 5.2.1
epoch: 0
release: 1
summary: Quilt: where data comes together
url: https://github.com/quiltdata/quilt
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d6deca31-801b-43ab-b520-ea23ad7a723e
location_href: 00011625-python-quilt3/python-quilt3-5.2.1-1.src.rpm
checksum_type: sha256
description:
  Quilt manages data like code (with packages, repositories, browsing and
  revision history) so that teams can experiment faster in machine learning,
  biotech, and other data-driven domains.

  The `quilt3` PyPI package allows you to build, push, and install data packages.
  Visit the `documentation quickstart <https://docs.quiltdata.com/quickstart>`_
  to learn more.


pkgId: 519cce1af58ae4d6c411b46264a593839fe7585333dbec67e6f4b41247218d83
name: python-quinn
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: Pyspark helper methods to maximize developer efficiency
url: https://github.com/MrPowers/quinn/
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-db3244a9-9b44-49bc-95ad-101f932118f1
location_href: 00010059-python-quinn/python-quinn-0.10.0-1.src.rpm
checksum_type: sha256
description:
  ![CI](https://github.com/MrPowers/quinn/workflows/CI/badge.svg?branch=master)

  Pyspark helper methods to maximize developer productivity.

  Quinn validates DataFrames, extends core classes, defines DataFrame transformations, and provides SQL functions.

  ![quinn](https://github.com/MrPowers/quinn/blob/master/quinn.png)



  Quinn is [uploaded to PyPi](https://pypi.org/project/quinn/) and can be installed with this command:

  ```
  pip install quinn
  ```



  ```
  from quinn.extensions import *
  ```



  **isFalsy()**

  ```python
  source_df.withColumn("is_stuff_falsy", F.col("has_stuff").isFalsy())
  ```

  Returns `True` if `has_stuff` is `None` or `False`.

  **isTruthy()**

  ```python
  source_df.withColumn("is_stuff_truthy", F.col("has_stuff").isTruthy())
  ```

  Returns `True` unless `has_stuff` is `None` or `False`.

  **isNullOrBlank()**

  ```python
  source_df.withColumn("is_blah_null_or_blank", F.col("blah").isNullOrBlank())
  ```

  Returns `True` if `blah` is `null` or blank (the empty string or a string that only contains whitespace).

  **isNotIn()**

  ```python
  source_df.withColumn("is_not_bobs_hobby", F.col("fun_thing").isNotIn(bobs_hobbies))
  ```

  Returns `True` if `fun_thing` is not included in the `bobs_hobbies` list.

  **nullBetween()**

  ```python
  source_df.withColumn("is_between", F.col("age").nullBetween(F.col("lower_age"), F.col("upper_age")))
  ```

  Returns `True` if `age` is between `lower_age` and `upper_age`.  If `lower_age` is populated and `upper_age` is `null`, it will return `True` if `age` is greater than or equal to `lower_age`.  If `lower_age` is `null` and `upper_age` is populate, it will return `True` if `age` is lower than or equal to `upper_age`.



  **create_df()**

  ```python
  spark.create_df(
      [("jose", "a"), ("li", "b"), ("sam", "c")],
      [("name", StringType(), True), ("blah", StringType(), True)]
  )
  ```

  Creates DataFrame with a syntax that's less verbose than the built-in `createDataFrame` method.



  **transform()**

  ```python
  source_df\
      .transform(lambda df: with_greeting(df))\
      .transform(lambda df: with_something(df, "crazy"))
  ```

  Allows for multiple DataFrame transformations to be run and executed.



  ```python
  import quinn
  ```



  **validate_presence_of_columns()**

  ```python
  quinn.validate_presence_of_columns(source_df, ["name", "age", "fun"])
  ```

  Raises an exception unless `source_df` contains the `name`, `age`, and `fun` column.

  **validate_schema()**

  ```python
  quinn.validate_schema(source_df, required_schema)
  ```

  Raises an exception unless `source_df` contains all the `StructFields` defined in the `required_schema`.

  **validate_absence_of_columns()**

  ```python
  quinn.validate_absence_of_columns(source_df, ["age", "cool"])
  ```

  Raises an exception if `source_df` contains `age` or `cool` columns.



  **single_space()**

  ```python
  actual_df = source_df.withColumn(
      "words_single_spaced",
      quinn.single_space(col("words"))
  )
  ```


  Replaces all multispaces with single spaces (e.g. changes `"this has   some"` to `"this has some"`.

  **remove_all_whitespace()**

  ```python
  actual_df = source_df.withColumn(
      "words_without_whitespace",
      quinn.remove_all_whitespace(col("words"))
  )
  ```

  Removes all whitespace in a string (e.g. changes `"this has some"` to `"thishassome"`.

  **anti_trim()**

  ```python
  actual_df = source_df.withColumn(
      "words_anti_trimmed",
      quinn.anti_trim(col("words"))
  )
  ```

  Removes all inner whitespace, but doesn't delete leading or trailing whitespace (e.g. changes `" this has some "` to `" thishassome "`.

  **remove_non_word_characters()**

  ```python
  actual_df = source_df.withColumn(
      "words_without_nonword_chars",
      quinn.remove_non_word_characters(col("words"))
  )
  ```

  Removes all non-word characters from a string (e.g. changes `"si%$#@!#$!@#mpsons"` to `"simpsons"`.

  **exists()**

  ```python
  source_df.withColumn(
      "any_num_greater_than_5",
      quinn.exists(lambda n: n > 5)(col("nums"))
  )
  ```

  `nums` contains lists of numbers and `exists()` returns `True` if any of the numbers in the list are greater than 5.  It's similar to the Python `any` function.

  **forall()**

  ```python
  source_df.withColumn(
      "all_nums_greater_than_3",
      quinn.forall(lambda n: n > 3)(col("nums"))
  )
  ```

  `nums` contains lists of numbers and `forall()` returns `True` if all of the numbers in the list are greater than 3.  It's similar to the Python `all` function.

  **multi_equals()**

  ```python
  source_df.withColumn(
      "are_s1_and_s2_cat",
      quinn.multi_equals("cat")(col("s1"), col("s2"))
  )
  ```

  `multi_equals` returns true if `s1` and `s2` are both equal to `"cat"`.



  **snake_case_col_names()**

  ```python
  quinn.snake_case_col_names(source_df)
  ```

  Converts all the column names in a DataFrame to snake_case.  It's annoying to write SQL queries when columns aren't snake cased.

  **sort_columns()**

  ```python
  quinn.sort_columns(source_df, "asc")
  ```

  Sorts the DataFrame columns in alphabetical order.  Wide DataFrames are easier to navigate when they're sorted alphabetically.



  **column_to_list()**

  ```python
  quinn.column_to_list(source_df, "name")
  ```

  Converts a column in a DataFrame to a list of values.

  **two_columns_to_dictionary()**

  ```python
  quinn.two_columns_to_dictionary(source_df, "name", "age")
  ```

  Converts two columns of a DataFrame into a dictionary.  In this example, `name` is the key and `age` is the value.

  **to_list_of_dictionaries()**

  ```python
  quinn.to_list_of_dictionaries(source_df)
  ```

  Converts an entire DataFrame into a list of dictionaries.



  We are actively looking for feature requests, pull requests, and bug fixes.

  Any developer that demonstrates excellence will be invited to be a maintainer of the project.


pkgId: 49dbac8926c8b3b74b5f1ded7aaf29d10af7e811248611958bda1dde38b89e48
name: python-qutepart
arch: src
version: 3.3.3
epoch: 0
release: 1
summary: Code editor component for PyQt5
url: https://github.com/andreikop/qutepart
rpm_license: GNU Lesser General Public License v2 or later (LGPLv2+)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7e88bafe-80f3-41c2-820f-7a646f0a379c
location_href: 00004918-python-qutepart/python-qutepart-3.3.3-1.src.rpm
checksum_type: sha256
description:
  **NOTE** wheels released on PyPi doesn't contain C extension which speedups long file hihglighting.
  Build Qutepart from sources if speed is critical for your project. You can help releasing binary parser by implementing [this issue](https://github.com/andreikop/qutepart/issues/85)

  Component has been created for [Enki editor](http://enki-editor.org)

  [API documentation](https://qutepart.readthedocs.org/en/latest/)


  * Syntax highlighting for 196 languages
  * Smart indentation for many languages
  * Line numbers
  * Bookmarks
  * Advanced edit operations
  * Matching braces highlighting
  * Autocompletion based on document content
  * Marking too long lines with red line
  * Rectangular selection and copy-paste
  * Vim mode


  [Kate](http://kate-editor.org/) and Katepart (an editor component) is really cool software. The Kate authors and community have created, probably, the biggest set of highlighters and indenters for programming languages.

  * Qutepart uses Kate syntax highlighters (XML files)
  * Qutepart contains a port from Javascript to Python of Kate indenters (12% of the code base in version 1.0.0)
  * Qutepart doesn't contain Katepart code.

  Nothing is wrong with Katepart. Qutepart has been created to enable reusing highlighters and indenters in projects where a KDE dependency is not acceptable.


  Andrei Kopats
  [andrei.kopats@gmail.com](mailto:andrei.kopats@gmail.com)


  [Github page](https://github.com/andreikop/qutepart)


  LGPL v2


pkgId: c25a632e84c2ebda2287ee9e557fb165ea5928483d300e72c62ef30a3becd01b
name: python-rabbitpy
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: A pure python, thread-safe, minimalistic and pythonic RabbitMQ client library
url: https://rabbitpy.readthedocs.io
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b396e4d5-cb94-45de-95e8-d64632208e33
location_href: 00010723-python-rabbitpy/python-rabbitpy-2.0.1-1.src.rpm
checksum_type: sha256
description:
  A pure python, thread-safe, minimalistic and Pythonic BSD Licensed
  AMQP/RabbitMQ library that supports Python 2.7+ and Python 3.4+.
  rabbitpy aims to provide a simple and easy to use API for interfacing with
  RabbitMQ, minimizing the programming overhead often found in other libraries.
  |Version| |Downloads| |Status| |Coverage| |License|


pkgId: 0e8a7661a1e739d5cefc18b3e916814345b490faa365144fb56d276b686d72d3
name: python-rake-nltk
arch: src
version: 1.0.6
epoch: 0
release: 1
url: https://csurfer.github.io/rake-nltk
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6413682a-b263-4411-b4a5-49c3f36cd4f2
location_href: 00010311-python-rake-nltk/python-rake-nltk-1.0.6-1.src.rpm
checksum_type: sha256
summary:
  RAKE short for Rapid Automatic Keyword Extraction algorithm, is a domain independent keyword extraction algorithm which tries to determine key phrases in a body of text by analyzing the frequency of word appearance and its co-occurance with other words in the text.

description:
  |pypiv| |pyv| |Licence| |Build Status| |Coverage Status|
  RAKE short for Rapid Automatic Keyword Extraction algorithm, is a domain
  independent keyword extraction algorithm which tries to determine key
  phrases in a body of text by analyzing the frequency of word appearance
  and its co-occurance with other words in the text.
  |Demo|


pkgId: dfa71fb5c2ce36d0bb6469ff893bbe811a51876c5abaffb9e63e5c153a43f1e0
name: python-random-password-generator
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Simple and custom random password generator for python
url: https://github.com/suryasr007/random-password-generator
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-768c0921-123b-476b-9298-4ee53e5a8b9a
location_href: 00010512-python-random-password-generator/python-random-password-generator-2.2.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/badge/PYPI-V%202.2.0-blue.svg)](https://pypi.org/project/random-password-generator)
  [![Build Status](https://travis-ci.org/suryasr007/random-password-generator.svg?branch=master)](https://travis-ci.org/suryasr007/random-password-generator)


   * No dependencies.
   * Generate a simple password of default length 6-16.
   * Generate a password with custom properties.
   * Generate a password from given characters.
   * Generate Non Duplicate Password.
   * Available at https://random-pg.herokuapp.com/ (API and WEB versions are available @ https://github.com/suryasr007/rpg-web repo)




   * Install the package.
   * Import the package.
   * Create an instance
   * Modify the default properties. (Optional)
   * Generate the password (Default length of password 6-16 unless specified via properties).

  ``` bash
    pip install random-password-generator
  ```

  ``` python
    from password_generator import PasswordGenerator

    pwo = PasswordGenerator()
    pwo.generate()
  ```




  | property   |                          Description                 | Default |
  | ---------- |------------------------------------------------------| ------- |
  | minlen     |   Minimum length of the password                     | 6 |
  | maxlen     |   Maximum length of the password                     | 16 |
  | minuchars  |   Minimum upper case characters required in password | 1 |
  | minlchars  |   Minimum lower case characters required in password | 1 |
  | minnumbers |   Minimum numbers required in password               | 1 |
  | minschars  |   Minimum special characters in the password         | 1 |



  Application is now minimal(No dependencies). The API and WEB version are moved to https://github.com/suryasr007/rpg-web


  Application uses [secrets](https://docs.python.org/3/library/secrets.html) module instead of `random` module on Python environments above 3.6.


  From version 1.1.0, Characters can be excluded from the required password by setting the properties on PasswordGenerator object

  example:
  ``` python
    pwo = PasswordGenerator()

    pwo.excludeuchars = "ABCDEFTUVWXY" # (Optional)
    pwo.excludelchars = "abcdefghijkl" # (Optional)
    pwo.excludenumbers = "012345" # (Optional)
    pwo.excludeschars = "!$%^" # (Optional)
  ```



  ``` python
    pwo = PasswordGenerator()

    
    pwo.minlen = 30 # (Optional)
    pwo.maxlen = 30 # (Optional)
    pwo.minuchars = 2 # (Optional)
    pwo.minlchars = 3 # (Optional)
    pwo.minnumbers = 1 # (Optional)
    pwo.minschars = 1 # (Optional)

    pwo.generate()
  ```


  ``` python
    pwo = PasswordGenerator()

    
    
    pwo.shuffle_password('sdafasdf#@&^#&234u8', 20)
  ```


  ``` python
    pwo = PasswordGenerator()

    
    pwo.non_duplicate_password(20)
  ```


  Contributions are welcomed via PR.


   * [MIT](LICENSE)


pkgId: 8b6471eb197874ddf1b6f62fa8057fec550e7c1056bcb4a2da31a4c2ca4e678c
name: python-rangehttpserver
arch: src
version: 1.3.3
epoch: 0
release: 1
summary: SimpleHTTPServer with support for Range requests
url: https://github.com/danvk/RangeHTTPServer/
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4f69bec2-5de7-4dfe-ad64-3002ddec099e
location_href: 00004923-python-rangehttpserver/python-rangehttpserver-1.3.3-1.src.rpm
checksum_type: sha256
description:
  SimpleHTTPServer with support for Range requests

  Quickstart:

      $ pip install rangehttpserver
      $ python -m RangeHTTPServer
      Serving HTTP on 0.0.0.0 port 8000 ...

  See the GitHub repo for more information:
  https://github.com/danvk/RangeHTTPServer


pkgId: 0337f938f433684242ba3bac16be2a6a6bfc84aa4b94ac5f8dd34a569d8628f3
name: python-rarfile
arch: src
version: 4.0
epoch: 0
release: 1
summary: RAR archive reader for Python
url: https://github.com/markokr/rarfile
rpm_license: ISC
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c82f9a87-cb2f-474b-ae33-f9b2015f5c68
location_href: 00004925-python-rarfile/python-rarfile-4.0-1.src.rpm
checksum_type: sha256
description:
  This is Python module for RAR_ archive reading.
  The interface follows the style of zipfile_.
  Licensed under ISC_ license.
  Features:
  * Supports both RAR3 and RAR5 format archives.
  * Supports multi volume archives.
  * Supports Unicode filenames.
  * Supports password-protected archives.
  * Supports archive and file comments.
  * Archive parsing and non-compressed files are handled in pure Python code.
  * Compressed files are extracted by executing external tool:
    unrar_ (preferred), unar_ or bsdtar_.
  * Works with Python 3.6+.
  Links:
  - `Documentation`_
  - `Downloads`_
  - `Git`_ repo


pkgId: e590c916cc31be81eb3b5a897d8e03f85d1310a05bfca9f72625304f6d1638f3
name: python-ratelim
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: Makes it easy to respect rate limits.
url: http://github.com/themiurgo/ratelim
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d67968b0-5de0-447f-8c29-2824c9a44216
location_href: 00010143-python-ratelim/python-ratelim-0.1.6-1.src.rpm
checksum_type: sha256
description:
  Ratelim is a simple Python library that limits the number of times a function can be called during a time interval. It is particularly useful when using online APIs, which commonly enforce rate limits.


pkgId: 1a01108635988183d01198a20536935deca08a00e003156dc546ed39c008922e
name: python-ratelimit
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: API rate limit decorator
url: https://github.com/tomasbasham/ratelimit
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4394cee4-d757-4cf8-973a-f4e96965ded3
location_href: 00009661-python-ratelimit/python-ratelimit-2.2.1-1.src.rpm
checksum_type: sha256
description:
  APIs are a very common way to interact with web services. As the need to
  consume data grows, so does the number of API calls necessary to remain up to
  date with data sources. However many API providers constrain developers from
  making too many API calls. This is know as rate limiting and in a worst case
  scenario your application can be banned from making further API calls if it
  abuses these limits.
  This packages introduces a function decorator preventing a function from being
  called more often than that allowed by the API provider. This should prevent
  API providers from banning your applications by conforming to their rate
  limits.


pkgId: 435bf67cd69f8b12c24f50946c4fea3b4fca7d96115bf729b82e919be83ce372
name: python-ratelimiter
arch: src
version: 1.2.0.post0
epoch: 0
release: 1
summary: Simple python rate limiting object
url: https://github.com/RazerM/ratelimiter
rpm_license: Apache
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c1e9838d-e173-45f7-8a18-869a3f0b9bd8
location_href: 00004927-python-ratelimiter/python-ratelimiter-1.2.0.post0-1.src.rpm
checksum_type: sha256
description:
  |PyPI Version| |Build Status| |Python Version| |License|
  Simple Python module providing rate limiting.


pkgId: fb7f384c258653fbbd9903ed2ffd9b0df53716dd950b740db1dc80c0b5242304
name: python-ratelimitingfilter
arch: src
version: 1.5
epoch: 0
release: 1
summary: A rate limiting filter for the Python logging system
url: https://github.com/wkeeling/ratelimitingfilter
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2c66ab69-ae93-46bc-92d1-c5d8a057d13f
location_href: 00004928-python-ratelimitingfilter/python-ratelimitingfilter-1.5-1.src.rpm
checksum_type: sha256
description:
  The ``RateLimitingFilter`` is a filter for the Python logging system
  that allows you to restrict the rate at which messages can pass through
  your logging handlers.
  The filter can be useful if you're using a handler such as Python's
  ``logging.handlers.SMTPHandler`` to send error notification emails.
  Error notification emails provide a useful means of keeping an eye on
  the health of a running system, but these emails have the potential to
  overload a mailbox if they start arriving in quick succession due to
  some kind of critical failure.
  The ``RateLimitingFilter`` can help prevent mailbox overload by
  throttling messages based on a configurable rate, whilst allowing for
  periodic bursts of messages which can be a useful indicator that
  something somewhere has broken.


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: 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: 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: 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: 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: 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!


