# packages

pkgId: 4cf60f12098741f8cdc87a5bca79848c193f6bc6969fcbbaa990c7538d3e37d9
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-c3dfdc44-155a-47b3-a5c6-dd584ae1690c
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: 05b7eead6addca4ab76cd77a4903c198ccc4dcced6f9cf3e4bac5fa53f75e7b2
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-bb68f359-dedd-491b-8594-4f33e031e3b9
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: ad70d96de3ea7c710e2660a4a9847a6ca3dfbea50db09f2b986cd5ba8192594e
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-09dc1490-5fba-4c51-9715-dcbd78733796
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: adb3357ced570984d7ee624493530fc903bb282c49ad68a396cbd2782f89ee03
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-778debec-9e61-4860-a4af-7d9b9da6f5de
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: 080c5415c57e28f95eaa21f9bfaad17d41474b021e2c2795bdb69d329dcfba8b
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-8792eb73-e406-4842-939c-2abb4240695b
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: c2fc3e4894cf6c2ab5f7ac7dc3e76310cedcb8e192284039e706386179694d7f
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-5e592f3e-793d-4bbb-bfd8-cb0aece06a8d
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: 2a215faea109f78b3c6bca5264137ac31d6d33708f33f155abb58c05dc1b1820
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-e41c6c2a-b943-4ce2-b793-906bc3dfeadc
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: a9c1584bcaf288e9562858490d98a2ff7ccc91ac00362e30da5838e5040f151a
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-693570bd-0438-4b66-835b-0983f4b98653
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: cd3559121b7bb599ddb112d48752dc5dd352c7d3fa545a0170d8d5b6d4481973
name: python-rec-avro
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: Avro schema and data converters supporting storing arbitrary nested python data structures.
url: https://github.com/bmizhen/rec-avro
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-20f75ad0-95c0-48ce-ae3d-3be7e0e89019
location_href: 00013816-python-rec-avro/python-rec-avro-0.0.4-1.src.rpm
checksum_type: sha256
description:
  Avro support for JSON and other nested data structures.

  Rec-avro provides a generic Avro schema and converter functions that allow for storing nested python data structures in avro.

  Tested in Python 3 only.


  ```sh
  $ pip3 install rec-avro
  ```



  ```python

  from fastavro import writer, reader, schema
  from rec_avro import to_rec_avro_destructive, from_rec_avro_destructive, rec_avro_schema

  def json_objects():
      return [{'a': 'a'}, {'b':'b'}]



  avro_objects = (to_rec_avro_destructive(rec) for rec in json_objects())


  with open('json_in_avro.avro', 'wb') as f_out:
      writer(f_out, schema.parse_schema(rec_avro_schema()), avro_objects)


  with open('json_in_avro.avro', 'rb') as f_in:
      
      
      loaded_json = [from_rec_avro_destructive(rec) for rec in reader(f_in)]

  assert loaded_json == json_objects()
  ```


  ```sh

  $ python setup.py pytest


  $ pip3 install fastavro pytest
  $ python setup.py develop
  $ pytest tests/test_rec_avro.py
  ```


pkgId: 214069ce0a893e940aa07bbfcff304f1710d2b514af57f59ffa06f28e847e1c0
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-d4959691-4b58-43b8-9a04-aa08e4d880a3
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: 0122500e21cce1064ddfef5961af6118be5fa5ab9dede23167c4c573b57be55b
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-16214fa0-bd71-466f-9251-c4eeb5f9e489
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: 2c8d87c19c899d8b503153ef1e57a8685805e180395a677c2622df5728a4446d
name: python-recordclass-debuginfo
arch: x86_64
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-16214fa0-bd71-466f-9251-c4eeb5f9e489
rpm_sourcerpm: python-recordclass-0.18.3-1.src.rpm
location_href: 00010456-python-recordclass/python-recordclass-debuginfo-0.18.3-1.x86_64.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: 77aab9033bb1e9d08316c0385c3fa4d67de6eb7a636eb0b93fd36cd2afac0435
name: python-recordclass-debugsource
arch: x86_64
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-16214fa0-bd71-466f-9251-c4eeb5f9e489
rpm_sourcerpm: python-recordclass-0.18.3-1.src.rpm
location_href: 00010456-python-recordclass/python-recordclass-debugsource-0.18.3-1.x86_64.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: 72463ce7b1f947ef43a414d672e0fd8dcb5c3997d29039b3d9cd8c54df7d8b7b
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-a10f080f-1bad-4fb9-9498-86e02effb168
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: 484084e5ba0868e70e396965eea44932d91733fec02181512d3d1f155feefc99
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-3fd9f7fd-479e-4371-ac68-e996986e5639
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: 769e7ede83ab1cc3bcdb5da25510581ccebb7cd9f860dde0d7f6a615bb07636a
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-3857c235-22af-4968-ae9d-bdee42115570
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: e2edfc1417b37740ad9215e742a5f8ecb026d769f53560cdd08cb913d7285950
name: python-redlock-py
arch: src
version: 1.0.8
epoch: 0
release: 1
summary: Redis locking mechanism
url: https://github.com/SPSCommerce/identity-service
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f878f745-8aed-4900-85f7-b880d8419820
location_href: 00011641-python-redlock-py/python-redlock-py-1.0.8-1.src.rpm
checksum_type: sha256
description:
  redlock-py - Redis distributed locks in Python

  This python lib implements the Redis-based distributed lock manager algorithm
  [described in this blog post](http://antirez.com/news/77).

  To create a lock manager:

      dlm = Redlock([{"host": "localhost", "port": 6379, "db": 0}, ])

  To acquire a lock:

      my_lock = dlm.lock("my_resource_name",1000)

  Where the resource name is an unique identifier of what you are trying to lock
  and 1000 is the number of milliseconds for the validity time.

  The returned value is `False` if the lock was not acquired (you may try again),
  otherwise an namedtuple representing the lock is returned, having three fields:

  * validity, an integer representing the number of milliseconds the lock will be valid.
  * resource, the name of the locked resource as specified by the user.
  * key, a random value which is used to safe reclaim the lock.

  To release a lock:

      dlm.unlock(my_lock)

  It is possible to setup the number of retries (by default 3) and the retry
  delay (by default 200 milliseconds) used to acquire the lock.


  **Disclaimer**: This code implements an algorithm which is currently a proposal,
  it was not formally analyzed. Make sure to understand how it works before using it
  in your production environments.

  The MIT License (MIT)

  Copyright (c) 2014 SPS Commerce, Inc.

  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included in
  all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.


pkgId: bcad03ad8601702854357cb6ef35987378a1d04cf63429e55a4adf6d545a1598
name: python-reedsolo
arch: src
version: 1.7.0
epoch: 0
release: 1
summary: Pure-Python Reed Solomon encoder/decoder
url: https://github.com/tomerfiliba/reedsolomon
rpm_license: Public Domain
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-931729a9-de59-4af4-835b-06e3e670454f
location_href: 00009907-python-reedsolo/python-reedsolo-1.7.0-1.src.rpm
checksum_type: sha256
description:
  |PyPI-Status| |PyPI-Versions| |PyPI-Downloads|
  |Build-Status| |Coverage|
  |Conda-Forge-Status| |Conda-Forge-Platforms| |Conda-Forge-Downloads|
  A pythonic `universal errors-and-erasures Reed-Solomon Codec <http://en.wikipedia.org/wiki/Reed%E2%80%93Solomon_error_correction>`_ to protect your data from errors and bitrot. It includes a pure python implementation and an optional speed-optimized Cython/C extension.
  This is a burst-type implementation, so that it supports any Galois field higher than 2^3, but not binary streams. Burst errors are non-random errors that more often happen on data storage mediums such as hard drives, hence this library is better suited for data storage protection, and less for streams noise correction, although it also works for this purpose but with a bit of overhead (since it works with bytes only, instead of bits).


pkgId: 0f5463a9734c564b85671037a1fe1ebe4954985da695a7285f6604dd43532001
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-2f9cdaef-66d6-4f6e-ba96-4e87206e2b63
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: af2dc0f3412dcd3e79695a14b296eedf0848a2721eb984863307c4df7c237f0e
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-59b1e23f-d058-4dd0-b7e4-fd02a67a85b1
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: 93c5ba78395b612284ca0e12ba2538404cf8407a1c76283dbf93d6a7933d0beb
name: python-regex-debuginfo
arch: x86_64
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-59b1e23f-d058-4dd0-b7e4-fd02a67a85b1
rpm_sourcerpm: python-regex-2022.10.31-1.src.rpm
location_href: 00004943-python-regex/python-regex-debuginfo-2022.10.31-1.x86_64.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: 923f1e69146187e7ce3df89ae2cc219726e45824d3e51489855190cceda3d139
name: python-regex-debugsource
arch: x86_64
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-59b1e23f-d058-4dd0-b7e4-fd02a67a85b1
rpm_sourcerpm: python-regex-2022.10.31-1.src.rpm
location_href: 00004943-python-regex/python-regex-debugsource-2022.10.31-1.x86_64.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: 4dd5e7c5347271bae5ed5ec01e76f4bfcac52d2e8b3ea5a3ebbe75eba9d3d621
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-6ae49aaa-a8d6-4fd8-a6c1-0ce7a7922b37
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: 95f898a8f62b4992c0d76a6edda39e67452baf51ff7089f6d8c549d6e3476e39
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-32144c41-c939-42d3-8daf-6d1c4522d84b
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: 82936a52f624851282a89f17b957e2e9788badde528142236cbe4ad8d78ebd21
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-15ea780f-316b-4b8a-9240-713674faf149
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: 6aac9da0d21cce336f4c65f58e6bd01020086d8653b1f75b0da84b11ac3c3afd
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-a506ddb2-6dba-4fc5-b941-b60ee4f29d26
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: fbbe4aa73c4398d1223c72fa6b3c2a2a5ef5c708e78c8d592d301d3332a7c3d9
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-1183c85f-310a-4e9b-ab46-66db5892b92a
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: abf198c843e42099a8bad9741378c58ab07fe4991e15969d95ee75ff4d61f537
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-f4fa8579-2779-4f17-b25f-be2762d9295d
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: a7a0bd01fa0dd84c8375d84258ac4f06b15129fcdf2f9352739edb76b35a5be2
name: python-repoze.sendmail
arch: src
version: 4.4.1
epoch: 0
release: 1
summary: Repoze Sendmail
url: http://www.repoze.org
rpm_license: ZPL 2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d3cd02c1-5360-4045-a958-d5c1e8823bf6
location_href: 00013732-python-repoze-sendmail/python-repoze.sendmail-4.4.1-1.src.rpm
checksum_type: sha256
description:
  `repoze.sendmail` allows coupling the sending of email messages with a
  transaction, using the Zope transaction manager.  This allows messages to
  only be sent out when and if a transaction is committed, preventing users
  from receiving notifications about events which may not have completed
  successfully.
  Please see `docs/index.rst` for complete documentation, or read the
  docs online at http://docs.repoze.org/sendmail
  Change history
  ~~~~~~~~~~~~~~


pkgId: 9a5dbcec7cd0f52a31ecd2b23b141c1a7723cac56230013689c4e7391a44261b
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-6131d18a-d3d4-43c1-b19c-b30c64f0b1d9
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: a65b2fd51ac5d2cfd74a76f6f716bf48a48e52b65eefe37c0caa7fcdb36d81a6
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-e7716b78-8876-45b2-b9af-1046a779ec48
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: 267f7d2274bbbc7fbdbfb1f2ce75856ccb2501568ffd60646e67a01f98dc3c27
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-7b9ac836-9545-4c5b-8e99-3e96d898d4e5
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: 3863734ec482629bb01c13858eba8f2699f87e8ce02ee814f6f1753ef68036e4
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-fe6ecb97-3a11-4a1e-8789-21771a2886f7
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: eb60e5b4c1568907f916449340e578c233d5fc671bd41a6a3699a34113ec3b4e
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-6197278f-1e96-4dd6-b4c6-9b0c13207d14
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: 4b632a99b1209864cb560eb7cbb6aa9bafb68c9d428142bbdf35eefce32d2d30
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-ac4d7d4b-5a75-4037-9617-bc34adcd22cc
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: 06380fa4e8855446eea45988190b5ab4252cb9b01f40a4d11733204044750337
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-068ec50e-6a98-43ee-b105-ba0a474ca5fa
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: 17fe9b0028dfd8851111bf5808d285fb9ea9d956d6c9e2f0d20f0625145347d7
name: python-requests-gssapi
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: A GSSAPI authentication handler for python-requests
url: https://github.com/pythongssapi/requests-gssapi
rpm_license: ISC License (ISCL)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-04f3b56b-316d-427f-ad94-654839b133a2
location_href: 00014118-python-requests-gssapi/python-requests-gssapi-1.2.3-1.src.rpm
checksum_type: sha256
description:
  Requests is an HTTP library, written in Python, for human beings. This library
  adds optional GSSAPI authentication support and supports mutual
  authentication.
  It provides a fully backward-compatible shim for the old
  python-requests-kerberos library: simply replace ``import requests_kerberos``
  with ``import requests_gssapi``.  A more powerful interface is provided by the
  HTTPSPNEGOAuth component, but this is of course not guaranteed to be
  compatible.  Documentation below is written toward the new interface.
  Basic GET usage:
      >>> import requests
      >>> from requests_gssapi import HTTPSPNEGOAuth
      >>> r = requests.get("http://example.org", auth=HTTPSPNEGOAuth())
  The entire ``requests.api`` should be supported.


pkgId: 58edc59845a02a9dc493d5ba789c114d51d8b82a2b6619d24eabde4172993a40
name: python-requests-html
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: HTML Parsing for Humans.
url: https://github.com/kennethreitz/requests-html
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c63dc376-1ceb-456a-af87-7dcfa2ce4c92
location_href: 00009926-python-requests-html/python-requests-html-0.10.0-1.src.rpm
checksum_type: sha256
description:
  This library intends to make parsing HTML (e.g. scraping the web) as
  simple and intuitive as possible.
  If you're interested in financially supporting Kenneth Reitz open source, consider `visiting this link <https://cash.me/$KennethReitz>`_. Your support helps tremendously with sustainability of motivation, as Open Source is no longer part of my day job.
  When using this library you automatically get:
  - **Full JavaScript support**!
  - *CSS Selectors* (a.k.a jQuery-style, thanks to PyQuery).
  - *XPath Selectors*, for the faint at heart.
  - Mocked user-agent (like a real web browser).
  - Automatic following of redirects.
  - Connection–pooling and cookie persistence.
  - The Requests experience you know and love, with magical parsing abilities.
  - **Async Support**
      - Markdown export of pages and elements.


pkgId: fa66b10cb24fbe145fed2911198aed6d9c72eb4031a02704dcc750bb67e354e4
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-a01eb2f4-2e89-481b-a0fa-3772dcbbdd0f
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: 9b0d477fe21774752d7f0010bd1d69b45374064e01e16eaf122b3475bf340a39
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-37348342-62e1-4703-ac75-7857f6213399
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: 814b876fca001a19f802a94039ca62c9fbb7f85ccecd016b3dae51f4fbeb55e4
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-7fc0cb15-9396-4b30-88fa-32a6f3f8a2e3
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: f3c989bc19372bacf81637fa3528dddc8a5849dc511cc3e71046d0fb03c0ecdd
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-a05c0d26-f181-45a1-9e15-2f8a20cc1c01
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: 3c693d025785c14e0807b2561e03cd76c21c839f706a43e8a26700d58a8cebc4
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-959af6da-0345-4c4e-a037-2f14d22eb77d
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: 164013b7596f92ce61200ca545d8537d39c39b04f4f6c6a72931ef15c5b34bea
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-89d3458d-7791-4877-a062-51ba97887052
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: cc1c98a048f9f1e65dcf4cc48a6305ed45e73d188f91370e19a59038b66eb473
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-d171ceda-527a-44da-8d73-c6faf31b2f11
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: ac2cb5d016c83b5e712e527cef8f9c5a2a9226406681ee8f7943be6ea4dc6206
name: python-requirements-parser
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: This is a small Python module for parsing Pip requirement files.
url: https://github.com/madpah/requirements-parser
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ca7094ad-1eaf-4b07-a16d-118cd41c813e
location_href: 00009850-python-requirements-parser/python-requirements-parser-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![Python CI](https://github.com/madpah/requirements-parser/actions/workflows/poetry.yml/badge.svg)](https://github.com/madpah/requirements-parser/actions/workflows/poetry.yml)
  [![Documentation Status](http://readthedocs.org/projects/requirements-parser/badge/?version=latest)](http://requirements-parser.readthedocs.io/en/latest/?badge=latest)
  [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  This is a small Python module for parsing [Pip](http://www.pip-installer.org/) requirement files.
  The goal is to parse everything in the
  [Pip requirement file format](https://pip.pypa.io/en/stable/reference/pip_install/#requirements-file-format) spec.


pkgId: 4fc23da7b4e8b2c4900660d92ba018e7fce084ab818003eb7380bc6ea0c20acb
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-b034deae-7bd4-47c1-8b7b-a1edaaf9af39
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: 6709cbc6b1364e0094f3793b30684848a1a04383f620cfa8efc0d1ad655c2893
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-1ddde7d9-37cf-46cc-a450-4d685f3bf108
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: 0570caaa3fd1ad3ee4794e19ceff6905cd0b961d384d8102aec42a8e8455270b
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-d8784b7c-89f4-4318-9c22-8ece2a64ca5c
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: c6f9e94b48544e8386e83f1de9b21c6d68bd71aa584aa9865f3b61bb87359807
name: python-resnest
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: ResNeSt
url: https://github.com/zhanghang1989/ResNeSt
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d92a13b3-98cf-4768-82e6-13378531ef8f
location_href: 00013844-python-resnest/python-resnest-0.0.5-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/resnest.svg)](https://pypi.python.org/pypi/resnest)
  [![PyPI Pre-release](https://img.shields.io/badge/pypi--prerelease-v0.0.5-ff69b4.svg)](https://pypi.org/project/resnest/#history)
  [![PyPI Nightly](https://github.com/zhanghang1989/ResNeSt/workflows/Pypi%20Nightly/badge.svg)](https://github.com/zhanghang1989/ResNeSt/actions)
  [![Downloads](http://pepy.tech/badge/resnest)](http://pepy.tech/project/resnest)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![Unit Test](https://github.com/zhanghang1989/ResNeSt/workflows/Unit%20Test/badge.svg)](https://github.com/zhanghang1989/ResNeSt/actions)
  [![arXiv](http://img.shields.io/badge/cs.CV-arXiv%3A2004.08955-B31B1B.svg)](https://arxiv.org/abs/2004.08955)

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



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

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


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




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

  ```bash

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


  pip install resnest --pre
  ```



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

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

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



  - Load using Torch Hub

  ```python
  import torch

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


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


  - Load using python package

  ```python

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




  - Load pretrained model:

  ```python

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





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




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




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

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


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



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



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



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




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



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

  ```bash
  cd scripts/dataset/

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



  ```bash

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



  ```bash

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





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



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



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



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

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

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



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


pkgId: ad6548a9e5a2b718d140b9825a91524e5fae92b6fc6140c0e027f6fc7a6762f2
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-1b2ef70d-7ac9-47c1-a910-b58a26e5b6c5
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: d9b1440da02709b7fd5b9a120731ed231e8305c93390a04cb83ea03cdbf0d720
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-74e8ffe7-7377-4775-8744-51a5b99370b4
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: fa82c7471cec4ebd65aadb4747de0a6a6928faabd5d8562c4611a825498a4f96
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-0b332cc4-f3df-4f71-b436-a7a64c1c33af
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: 10cfa7b1edb5f7314f974d0274ba30773c9938c851404943fab36dab4feeabce
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-6075236e-c331-4e38-a697-332d93e2ea64
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: 3785b1e7b327a4be0e4e882df90183acce61a47d9b206f273cd95dd1b8e0e37e
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-b405e639-19f9-4d1a-a7f4-c4f9903bf5fa
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: 61530517615b000ce4c9edb50f07f503c728015b868723b0428c8f240de618e2
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-226b721c-1157-4978-aab8-9cecaf5a1505
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: aed2ac64bc6758e373cbcf12e6150842d925c58aa2c98e2d4774b8b3d61f6132
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-c66698e7-880a-49c7-8c56-7c39136f1fb9
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: 903178b3f7114ea4941753d55a193e35d081f0bd4f9fa23b3a5ec0336d6b0033
name: python-reverse_geocoder
arch: src
version: 1.5.1
epoch: 0
release: 1
summary: Fast, offline reverse geocoder
url: https://github.com/thampiman/reverse-geocoder
rpm_license: lgpl
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-31106bfb-548a-41a1-8022-54371f9a36cf
location_href: 00010369-python-reverse-geocoder/python-reverse_geocoder-1.5.1-1.src.rpm
checksum_type: sha256
description:
  Reverse Geocoder takes a latitude / longitude coordinate and returns the nearest town/city.
  This library improves on an existing library called reverse_geocode developed by Richard Penman in the following ways:
  1. Besides city and country, this library also returns the administrative 1 & 2 regions, latitude and longitude
  2. The performance is much faster since a parallelized K-D tree is implemented
  (See https://github.com/thampiman/reverse-geocoder for performance comparison)
  Supports Python 2 and 3. You can also load a custom data source. Fore more help, see https://github.com/thampiman/reverse-geocoder.
  Example usage:
      >>> import reverse_geocoder as rg
      >>> coordinates = (51.5214588,-0.1729636),(9.936033, 76.259952),(37.38605,-122.08385)
      >>> rg.search(coordinates)
      [{'name': 'Bayswater',
        'cc': 'GB',
        'lat': '51.51116',
        'lon': '-0.18426',
        'admin1': 'England',
        'admin2': 'Greater London'},
       {'name': 'Cochin',
        'cc': 'IN',
        'lat': '9.93988',
        'lon': '76.26022',
        'admin1': 'Kerala',
        'admin2': 'Ernakulam'},
       {'name': 'Mountain View',
        'cc': 'US',
        'lat': '37.38605',
        'lon': '-122.08385',
        'admin1': 'California',
        'admin2': 'Santa Clara County'}]


pkgId: 268e3169527025782e9a0ac3d83c40d7f711c485cdd8fc10588cd9fbebdaee05
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-49b30433-959e-4e60-ba60-e41958462149
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: 780ab5d03c6a3126fa0a8cde0c19df7a9398ff290e80e4072273df51e88defee
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-7f6a3616-a738-4cd6-8f66-0c6c9aece3d2
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: 27f2ecc40d7033f96d2920716536de6ed55f8f51cb4e74fbfaa090e205c9e0f5
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-57699ca1-9221-43a3-966a-f116d7bf694d
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: 10c9891e45641c5423546d8e531b3c8b8fd7d6487d3365f9833627247fa6b1ab
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-823c4632-a6ec-4d1c-8a52-6638cc41ea47
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: d2975073fc8aca2bb2e809e78dbc5889f557e6a4b72798c761cabe61337b8182
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-7b96e10e-8ba5-445d-838f-8fece93a4ebf
location_href: 00004987-python-rmol/python-rmol-1.0.6.post1-1.src.rpm
checksum_type: sha256
description:
  RMOL is a C++ library of Revenue Management and Optimisation classes
  and functions. Typically, that library may be used by service providers
  (_e.g._, airlines offering flight seats, hotels offering rooms, rental car
  companies offering rental days, broadcasting company offering advertisement
  slots, theaters offering seats, _etc_) to help in optimising their revenues
  from seat capacities.
  Most of the algorithms implemented are public and documented in the
  following book:
  The Theory and practice of Revenue Management, by Kalyan T. Talluri and
  Garrett J. van Ryzin, Kluwer Academic Publishers, 2004, ISBN 1-4020-7701-7
  RMOL makes an extensive use of existing open-source libraries for
  increased functionality, speed and accuracy. In particular the
  Boost (C++ Standard Extensions: http://www.boost.org) library is used.
  RMOL is the one of the components of the Travel Market Simulator
  (https://travel-sim.org). However, it may be used in a
  stand-alone mode.


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

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

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

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

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

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

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


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


pkgId: bbf6d2b9109a5ea80af2e5bd7822f410c5cbc99226d8dc629c5276d14e982ed7
name: python-robotframework-appiumlibrary-help
arch: noarch
version: 2.0.0
epoch: 0
release: 1
summary: Development documents and examples for robotframework-appiumlibrary
url: https://github.com/serhatbolsu/robotframework-appiumlibrary
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b2278efb-0df1-4219-b7d4-f450fea061aa
rpm_sourcerpm: python-robotframework-appiumlibrary-2.0.0-1.src.rpm
checksum_type: sha256
location_href:
  00012949-python-robotframework-appiumlibrary/python-robotframework-appiumlibrary-help-2.0.0-1.noarch.rpm


pkgId: 4469c1d02adf20c8984f5636454c31deec3d9e62e8c664022cb147970e8ecb20
name: python-robotframework-pabot
arch: src
version: 2.15.0
epoch: 0
release: 1
summary: Parallel test runner for Robot Framework
url: https://pabot.org
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7f1de26f-4df1-4ee5-b36d-289f7726d223
location_href: 00010919-python-robotframework-pabot/python-robotframework-pabot-2.15.0-1.src.rpm
checksum_type: sha256
description:
  A parallel executor for Robot Framework tests. With Pabot you can split one execution into multiple and save test execution time.


pkgId: dab8dee856f0e8eef45498fa71fcb0037dc26fc3ac9aec7d9068313733125187
name: python-robotframework-requests
arch: src
version: 0.9.4
epoch: 0
release: 1
summary: Robot Framework keyword library wrapper around requests
url: https://github.com/MarketSquare/robotframework-requests
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-957e8c2b-c461-4d8f-85b1-2d66d352a52c
location_href: 00010353-python-robotframework-requests/python-robotframework-requests-0.9.4-1.src.rpm
checksum_type: sha256
description:
  ![Python application](https://github.com/MarketSquare/robotframework-requests/workflows/Python%20application/badge.svg?branch=master)
  [![codecov](https://codecov.io/gh/MarketSquare/robotframework-requests/branch/master/graph/badge.svg)](https://codecov.io/gh/MarketSquare/robotframework-requests)
  [![PyPi downloads](https://img.shields.io/pypi/dm/robotframework-requests)](https://pypi.python.org/pypi/robotframework-requests)
  [![Latest Version](https://img.shields.io/pypi/v/robotframework-requests)](https://pypi.python.org/pypi/robotframework-requests)

  🏠 ``RequestsLibrary`` is a [Robot Framework](https://robotframework.org/) library
  aimed to provide HTTP api testing functionalities by wrapping the well known [Python Requests Library](https://github.com/kennethreitz/requests).


  ```sh
  pip install robotframework-requests
  ```


  ```robotframework
  *** Settings ***
  Library               RequestsLibrary

  *** Test Cases ***

  Quick Get Request Test
      ${response}=    GET  https://www.google.com

  Quick Get Request With Parameters Test
      ${response}=    GET  https://www.google.com/search  params=query=ciao  expected_status=200

  Quick Get A JSON Body Test
      ${response}=    GET  https://jsonplaceholder.typicode.com/posts/1
      Should Be Equal As Strings    1  ${response.json()}[id]
  ```


  Sessionless keywords are now available, you can just `GET`, `POST`, etc.. no need to create a session anymore!
  ```robotframework
  ${resp}=  GET  https://www.google.com
  ```

  `Status Should Be` and `Request Should Be Successfull` can use the last response, no need to pass the response anymore!
  ```robotframework
  GET  https://www.google.com
  Status Should Be  200
  ```



  **New keywords structure:**
  All requests keywords have been rewritten because of many not backward compatible changes
  and to allow in the near future requests keywords without a session.
  Example `Get Request` become `GET On Session` and soon there will be also just `GET`
  when a session is not needed.
  Old keywords `* Request` are now deprecated and will be removed in 1.0.0 version.

  **Implicit assert on status code:**
  `* On Session` keywords automatically fail if an error status code is returned.
  `expect_status=` could be used to specify a status code (`201`, `OK`, `Bad request`)
  or `any` if you want to evaluate the response in any case.

  **Closer to the original Requests library:**
  New keywords have the same parameter orders and structure as the original.
  Lot of pre-parsing / encoding has been removed to have a more accurate and unchanged behaviour.

  **Cleaner project architecture:**
  Main keywords file has been split with a more logic division to allow better and faster maintenance.


  ```robotframework
  *** Settings ***
  Library    Collections
  Library    RequestsLibrary

  Suite Setup    Create Session  jsonplaceholder  https://jsonplaceholder.typicode.com

  *** Test Cases ***

  Get Request Test
      Create Session    google  http://www.google.com

      ${resp_google}=   GET On Session  google  /  expected_status=200
      ${resp_json}=     GET On Session  jsonplaceholder  /posts/1

      Should Be Equal As Strings          ${resp_google.reason}  OK
      Dictionary Should Contain Value     ${resp_json.json()}  sunt aut facere repellat provident

  Post Request Test
      &{data}=    Create dictionary  title=Robotframework requests  body=This is a test!  userId=1
      ${resp}=    POST On Session    jsonplaceholder  /posts  json=${data}  expected_status=anything

      Status Should Be                 201  ${resp}
  ```


  Robotframework-requests offers a wide set of keywords which can be found in the [Keywords documentation](http://marketsquare.github.io/robotframework-requests/doc/RequestsLibrary.html)


  You can find many test examples inside the `atests` folder.


  Feel free to contribute and open an issue in order to discuss it. Before doing it take a look at the [contribution guidelines](CONTRIBUTING.md).

  📢 Get in touch with the community via slack and Users group
  - [Robot Framework Slack #requests channel](https://robotframework-slack-invite.herokuapp.com/)
  - [Robot Framework Users Group](https://groups.google.com/forum/#!forum/robotframework-users)


pkgId: 4d616960bd83d415090881e8685a73dae19fa051b059559ed9d60ec216fb237f
name: python-robotframework-robocop
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Static code analysis tool (linter) for Robot Framework
url: https://github.com/MarketSquare/robotframework-robocop
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8523060b-ee90-4004-8077-55564ed6bd87
location_href: 00013575-python-robotframework-robocop/python-robotframework-robocop-3.0.0-1.src.rpm
checksum_type: sha256
description:
  <img style="float:right" src="https://raw.githubusercontent.com/MarketSquare/robotframework-robocop/master/docs/images/robocop_logo_small.png">


pkgId: 277af04ff5c08af7d41e1562dbe8b4b060553a27e3887598f86240b7020f4d9a
name: python-robotframework-selenium2library
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Web testing library for Robot Framework
url: https://github.com/robotframework/Selenium2Library
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f4b6cf42-cb60-4898-b544-92159d9a3e36
checksum_type: sha256
description:
  Selenium2Library is a web testing library for `Robot Framework`_
  that uses the Selenium_ tool internally. The project is hosted on
  GitHub_ and downloads can be found from PyPI_.
  Starting from version 3.0, Selenium2Library is renamed to SeleniumLibrary_
  and this project exists mainly to help with transitioning.

location_href:
  00011563-python-robotframework-selenium2library/python-robotframework-selenium2library-3.0.0-1.src.rpm


pkgId: d31786f6d045dc01d91b0c816a9bb14c66760abc8f3842dc3219abc3dda9182c
name: python-robotframework-selenium2library-help
arch: noarch
version: 3.0.0
epoch: 0
release: 1
summary: Development documents and examples for robotframework-selenium2library
url: https://github.com/robotframework/Selenium2Library
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f4b6cf42-cb60-4898-b544-92159d9a3e36
rpm_sourcerpm: python-robotframework-selenium2library-3.0.0-1.src.rpm
checksum_type: sha256
description:
  Selenium2Library is a web testing library for `Robot Framework`_
  that uses the Selenium_ tool internally. The project is hosted on
  GitHub_ and downloads can be found from PyPI_.
  Starting from version 3.0, Selenium2Library is renamed to SeleniumLibrary_
  and this project exists mainly to help with transitioning.

location_href:
  00011563-python-robotframework-selenium2library/python-robotframework-selenium2library-help-3.0.0-1.noarch.rpm


pkgId: e599213dd5b2eba5fe888e360ac27111f115202c67d61b085a0cd5cac2e0f189
name: python-robotframework-seleniumlibrary
arch: src
version: 6.0.0
epoch: 0
release: 1
summary: Web testing library for Robot Framework
url: https://github.com/robotframework/SeleniumLibrary
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7d9579c2-4d29-4e30-a8dd-8f6f5e59519c
checksum_type: sha256
location_href:
  00009974-python-robotframework-seleniumlibrary/python-robotframework-seleniumlibrary-6.0.0-1.src.rpm


pkgId: 4336f7a8c7cf8898b88a147bf9eecf3fee2d686546ffa529444651ed5004b813
name: python-robotframework-seleniumlibrary-help
arch: noarch
version: 6.0.0
epoch: 0
release: 1
summary: Development documents and examples for robotframework-seleniumlibrary
url: https://github.com/robotframework/SeleniumLibrary
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7d9579c2-4d29-4e30-a8dd-8f6f5e59519c
rpm_sourcerpm: python-robotframework-seleniumlibrary-6.0.0-1.src.rpm
checksum_type: sha256
location_href:
  00009974-python-robotframework-seleniumlibrary/python-robotframework-seleniumlibrary-help-6.0.0-1.noarch.rpm


pkgId: ab45a939f3c4d1e7dec416ab2821f9908ce3589fa1def2d642fd09a02bfc38af
name: python-robotframework-stacktrace
arch: src
version: 0.4.1
epoch: 0
release: 1
url: https://github.com/MarketSquare/robotframework-stacktrace
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f4ae47d5-577a-4df7-a899-f44f9dd02346
location_href: 00012495-python-robotframework-stacktrace/python-robotframework-stacktrace-0.4.1-1.src.rpm
checksum_type: sha256
summary:
  A listener that prints a Stack Trace to console to faster find the code section where the failure appears.


pkgId: 8375283cb21d8b7bd6f1d863bb1f24a9277efe08bb75626c0e9bf142aec6ab2a
name: python-rollbar
arch: src
version: 0.16.3
epoch: 0
release: 1
url: http://github.com/rollbar/pyrollbar
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-340c8005-be49-4e34-8982-ead3860e3136
location_href: 00010401-python-rollbar/python-rollbar-0.16.3-1.src.rpm
checksum_type: sha256
summary:
  Easy and powerful exception tracking with Rollbar. Send messages and exceptions with arbitrary context, get back aggregates, and debug production issues quickly.

description:
  ![Build Status](https://github.com/rollbar/pyrollbar/workflows/Pyrollbar%20CI/badge.svg?tag=latest)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/rollbar)

  Python notifier for reporting exceptions, errors, and log messages to [Rollbar](https://rollbar.com).



  1. [Sign up for a Rollbar account](https://rollbar.com/signup)
  2. Follow the [Quick Start](https://docs.rollbar.com/docs/python#section-quick-start) instructions in our [Python SDK docs](https://docs.rollbar.com/docs/python) to install pyrollbar and configure it for your platform.



  For complete usage instructions and configuration reference, see our [Python SDK docs](https://docs.rollbar.com/docs/python).



  See our [Releases](https://github.com/rollbar/pyrollbar/releases) page for a list of all releases, including changes.



  If you run into any issues, please email us at [support@rollbar.com](mailto:support@rollbar.com)

  For bug reports, please [open an issue on GitHub](https://github.com/rollbar/pyrollbar/issues/new).




  1. Fork it
  2. Create your feature branch (```git checkout -b my-new-feature```).
  3. Commit your changes (```git commit -am 'Added some feature'```)
  4. Push to the branch (```git push origin my-new-feature```)
  5. Create new Pull Request

  Tests are in `rollbar/test`. To run the tests: `python setup.py test`


pkgId: cc5ebd83438f3528c42a6fa398d99a55dbb1d174d691cf172788304b36d85ea0
name: python-roman
arch: src
version: 4.0
epoch: 0
release: 1
summary: Integer to Roman numerals converter
url: https://github.com/zopefoundation/roman
rpm_license: Python 2.1.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f01f8223-fef1-48ca-bb45-f5366d1c5116
location_href: 00004991-python-roman/python-roman-4.0-1.src.rpm
checksum_type: sha256
description:
  Small helper library to convert arabic to roman numerals.
  There are two ways to use this library.
  1. Importing it into your application
      import roman
      
      number = int(input('> ')) # 10
      print(roman.toRoman(number))
      
      number = input('> ') # X
      print(roman.fromRoman(number))
  2. ``roman`` CLI command
      ~$ roman 972
      CMLXXII
      
      ~$ roman -r CMLXXII
      972
      
      ~$ roman -r cMlxxii
      972


pkgId: 43c1915e92078d6746000650ac6d0125f3e8c9a51fa7b27d91b0098df6e5f910
name: python-ropwr
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: RoPWR: Robust Piecewise Regression
url: https://github.com/guillermo-navas-palencia/ropwr
rpm_license: Apache Licence 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bc0c4e55-96b3-4952-bfc9-70a3d4a634a5
location_href: 00010435-python-ropwr/python-ropwr-1.0.0-1.src.rpm
checksum_type: sha256
description:
  **RoPWR** is a library written in Python implementing several mathematical
  programming formulations to compute the optimal continuous/discontinuous
  piecewise polynomial regression given a list of split points.

  Read the documentation at: http://gnpalencia.org/ropwr/

  RoPWR is distributed under the Apache Software License (Apache 2.0).


pkgId: 92420bb58dda3e182a190a79f93f59295ee9b90c95fd7b9cc9423bcf0f718ec8
name: python-roundrobin
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: Collection of roundrobin utilities
url: https://github.com/linnik/roundrobin
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-00111af5-16cf-4cc7-8622-873a20adfa38
location_href: 00011189-python-roundrobin/python-roundrobin-0.0.4-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/linnik/roundrobin.svg?branch=master)](https://travis-ci.org/linnik/roundrobin)
  [![PyPI install](https://img.shields.io/badge/pip%20install-roundrobin-informational)](https://pypi.org/project/roundrobin/)
  ![versions](https://img.shields.io/pypi/pyversions/roundrobin.svg)



  This is rather small collection of round robin utilites

  ```python
  >>> import roundrobin
  >>> get_roundrobin = roundrobin.basic(["A", "B", "C"])
  >>> ''.join([get_roundrobin() for _ in range(7)])
  'ABCABCA'
  >>> # weighted round-robin balancing algorithm as seen in LVS
  >>> get_weighted = roundrobin.weighted([("A", 5), ("B", 1), ("C", 1)])
  >>> ''.join([get_weighted() for _ in range(7)])
  'AAAAABC'
  >>> # smooth weighted round-robin balancing algorithm as seen in Nginx
  >>> get_weighted_smooth = roundrobin.smooth([("A", 5), ("B", 1), ("C", 1)])
  >>> ''.join([get_weighted_smooth() for _ in range(7)])
  'AABACAA'
  ```


pkgId: 7c1eb159fdfff91359b68eb8f335c375a34adac604b20acbc8c8b69a1039e1b0
name: python-rpdb
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: pdb wrapper with remote access via tcp socket
url: http://tamentis.com/projects/rpdb
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6aee9130-e52b-41c2-bd94-3c7efa564365
location_href: 00005000-python-rpdb/python-rpdb-0.1.6-1.src.rpm
checksum_type: sha256
description:
  rpdb is a wrapper around pdb that re-routes stdin and stdout to a socket
  handler. By default it opens the debugger on port 4444::
      import rpdb; rpdb.set_trace()
  But you can change that by simply instantiating Rpdb manually::
      import rpdb
      debugger = rpdb.Rpdb(port=12345)
      debugger.set_trace()
  It is known to work on Jython 2.5 to 2.7, Python 2.5 to 3.1. It was written
  originally for Jython since this is pretty much the only way to debug it when
  running it on Tomcat.
  Upon reaching `set_trace()`, your script will "hang" and the only way to get it
  to continue is to access rpdb using telnet, netcat, etc..::
      nc 127.0.0.1 4444


pkgId: f61f6d2b9b20c5c10c98e92b0bf2869546484ed46df1e54f65c0deb16a25dc30
name: python-rpkg
arch: src
version: 1.66
epoch: 0
release: 1
summary: A python library and runtime script for managing RPMpackage sources in a git repository
url: https://pagure.io/rpkg
rpm_license: GPLv2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ecbb00f0-9b8e-420b-84a8-be7b74902c45
location_href: 00005001-python-rpkg/python-rpkg-1.66-1.src.rpm
checksum_type: sha256
description:
  This is the rpkg project, which mostly is a python library for dealing with
  rpm packaging in a git source control.  pyrpkg is the base library that sites
  can subclass to create useful tools.
  rpkg works with Python 2.7, 3.6, 3.9, 3.10 and 3.11.


pkgId: 8b83b87cb2fb86ae45016f815a6c40c5d9282a7628add93b43f115a317b2442f
name: python-rply
arch: src
version: 0.7.8
epoch: 0
release: 1
summary: A pure Python Lex/Yacc that works with RPython
url: https://pypi.org/project/rply/
rpm_license: BSD 3-Clause License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6efdb075-b430-4504-b762-ce2d183127f3
location_href: 00005002-python-rply/python-rply-0.7.8-1.src.rpm
checksum_type: sha256
description:
  Welcome to RPLY! A pure Python parser generator, that also works with RPython.
  It is a more-or-less direct port of David Beazley's awesome PLY, with a new
  public API, and RPython support.
  You can find the documentation `online`_.
  Basic API:
      from rply import ParserGenerator, LexerGenerator
      from rply.token import BaseBox
      lg = LexerGenerator()
      
      lg.add("PLUS", r"\+")
      lg.add("MINUS", r"-")
      lg.add("NUMBER", r"\d+")
      lg.ignore(r"\s+")
      
      
      
      
      
      
      
      pg = ParserGenerator(["NUMBER", "PLUS", "MINUS"],
              precedence=[("left", ['PLUS', 'MINUS'])], cache_id="myparser")
      @pg.production("main : expr")
      def main(p):
          
          
          return p[0]
      @pg.production("expr : expr PLUS expr")
      @pg.production("expr : expr MINUS expr")
      def expr_op(p):
          lhs = p[0].getint()
          rhs = p[2].getint()
          if p[1].gettokentype() == "PLUS":
              return BoxInt(lhs + rhs)
          elif p[1].gettokentype() == "MINUS":
              return BoxInt(lhs - rhs)
          else:
              raise AssertionError("This is impossible, abort the time machine!")
      @pg.production("expr : NUMBER")
      def expr_num(p):
          return BoxInt(int(p[0].getstr()))
      lexer = lg.build()
      parser = pg.build()
      class BoxInt(BaseBox):
          def __init__(self, value):
              self.value = value
          def getint(self):
              return self.value
  Then you can do:
      parser.parse(lexer.lex("1 + 3 - 2+12-32"))
  You can also substitute your own lexer. A lexer is an object with a ``next()``
  method that returns either the next token in sequence, or ``None`` if the token
  stream has been exhausted.


pkgId: 41c541b287b15743e79198eb5a2e30511056521331d4b365b8b36560e75972e0
name: python-rpmfluff
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: Lightweight way of building RPMs, and sabotaging them
url: https://pagure.io/rpmfluff
rpm_license: GPL-2.0+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-69b8a5cf-45ce-4b33-8cfa-8f3e98862447
location_href: 00005008-python-rpmfluff/python-rpmfluff-0.6.2-1.src.rpm
checksum_type: sha256
description:
  rpmfluff provides a python library for building RPM packages, and
  sabotaging them so they are broken in controlled ways.

  It is intended for use when validating package analysis tools such as RPM lint.
  It can also be used to construct test cases for package management software
  such as RPM, YUM, and DNF.


pkgId: 485f510035358227214f6394ee1178df313e22a9af4ee4cdf6ea82ace91b2701
name: python-rpyc
arch: src
version: 5.3.1
epoch: 0
release: 1
summary: Remote Python Call (RPyC) is a transparent and symmetric distributed computing library
url: https://rpyc.readthedocs.org
rpm_license: None
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a288e76a-a73a-46a8-859a-9f70ffa94fc9
location_href: 00005010-python-rpyc/python-rpyc-5.3.1-1.src.rpm
checksum_type: sha256
description:
  |Version| |Python| |Tests| |License|

  RPyC_ (pronounced like *are-pie-see*), or *Remote Python Call*, is a
  **transparent** library for **symmetrical** `remote procedure calls`_,
  clustering_, and distributed-computing_.  RPyC makes use of object-proxying_,
  a technique that employs python's dynamic nature, to overcome the physical
  boundaries between processes and computers, so that remote objects can be
  manipulated as if they were local.

  Documentation can be found at https://rpyc.readthedocs.io

  .. figure:: http://rpyc.readthedocs.org/en/latest/_images/screenshot.png
     :align: center

     A screenshot of a Windows client connecting to a Linux server.

     Note that text written to the server's ``stdout`` is actually printed on
     the server's console.


  .. References:

  .. _RPyC:                   https://github.com/tomerfiliba-org/rpyc
  .. _remote procedure calls: http://en.wikipedia.org/wiki/Remote_procedure_calls
  .. _clustering:             http://en.wikipedia.org/wiki/Clustering
  .. _distributed-computing:  http://en.wikipedia.org/wiki/Distributed_computing
  .. _object-proxying:        http://en.wikipedia.org/wiki/Proxy_pattern

  .. Badges:

  .. |Version| image::   https://img.shields.io/pypi/v/rpyc.svg?style=flat
     :target:            https://pypi.python.org/pypi/rpyc
     :alt:               Version

  .. |Python| image::    https://img.shields.io/pypi/pyversions/rpyc.svg?style=flat
     :target:            https://pypi.python.org/pypi/rpyc#downloads
     :alt:               Python Versions

  .. |Tests| image::     https://github.com/tomerfiliba-org/rpyc/actions/workflows/python-app.yml/badge.svg
     :target:            https://github.com/tomerfiliba-org/rpyc/actions/workflows/python-app.yml
     :alt:               Build Status

  .. |License| image::   https://img.shields.io/pypi/l/rpyc.svg?style=flat
     :target:            https://github.com/tomerfiliba-org/rpyc/blob/master/LICENSE
     :alt:               License: MIT


pkgId: 4bfec68b651c8e412f9b3a2a65b3ef4f9203c8142f24ba4feaa6fe8fe8115105
name: python-rq-dashboard
arch: src
version: 0.6.1
epoch: 0
release: 1
url: https://github.com/Parallels/rq-dashboard
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8ca89ec2-99e7-4243-8750-5cdf638a3944
location_href: 00013482-python-rq-dashboard/python-rq-dashboard-0.6.1-1.src.rpm
checksum_type: sha256
summary:
  rq-dashboard is a general purpose, lightweight, web interface to monitor your RQ queues, jobs, and workers in realtime.

description:
  `rq-dashboard` is a general purpose, lightweight,
  [Flask](https://flask.palletsprojects.com/)-based web front-end to monitor your
  [RQ](http://python-rq.org/) queues, jobs, and workers in realtime.
  [![Build
  Status](https://travis-ci.org/Parallels/rq-dashboard.svg?branch=master)](https://travis-ci.org/Parallels/rq-dashboard)
  [![Python
  Support](https://img.shields.io/pypi/pyversions/rq-dashboard.svg)](https://pypi.python.org/pypi/rq-dashboard)
  ![PyPI Downloads](https://img.shields.io/pypi/dw/rq-dashboard)


pkgId: 633afe06bc815cfd476ae0d243f6ecfb07c80861f1f8db7f4784f34b98eb46de
name: python-rsa
arch: src
version: 4.9
epoch: 0
release: 1
summary: Pure-Python RSA implementation
url: https://stuvel.eu/rsa
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cd816523-d184-429e-ac3f-32331fcc0411
location_href: 00008892-python-rsa/python-rsa-4.9-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/rsa.svg)](https://pypi.org/project/rsa/)
  [![Build Status](https://travis-ci.org/sybrenstuvel/python-rsa.svg?branch=master)](https://travis-ci.org/sybrenstuvel/python-rsa)
  [![Coverage Status](https://coveralls.io/repos/github/sybrenstuvel/python-rsa/badge.svg?branch=master)](https://coveralls.io/github/sybrenstuvel/python-rsa?branch=master)
  [![Code Climate](https://api.codeclimate.com/v1/badges/a99a88d28ad37a79dbf6/maintainability)](https://codeclimate.com/github/codeclimate/codeclimate/maintainability)

  [Python-RSA](https://stuvel.eu/rsa) is a pure-Python RSA implementation. It supports
  encryption and decryption, signing and verifying signatures, and key
  generation according to PKCS#1 version 1.5. It can be used as a Python
  library as well as on the commandline. The code was mostly written by
  Sybren A.  Stüvel.

  Documentation can be found at the [Python-RSA homepage](https://stuvel.eu/rsa). For all changes, check [the changelog](https://github.com/sybrenstuvel/python-rsa/blob/master/CHANGELOG.md).

  Download and install using:

      pip install rsa

  or download it from the [Python Package Index](https://pypi.org/project/rsa/).

  The source code is maintained at [GitHub](https://github.com/sybrenstuvel/python-rsa/) and is
  licensed under the [Apache License, version 2.0](https://www.apache.org/licenses/LICENSE-2.0)



  Because of how Python internally stores numbers, it is very hard (if not impossible) to make a pure-Python program secure against timing attacks. This library is no exception, so use it with care. See https://securitypitfalls.wordpress.com/2018/08/03/constant-time-compare-in-python/ for more info.



  ```
  python3 -m venv .venv
  . ./.venv/bin/activate
  pip install poetry
  poetry install
  ```



  Since this project is considered critical on the Python Package Index,
  two-factor authentication is required. For uploading packages to PyPi, an API
  key is required; username+password will not work.

  First, generate an API token at https://pypi.org/manage/account/token/. Then,
  use this token when publishing instead of your username and password.

  As username, use `__token__`.
  As password, use the token itself, including the `pypi-` prefix.

  See https://pypi.org/help/#apitoken for help using API tokens to publish. This
  is what I have in `~/.pypirc`:

  ```
  [distutils]
  index-servers =
      rsa


  [rsa]
    repository = https://upload.pypi.org/legacy/
    username = __token__
    password = pypi-token
  ```

  ```
  . ./.venv/bin/activate
  pip install twine

  poetry build
  twine check dist/rsa-4.9.tar.gz dist/rsa-4.9-*.whl
  twine upload -r rsa dist/rsa-4.9.tar.gz dist/rsa-4.9-*.whl
  ```

  The `pip install twine` is necessary as Python-RSA requires Python >= 3.6, and
  Twine requires at least version 3.7. This means Poetry refuses to add it as
  dependency.


pkgId: 97496c56b18d4f34ab64d9ded13dbacc0a5ec2ce4897f5aaa6a2b99ecb06d48c
name: python-rst2ansi
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: A rst converter to ansi-decorated console output
url: https://github.com/Snaipe/python-rst-to-ansi
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-90621b66-9879-45d4-b158-0fa5b93143a7
location_href: 00013098-python-rst2ansi/python-rst2ansi-0.1.5-1.src.rpm
checksum_type: sha256
description:
  |build| |downloads| |pyversions| |format|
  A python module dedicated to rendering RST (reStructuredText) documents
  to ansi-escaped strings suitable for display in a terminal.
  |asciicast|


pkgId: e9b18af48c16b2b3bb650565ca6dfe2091e6cc073d9e4316d314c7a669ce39b0
name: python-ruamel.yaml
arch: src
version: 0.17.21
epoch: 0
release: 1
url: https://sourceforge.net/p/ruamel-yaml/code/ci/default/tree
rpm_license: MIT license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d1561370-5576-47c1-82ee-b0135fbc6035
location_href: 00005020-python-ruamel-yaml/python-ruamel.yaml-0.17.21-1.src.rpm
checksum_type: sha256
summary:
  ruamel.yaml is a YAML parser/emitter that supports roundtrip preservation of comments, seq/map flow style, and map key order

description:
  ``ruamel.yaml`` is a YAML 1.2 loader/dumper package for Python.
  *The 0.16.13 release was the last that was tested to be working on Python 2.7.
  The 0.17.21 is the last one tested to be working on Python 3.5,
  that is also the last release supporting old PyYAML functions, you'll have to create a
  `YAML()` instance and use its `.load()` and `.dump()` methods.*
  *Please adjust your dependencies accordingly if necessary. (`ruamel.yaml<0.18`)*
  Starting with version 0.15.0 the way YAML files are loaded and dumped
  has been changing, see the API doc for details.  Currently existing
  functionality will throw a warning before being changed/removed.
  **For production systems already using a pre 0.16 version, you should
  pin the version being used with ``ruamel.yaml<=0.15``** if you cannot
  fully test upgrading to a newer version. For new usage
  pin to the minor version tested ( ``ruamel.yaml<=0.17``) or even to the
  exact version used.
  New functionality is usually only available via the new API, so
  make sure you use it and stop using the `ruamel.yaml.safe_load()`,
  `ruamel.yaml.round_trip_load()` and `ruamel.yaml.load()` functions
  (and their `....dump()` counterparts).
  If your package uses ``ruamel.yaml`` and is not listed on PyPI, drop
  me an email, preferably with some information on how you use the
  package (or a link to the repository) and I'll keep you informed
  when the status of the API is stable enough to make the transition.
  * `Overview <http://yaml.readthedocs.org/en/latest/overview.html>`_
  * `Installing <http://yaml.readthedocs.org/en/latest/install.html>`_
  * `Basic Usage <http://yaml.readthedocs.org/en/latest/basicuse.html>`_
  * `Details <http://yaml.readthedocs.org/en/latest/detail.html>`_
  * `Examples <http://yaml.readthedocs.org/en/latest/example.html>`_
  * `API <http://yaml.readthedocs.org/en/latest/api.html>`_
  * `Differences with PyYAML <http://yaml.readthedocs.org/en/latest/pyyaml.html>`_


pkgId: 8ed55b7100f6e93a629c64270244ce395cf1983a950119fd7aa79e53aa51fdec
name: python-rubymarshal
arch: src
version: 1.2.7
epoch: 0
release: 1
summary: Read and write Ruby-marshalled data
url: https://github.com/d9pouces/RubyMarshal
rpm_license: WTFPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8c8874a2-5464-483b-8f23-bbc61b0a739a
location_href: 00011745-python-rubymarshal/python-rubymarshal-1.2.7-1.src.rpm
checksum_type: sha256
description:
  Read and write Ruby-marshalled data.
  Only basics Ruby data types can be directly read and written, but you can use any custom Python and Ruby types:
    * `float`,
    * `bool`,
    * `int`,
    * `str` (mapped to `rubymarshal.classes.RubyString` if dumped with instance variables),
    * `nil` (mapped to `None` in Python),
    * `array` (mapped to `list`),
    * `hash` (mapped to `dict`),
    * symbols and other classes are mapped to specific Python classes.


pkgId: 4cb50e9765e08f2fddeb95bada320924de98851433a5940f8e824498fbe10954
name: python-ruffus
arch: src
version: 2.8.4
epoch: 0
release: 1
summary: Light-weight Python Computational Pipeline Management
url: http://www.ruffus.org.uk
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fcc6a5d4-7572-4477-b8f5-ebf981f45c21
location_href: 00005021-python-ruffus/python-ruffus-2.8.4-1.src.rpm
checksum_type: sha256
description:
  ***************************************
  Overview
  ***************************************


      The Ruffus module is a lightweight way to add support
      for running computational pipelines.

      Computational pipelines are often conceptually quite simple, especially
      if we breakdown the process into simple stages, or separate **tasks**.

      Each stage or **task** in a computational pipeline is represented by a python function
      Each python function can be called in parallel to run multiple **jobs**.

      Ruffus was originally designed for use in bioinformatics to analyse multiple genome
      data sets.

  ***************************************
  Documentation
  ***************************************

      Ruffus documentation can be found `here <http://www.ruffus.org.uk>`__ ,
      with `download notes <http://www.ruffus.org.uk/installation.html>`__ ,
      a `tutorial <http://www.ruffus.org.uk/tutorials/new_tutorial/introduction.html>`__ and
      an `in-depth manual <http://www.ruffus.org.uk/tutorials/new_tutorial/manual_contents.html>`__ .


  ***************************************
  Background
  ***************************************

      The purpose of a pipeline is to determine automatically which parts of a multi-stage
      process needs to be run and in what order in order to reach an objective ("targets")

      Computational pipelines, especially for analysing large scientific datasets are
      in widespread use.
      However, even a conceptually simple series of steps can be difficult to set up and
      maintain.

  ***************************************
  Design
  ***************************************
      The ruffus module has the following design goals:

          * Lightweight
          * Scalable / Flexible / Powerful
          * Standard Python
          * Unintrusive
          * As simple as possible

  ***************************************
  Features
  ***************************************

      Automatic support for

          * Managing dependencies
          * Parallel jobs, including dispatching work to computational clusters
          * Re-starting from arbitrary points, especially after errors (checkpointing)
          * Display of the pipeline as a flowchart
          * Managing complex pipeline topologies


  ***************************************
  A Simple example
  ***************************************

          Use the **@follows(...)** python decorator before the function definitions::

              from ruffus import *
              import sys

              def first_task():
                  print "First task"

              @follows(first_task)
              def second_task():
                  print "Second task"

              @follows(second_task)
              def final_task():
                  print "Final task"




          the ``@follows`` decorator indicate that the ``first_task`` function precedes ``second_task`` in
          the pipeline.

          The canonical Ruffus decorator is ``@transform`` which **transforms** data flowing down a
          computational pipeline from one stage to teh next.

  ********
  Usage
  ********

      Each stage or **task** in a computational pipeline is represented by a python function
      Each python function can be called in parallel to run multiple **jobs**.

      1. Import module::

              import ruffus


      1. Annotate functions with python decorators

      2. Print dependency graph if you necessary

          - For a graphical flowchart in ``jpg``, ``svg``, ``dot``, ``png``, ``ps``, ``gif`` formats::

              pipeline_printout_graph ("flowchart.svg")

          This requires ``dot`` to be installed

          - For a text printout of all jobs ::

              pipeline_printout(sys.stdout)


      3. Run the pipeline::

          pipeline_run()


pkgId: 19be5d59f64b3723175434a94c1b37bf1dae0f7ca20fa1776ed526a76c0cac86
name: python-rules
arch: src
version: 3.3
epoch: 0
release: 1
summary: Awesome Django authorization, without the database
url: http://github.com/dfunckt/django-rules
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5f139051-27f1-4e34-bd23-d4c11a209923
location_href: 00011481-python-rules/python-rules-3.3-1.src.rpm
checksum_type: sha256
description:
  ``rules`` has got you covered. ``rules`` is:
  -   **Documented**, **tested**, **reliable** and **easy to use**.
  -   **Versatile**. Decorate callables to build complex graphs of predicates.
      Predicates can be any type of callable -- simple functions, lambdas,
      methods, callable class objects, partial functions, decorated functions,
      anything really.
  -   **A good Django citizen**. Seamless integration with Django views,
      templates and the Admin for testing for object-level permissions.
  -   **Efficient** and **smart**. No need to mess around with a database to figure
      out whether John really wrote that book.
  -   **Simple**. Dive in the code. You'll need 10 minutes to figure out how it
      works.
  -   **Powerful**. ``rules`` comes complete with advanced features, such as
      invocation context and storage for arbitrary data, skipping evaluation of
      predicates under specific conditions, logging of evaluated predicates and more!


pkgId: 85f724381f16b283ab81d85b5dba350cdedff587d16bfdeafc9def8dbec5af4e
name: python-rustcfg
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Rust cfg expression parser in python
url: https://pagure.io/fedora-rust/python-rustcfg
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b7760f1d-0063-4ca0-9dca-b3b873871d8f
location_href: 00005022-python-rustcfg/python-rustcfg-0.0.2-1.src.rpm
checksum_type: sha256
description:
  - https://doc.rust-lang.org/reference/attributes.html#conditional-compilation
  - https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html
  - https://gitlab.com/kornelski/parse_cfg
  - https://pagure.io/fedora-rust/rust2rpm


pkgId: 4c1eb5d6fb1ca925b63b5c15e5b7832388293a8d906189e868f21b7d73f026e7
name: python-rxjson
arch: src
version: 0.3
epoch: 0
release: 1
summary: JSON RX Schema validation tool
url: https://github.com/spiral-project/rxjson
rpm_license: GPLv2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e1a77bde-d47b-444f-ac5d-5692899abc70
location_href: 00005025-python-rxjson/python-rxjson-0.3-1.src.rpm
checksum_type: sha256
description:
  When adding an API to your web service, you have to choose how to encode the
  data you send across the line. XML is one common choice for this, but it can
  grow arcane and cumbersome pretty quickly. Lots of webservice authors want to
  avoid thinking about XML, and instead choose formats that provide a few simple
  data types that correspond to common data structures in modern programming
  languages. In other words, JSON and YAML.
  Unfortunately, while these formats make it easy to pass around complex data
  structures, they lack a system for validation. XML has XML Schemas and RELAX
  NG, but these are complicated and sometimes confusing standards. They're not
  very portable to the kind of data structure provided by JSON, and if you wanted
  to avoid XML as a data encoding, writing more XML to validate the first XML is
  probably even less appealing.
  Rx is meant to provide a system for data validation that matches up with
  JSON-style data structures and is as easy to work with as JSON itself.


pkgId: ac668ca3f7ba83ad8ce191a8051088da880a42170be9048cdf79e305b8e1ec5e
name: python-ryu
arch: src
version: 4.34
epoch: 0
release: 1
summary: Component-based Software-defined Networking Framework
url: http://osrg.github.io/ryu/
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-663e0444-8813-4e51-ba5d-16ebc957f325
location_href: 00005026-python-ryu/python-ryu-4.34-1.src.rpm
checksum_type: sha256
description:
  Ryu is a component-based software defined networking framework.
  Ryu provides software components with well defined API's that make it
  easy for developers to create new network management and control
  applications. Ryu supports various protocols for managing network
  devices, such as OpenFlow, Netconf, OF-config, etc. About OpenFlow,
  Ryu supports fully 1.0, 1.2, 1.3, 1.4, 1.5 and Nicira Extensions.
  All of the code is freely available under the Apache 2.0 license. Ryu
  is fully written in Python.


pkgId: 761df865a85a81b914b00ddec4e674a17fddb379d4785758c356433fec092712
name: python-s2sphere
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: Python implementation of the S2 Geometry Library
url: http://s2sphere.readthedocs.io
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eeba5c6e-641b-4e8e-ab6a-680720be0d4b
location_href: 00010691-python-s2sphere/python-s2sphere-0.2.5-1.src.rpm
checksum_type: sha256
description:
  Python implementation of a part of the C++ `S2 geometry library <https://code.google.com/p/s2-geometry-library/>`_.
  Links: `Documentation <http://s2sphere.readthedocs.io>`_,
  `GitHub <https://github.com/sidewalklabs/s2sphere>`_,
  `Issue Tracker <https://github.com/sidewalklabs/s2sphere/issues>`_
  Install with:
      pip install s2sphere
  Quick set up for development (see the `Developing section in the docs <http://s2sphere.readthedocs.io/en/latest/dev.html>`_ for more details):
      pip install .[tests]
      nosetests -vv


pkgId: 998723ff787245e959fbc41d1ec569a16278b3777bbe76b8c1c7c34d368fff92
name: python-s3cmd
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: Command line tool for managing Amazon S3 and CloudFront services
url: http://s3tools.org
rpm_license: GNU GPL v2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-97dc119e-2944-426e-802e-908aede90115
location_href: 00009460-python-s3cmd/python-s3cmd-2.3.0-1.src.rpm
checksum_type: sha256
description:
      Florent Viard <florent@sodria.com>
      Michal Ludvig  <michal@logix.cz>
      Matt Domsch (github.com/mdomsch)


pkgId: e8642c62f81f98c3c49f1d26b1ebdb4fc6f4ceb51050cfe83ec1a389f2656eaf
name: python-s3path
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/liormizr/s3path
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3bbafbc2-0d50-4599-981a-e8d594e65fa0
location_href: 00013635-python-s3path/python-s3path-0.4.1-1.src.rpm
checksum_type: sha256
description:
  S3Path provide a Python convenient File-System/Path like interface for AWS S3 Service using boto3 S3 resource as a driver.
  Like pathlib, but for S3 Buckets
  ________________________________
  AWS S3 is among the most popular cloud storage solutions. It's object storage, is built to store and retrieve various amounts of data from anywhere.
  Currently, Python developers use Boto3 as the default API to connect / put / get / list / delete files from S3.
  S3Path blends Boto3's ease of use and the familiarity of pathlib api.


pkgId: 3a542eeb176f3c0ef02ddab8146cd7b1f9fc03a05420959713864f572c4506c1
name: python-sacred
arch: src
version: 0.8.4
epoch: 0
release: 1
summary: Facilitates automated and reproducible experimental research
url: https://github.com/IDSIA/sacred
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0a91b707-d80d-4ed0-81d9-bfefeb5c2561
location_href: 00013603-python-sacred/python-sacred-0.8.4-1.src.rpm
checksum_type: sha256
description:
      | *Every experiment is sacred*
      | *Every experiment is great*
      | *If an experiment is wasted*
      | *God gets quite irate*
  |pypi| |py_versions| |license| |rtfd| |doi|
  |build| |coverage| |code_quality| |black|
  Sacred is a tool to help you configure, organize, log and reproduce experiments.
  It is designed to do all the tedious overhead work that you need to do around
  your actual experiment in order to:
  - keep track of all the parameters of your experiment
  - easily run your experiment for different settings
  - save configurations for individual runs in a database
  - reproduce your results
  Sacred achieves this through the following main mechanisms:
  -  **Config Scopes** A very convenient way of the local variables in a function
     to define the parameters your experiment uses.
  -  **Config Injection**: You can access all parameters of your configuration
     from every function. They are automatically injected by name.
  -  **Command-line interface**: You get a powerful command-line interface for each
     experiment that you can use to change parameters and run different variants.
  -  **Observers**: Sacred provides Observers that log all kinds of information
     about your experiment, its dependencies, the configuration you used,
     the machine it is run on, and of course the result. These can be saved
     to a MongoDB, for easy access later.
  -  **Automatic seeding** helps controlling the randomness in your experiments,
     such that the results remain reproducible.


pkgId: ffdbc0bd7ff4d44fd043bb9a0b1ce0049d37244526fd822608311425339cf260
name: python-sailthru-client
arch: src
version: 2.3.5
epoch: 0
release: 1
summary: Python client for Sailthru API
url: https://github.com/sailthru/sailthru-python-client
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-87be171a-0e32-4a4e-8912-c97cc0953715
location_href: 00011508-python-sailthru-client/python-sailthru-client-2.3.5-1.src.rpm
checksum_type: sha256
description:
  For installation instructions, documentation, and examples please visit:
  [http://getstarted.sailthru.com/new-for-developers-overview/api-client-library/python](http://getstarted.sailthru.com/new-for-developers-overview/api-client-library/python)
  A simple client library to remotely access the `Sailthru REST API` as per [http://getstarted.sailthru.com/api](http://getstarted.sailthru.com/developers/api)
  Python binding for [Sailthru API](http://getstarted.sailthru.com/api) based on [Requests](http://docs.python-requests.org/en/latest/)
  It will make requests in `JSON` format.
  Supports Python 2.6, 2.7, 3.3+

  Installing with [pip](http://www.pip-installer.org/):
      pip install sailthru-client

  Install tox and then type:
      tox

  Here is an example how to check rate limiting and throttle API calls based on that. For more information about Rate Limiting, see [Sailthru Documentation](https://getstarted.sailthru.com/new-for-developers-overview/api/api-technical-details/#Rate_Limiting)
  ```python
  sailthru_client = SailthruClient(api_key, api_secret)

  rate_limit_info = sailthru_client.get_last_rate_limit_info('user', 'POST')

  if rate_limit_info is not None:
      limit = rate_limit_info['limit'];
      remaining = rate_limit_info['remaining'];
      reset_timestamp = rate_limit_info['reset'];
      
      if remaining <= 0:
           seconds_till_reset = reset_timestamp - time.time()
           
           time.sleep(seconds_till_reset);
  ```


pkgId: 0aa8860944d2c64cfa7e15a8c7da7aaf1ef227db26288f14335acf78bd4cac31
name: python-salesforce-api
arch: src
version: 0.1.45
epoch: 0
release: 1
summary: Salesforce API wrapper
url: https://github.com/felixlindstrom/python-salesforce-api
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-16801a29-99cf-43fe-a77e-96abda7df82d
location_href: 00012575-python-salesforce-api/python-salesforce-api-0.1.45-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/felixlindstrom/python-salesforce-api.svg?branch=master)](https://travis-ci.org/felixlindstrom/python-salesforce-api)
  This project aims to provide an easy to use, highly flexible and testable solution for communicating with Salesforce
  through its REST and SOAP api.


pkgId: ece074fa6eb1d7b3e8ee7872eb1e614e1cb8da49c4e05728e0f3e5bbe23ea96c
name: python-samba
arch: src
version: 0.0.0
epoch: 0
release: 1
summary: A very small PaaS to do git push app deployments to your own servers, similar to Heroku
url: https://github.com/mardix/samba/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3933f7b5-eebf-448e-9735-ccd7651f49c7
location_href: 00005028-python-samba/python-samba-0.0.0-1.src.rpm
checksum_type: sha256
description:
  Samba

  A small PAAS to deploy Flask/Django, Node, PHP and Static HTML sites using GIT, similar to Heroku

  https://github.com/mardix/samba/


pkgId: d1dba78b60feb32073ec5d5624741011df4dc4d4ca34d49be7a3c218a4eff446
name: python-sanic
arch: src
version: 23.3.0
epoch: 0
release: 1
summary: A web server and web framework that's written to go fast. Build fast. Run fast.
url: http://github.com/sanic-org/sanic/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dc887b13-14a2-48eb-a8f7-97d1914335a9
location_href: 00009237-python-sanic/python-sanic-23.3.0-1.src.rpm
checksum_type: sha256
description:
      * - Build
        - | |Py310Test| |Py39Test| |Py38Test| |Py37Test|
      * - Docs
        - | |UserGuide| |Documentation|
      * - Package
        - | |PyPI| |PyPI version| |Wheel| |Supported implementations| |Code style black|
      * - Support
        - | |Forums| |Discord| |Awesome|
      * - Stats
        - | |Downloads| |WkDownloads| |Conda downloads|
  Sanic is a **Python 3.7+** web server and web framework that's written to go fast. It allows the usage of the ``async/await`` syntax added in Python 3.5, which makes your code non-blocking and speedy.
  Sanic is also ASGI compliant, so you can deploy it with an `alternative ASGI webserver <https://sanicframework.org/en/guide/deployment/running.html#asgi>`_.
  `Source code on GitHub <https://github.com/sanic-org/sanic/>`_ | `Help and discussion board <https://community.sanicframework.org/>`_ | `User Guide <https://sanicframework.org>`_ | `Chat on Discord <https://discord.gg/FARQzAEMAA>`_
  The project is maintained by the community, for the community. **Contributions are welcome!**
  The goal of the project is to provide a simple way to get up and running a highly performant HTTP server that is easy to build, to expand, and ultimately to scale.


pkgId: 488af7c58e67dfa9922d8e699862fdb1df87bd31c12b25e76136270129de7e84
name: python-sanic-jwt
arch: src
version: 1.8.0
epoch: 0
release: 1
summary: JWT oauth flow for Sanic
url: https://github.com/ahopkins/sanic-jwt
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d3fb3a35-2bb0-4055-8b57-743feda82909
location_href: 00012180-python-sanic-jwt/python-sanic-jwt-1.8.0-1.src.rpm
checksum_type: sha256
description:
  **What do I do?**
  It's easy: (1) install, (2) initialize, and (3) authenticate.
  **Install:**
  ```
  pip install sanic-jwt
  ```
    [Sanic]: http://sanic.readthedocs.io
    [JWT]: https://jwt.io
  **Initialize:**
  ```python
  from sanic import Sanic
  from sanic_jwt import Initialize
  def my_authenticate(request, *args, **kwargs):
  app = Sanic()
  Initialize(
      app,
      authenticate=my_authenticate
  )
  ```
  **Authenticate:**


pkgId: ac2fc0e188070376af399d2b66d673775f102564d0b5852594301ebe8ff9088a
name: python-sanic-openapi
arch: src
version: 21.12.0
epoch: 0
release: 1
summary: Easily document your Sanic API with a UI.
url: http://github.com/sanic-org/sanic-openapi/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-69fde657-47b4-48fc-8e6f-3dcab0052b87
location_href: 00012885-python-sanic-openapi/python-sanic-openapi-21.12.0-1.src.rpm
checksum_type: sha256
description:
  ⚠️ This package is being replaced by [Sanic Extensions](https://sanicframework.org/en/plugins/sanic-ext/getting-started.html). The project will continue to be monitored, but no new features or major development is anticipated. Sanic Extensions contains a near 1:1 upgrade if you are using Sanic OpenAPI with OAS3. Ask in the [forums](https://community.sanicframework.org/) or [discord server](https://discord.gg/FARQzAEMAA) for questions about upgrading.



  [![Build Status](https://travis-ci.com/sanic-org/sanic-openapi.svg?branch=master)](https://travis-ci.com/sanic-org/sanic-openapi)
  [![PyPI](https://img.shields.io/pypi/v/sanic-openapi.svg)](https://pypi.python.org/pypi/sanic-openapi/)
  [![PyPI](https://img.shields.io/pypi/pyversions/sanic-openapi.svg)](https://pypi.python.org/pypi/sanic-openapi/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/python/black)
  [![codecov](https://codecov.io/gh/sanic-org/sanic-openapi/branch/master/graph/badge.svg)](https://codecov.io/gh/sanic-org/sanic-openapi)

  Give your Sanic API a UI and OpenAPI documentation, all for the price of free!

  ![Example Swagger UI](docs/_static/images/code-to-ui.png?raw=true "Swagger UI")

  Check out [open collective](https://opencollective.com/sanic-org) to learn more about helping to fund Sanic.




  ```shell
  pip install sanic-openapi
  ```

  Add Swagger UI with the OpenAPI spec:

  ```python
  from sanic_openapi import swagger_blueprint

  app.blueprint(swagger_blueprint)
  ```

  You'll now have a Swagger UI at the URL `/swagger/` and an OpenAPI 2.0 spec at `/swagger/swagger.json`.
  Your routes will be automatically categorized by their blueprints.



  Here is an example to use Sanic-OpenAPI 2:

  ```python
  from sanic import Sanic
  from sanic.response import json
  from sanic_openapi import openapi2_blueprint

  app = Sanic(name="AwesomeApi")
  app.blueprint(openapi2_blueprint)


  @app.route("/")
  async def test(request):
      return json({"hello": "world"})


  if __name__ == "__main__":
      app.run(host="0.0.0.0", port=8000)

  ```

  And you can get your Swagger document at <http://localhost:8000/swagger> like this:
  ![](docs/_static/images/hello_world_example.png)




  Here is an example to use Sanic-OpenAPI 3:

  ```python
  from sanic import Sanic
  from sanic.response import json
  from sanic_openapi import openapi3_blueprint

  app = Sanic(name="AwesomeApi")
  app.blueprint(openapi3_blueprint)


  @app.route("/")
  async def test(request):
      return json({"hello": "world"})


  if __name__ == "__main__":
      app.run(host="0.0.0.0", port=8000)

  ```

  And you can get your Swagger document at <http://localhost:8000/swagger> like this:
  ![](docs/_static/images3/hello_world_example.png)



  Please check the documentation on [Readthedocs](https://sanic-openapi.readthedocs.io)



  Any contribution is welcome. If you don't know how to getting started, please check issues first and check our [Contributing Guide](CONTRIBUTING.md) to start you contribution.


pkgId: feba672ae6c8aa97b487f1259f8b9b4d1ef383fbf47beb7629f574e2bc7489c7
name: python-sanic-routing
arch: src
version: 22.8.0
epoch: 0
release: 1
summary: Core routing component for Sanic
url: https://github.com/sanic-org/sanic-routing/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-845f4888-49a9-4c60-8105-c9401a1715e0
location_href: 00009317-python-sanic-routing/python-sanic-routing-22.8.0-1.src.rpm
checksum_type: sha256
description:
  Beginning in v21.3, Sanic makes use of this new AST-style router in two use cases:

  1. Routing paths; and
  2. Routing signals.

  Therefore, this package comes with a `BaseRouter` that needs to be subclassed in order to be used for its specific needs.

  Most Sanic users should never need to concern themselves with the details here.



  A simple implementation:

  ```python
  import logging

  from sanic_routing import BaseRouter

  logging.basicConfig(level=logging.DEBUG)


  class Router(BaseRouter):
      def get(self, path, *args, **kwargs):
          return self.resolve(path, *args, **kwargs)


  router = Router()

  router.add("/<foo>", lambda: ...)
  router.finalize()
  router.tree.display()
  logging.info(router.find_route_src)

  route, handler, params = router.get("/matchme", method="BASE", extra=None)
  ```

  The above snippet uses `router.tree.display()` to show how the router has decided to arrange the routes into a tree. In this simple example:

  ```
  <Node: level=0>
      <Node: part=__dynamic__:str, level=1, groups=[<RouteGroup: path=<foo:str> len=1>], dynamic=True>
  ```

  We can can see the code that the router has generated for us. It is available as a string at `router.find_route_src`.

  ```python
  def find_route(path, method, router, basket, extra):
      parts = tuple(path[1:].split(router.delimiter))
      num = len(parts)

      
      if num == 1:  # CHECK 1
          try:
              basket['__matches__'][0] = str(parts[0])
          except ValueError:
              pass
          else:
              
              return router.dynamic_routes[('<__dynamic__:str>',)][0], basket
      raise NotFound
  ```

  _FYI: If you are on Python 3.9, you can see a representation of the source after compilation at `router.find_route_src_compiled`_



  Therefore, in general implementation requires you to:

  1. Define a router with a `get` method;
  2. Add one or more routes;
  3. Finalize the router (`router.finalize()`); and
  4. Call the router's `get` method.

  _NOTE: You can call `router.finalize(False)` if you do not want to compile the source code into executable form. This is useful if you only intend to review the generated output._

  Every time you call `router.add` you create one (1) new `Route` instance. Even if that one route is created with multiple methods, it generates a single instance. If you `add()` another `Route` that has a similar path structure (but, perhaps has differen methods) they will be grouped together into a `RouteGroup`. It is worth also noting that a `RouteGroup` is created the first time you call `add()`, but subsequent similar routes will reuse the existing grouping instance.


  When you call `finalize()`, it is taking the defined route groups and arranging them into "nodes" in a hierarchical tree. A single node is a path segment. A `Node` instance can have one or more `RouteGroup` on it where the `Node` is the termination point for that path.

  Perhaps an example is easier:

  ```python
  router.add("/path/to/<foo>", lambda: ...)
  router.add("/path/to/<foo:int>", lambda: ...)
  router.add("/path/to/different/<foo>", lambda: ...)
  router.add("/path/to/different/<foo>", lambda: ..., methods=["one", "two"])
  ```

  The generated `RouteGroup` instances (3):

  ```
  <RouteGroup: path=path/to/<foo:str> len=1>
  <RouteGroup: path=path/to/<foo:int> len=1>
  <RouteGroup: path=path/to/different/<foo:str> len=2>
  ```

  The generated `Route` instances (4):

  ```
  <Route: path=path/to/<foo:str>>
  <Route: path=path/to/<foo:int>>
  <Route: path=path/to/different/<foo:str>>
  <Route: path=path/to/different/<foo:str>>
  ```

  The Node Tree:

  ```
  <Node: level=0>
      <Node: part=path, level=1>
          <Node: part=to, level=2>
              <Node: part=different, level=3>
                  <Node: part=__dynamic__:str, level=4, groups=[<RouteGroup: path=path/to/different/<foo:str> len=2>], dynamic=True>
              <Node: part=__dynamic__:int, level=3, groups=[<RouteGroup: path=path/to/<foo:int> len=1>], dynamic=True>
              <Node: part=__dynamic__:str, level=3, groups=[<RouteGroup: path=path/to/<foo:str> len=1>], dynamic=True>
  ```

  And, the generated source code:

  ```python
  def find_route(path, method, router, basket, extra):
      parts = tuple(path[1:].split(router.delimiter))
      num = len(parts)

      
      if num > 1:  # CHECK 1
          if parts[0] == "path":  # CHECK 4

              
              if num > 2:  # CHECK 1
                  if parts[1] == "to":  # CHECK 4

                      
                      if num > 3:  # CHECK 1
                          if parts[2] == "different":  # CHECK 4

                              
                              if num == 4:  # CHECK 1
                                  try:
                                      basket['__matches__'][3] = str(parts[3])
                                  except ValueError:
                                      pass
                                  else:
                                      if method in frozenset({'one', 'two'}):
                                          route_idx = 0
                                      elif method in frozenset({'BASE'}):
                                          route_idx = 1
                                      else:
                                          raise NoMethod
                                      
                                      return router.dynamic_routes[('path', 'to', 'different', '<__dynamic__:str>')][route_idx], basket

                      
                      if num >= 3:  # CHECK 1
                          try:
                              basket['__matches__'][2] = int(parts[2])
                          except ValueError:
                              pass
                          else:
                              if num == 3:  # CHECK 5
                                  
                                  return router.dynamic_routes[('path', 'to', '<__dynamic__:int>')][0], basket

                      
                      if num >= 3:  # CHECK 1
                          try:
                              basket['__matches__'][2] = str(parts[2])
                          except ValueError:
                              pass
                          else:
                              if num == 3:  # CHECK 5
                                  
                                  return router.dynamic_routes[('path', 'to', '<__dynamic__:str>')][0], basket
      raise NotFound
  ```



  The above example only shows routes that have a dynamic path segment in them (example: `<foo>`). But, there are other use cases that are covered differently:

  1. *fully static paths* - These are paths with no parameters (example: `/user/login`). These are basically matched against a key/value store.
  2. *regex paths* - If a route as a single regular expression match, then the whole route will be matched via regex. In general, this happens inline not too dissimilar than what we see in the above example.
  3. *special regex paths* - The router comes with a special `path` type (example: `<foo:path>`) that can match on an expanded delimiter. This is also true for any regex that uses the path delimiter in it. These cannot be matched in the normal course since they are of unknown length.


pkgId: bfe0e16f44c3ab7de386e50fb3da456c3b4904eed5558f67428679c36c5be00c
name: python-saspy
arch: src
version: 5.0.2
epoch: 0
release: 1
summary: A Python interface to SAS
url: https://github.com/sassoftware/saspy
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2d54bf51-d61a-477f-8200-fffdbdb64916
location_href: 00013163-python-saspy/python-saspy-5.0.2-1.src.rpm
checksum_type: sha256
description:
  ![224493-SASPy-logo-OL-01](https://user-images.githubusercontent.com/17710182/171252212-4af121a6-72d9-4234-b6cf-2a0d31eb8bf7.png)


  This package provides interfaces between Python and SAS. This package enables a Python developer to create mixed Python/SAS workflows to leverage the
  powers of both SAS and Python, by connecting a Python process to any of a variety of SAS deployments, where it will run SAS code. The SAS code is
  generated by the SASPy object and methods or explicitly user written. Results from SAS are returned as text, HTML5 documents (via SAS ODS), or as
  Pandas Data Frames. This package supports running analytics and returning the resulting graphics and result data to the Python process. It can convert
  data representations between SAS Data Sets and Pandas Data Frames.

  This package has multiple access methods which allow it to connect to local or remote Linux SAS, IOM SAS on Windows, Linux (Including Grid Manager),
  or MVS, and local PC SAS. It can run within various Notebooks platforms, or IDE's/UI's or in interactive line mode Python or in Python batch scripts.

  It is expected that the user community can, and will, contribute enhancements.


  [![OpenSSF Best Practices](https://bestpractices.coreinfrastructure.org/projects/6716/badge)](https://bestpractices.coreinfrastructure.org/projects/6716)


  - Python3.x or above
  - SAS 9.4 or above
  - SAS Viya 3 or above


  - Linux SAS: local or remote, including Grid Manager
  - Windows SAS: local or remote
  - MVS SAS: remote
  - Jupyter, Databricks and/or Zeppelin Notebooks
  - Interactive Line mode, Python IDE's or other UI's
  - Batch Python scripts



  This package can be installed via pip or Conda. This will pull down the latest PyPI package and install it.

      pip install saspy

  However, if that's too easy, you can also download a specific release from
  [SASpy project releases page](https://github.com/sassoftware/saspy/releases), or just clone
  the repo and and instll from that. To install a given release, use the following,
  where the X.X.X is the release version you want.

      pip install https://github.com/sassoftware/saspy/archive/vX.X.X.tar.gz



  All of the doc, including install and configuration information can be found at
  [sassoftware.github.io/saspy](https://sassoftware.github.io/saspy/).

  Also, example Notebooks and use cases can be found at
  [sassoftware/saspy-examples](https://github.com/sassoftware/saspy-examples/).


  The [Contributing](https://github.com/sassoftware/saspy/blob/main/CONTRIBUTING.md) file explains the rules and conventions to follow while
  Contributing to this project. It also contains the **Contributor Agreement** instructions.


  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of
  the License at [LICENSE.txt](https://github.com/sassoftware/saspy/blob/main/LICENSE.md)

  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES
  OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


  - [Python Website](http://www.python.org/)
  - [SASPy Documentation](https://sassoftware.github.io/saspy/).
  - [SASPy Examples](https://github.com/sassoftware/saspy-examples)


pkgId: f036dc8aea01fea38eb70d81fbcffbd93717bce1388ea0da9e1c72335a5d9773
name: python-sbvirtualdisplay
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: A customized pyvirtualdisplay for SeleniumBase.
url: https://github.com/mdmintz/sbVirtualDisplay
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e56cd4e7-9992-451c-94bd-cffea4610560
location_href: 00012368-python-sbvirtualdisplay/python-sbvirtualdisplay-1.2.0-1.src.rpm
checksum_type: sha256
description:
  A customized [pyvirtualdisplay](https://github.com/ponty/PyVirtualDisplay) for use with [SeleniumBase](https://github.com/seleniumbase/SeleniumBase) automation.



  ```python
  from sbvirtualdisplay import Display

  display = Display(visible=0, size=(1440, 1880))
  display.start()



  display.stop()
  ```



  ```python
  with Display(visible=0, size=(1440, 1880)):
      
      ...
  ```



  If you need to run browser tests on a headless machine (such as a Linux backend), and you can't use a browser's headless mode (such as Chrome's headless mode), then this may help. For example, Chrome does not allow extensions in headless mode, so if you need to run automated tests on a headless Linux machine and you need to use Chrome extensions, then this will let you run those tests using a virtual display.




  * [Xvfb](https://en.wikipedia.org/wiki/Xvfb) is required for this to work.


pkgId: 6944e40cee29c1fdd90911bcbed52c89e63e84e1b0cedb7e7b8b65ac481ba6f7
name: python-scalecodec
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: Python SCALE Codec Library
url: https://github.com/polkascan/py-scale-codec
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6c568c9c-7eb4-45be-9989-2e618571efba
location_href: 00013685-python-scalecodec/python-scalecodec-1.2.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://img.shields.io/github/actions/workflow/status/polkascan/py-scale-codec/unittests.yml?branch=master)](https://github.com/polkascan/py-scale-codec/actions/workflows/unittests.yml?query=workflow%3A%22Run+unit+tests%22)
  [![Latest Version](https://img.shields.io/pypi/v/scalecodec.svg)](https://pypi.org/project/scalecodec/)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/scalecodec.svg)](https://pypi.org/project/scalecodec/)
  [![License](https://img.shields.io/pypi/l/scalecodec.svg)](https://github.com/polkascan/py-scale-codec/blob/master/LICENSE)



  [Substrate](https://github.com/paritytech/substrate) uses a lightweight and efficient [encoding and decoding program](https://docs.substrate.io/reference/scale-codec/) to optimize how data is sent and received over the network. The program used to serialize and deserialize data is called the SCALE codec, with SCALE being an acronym for **S**imple **C**oncatenated **A**ggregate **L**ittle-**E**ndian.


  https://polkascan.github.io/py-scale-codec/



  ```bash
  pip install scalecodec
  ```



  | Type                                                                         | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Example SCALE decoding value                                                | SCALE encoded value                                                             |
  |------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------|---------------------------------------------------------------------------------|
  | `bool`                                                                       | Boolean values are encoded using the least significant bit of a single byte.                                                                                                                                                                                                                                                                                                                                                                                                         | `True`                                                                      | `0x01`                                                                          |
  | `u16`                                                                        | Basic integers are encoded using a fixed-width little-endian (LE) format.                                                                                                                                                                                                                                                                                                                                                                                                            | `42`                                                                        | `0x2a00`                                                                        |
  | `Compact`                                                                    | A "compact" or general integer encoding is sufficient for encoding large integers (up to 2**536) and is more efficient at encoding most values than the fixed-width version. (Though for single-byte values, the fixed-width integer is never worse.)                                                                                                                                                                                                                                | `0`                                                                         | `0x00`                                                                          |
  |                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `1`                                                                         | `0x04`                                                                          |
  |                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `42`                                                                        | `0xa8`                                                                          |
  |                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `69`                                                                        | `0x1501`                                                                        |
  |                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `100000000000000`                                                           | `0x0b00407a10f35a`                                                              |
  | `Vec`                                                                        | A collection of same-typed values is encoded, prefixed with a compact encoding of the number of items, followed by each item's encoding concatenated in turn.                                                                                                                                                                                                                                                                                                                        | `[4, 8, 15, 16, 23, 42]`                                                    | `0x18040008000f00100017002a00`                                                  |
  | `BitVec`                                                                     | A sequence of bools, represented in a more space efficient bit format                                                                                                                                                                                                                                                                                                                                                                                                             | `0b00000010_01111101`                                                    | `0x287d02`                                                  |
  | `str`,`Bytes`, `String`                                                      | Strings are Vectors of bytes (`Vec<u8>`) containing a valid UTF8 sequence.                                                                                                                                                                                                                                                                                                                                                                                                           | `"Test"`                                                                    | `0x1054657374`                                                                  |
  |                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `b"Test"`                                                                   | `0x1054657374`                                                                  |
  |                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `[84, 101, 115, 116]`                                                       | `0x1054657374`                                                                  |
  | `[u8; 4]`                                                                    | Fixed sized array of in this case an `u8`                                                                                                                                                                                                                                                                                                                                                                                                                                            | `b"babe"`                                                                   | `0x62616265`                                                                    |
  |                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `"0x62616265"`                                                              | `0x62616265`                                                                    |
  |                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `[98, 97, 98, 101]`                                                         | `0x62616265`                                                                    |
  | `AccountId`                                                                  | An [SS58 formatted](https://docs.substrate.io/reference/address-formats/) representation of an account. See also the [SS58 util functions](https://polkascan.github.io/py-scale-codec/utils/ss58.html)                                                                                                                                                                                                                                                                               | `"5GDyPHLVHcQYPTWfygtPY eogQjyZy7J9fsi4brPhgEFq4pcv"`                       | `0xb80269ec500e458a630846b99105c397 ee574125823d6f4388e9c7572e115c05`           |
  | `Enum` Example: `enum IntOrBool { Int(u8), Bool(bool),}`                     | A fixed number of variants, each mutually exclusive and potentially implying a further value or series of values. Encoded as the first byte identifying the index of the variant that the value is. Any further bytes are used to encode any data that the variant implies. Thus, no more than 256 variants are supported.                                                                                                                                                           | `{'Int': 8}`                                                                | `0x002a`                                                                        |
  |                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `{'Bool': True}`                                                            | `0x0101`                                                                        |
  | `Struct` Example: `struct Motion { pub votes: Vec<AccountId>, pub id: u32 }` | For structures, the values are named, but that is irrelevant for the encoding (names are ignored - only order matters). All containers store elements consecutively. The order of the elements is not fixed, depends on the container, and cannot be relied on at decoding. This implicitly means that decoding some byte-array into a specified structure that enforces an order and then re-encoding it could result in a different byte array than the original that was decoded. | `{"votes": ["5GDyPHLVHcQYPTWfygtPYeo gQjyZy7J9fsi4brPhgEFq4pcv"], "id": 4}` | `0x04b80269ec500e458a630846b99105c397ee57 4125823d6f4388e9c7572e115c0504000000` |


  https://github.com/polkascan/py-scale-codec/blob/master/LICENSE


pkgId: 750d86f5e9a2d6c46d73e47f4bc5c239046c8ef3148da7b89a437407d2978352
name: python-scan-build
arch: src
version: 2.0.20
epoch: 0
release: 1
summary: static code analyzer wrapper for Clang.
url: https://github.com/rizsotto/scan-build
rpm_license: LICENSE.txt
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0bc77039-b179-4b62-ac15-5f14ff7058f0
location_href: 00010988-python-scan-build/python-scan-build-2.0.20-1.src.rpm
checksum_type: sha256
description:
  A package designed to wrap a build so that all calls to gcc/clang are
  intercepted and logged into a `compilation database`_ and/or piped to
  the clang static analyzer. Includes intercept-build tool, which logs
  the build, as well as scan-build tool, which logs the build and runs
  the clang static analyzer on it.


pkgId: 8b3b15fe8603e7fa3033de004082eaa4dad9a263a53017fe2ff1639b2313222e
name: python-scandir
arch: src
version: 1.10.0
epoch: 0
release: 1
summary: scandir, a better directory iterator and faster os.walk()
url: https://github.com/benhoyt/scandir
rpm_license: New BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dabfc3c6-3e87-4d11-9b9c-a8171a5939ea
location_href: 00009227-python-scandir/python-scandir-1.10.0-1.src.rpm
checksum_type: sha256
description:
  ``scandir()`` is a directory iteration function like ``os.listdir()``,
  except that instead of returning a list of bare filenames, it yields
  ``DirEntry`` objects that include file type and stat information along
  with the name. Using ``scandir()`` increases the speed of ``os.walk()``
  by 2-20 times (depending on the platform and file system) by avoiding
  unnecessary calls to ``os.stat()`` in most cases.


pkgId: fd64647f2abffc972af227fbe7aacb4fb76dba746ceb6ca512ae843af1d70c5b
name: python-scandir-debuginfo
arch: x86_64
version: 1.10.0
epoch: 0
release: 1
summary: Debug information for package python-scandir
url: https://github.com/benhoyt/scandir
rpm_license: New BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-dabfc3c6-3e87-4d11-9b9c-a8171a5939ea
rpm_sourcerpm: python-scandir-1.10.0-1.src.rpm
location_href: 00009227-python-scandir/python-scandir-debuginfo-1.10.0-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-scandir.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 58627b956b897b69bff43c2778eb8ebc4c880a5c15f56be683e6686446d4f9cb
name: python-scandir-debugsource
arch: x86_64
version: 1.10.0
epoch: 0
release: 1
summary: Debug sources for package python-scandir
url: https://github.com/benhoyt/scandir
rpm_license: New BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-dabfc3c6-3e87-4d11-9b9c-a8171a5939ea
rpm_sourcerpm: python-scandir-1.10.0-1.src.rpm
location_href: 00009227-python-scandir/python-scandir-debugsource-1.10.0-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-scandir.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 8f66fdc47238f0e2e6d276a3a7fbb1cf5eb7a052478d59078f05fd6c8e9a9a69
name: python-scanless
arch: src
version: 2.1.6
epoch: 0
release: 1
summary: An online port scan scraper.
url: https://github.com/vesche/scanless
rpm_license: Unlicense
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8d37f7b0-2480-42bf-8f42-6b4d25b741df
location_href: 00005036-python-scanless/python-scanless-2.1.6-1.src.rpm
checksum_type: sha256
description:
  This is a Python 3 command-line utility and library for using websites that can perform port scans on your behalf.



  * [hackertarget](https://hackertarget.com/nmap-online-port-scanner/)
  * [ipfingerprints](http://www.ipfingerprints.com/portscan.php)
  * [spiderip](https://spiderip.com/online-port-scan.php)
  * [standingtech](https://portscanner.standingtech.com/)
  * [viewdns](http://viewdns.info/)
  * [yougetsignal](http://www.yougetsignal.com/tools/open-ports/)



  Do it up:
  ```
  $ pip install scanless --user
  ```



  ```
  $ scanless --help
  usage: scanless [-h] [-v] [-t TARGET] [-s SCANNER] [-r] [-l] [-a]

  scanless, an online port scan scraper.

  optional arguments:
    -h, --help            show this help message and exit
    -v, --version         display the current version
    -t TARGET, --target TARGET
                          ip or domain to scan
    -s SCANNER, --scanner SCANNER
                          scanner to use (default: hackertarget)
    -r, --random          use a random scanner
    -l, --list            list scanners
    -a, --all             use all the scanners
    -d, --debug           debug mode (cli mode off & show network errors)

  $ scanless --list
  +----------------+--------------------------------------+
  | Scanner Name   | Website                              |
  +----------------+--------------------------------------+
  | hackertarget   | https://hackertarget.com             |
  | ipfingerprints | https://www.ipfingerprints.com       |
  | spiderip       | https://spiderip.com                 |
  | standingtech   | https://portscanner.standingtech.com |
  | viewdns        | https://viewdns.info                 |
  | yougetsignal   | https://www.yougetsignal.com         |
  +----------------+--------------------------------------+

  $ scanless -t scanme.nmap.org -s spiderip
  Running scanless v2.1.6...

  spiderip:
  PORT      STATE  SERVICE
  21/tcp    closed ftp
  22/tcp    open   ssh
  25/tcp    closed smtp
  80/tcp    open   http
  110/tcp   closed pop3
  143/tcp   closed imap
  443/tcp   closed https
  465/tcp   closed smtps
  993/tcp   closed imaps
  995/tcp   closed pop3s
  1433/tcp  closed ms-sql-s
  3306/tcp  closed mysql
  3389/tcp  closed ms-wbt-server
  5900/tcp  closed vnc
  8080/tcp  closed http-proxy
  8443/tcp  closed https-alt
  ```



  ```
  >>> import scanless
  >>> sl = scanless.Scanless()
  >>> output = sl.scan('scanme.nmap.org', scanner='hackertarget')
  >>> print(output['raw'])
  Starting Nmap 7.70 ( https://nmap.org ) at 2020-05-12 21:39 UTC
  Nmap scan report for scanme.nmap.org (45.33.32.156)
  Host is up (0.065s latency).
  Other addresses for scanme.nmap.org (not scanned): 2600:3c01::f03c:91ff:fe18:bb2f

  PORT    STATE  SERVICE
  21/tcp  closed ftp
  22/tcp  open   ssh
  80/tcp  open   http
  443/tcp closed https

  Nmap done: 1 IP address (1 host up) scanned in 0.11 seconds
  >>> import json
  >>> print(json.dumps(output['parsed'], indent=2))
  [
    {
      "port": "21",
      "state": "closed",
      "service": "ftp",
      "protocol": "tcp"
    },
    {
      "port": "22",
      "state": "open",
      "service": "ssh",
      "protocol": "tcp"
    },
    {
      "port": "80",
      "state": "open",
      "service": "http",
      "protocol": "tcp"
    },
    {
      "port": "443",
      "state": "closed",
      "service": "https",
      "protocol": "tcp"
    }
  ]
  ```


pkgId: c05544c84c0f6a78c8fe0341b62b019de3357f8af4b6f6db2cdb8c33ed493bfa
name: python-scanless
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: An online port scan scraper.
url: https://github.com/vesche/scanless
rpm_license: Unlicense
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-26ec509e-0980-4acc-807d-269d76734b8a
location_href: 00008365-python-scanless/python-scanless-2.2.1-1.src.rpm
checksum_type: sha256
description:
  This is a Python command-line utility and library for using websites that can perform port scans on your behalf.



  * [ipfingerprints](http://www.ipfingerprints.com/portscan.php)
  * [spiderip](https://spiderip.com/online-port-scan.php)
  * [standingtech](https://portscanner.standingtech.com/)
  * [viewdns](http://viewdns.info/)
  * [yougetsignal](http://www.yougetsignal.com/tools/open-ports/)



  Do it up:
  ```
  $ pip install scanless --user
  ```



  ```
  $ scanless --help
  usage: scanless [-h] [-v] [-t TARGET] [-s SCANNER] [-r] [-l] [-a] [-d]

  scanless, an online port scan scraper.

  options:
    -h, --help            show this help message and exit
    -v, --version         display the current version
    -t TARGET, --target TARGET
                          ip or domain to scan
    -s SCANNER, --scanner SCANNER
                          scanner to use (default: yougetsignal)
    -r, --random          use a random scanner
    -l, --list            list scanners
    -a, --all             use all the scanners
    -d, --debug           debug mode (cli mode off & show network errors)

  $ scanless --list
  +----------------+--------------------------------------+
  | Scanner Name   | Website                              |
  +----------------+--------------------------------------+
  | ipfingerprints | https://www.ipfingerprints.com       |
  | spiderip       | https://spiderip.com                 |
  | standingtech   | https://portscanner.standingtech.com |
  | viewdns        | https://viewdns.info                 |
  | yougetsignal   | https://www.yougetsignal.com         |
  +----------------+--------------------------------------+

  $ scanless -t scanme.nmap.org -s spiderip
  Running scanless v2.2.1 ...

  spiderip:
  PORT      STATE  SERVICE
  21/tcp    closed ftp
  22/tcp    open   ssh
  25/tcp    closed smtp
  80/tcp    open   http
  110/tcp   closed pop3
  143/tcp   closed imap
  443/tcp   closed https
  465/tcp   closed smtps
  993/tcp   closed imaps
  995/tcp   closed pop3s
  1433/tcp  closed ms-sql-s
  3306/tcp  closed mysql
  3389/tcp  closed ms-wbt-server
  5900/tcp  closed vnc
  8080/tcp  closed http-proxy
  8443/tcp  closed https-alt
  ```



  ```
  >>> import scanless
  >>> sl = scanless.Scanless()
  >>> output = sl.scan('scanme.nmap.org', scanner='yougetsignal')
  >>> print(output['raw'])
  PORT      STATE  SERVICE
  21/tcp    closed ftp
  22/tcp    open   ssh
  23/tcp    closed telnet
  25/tcp    closed smtp
  53/tcp    closed domain
  80/tcp    open   http
  110/tcp   closed pop3
  115/tcp   closed sftp
  135/tcp   closed msrpc
  139/tcp   closed netbios-ssn
  143/tcp   closed imap
  194/tcp   closed irc
  443/tcp   closed https
  445/tcp   closed microsoft-ds
  1433/tcp  closed ms-sql-s
  3306/tcp  closed mysql
  3389/tcp  closed ms-wbt-server
  5632/tcp  closed pcanywherestat
  5900/tcp  closed vnc
  6112/tcp  closed dtspc
  >>> import json
  >>> print(json.dumps(output['parsed'], indent=2))
  [
    {
      "port": "21",
      "state": "closed",
      "service": "ftp",
      "protocol": "tcp"
    },
    {
      "port": "22",
      "state": "open",
      "service": "ssh",
      "protocol": "tcp"
    },
    {
      "port": "23",
      "state": "closed",
      "service": "telnet",
      "protocol": "tcp"
    },
    {
      "port": "25",
      "state": "closed",
      "service": "smtp",
      "protocol": "tcp"
    },
    {
      "port": "53",
      "state": "closed",
      "service": "domain",
      "protocol": "tcp"
    },
    {
      "port": "80",
      "state": "open",
      "service": "http",
      "protocol": "tcp"
    },
    ...
  ]
  ```


pkgId: 756939461c9cf4f515b167b0e3e1ff4624ada87a9905fd3fc500c058909a28ef
name: python-scapy
arch: src
version: 2.5.0
epoch: 0
release: 1
summary: Scapy: interactive packet manipulation tool
url: https://scapy.net
rpm_license: GPL-2.0-only
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b862181c-195f-43cf-88f6-c69b15f6f6c5
location_href: 00005037-python-scapy/python-scapy-2.5.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI Version](https://img.shields.io/pypi/v/scapy.svg)](https://pypi.python.org/pypi/scapy/)
  [![License: GPL v2](https://img.shields.io/badge/License-GPL%20v2-blue.svg)](LICENSE)

  Scapy is a powerful Python-based interactive packet manipulation program and
  library.

  It is able to forge or decode packets of a wide number of protocols, send them
  on the wire, capture them, store or read them using pcap files, match requests
  and replies, and much more. It is designed to allow fast packet prototyping by
  using default values that work.

  It can easily handle most classical tasks like scanning, tracerouting, probing,
  unit tests, attacks or network discovery (it can replace `hping`, 85% of `nmap`,
  `arpspoof`, `arp-sk`, `arping`, `tcpdump`, `wireshark`, `p0f`, etc.). It also
  performs very well at a lot of other specific tasks that most other tools can't
  handle, like sending invalid frames, injecting your own 802.11 frames, combining
  techniques (VLAN hopping+ARP cache poisoning, VoIP decoding on WEP protected
  channel, ...), etc.

  Scapy supports Python 2.7 and Python 3 (3.4 to 3.9). It's intended to
  be cross platform, and runs on many different platforms (Linux, OSX,
  \*BSD, and Windows).



  Scapy is usable either as a **shell** or as a **library**.
  For further details, please head over to [Getting started with Scapy](https://scapy.readthedocs.io/en/latest/introduction.html), which is part of the documentation.



  ![Scapy install demo](https://secdev.github.io/files/doc/animation-scapy-install.svg)

  Scapy can easily be used as an interactive shell to interact with the network.
  The following example shows how to send an ICMP Echo Request message to
  `github.com`, then display the reply source IP address:

  ```python
  sudo ./run_scapy
  Welcome to Scapy
  >>> p = IP(dst="github.com")/ICMP()
  >>> r = sr1(p)
  Begin emission:
  .Finished to send 1 packets.
  *
  Received 2 packets, got 1 answers, remaining 0 packets
  >>> r[IP].src
  '192.30.253.113'
  ```



  The [documentation](https://scapy.readthedocs.io/en/latest/) contains more
  advanced use cases, and examples.

  Other useful resources:

  -   [Scapy in 20 minutes](https://github.com/secdev/scapy/blob/master/doc/notebooks/Scapy%20in%2015%20minutes.ipynb)
  -   [Interactive tutorial](https://scapy.readthedocs.io/en/latest/usage.html#interactive-tutorial) (part of the documentation)
  -   [The quick demo: an interactive session](https://scapy.readthedocs.io/en/latest/introduction.html#quick-demo)
  (some examples may be outdated)
  -   [HTTP/2 notebook](https://github.com/secdev/scapy/blob/master/doc/notebooks/HTTP_2_Tuto.ipynb)
  -   [TLS notebooks](https://github.com/secdev/scapy/blob/master/doc/notebooks/tls)



  Scapy works without any external Python modules on Linux and BSD like operating
  systems. On Windows, you need to install some mandatory dependencies as
  described in [the
  documentation](http://scapy.readthedocs.io/en/latest/installation.html#windows).

  On most systems, using Scapy is as simple as running the following commands:

  ```bash
  git clone https://github.com/secdev/scapy
  cd scapy
  ./run_scapy
  ```

  To benefit from all Scapy features, such as plotting, you might want to install
  Python modules, such as `matplotlib` or `cryptography`. See the
  [documentation](http://scapy.readthedocs.io/en/latest/installation.html) and
  follow the instructions to install them.


pkgId: f7b5d580de26879490b36029469d4392a2153c51b7cf6dedc385d37d1af30379
name: python-schedule
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Job scheduling for humans.
url: https://github.com/dbader/schedule
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4288ac3e-723f-42ea-8281-637b04540c18
location_href: 00005038-python-schedule/python-schedule-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Python job scheduling for humans. Run Python functions (or any other callable) periodically using a friendly syntax.
  - A simple to use API for scheduling jobs, made for humans.
  - In-process scheduler for periodic jobs. No extra processes needed!
  - Very lightweight and no external dependencies.
  - Excellent test coverage.
  - Tested on Python and 3.6, 3.7, 3.8, 3.9


pkgId: 26606da96e82cbe745932b478564a2ab1dd085d1cb6b1fabc83f752efcec2816
name: python-schema
arch: src
version: 0.7.5
epoch: 0
release: 1
summary: Simple data validation library
url: https://github.com/keleshev/schema
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-07e3d83f-3857-4ef3-9f8d-a9b1f7ae225d
location_href: 00009532-python-schema/python-schema-0.7.5-1.src.rpm
checksum_type: sha256
description:
  **schema** is a library for validating Python data structures, such as those
  obtained from config-files, forms, external services or command-line
  parsing, converted from JSON/YAML (or something else) to Python data-types.


pkgId: a0d80dfd6817dd8a633675019837973458afe7515f181043c20cac7e55053112
name: python-scikit-optimize
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: Sequential model-based optimization toolbox.
url: https://scikit-optimize.github.io/
rpm_license: BSD 3-clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-50e8cced-ca0b-439c-b91a-5423d735e626
location_href: 00009941-python-scikit-optimize/python-scikit-optimize-0.9.0-1.src.rpm
checksum_type: sha256
description:
  Scikit-Optimize, or ``skopt``, is a simple and efficient library to
  minimize (very) expensive and noisy black-box functions. It implements
  several methods for sequential model-based optimization. ``skopt`` aims
  to be accessible and easy to use in many contexts.
  The library is built on top of NumPy, SciPy and Scikit-Learn.
  We do not perform gradient-based optimization. For gradient-based
  optimization algorithms look at
  ``scipy.optimize``
  `here <http://docs.scipy.org/doc/scipy/reference/optimize.html>`_.
  Approximated objective function after 50 iterations of ``gp_minimize``.
  Plot made using ``skopt.plots.plot_objective``.


pkgId: 364a784febb8d9575d5d1750d042f4b1c5f4d28d5a86f6b6c533de571311df85
name: python-scikit-plot
arch: src
version: 0.3.7
epoch: 0
release: 1
summary: An intuitive library to add plotting functionality to scikit-learn objects.
url: https://github.com/reiinakano/scikit-plot
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-13ffd590-75fe-4ef4-94d7-eddd89310543
location_href: 00010114-python-scikit-plot/python-scikit-plot-0.3.7-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/scikit-plot.svg)](https://badge.fury.io/py/scikit-plot)
  [![license](https://img.shields.io/github/license/mashape/apistatus.svg)]()
  [![Build Status](https://travis-ci.org/reiinakano/scikit-plot.svg?branch=master)](https://travis-ci.org/reiinakano/scikit-plot)
  [![PyPI](https://img.shields.io/pypi/pyversions/scikit-plot.svg)]()
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.293191.svg)](https://doi.org/10.5281/zenodo.293191)





  ![roc_curves](docs/_static/readme_collage.jpg)



  Scikit-plot is the result of an unartistic data scientist's dreadful realization that *visualization is one of the most crucial components in the data science process, not just a mere afterthought*.

  Gaining insights is simply a lot easier when you're looking at a colored heatmap of a confusion matrix complete with class labels rather than a single-line dump of numbers enclosed in brackets. Besides, if you ever need to present your results to someone (virtually any time anybody hires you to do data science), you show them visualizations, not a bunch of numbers in Excel.

  That said, there are a number of visualizations that frequently pop up in machine learning. Scikit-plot is a humble attempt to provide aesthetically-challenged programmers (such as myself) the opportunity to generate quick and beautiful graphs and plots with as little boilerplate as possible.



  Say we use Naive Bayes in multi-class classification and decide we want to visualize the results of a common classification metric, the Area under the Receiver Operating Characteristic curve. Since the ROC is only valid in binary classification, we want to show the respective ROC of each class if it were the positive class. As an added bonus, let's show the micro-averaged and macro-averaged curve in the plot as well.

  Let's use scikit-plot with the sample digits dataset from scikit-learn.

  ```python

  from sklearn.datasets import load_digits
  from sklearn.model_selection import train_test_split
  from sklearn.naive_bayes import GaussianNB

  X, y = load_digits(return_X_y=True)
  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33)
  nb = GaussianNB()
  nb.fit(X_train, y_train)
  predicted_probas = nb.predict_proba(X_test)


  import matplotlib.pyplot as plt
  import scikitplot as skplt
  skplt.metrics.plot_roc(y_test, predicted_probas)
  plt.show()
  ```
  ![roc_curves](examples/roc_curves.png)

  Pretty.

  And... That's it. Encaptured in that small example is the entire philosophy of Scikit-plot: **single line functions for detailed visualization**. You simply browse the plots available in the documentation, and call the function with the necessary arguments. Scikit-plot tries to stay out of your way as much as possible. No unnecessary bells and whistles. And when you *do* need the bells and whistles, each function offers a myriad of parameters for customizing various elements in your plots.

  Finally, compare and [view the non-scikit-plot way of plotting the multi-class ROC curve](http://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html). Which one would you rather do?



  Although Scikit-plot is loosely based around the scikit-learn interface, you don't actually need Scikit-learn objects to use the available functions. As long as you provide the functions what they're asking for, they'll happily draw the plots for you.

  Here's a quick example to generate the precision-recall curves of a Keras classifier on a sample dataset.

  ```python

  import matplotlib.pyplot as plt
  import scikitplot as skplt


  keras_clf.fit(X_train, y_train, batch_size=64, nb_epoch=10, verbose=2)
  probas = keras_clf.predict_proba(X_test, batch_size=64)


  skplt.metrics.plot_precision_recall_curve(y_test, probas)
  plt.show()
  ```
  ![p_r_curves](examples/p_r_curves.png)

  You can see clearly here that `skplt.metrics.plot_precision_recall_curve` needs only the ground truth y-values and the predicted probabilities to generate the plot. This lets you use *anything* you want as the classifier, from Keras NNs to NLTK Naive Bayes to that groundbreaking classifier algorithm you just wrote.

  The possibilities are endless.



  Installation is simple! First, make sure you have the dependencies [Scikit-learn](http://scikit-learn.org) and [Matplotlib](http://matplotlib.org/) installed.

  Then just run:
  ```bash
  pip install scikit-plot
  ```

  Or if you want the latest development version, clone this repo and run
  ```bash
  python setup.py install
  ```
  at the root folder.

  If using conda, you can install Scikit-plot by running:
  ```bash
  conda install -c conda-forge scikit-plot
  ```



  Explore the full features of Scikit-plot.

  You can find detailed documentation [here](http://scikit-plot.readthedocs.io).

  Examples are found in the [examples folder of this repo](examples/).



  Reporting a bug? Suggesting a feature? Want to add your own plot to the library? Visit our [contributor guidelines](CONTRIBUTING.md).



  Are you using Scikit-plot in an academic paper? You should be! Reviewers love eye candy.

  If so, please consider citing Scikit-plot with DOI [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.293191.svg)](https://doi.org/10.5281/zenodo.293191)



  > Reiichiro Nakano. (2018). reiinakano/scikit-plot: 0.3.7 [Data set]. Zenodo. http://doi.org/10.5281/zenodo.293191



  > [1]Reiichiro Nakano, “reiinakano/scikit-plot: 0.3.7”. Zenodo, 19-Feb-2017.



  > [1]Reiichiro Nakano 2018. reiinakano/scikit-plot: 0.3.7. Zenodo.

  Happy plotting!


pkgId: 371c245b4d61c71de72fb393c879287fdbeeefb48f85fa974698b58bbeabcd14
name: python-scikit-spark
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Spark acceleration for Scikit-Learn cross validation techniques
url: https://github.com/scikit-spark/scikit-spark
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-43ef7b5a-72fa-4b1e-8e92-413d3eec426d
location_href: 00013869-python-scikit-spark/python-scikit-spark-0.4.0-1.src.rpm
checksum_type: sha256
description:
  This project is a major re-write of the
  [spark-sklearn](https://github.com/databricks/spark-sklearn) project, which
  seems to no longer be under development. It focuses specifically on the
  acceleration of Scikit-Learn's cross validation functionality using PySpark.


  `scikit-spark` supports `scikit-learn` versions past 0.19, `spark-sklearn` [have stated that they are probably not
  going to support newer versions](https://github.com/databricks/spark-sklearn/issues/113).

  The functionality in `scikit-spark` is based on `sklearn.model_selection` module rather than the
  deprecated and soon to be removed `sklearn.grid_search`. The new `model_selection` versions
  contain several nicer features and `scikit-spark` maintains full compatibility.


  The package can be installed through pip:
  ```bash
  pip install scikit-spark
  ```

  It has so far only been tested with Spark 2.2.0 and up, but may work with
  older versions.


  - 0.18 untested, likely doesn't work
  - 0.19 supported
  - 0.20 supported
  - 0.21 supported (Python 3 only)
  - 0.22 supported (Python 3 only)



  The functionality here is meant to as closely resemble using Scikit-Learn as
  possible. By default (with `spark=True`) the `SparkSession` is obtained
  internally by calling `SparkSession.builder.getOrCreate()`, so the instantiation
  and calling of the functions is the same (You will preferably have already
  created a `SparkSession`).

  This example is adapted from the Scikit-Learn documentation. It instantiates
  a local `SparkSession`, and distributes the cross validation folds and
  iterations using this. In actual use, to get the benefit of this package it
  should be used distributed across several machines with Spark as running it
  locally is slower than the `Scikit-Learn` parallelisation implementation.

  ```python
  from sklearn import svm, datasets
  from pyspark.sql import SparkSession

  iris = datasets.load_iris()
  parameters = {'kernel':('linear', 'rbf'), 'C':[0.01, 0.1, 1, 10, 100]}
  svc = svm.SVC()

  spark = SparkSession.builder\
      .master("local[*]")\
      .appName("skspark-grid-search-doctests")\
      .getOrCreate()


  from skspark.model_selection import GridSearchCV

  gs = GridSearchCV(svc, parameters)
  gs.fit(iris.data, iris.target)


  from skspark.model_selection import RandomizedSearchCV

  rs = RandomizedSearchCV(spark, svc, parameters)
  rs.fit(iris.data, iris.target)
  ```


  - Current
      - model_selection.RandomizedSearchCV
      - model_selection.GridSearchCV
  - Upcoming
      - model_selection.cross_val_predict
      - model_selection.cross_val_score

  *The docstrings are modifications of the Scikit-Learn ones and are still being
  converted to specifically refer to this project.*




  *Coming soon*


pkgId: a8f20f27aca73e37a7fbdecaab84d0a577c8046c3fa7ffefb4e4ae342bceedc9
name: python-sciunit
arch: src
version: 0.2.7
epoch: 0
release: 1
summary: A test-driven framework for formally validating scientific models against data.
url: http://sciunit.scidash.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-466be479-3112-4def-814c-367b8355b807
location_href: 00005041-python-sciunit/python-sciunit-0.2.7-1.src.rpm
checksum_type: sha256
description:
  [![Python package](https://github.com/scidash/sciunit/actions/workflows/python-package.yml/badge.svg)](https://github.com/scidash/sciunit/actions/workflows/python-package.yml)
  [![RTFD](https://readthedocs.org/projects/sciunit/badge/?version=master&x=1)](http://sciunit.readthedocs.io/en/latest/?badge=master)
  [![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/scidash/sciunit/master?filepath=docs%2Fchapter1.ipynb)
  [![Coveralls](https://coveralls.io/repos/github/scidash/sciunit/badge.svg?branch=master&x=1)](https://coveralls.io/github/scidash/sciunit?branch=master)
  [![Repos using Sciunit](https://img.shields.io/librariesio/dependent-repos/pypi/sciunit.svg?x=3)](https://github.com/scidash/sciunit/network/dependents?dependent_type=REPOSITORY)
  ![Downloads from PyPI](https://img.shields.io/pypi/dm/sciunit?x=1)

  <img src="https://raw.githubusercontent.com/scidash/assets/master/logos/SciUnit/sci-unit-square-small.png" alt="SciUnit Logo" width="400px">




  [The conference paper](https://github.com/cyrus-/papers/raw/master/sciunit-icse14/sciunit-icse14.pdf)


  [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/scidash/sciunit/blob/master/docs/chapter1.ipynb) <br>
  [Jupyter Tutorials](https://scidash.org/sciunit/README.html)<br>
  [API Documentation](http://sciunit.rtfd.io)


  ```python
  pip install sciunit
  ```
  or
  ```python
  conda install -c conda-forge sciunit
  ```


  ```python
  my_model = MyModel(**my_args) # Instantiate a class that wraps your model of interest.
  my_test = MyTest(**my_params) # Instantiate a test that you write.
  score = my_test.judge() # Runs the test and return a rich score containing test results and more.
  ```


  [NeuronUnit](https://github.com/scidash/neuronunit) for neuron and ion channel physiology<br>
  See others [here](https://github.com/scidash/sciunit/network/dependents?dependent_type=REPOSITORY)


  There is a [mailing list](https://groups.google.com/forum/?fromgroups#!forum/sciunit) for announcements and discussion.
  Please join it if you are at all interested!


   * [Rick Gerkin](http://rick.gerk.in), Arizona State University (School of Life Science)
   * [Cyrus Omar](http://cs.cmu.edu/~comar), Carnegie Mellon University (Dept. of Computer Science)


  RRID:[SCR_014528](https://scicrunch.org/resources/Any/record/nlx_144509-1/3faed1d9-6579-5da6-b4b4-75a5077656bb/search?q=sciunit&l=sciunit)


  SciUnit is released under the permissive [MIT license](https://opensource.org/licenses/MIT), requiring only attribution in derivative works. See the LICENSE file for terms.


pkgId: 84887c7406ce1c148b33786497005628b40125963dacea168b06b74cc248cda7
name: python-scour
arch: src
version: 0.38.2
epoch: 0
release: 1
summary: Scour SVG Optimizer
url: https://github.com/scour-project/scour
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7729da90-3031-41f7-afee-92754f5019da
location_href: 00005042-python-scour/python-scour-0.38.2-1.src.rpm
checksum_type: sha256
description:
  Scour is an SVG optimizer/cleaner that reduces the size of scalable
  vector graphics by optimizing structure and removing unnecessary data.

  It can be used to create streamlined vector graphics suitable for web
  deployment, publishing/sharing or further processing.

  The goal of Scour is to output a file that renderes identically at a
  fraction of the size by removing a lot of redundant information created
  by most SVG editors. Optimization options are typically lossless but can
  be tweaked for more agressive cleaning.

  Website
    - http://www.codedread.com/scour/ (original website)
    - https://github.com/scour-project/scour (today)

  Authors:
    - Jeff Schiller, Louis Simard (original authors)
    - Tobias Oberstein (maintainer)
    - Patrick Storz (maintainer)


pkgId: f3e0d7969dbebd7f98f397077598f404c0cc7cbb95f18ececc72a36ad164824e
name: python-scp
arch: src
version: 0.14.5
epoch: 0
release: 1
summary: scp module for paramiko
url: https://github.com/jbardin/scp.py
rpm_license: LGPL-2.1-or-later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5da3326b-f005-4e7e-afd7-435bfc7c5ad9
location_href: 00009426-python-scp/python-scp-0.14.5-1.src.rpm
checksum_type: sha256
description:
  The scp.py module uses a paramiko transport to send and receive files via the
  scp1 protocol. This is the protocol as referenced from the openssh scp program,
  and has only been tested with this implementation.


pkgId: e22a427ad7fbe11592188c78a4dfde0695c09dcee67fcd99a16418571b207270
name: python-scripttest
arch: src
version: 1.3
epoch: 0
release: 1
summary: Helper to test command-line scripts
url: http://pythonpaste.org/scripttest/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b157a555-e3eb-4c87-bc86-41c908047b3e
location_href: 00005046-python-scripttest/python-scripttest-1.3-1.src.rpm
checksum_type: sha256
description:
  scripttest is a library to help you test your interactive command-line
  applications.
  With it you can easily run the command (in a subprocess) and see the
  output (stdout, stderr) and any file modifications.
  * The `source repository <https://github.com/pypa/scripttest>`_.
  * The `documentation <https://scripttest.readthedocs.org/>`_.


pkgId: 176f457ed60dbf4b315c17ffc18e43b37ed812e7103a6dd5c94f89a017663f55
name: python-scripttester
arch: src
version: 0.1
epoch: 0
release: 1
summary: Utility for testing command line scripts
url: http://github.com/matthew-brett/scripttester
rpm_license: BSD license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c0db7376-8a82-49a0-a328-609eedea7b01
location_href: 00005047-python-scripttester/python-scripttester-0.1-1.src.rpm
checksum_type: sha256
description:
  ScriptTester - utility for testing command line scripts


  .. shared-text-body

  **********
  Quickstart
  **********

  Provides class to be instantiated in tests that check that scripts can be run
  and give correct output.  Usually works something like this in a test module::

      import mymodule
      from scripttester import ScriptTester
      runner = ScriptTester(mymodule)

  Then, in the tests, something like::

      code, stdout, stderr = runner.run_command(['my-script', my_arg])
      assert code == 0
      assert stdout == b'This script ran OK'

  The class aims to find your scripts whether you have installed (with ``pip
  install .`` or ``pip install -e .`` or ``python setup.py install``), or not.
  If you have not installed, the scripts will not be on your system PATH, and we
  have to find them.  The heuristic is to look (by default) in the directory
  containing ``mymodule``; if there is a ``setup.py`` file there, and a
  ``scripts`` sub-directory, assume that directory contains the scripts.

  Note there is no way of using this not-installed mechanism to find entrypoint
  scripts, that have not been installed. To find these, we would have to run the
  ``setup.py`` file.

  ************
  Installation
  ************

  ::

      pip install scripttester

  ****
  Code
  ****

  See https://github.com/matthew-brett/scripttester

  Released under the BSD two-clause license - see the file ``LICENSE`` in the
  source distribution.

  `travis-ci <https://travis-ci.org/matthew-brett/scripttester>`_ kindly tests
  the code automatically under Python versions 2.7, and 3.3 through 3.6.

  The latest released version is at https://pypi.python.org/pypi/scripttester

  *****
  Tests
  *****

  * Install ``scripttester``
  * Install the pytest_ testing framework::

      pip install pytest

  * Run the tests with::

      py.test --pyargs scripttester

  *******
  Support
  *******

  Please put up issues on the `scripttester issue tracker`_.

  .. standalone-references

  .. |scripttester-documentation| replace:: `scripttester documentation`_
  .. _scripttester documentation:
      https://matthew-brett.github.com/scripttester/scripttester.html
  .. _documentation: https://matthew-brett.github.com/scripttester
  .. _pandoc: http://pandoc.org
  .. _jupyter: jupyter.org
  .. _homebrew: brew.sh
  .. _sphinx: http://sphinx-doc.org
  .. _rest: http://docutils.sourceforge.net/rst.html
  .. _scripttester issue tracker: https://github.com/matthew-brett/scripttester/issues
  .. _pytest: https://pytest.readthedocs.io
  .. _mock: https://github.com/testing-cabal/mock


pkgId: 9a71f56e9d4ee07b4e2f7a06a051999d9152dea808d82a0087a7be704dbd221e
name: python-scs
arch: src
version: 3.2.3
epoch: 0
release: 1
summary: scs: splitting conic solver
url: http://github.com/cvxgrp/scs
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-23bd285b-a60e-4148-be58-f809b2203dc7
location_href: 00010001-python-scs/python-scs-3.2.3-1.src.rpm
checksum_type: sha256
description:
  Solves convex quadratic cone programs via operator splitting. Can solve: linear programs (LPs), second-order cone programs (SOCPs), semidefinite programs (SDPs), exponential cone programs (ECPs), and power cone programs (PCPs), or problems with any combination of those cones. See https://www.cvxgrp.org/scs/ for more details.


pkgId: fcb7832909250a1ba022f5f2c6d0a4e518e18d6ac16b2c1df5399a7b5a961731
name: python-scs-debuginfo
arch: x86_64
version: 3.2.3
epoch: 0
release: 1
summary: Debug information for package python-scs
url: http://github.com/cvxgrp/scs
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-23bd285b-a60e-4148-be58-f809b2203dc7
rpm_sourcerpm: python-scs-3.2.3-1.src.rpm
location_href: 00010001-python-scs/python-scs-debuginfo-3.2.3-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-scs.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: e5044b09973a4f80dc756b555189f7de6bd68ccb6c56dbb80532f1d57aa28fd7
name: python-scs-debugsource
arch: x86_64
version: 3.2.3
epoch: 0
release: 1
summary: Debug sources for package python-scs
url: http://github.com/cvxgrp/scs
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-23bd285b-a60e-4148-be58-f809b2203dc7
rpm_sourcerpm: python-scs-3.2.3-1.src.rpm
location_href: 00010001-python-scs/python-scs-debugsource-3.2.3-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-scs.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 64260833dfba35c206465b04229581eeaad7497c937c563884116f500fcac822
name: python-sdnotify
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: A pure Python implementation of systemd's service notification protocol (sd_notify)
url: https://github.com/bb4242/sdnotify
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6ea35546-8d59-4745-b6c1-25a1a1095b94
location_href: 00013494-python-sdnotify/python-sdnotify-0.3.2-1.src.rpm
checksum_type: sha256
description:
  systemd Service Notification

  This is a pure Python implementation of the systemd sd_notify protocol. This protocol can be used to inform systemd about service start-up completion, watchdog events, and other service status changes. Thus, this package can be used to write system services in Python that play nicely with systemd. sdnotify is compatible with both Python 2 and Python 3.


pkgId: f25a079866107e32394dafb0fc0fbde9795073b65d0119ec09871617fe26fc12
name: python-search-engine-parser
arch: src
version: 0.6.8
epoch: 0
release: 1
summary: scrapes search engine pages for query titles, descriptions and links
url: https://github.com/bisoncorps/search-engine-parser
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9e4c4722-1d5b-4ec5-8db0-ec7a4b2f8bc4
location_href: 00010204-python-search-engine-parser/python-search-engine-parser-0.6.8-1.src.rpm
checksum_type: sha256
description:
  <span><i>"If it is a search engine, then it can be parsed"</i> - some random guy</span>

  ![Demo](https://github.com/bisoncorps/search-engine-parser/raw/master/assets/animate.gif)

  [![Python 3.6|3.7|3.8|3.9](https://img.shields.io/badge/python-3.5%7C3.6%7C3.7%7C3.8-blue)](https://www.python.org/downloads/)
  [![PyPI version](https://img.shields.io/pypi/v/search-engine-parser)](https://pypi.org/project/search-engine-parser/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/search-engine-parser)](https://pypi.org/project/search-engine-parser/)
  [![Deploy to Pypi](https://github.com/bisohns/search-engine-parser/actions/workflows/deploy.yml/badge.svg)](https://github.com/bisohns/search-engine-parser/actions/workflows/deploy.yml)
  [![Test](https://github.com/bisohns/search-engine-parser/actions/workflows/test.yml/badge.svg)](https://github.com/bisohns/search-engine-parser/actions/workflows/test.yml)
  [![Documentation Status](https://readthedocs.org/projects/search-engine-parser/badge/?version=latest)](https://search-engine-parser.readthedocs.io/en/latest/?badge=latest)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![All Contributors](https://img.shields.io/badge/all_contributors-10-orange.svg)](#contributors)
  <hr/>

  search-engine-parser is a package that lets you query popular search engines and scrape for result titles, links, descriptions and more. It aims to scrape the widest range of search engines.
  View all supported engines [here.](https://github.com/bisoncorps/search-engine-parser/blob/master/docs/supported_engines.md)

  - [Search Engine Parser](#search-engine-parser)
    - [Popular Supported Engines](#popular-supported-engines)
    - [Installation](#installation)
    - [Development](#development)
    - [Code Documentation](#code-documentation)
    - [Running the tests](#running-the-tests)
    - [Usage](#usage)
      - [Code](#code)
      - [Command line](#command-line)
    - [FAQ](docs/faq.md)
    - [Code of Conduct](#code-of-conduct)
    - [Contribution](#contribution)
    - [License (MIT)](#license-mit)


  Popular search engines supported include:

  - Google
  - DuckDuckGo
  - GitHub
  - StackOverflow
  - Baidu
  - YouTube

  View all supported engines [here.](docs/supported_engines.md)


  Install from PyPi:

  ```bash
      
      pip install search-engine-parser
      
      pip install "search-engine-parser[cli]"
  ```

  or from master:
  ```bash
    pip install git+https://github.com/bisoncorps/search-engine-parser
  ```


  Clone the repository:

  ```bash
      git clone git@github.com:bisoncorps/search-engine-parser.git
  ```

  Then create a virtual environment and install the required packages:

  ```bash
      mkvirtualenv search_engine_parser
      pip install -r requirements/dev.txt
  ```



  Code docs can be found on [Read the Docs](https://search-engine-parser.readthedocs.io/en/latest).


  ```bash
      pytest
  ```




  Query results can be scraped from popular search engines, as shown in the example snippet below.

  ```python
    import pprint

    from search_engine_parser.core.engines.bing import Search as BingSearch
    from search_engine_parser.core.engines.google import Search as GoogleSearch
    from search_engine_parser.core.engines.yahoo import Search as YahooSearch

    search_args = ('preaching to the choir', 1)
    gsearch = GoogleSearch()
    ysearch = YahooSearch()
    bsearch = BingSearch()
    gresults = gsearch.search(*search_args)
    yresults = ysearch.search(*search_args)
    bresults = bsearch.search(*search_args)
    a = {
        "Google": gresults,
        "Yahoo": yresults,
        "Bing": bresults
        }

    
    for k, v in a.items():
        print(f"-------------{k}------------")
        for result in v:
            pprint.pprint(result)

    
    print(gresults["titles"][0])
    
    print(yresults["links"][9])
    
    print(bresults["descriptions"][5])

    
    print(gresults[0])
  ```

  For localization, you can pass the `url` keyword and a localized url. This queries and parses the localized url using the same engine's parser:
  ```python
    
    results = gsearch.search(*search_args, url="google.de")
  ```

  If you need results in a specific language you can pass the 'hl' keyword and the 2-letter country abbreviation (here's a [handy list](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes)):
  ```python
    
    results = gsearch.search(*search_args, hl="it")
  ```


  The results are automatically cached for engine searches. You can either bypass the cache by adding `cache=False` to the `search` or `async_search` method or clear the engine's cache
  ```python
      from search_engine_parser.core.engines.github import Search as GitHub
      github = GitHub()
      
      github.search("search-engine-parser", cache=False)

      
      
      github.clear_cache()
      github.search("search-engine-parser")
  ```


  Adding a proxy entails sending details to the search function
  ```python
      from search_engine_parser.core.engines.github import Search as GitHub
      github = GitHub()
      github.search("search-engine-parser",
          
          proxy='http://123.12.1.0',
          proxy_auth=('username', 'password'))
  ```



  search-engine-parser supports `async`:
  ```python
     results = await gsearch.async_search(*search_args)
  ```


  The `SearchResults` after searching:
  ```python
    >>> results = gsearch.search("preaching to the choir", 1)
    >>> results
    <search_engine_parser.core.base.SearchResult object at 0x7f907426a280>
    
    >>> results[0] # returns the first <SearchItem>
    >>> results[0]["description"] # gets the description of the first item
    >>> results[0]["link"] # gets the link of the first item
    >>> results["descriptions"] # returns a list of all descriptions from all results
  ```
  It can be iterated like a normal list to return individual `SearchItem`s.



  search-engine-parser comes with a CLI tool known as `pysearch`. You can use it as such:

  ```bash
  pysearch --engine bing  --type descriptions "Preaching to the choir"
  ```

  Result:

  ```bash
  'Preaching to the choir' originated in the USA in the 1970s. It is a variant of the earlier 'preaching to the converted', which dates from England in the late 1800s and has the same meaning. Origin - the full story 'Preaching to the choir' (also sometimes spelled quire) is of US origin.
  ```

  ![Demo](https://github.com/bisoncorps/search-engine-parser/raw/master/assets/example.gif)

  ```bash
  usage: pysearch [-h] [-V] [-e ENGINE] [--show-summary] [-u URL] [-p PAGE]
                  [-t TYPE] [-cc] [-r RANK] [--proxy PROXY]
                  [--proxy-user PROXY_USER] [--proxy-password PROXY_PASSWORD]
                  query

  SearchEngineParser

  positional arguments:
    query                 Query string to search engine for

  optional arguments:
    -h, --help            show this help message and exit
    -V, --version         show program's version number and exit
    -e ENGINE, --engine ENGINE
                          Engine to use for parsing the query e.g google, yahoo,
                          bing,duckduckgo (default: google)
    --show-summary        Shows the summary of an engine
    -u URL, --url URL     A custom link to use as base url for search e.g
                          google.de
    -p PAGE, --page PAGE  Page of the result to return details for (default: 1)
    -t TYPE, --type TYPE  Type of detail to return i.e full, links, desciptions
                          or titles (default: full)
    -cc, --clear-cache    Clear cache of engine before searching
    -r RANK, --rank RANK  ID of Detail to return e.g 5 (default: 0)
    --proxy PROXY         Proxy address to make use of
    --proxy-user PROXY_USER
                          Proxy user to make use of
    --proxy-password PROXY_PASSWORD
                          Proxy password to make use of
  ```




  Make sure to adhere to the [code of conduct](CODE_OF_CONDUCT.md) at all times.


  Before making any contributions, please read the [contribution guide](CONTRIBUTING.md).


  This project is licensed under the [MIT 2.0 License](LICENSE) which allows very broad use for both academic and commercial purposes.



  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tr>
      <td align="center"><a href="https://github.com/Rexogamer"><img src="https://avatars0.githubusercontent.com/u/42586271?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Ed Luff</b></sub></a><br /><a href="https://github.com/bisoncorps/search-engine-parser/commits?author=Rexogamer" title="Code">💻</a></td>
      <td align="center"><a href="http://diretnandomnan.webnode.com"><img src="https://avatars3.githubusercontent.com/u/23453888?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Diretnan Domnan</b></sub></a><br /><a href="#infra-deven96" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="https://github.com/bisoncorps/search-engine-parser/commits?author=deven96" title="Tests">⚠️</a> <a href="#tool-deven96" title="Tools">🔧</a> <a href="https://github.com/bisoncorps/search-engine-parser/commits?author=deven96" title="Code">💻</a></td>
      <td align="center"><a href="http://mensaah.github.io"><img src="https://avatars3.githubusercontent.com/u/24734308?v=4?s=100" width="100px;" alt=""/><br /><sub><b>MeNsaaH</b></sub></a><br /><a href="#infra-MeNsaaH" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="https://github.com/bisoncorps/search-engine-parser/commits?author=MeNsaaH" title="Tests">⚠️</a> <a href="#tool-MeNsaaH" title="Tools">🔧</a> <a href="https://github.com/bisoncorps/search-engine-parser/commits?author=MeNsaaH" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/PalAditya"><img src="https://avatars2.githubusercontent.com/u/25523604?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Aditya Pal</b></sub></a><br /><a href="https://github.com/bisoncorps/search-engine-parser/commits?author=PalAditya" title="Tests">⚠️</a> <a href="https://github.com/bisoncorps/search-engine-parser/commits?author=PalAditya" title="Code">💻</a> <a href="https://github.com/bisoncorps/search-engine-parser/commits?author=PalAditya" title="Documentation">📖</a></td>
      <td align="center"><a href="http://energized.pro"><img src="https://avatars1.githubusercontent.com/u/27774996?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Avinash Reddy</b></sub></a><br /><a href="https://github.com/bisoncorps/search-engine-parser/issues?q=author%3AAvinashReddy3108" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/Iamdavidonuh"><img src="https://avatars3.githubusercontent.com/u/37768509?v=4?s=100" width="100px;" alt=""/><br /><sub><b>David Onuh</b></sub></a><br /><a href="https://github.com/bisoncorps/search-engine-parser/commits?author=Iamdavidonuh" title="Code">💻</a> <a href="https://github.com/bisoncorps/search-engine-parser/commits?author=Iamdavidonuh" title="Tests">⚠️</a></td>
      <td align="center"><a href="http://simakis.me"><img src="https://avatars2.githubusercontent.com/u/8322266?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Panagiotis Simakis</b></sub></a><br /><a href="https://github.com/bisoncorps/search-engine-parser/commits?author=sp1thas" title="Code">💻</a> <a href="https://github.com/bisoncorps/search-engine-parser/commits?author=sp1thas" title="Tests">⚠️</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/reiarthur"><img src="https://avatars2.githubusercontent.com/u/20190646?v=4?s=100" width="100px;" alt=""/><br /><sub><b>reiarthur</b></sub></a><br /><a href="https://github.com/bisoncorps/search-engine-parser/commits?author=reiarthur" title="Code">💻</a></td>
      <td align="center"><a href="http://ashokkumarta.blogspot.com/"><img src="https://avatars0.githubusercontent.com/u/5450267?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Ashokkumar TA</b></sub></a><br /><a href="https://github.com/bisoncorps/search-engine-parser/commits?author=ashokkumarta" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/ateuber"><img src="https://avatars2.githubusercontent.com/u/44349054?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Andreas Teuber</b></sub></a><br /><a href="https://github.com/bisoncorps/search-engine-parser/commits?author=ateuber" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/mi096684"><img src="https://avatars3.githubusercontent.com/u/22032932?v=4?s=100" width="100px;" alt=""/><br /><sub><b>mi096684</b></sub></a><br /><a href="https://github.com/bisoncorps/search-engine-parser/issues?q=author%3Ami096684" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/devajithvs"><img src="https://avatars1.githubusercontent.com/u/29475282?v=4?s=100" width="100px;" alt=""/><br /><sub><b>devajithvs</b></sub></a><br /><a href="https://github.com/bisoncorps/search-engine-parser/commits?author=devajithvs" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/zakaryan2004"><img src="https://avatars3.githubusercontent.com/u/29994884?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Geg Zakaryan</b></sub></a><br /><a href="https://github.com/bisoncorps/search-engine-parser/commits?author=zakaryan2004" title="Code">💻</a> <a href="https://github.com/bisoncorps/search-engine-parser/issues?q=author%3Azakaryan2004" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://www.hakanbogan.com"><img src="https://avatars1.githubusercontent.com/u/24498747?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Hakan Boğan</b></sub></a><br /><a href="https://github.com/bisoncorps/search-engine-parser/issues?q=author%3Aredrussianarmy" title="Bug reports">🐛</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/NicKoehler"><img src="https://avatars3.githubusercontent.com/u/53040044?v=4?s=100" width="100px;" alt=""/><br /><sub><b>NicKoehler</b></sub></a><br /><a href="https://github.com/bisoncorps/search-engine-parser/issues?q=author%3ANicKoehler" title="Bug reports">🐛</a> <a href="https://github.com/bisoncorps/search-engine-parser/commits?author=NicKoehler" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/chris4540"><img src="https://avatars1.githubusercontent.com/u/12794588?v=4?s=100" width="100px;" alt=""/><br /><sub><b>ChrisLin</b></sub></a><br /><a href="https://github.com/bisoncorps/search-engine-parser/issues?q=author%3Achris4540" title="Bug reports">🐛</a> <a href="https://github.com/bisoncorps/search-engine-parser/commits?author=chris4540" title="Code">💻</a></td>
      <td align="center"><a href="http://pete.world"><img src="https://avatars.githubusercontent.com/u/10454135?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Pietro</b></sub></a><br /><a href="https://github.com/bisoncorps/search-engine-parser/commits?author=pgrandinetti" title="Code">💻</a> <a href="https://github.com/bisoncorps/search-engine-parser/issues?q=author%3Apgrandinetti" title="Bug reports">🐛</a></td>
    </tr>
  </table>

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

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

  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!


pkgId: 1f949519716b0d0af2f153e813ef0971fa7cbba8c4133db31e35cb348371cc10
name: python-secure-cookie
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Secure cookie and session interface for WSGI applications.
url: https://secure-cookie.readthedocs.io/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-381e30bd-86fc-4b81-ba36-0df3efbbc6ca
location_href: 00005052-python-secure_cookie/python-secure-cookie-0.2.0-1.src.rpm
checksum_type: sha256
description:
  Provides interfaces for secure cookies and sessions in WSGI
  applications. Secure cookies are cryptographically signed (but not
  encrypted) to prevent tampering. Sessions are data associated with a
  given user across requests and responses.


pkgId: 124915adefa2ee47d164fe248d84f82acb6499a378d019dcb5628cfb0ee5f627
name: python-segno
arch: src
version: 1.5.2
epoch: 0
release: 1
summary: QR Code and Micro QR Code generator for Python 2 and Python 3
url: https://github.com/heuer/segno/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-18879a8b-eadb-450f-9910-6dd8f7b70ac9
location_href: 00013999-python-segno/python-segno-1.5.2-1.src.rpm
checksum_type: sha256
description:
  Pure Python QR Code generator with no dependencies.
  This package implements ISO/IEC 18004:2015(E) "QR Code bar code symbology
  specification" and produces QR Codes and Micro QR Codes with nearly no effort.
  It supports the `Structured Append mode <https://segno.readthedocs.io/en/stable/structured-append.html>`_
  which splits a message across several QR codes.
  Segno (Italian for "sign" / "symbol") provides several serialization formats
  like Scalable Vector Graphics (SVG), Encapsulated PostScript (EPS),
  Portable Network Graphics (PNG), Portable Document Format (PDF), Netpbm (PAM, PBM, PPM),
  LaTeX (PGF/TikZ), X PixMap (XBM), and X Bitmap (XPM) etc.
  None of these serializers require an external lib.
  Further, it provides several high level functions to create QR Codes which encode
  `contact data (vCard, MeCard) <https://segno.readthedocs.io/en/stable/contact-information.html>`_,
  `EPC QR Codes <https://segno.readthedocs.io/en/stable/epc-qrcodes.html>`_,
  or `WIFI QR Codes <https://segno.readthedocs.io/en/stable/special-qrcode-factories.html#create-a-qr-code-for-a-wifi-configuration>`_.
  The project provides more than 1500 test cases (coverage >= 98%) to verify a
  standard conform QR Code and Micro QR Code generation acc. to ISO/IEC 18004:2015(E).


pkgId: 490b3624cb8bc1ff9babfa45061c09572a37c3bc2eeddc466b0e1e83dd805165
name: python-selectors2
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: Back-ported, durable, and portable selectors
url: https://www.github.com/sethmlarson/selectors2
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8a7c82fe-0361-4475-8f89-ad417c6ff85b
location_href: 00011028-python-selectors2/python-selectors2-2.0.2-1.src.rpm
checksum_type: sha256
description:
  Backported, durable, and portable selectors designed to replace
  the standard library selectors module.


pkgId: f0d6ff16447ee377b3f24141fb225da2382768e582009aece7bcb7825b9cff19
name: python-selenium-wire
arch: src
version: 5.1.0
epoch: 0
release: 1
summary: Extends Selenium to give you the ability to inspect requests made by the browser.
url: https://github.com/wkeeling/selenium-wire
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f636ed96-e826-4513-8e49-6c50bbc73e88
location_href: 00009805-python-selenium-wire/python-selenium-wire-5.1.0-1.src.rpm
checksum_type: sha256
description:
  Selenium Wire extends `Selenium's <https://www.selenium.dev/documentation/en/>`_ Python bindings to give you access to the underlying requests made by the browser. You author your code in the same way as you do with Selenium, but you get extra APIs for inspecting requests and responses and making changes to them on the fly.
  Simple Example
  ~~~~~~~~~~~~~~
      from seleniumwire import webdriver  # Import from seleniumwire
      
      driver = webdriver.Chrome()
      
      driver.get('https://www.google.com')
      
      for request in driver.requests:
          if request.response:
              print(
                  request.url,
                  request.response.status_code,
                  request.response.headers['Content-Type']
              )
  Prints:
      https://www.google.com/ 200 text/html; charset=UTF-8
      https://www.google.com/images/branding/googlelogo/2x/googlelogo_color_120x44dp.png 200 image/png
      https://consent.google.com/status?continue=https://www.google.com&pc=s&timestamp=1531511954&gl=GB 204 text/html; charset=utf-8
      https://www.google.com/images/branding/googlelogo/2x/googlelogo_color_272x92dp.png 200 image/png
      https://ssl.gstatic.com/gb/images/i2_2ec824b0.png 200 image/png
      https://www.google.com/gen_204?s=webaft&t=aft&atyp=csi&ei=kgRJW7DBONKTlwTK77wQ&rt=wsrt.366,aft.58,prt.58 204 text/html; charset=UTF-8
  Features
  ~~~~~~~~
  * Pure Python, user-friendly API
  * HTTP and HTTPS requests captured
  * Intercept requests and responses
  * Modify headers, parameters, body content on the fly
  * Capture websocket messages
  * HAR format supported
  * Proxy server support
  Compatibilty
  ~~~~~~~~~~~~
  * Python 3.7+
  * Selenium 4.0.0+
  * Chrome, Firefox, Edge and Remote Webdriver supported
  Table of Contents
  ~~~~~~~~~~~~~~~~~
  - `Installation`_
    * `Browser Setup`_
    * `OpenSSL`_
  - `Creating the Webdriver`_
  - `Accessing Requests`_
  - `Request Objects`_
  - `Response Objects`_
  - `Intercepting Requests and Responses`_
    * `Example: Add a request header`_
    * `Example: Replace an existing request header`_
    * `Example: Add a response header`_
    * `Example: Add a request parameter`_
    * `Example: Update JSON in a POST request body`_
    * `Example: Basic authentication`_
    * `Example: Block a request`_
    * `Example: Mock a response`_
    * `Unset an interceptor`_
  - `Limiting Request Capture`_
  - `Request Storage`_
    * `In-Memory Storage`_
  - `Proxies`_
    * `SOCKS`_
    * `Switching Dynamically`_
  - `Bot Detection`_
  - `Certificates`_
    * `Using Your Own Certificate`_
  - `All Options`_
  - `License`_
  Installation
  ~~~~~~~~~~~~
  Install using pip:
      pip install selenium-wire
  If you get an error about not being able to build cryptography you may be running an old version of pip. Try upgrading pip with ``python -m pip install --upgrade pip`` and then re-run the above command.


pkgId: 6269c8b54e5058bd86bc7f472ba8114b3c5b3306104d5c94449e0f7d33a161ec
name: python-selinux
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: shim selinux module
url: https://github.com/pycontribs/selinux
rpm_license: MIT license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3acd909b-27d2-479c-9782-0def2398ee10
location_href: 00010550-python-selinux/python-selinux-0.3.0-1.src.rpm
checksum_type: sha256
description:
  Pure-python selinux **shim** module for use in virtualenvs in order to avoid
  failure to load selinux in Ansible modules.
  You still need to have libselinux python bindings package installed on your
  system for it to work but you no longer have the problem of not being able
  to import it from inside isolated (default) virtualenvs.
  This package was also tested as installed outside virtualenvs and seems not
  to interfere with the original library.
  The change-list can be accessed at `releases`__.
  __ https://github.com/pycontribs/selinux/releases


pkgId: 563a9c1d65ad8ca75214f79c94b30d693e2551155141a9672b45f51cf8db9e9d
name: python-semver
arch: src
version: 2.13.0
epoch: 0
release: 1
summary: Python helper for Semantic Versioning (http://semver.org/)
url: https://github.com/python-semver/python-semver
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-305eec8e-b6fd-4bb7-ad77-c6dfade26630
location_href: 00005054-python-semver/python-semver-2.13.0-1.src.rpm
checksum_type: sha256
description:
  A Python module for `semantic versioning`_. Simplifies comparing versions.
  |build-status| |python-support| |downloads| |license| |docs| |black|
     As anything comes to an end, this project will focus on Python 3.x only.
     New features and bugfixes will be integrated into the 3.x.y branch only.
     Major version 3 of semver will contain some incompatible changes:
     * removes support for Python 2.7 and 3.3
     * removes deprecated functions.
     The last version of semver which supports Python 2.7 and 3.4 will be
     2.10.x. However, keep in mind, version 2.10.x is frozen: no new
     features nor backports will be integrated.
     We recommend to upgrade your workflow to Python 3.x to gain support,
     bugfixes, and new features.
  The module follows the ``MAJOR.MINOR.PATCH`` style:
  * ``MAJOR`` version when you make incompatible API changes,
  * ``MINOR`` version when you add functionality in a backwards compatible manner, and
  * ``PATCH`` version when you make backwards compatible bug fixes.
  Additional labels for pre-release and build metadata are supported.
  To import this library, use:
      >>> import semver
  Working with the library is quite straightforward. To turn a version string into the
  different parts, use the ``semver.VersionInfo.parse`` function:
      >>> ver = semver.VersionInfo.parse('1.2.3-pre.2+build.4')
      >>> ver.major
      1
      >>> ver.minor
      2
      >>> ver.patch
      3
      >>> ver.prerelease
      'pre.2'
      >>> ver.build
      'build.4'
  To raise parts of a version, there are a couple of functions available for
  you. The function ``semver.VersionInfo.bump_major`` leaves the original object untouched, but
  returns a new ``semver.VersionInfo`` instance with the raised major part:
      >>> ver = semver.VersionInfo.parse("3.4.5")
      >>> ver.bump_major()
      VersionInfo(major=4, minor=0, patch=0, prerelease=None, build=None)
  It is allowed to concatenate different "bump functions":
      >>> ver.bump_major().bump_minor()
      VersionInfo(major=4, minor=1, patch=0, prerelease=None, build=None)
  To compare two versions, semver provides the ``semver.compare`` function.
  The return value indicates the relationship between the first and second
  version:
      >>> semver.compare("1.0.0", "2.0.0")
      -1
      >>> semver.compare("2.0.0", "1.0.0")
      1
      >>> semver.compare("2.0.0", "2.0.0")
      0
  There are other functions to discover. Read on!


pkgId: e43f9e0a7e5a2c5148f40b9f3442b82d1309d16d7670b66a2ae08bc92cd554e1
name: python-sendgrid
arch: src
version: 6.10.0
epoch: 0
release: 1
summary: Twilio SendGrid library for Python
url: https://github.com/sendgrid/sendgrid-python/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7154c638-3faa-45ba-a36c-9b6b87adb89d
location_href: 00008386-python-sendgrid/python-sendgrid-6.10.0-1.src.rpm
checksum_type: sha256
description:
  -  `Installation <#installation>`__
  -  `Quick Start <#quick-start>`__
  -  `Common Use Cases <#use-cases>`__
  -  `General Usage <#usage>`__
  -  `Processing Inbound Email <#processing-inbound-email>`__
  -  `Announcements <#announcements>`__
  -  `How to Contribute <#how-to-contribute>`__
  -  `Troubleshooting <#troubleshooting>`__
  -  `About <#about>`__
  -  `License <#license>`__


pkgId: 263429ca3bd0b26bea225375cff3ec54471df7a47d48f2bb80b0451eb8e1c9b8
name: python-sentence-transformers
arch: src
version: 2.2.2
epoch: 0
release: 1
summary: Multilingual text embeddings
url: https://github.com/UKPLab/sentence-transformers
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-733616d0-d13b-48c5-850f-65de3d8a4769
location_href: 00009990-python-sentence-transformers/python-sentence-transformers-2.2.2-1.src.rpm
checksum_type: sha256
description:
  [#github-license]: https://github.com/UKPLab/sentence-transformers/blob/master/LICENSE
  [#pypi-package]: https://pypi.org/project/sentence-transformers/
  [#conda-forge-package]: https://anaconda.org/conda-forge/sentence-transformers
  [#docs-package]: https://www.sbert.net/
  <!--- BADGES: END --->

  This framework provides an easy method to compute dense vector representations for **sentences**, **paragraphs**, and **images**. The models are based on transformer networks like BERT / RoBERTa / XLM-RoBERTa etc. and achieve state-of-the-art performance in various task. Text is embedding in vector space such that similar text is close and can efficiently be found using cosine similarity.
  We provide an increasing number of **[state-of-the-art pretrained models](https://www.sbert.net/docs/pretrained_models.html)** for more than 100 languages, fine-tuned for various use-cases.
  Further, this framework allows an easy  **[fine-tuning of custom embeddings models](https://www.sbert.net/docs/training/overview.html)**, to achieve maximal performance on your specific task.
  For the **full documentation**, see **[www.SBERT.net](https://www.sbert.net)**.
  The following publications are integrated in this framework:
  - [Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks](https://arxiv.org/abs/1908.10084) (EMNLP 2019)
  - [Making Monolingual Sentence Embeddings Multilingual using Knowledge Distillation](https://arxiv.org/abs/2004.09813) (EMNLP 2020)
  - [Augmented SBERT: Data Augmentation Method for Improving Bi-Encoders for Pairwise Sentence Scoring Tasks](https://arxiv.org/abs/2010.08240) (NAACL 2021)
  - [The Curse of Dense Low-Dimensional Information Retrieval for Large Index Sizes](https://arxiv.org/abs/2012.14210) (arXiv 2020)
  - [TSDAE: Using Transformer-based Sequential Denoising Auto-Encoder for Unsupervised Sentence Embedding Learning](https://arxiv.org/abs/2104.06979) (arXiv 2021)
  - [BEIR: A Heterogenous Benchmark for Zero-shot Evaluation of Information Retrieval Models](https://arxiv.org/abs/2104.08663) (arXiv 2021)

  We recommend **Python 3.6** or higher, **[PyTorch 1.6.0](https://pytorch.org/get-started/locally/)** or higher and **[transformers v4.6.0](https://github.com/huggingface/transformers)** or higher. The code does **not** work with Python 2.7.
  **Install with pip**
  Install the *sentence-transformers* with `pip`:
  ```
  pip install -U sentence-transformers
  ```
  **Install with conda**
  You can install the *sentence-transformers* with `conda`:
  ```
  conda install -c conda-forge sentence-transformers
  ```
  **Install from sources**
  Alternatively, you can also clone the latest version from the [repository](https://github.com/UKPLab/sentence-transformers) and install it directly from the source code:
  ````
  pip install -e .
  ````
  **PyTorch with CUDA**
  If you want to use a GPU / CUDA, you must install PyTorch with the matching CUDA Version. Follow
  [PyTorch - Get Started](https://pytorch.org/get-started/locally/) for further details how to install PyTorch.

  See [Quickstart](https://www.sbert.net/docs/quickstart.html) in our documenation.
  [This example](https://github.com/UKPLab/sentence-transformers/tree/master/examples/applications/computing-embeddings/computing_embeddings.py) shows you how to use an already trained Sentence Transformer model to embed sentences for another task.
  First download a pretrained model.
  ````python
  from sentence_transformers import SentenceTransformer
  model = SentenceTransformer('all-MiniLM-L6-v2')
  ````
  Then provide some sentences to the model.
  ````python
  sentences = ['This framework generates embeddings for each input sentence',
      'Sentences are passed as a list of string.',
      'The quick brown fox jumps over the lazy dog.']
  sentence_embeddings = model.encode(sentences)
  ````
  And that's it already. We now have a list of numpy arrays with the embeddings.
  ````python
  for sentence, embedding in zip(sentences, sentence_embeddings):
      print("Sentence:", sentence)
      print("Embedding:", embedding)
      print("")
  ````

  We provide a large list of [Pretrained Models](https://www.sbert.net/docs/pretrained_models.html) for more than 100 languages. Some models are general purpose models, while others produce embeddings for specific use cases. Pre-trained models can be loaded by just passing the model name: `SentenceTransformer('model_name')`.
  [»  Full list of pretrained models](https://www.sbert.net/docs/pretrained_models.html)

  This framework allows you to fine-tune your own sentence embedding methods, so that you get task-specific sentence embeddings. You have various options to choose from in order to get perfect sentence embeddings for your specific task.
  See [Training Overview](https://www.sbert.net/docs/training/overview.html) for an introduction how to train your own embedding models. We provide [various examples](https://github.com/UKPLab/sentence-transformers/tree/master/examples/training) how to train models on various datasets.
  Some highlights are:
  - Support of various transformer networks including BERT, RoBERTa, XLM-R, DistilBERT, Electra, BART, ...
  - Multi-Lingual and multi-task learning
  - Evaluation during training to find optimal model
  - [10+ loss-functions](https://www.sbert.net/docs/package_reference/losses.html) allowing to tune models specifically for semantic search, paraphrase mining, semantic similarity comparison, clustering, triplet loss, contrastive loss.

  Our models are evaluated extensively on 15+ datasets including challening domains like Tweets, Reddit, emails. They achieve by far the **best performance** from all available sentence embedding methods. Further, we provide several **smaller models** that are **optimized for speed**.
  [» Full list of pretrained models](https://www.sbert.net/docs/pretrained_models.html)

  You can use this framework for:
  - [Computing Sentence Embeddings](https://www.sbert.net/examples/applications/computing-embeddings/README.html)
  - [Semantic Textual Similarity](https://www.sbert.net/docs/usage/semantic_textual_similarity.html)
  - [Clustering](https://www.sbert.net/examples/applications/clustering/README.html)
  - [Paraphrase Mining](https://www.sbert.net/examples/applications/paraphrase-mining/README.html)
   - [Translated Sentence Mining](https://www.sbert.net/examples/applications/parallel-sentence-mining/README.html)
   - [Semantic Search](https://www.sbert.net/examples/applications/semantic-search/README.html)
   - [Retrieve & Re-Rank](https://www.sbert.net/examples/applications/retrieve_rerank/README.html)
   - [Text Summarization](https://www.sbert.net/examples/applications/text-summarization/README.html)
  - [Multilingual Image Search, Clustering & Duplicate Detection](https://www.sbert.net/examples/applications/image-search/README.html)
  and many more use-cases.
  For all examples, see [examples/applications](https://github.com/UKPLab/sentence-transformers/tree/master/examples/applications).

  If you find this repository helpful, feel free to cite our publication [Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks](https://arxiv.org/abs/1908.10084):
  ```bibtex
  @inproceedings{reimers-2019-sentence-bert,
      title = "Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks",
      author = "Reimers, Nils and Gurevych, Iryna",
      booktitle = "Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing",
      month = "11",
      year = "2019",
      publisher = "Association for Computational Linguistics",
      url = "https://arxiv.org/abs/1908.10084",
  }
  ```
  If you use one of the multilingual models, feel free to cite our publication [Making Monolingual Sentence Embeddings Multilingual using Knowledge Distillation](https://arxiv.org/abs/2004.09813):
  ```bibtex
  @inproceedings{reimers-2020-multilingual-sentence-bert,
      title = "Making Monolingual Sentence Embeddings Multilingual using Knowledge Distillation",
      author = "Reimers, Nils and Gurevych, Iryna",
      booktitle = "Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing",
      month = "11",
      year = "2020",
      publisher = "Association for Computational Linguistics",
      url = "https://arxiv.org/abs/2004.09813",
  }
  ```
  Please have a look at [Publications](https://www.sbert.net/docs/publications.html) for our different publications that are integrated into SentenceTransformers.
  Contact person: [Nils Reimers](https://www.nils-reimers.de), [info@nils-reimers.de](mailto:info@nils-reimers.de)
  https://www.ukp.tu-darmstadt.de/
  Don't hesitate to send us an e-mail or report an issue, if something is broken (and it shouldn't be) or if you have further questions.
  > This repository contains experimental software and is published for the sole purpose of giving additional background details on the respective publication.


pkgId: 72dcc014c3a7e1b00675f110e34e9a242eb0c68425053fb1322d8f0cabed482c
name: python-sentencepiece
arch: src
version: 0.1.97
epoch: 0
release: 1
summary: SentencePiece python wrapper
url: https://github.com/google/sentencepiece
rpm_license: Apache
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f7edfe83-b301-4af2-b765-9819335e2670
location_href: 00005058-python-sentencepiece/python-sentencepiece-0.1.97-1.src.rpm
checksum_type: sha256
description:
  Python wrapper for SentencePiece. This API will offer the encoding, decoding and training of Sentencepiece.


  For Linux (x64/i686), macOS, and Windows(win32/x64) environment, you can simply use pip command to install SentencePiece python module.

  ```
  % pip install sentencepiece
  ```

  To build and install the Python wrapper from source, try the following commands to build and install wheel package.
  ```
  % git clone https://github.com/google/sentencepiece.git
  % cd sentencepiece
  % mkdir build
  % cd build
  % cmake .. -DSPM_ENABLE_SHARED=OFF -DCMAKE_INSTALL_PREFIX=./root
  % make install
  % cd ../python
  % python setup.py bdist_wheel
  % pip install dist/sentencepiece*.whl
  ```

  If you don’t have write permission to the global site-packages directory or don’t want to install into it, please try:
  ```
  % python setup.py install --user
  ```



  See [this google colab page](https://github.com/google/sentencepiece/blob/master/python/sentencepiece_python_module_example.ipynb) to run sentencepiece interactively.


  ```
  % python
  >>> import sentencepiece as spm
  >>> sp = spm.SentencePieceProcessor(model_file='test/test_model.model')

  >>> sp.encode('This is a test')
  [284, 47, 11, 4, 15, 400]

  >>> sp.encode(['This is a test', 'Hello world'], out_type=int)
  [[284, 47, 11, 4, 15, 400], [151, 88, 21, 887]]

  >>> sp.encode_as_ids(['This is a test', 'Hello world'])
  [[284, 47, 11, 4, 15, 400], [151, 88, 21, 887]]

  >>> sp.encode('This is a test', out_type=str)
  ['▁This', '▁is', '▁a', '▁', 't', 'est']

  >>> sp.encode(['This is a test', 'Hello world'], out_type=str)
  [['▁This', '▁is', '▁a', '▁', 't', 'est'], ['▁He', 'll', 'o', '▁world']]

  >>> sp.encode_as_pieces(['This is a test', 'Hello world'])
  [['▁This', '▁is', '▁a', '▁', 't', 'est'], ['▁He', 'll', 'o', '▁world']]

  >>> proto = sp.encode('This is a test', out_type='immutable_proto')
  >>> for n in proto.pieces:
  ...     print('piece="{}" surface="{}" id={} begin={} end={}'.format(n.piece, n.surface, n.id, n.begin, n.end))
  ...
  piece="▁This" surface="This" id=284 begin=0 end=4
  piece="▁is" surface=" is" id=47 begin=4 end=7
  piece="▁a" surface=" a" id=11 begin=7 end=9
  piece="▁" surface=" " id=4 begin=9 end=10
  piece="t" surface="t" id=15 begin=10 end=11
  piece="est" surface="est" id=400 begin=11 end=14

  >>> [[x.id for x in proto.pieces], [x.piece for x in proto.pieces], [x.begin for x in proto.pieces], [x.end for x in proto.pieces]]
  [[284, 47, 11, 4, 15, 400], ['▁This', '▁is', '▁a', '▁', 't', 'est'], [0, 4, 7, 9, 10, 11], [4, 7, 9, 10, 11, 14]]

  >>> proto2 = sp.encode_as_immutable_proto('This is a test')
  >>> proto2 == proto
  True

  >>> for _ in range(10):
  ...     sp.encode('This is a test', out_type=str, enable_sampling=True, alpha=0.1, nbest_size=-1)
  ...
  ['▁', 'This', '▁', 'is', '▁a', '▁', 't', 'e', 'st']
  ['▁T', 'h', 'i', 's', '▁is', '▁a', '▁', 'te', 's', 't']
  ['▁T', 'h', 'is', '▁', 'is', '▁', 'a', '▁', 't', 'est']
  ['▁', 'This', '▁is', '▁', 'a', '▁', 't', 'e', 'st']
  ['▁', 'This', '▁', 'is', '▁', 'a', '▁', 't', 'e', 's', 't']
  ['▁This', '▁is', '▁a', '▁', 'te', 's', 't']
  ['▁This', '▁is', '▁', 'a', '▁', 't', 'e', 'st']
  ['▁', 'T', 'h', 'is', '▁', 'is', '▁', 'a', '▁', 'te', 'st']
  ['▁', 'This', '▁', 'i', 's', '▁a', '▁', 't', 'e', 'st']
  ['▁This', '▁', 'is', '▁a', '▁', 't', 'est']

  >> sp.nbest_encode('This is a test', nbest_size=5, out_type=str)
  [['▁This', '▁is', '▁a', '▁', 't', 'est'],
  ['▁This', '▁is', '▁a', '▁', 'te', 'st'],
  ['▁This', '▁is', '▁a', '▁', 'te', 's', 't'],
  ['▁This', '▁is', '▁a', '▁', 't', 'e', 'st'],
  ['▁This', '▁is', '▁a', '▁', 't', 'es', 't']]

  >>> sp.sample_encode_and_score('This is a test', num_samples=5, alpha=0.1, out_type=str, wor=True)
  [(['▁This', '▁', 'i', 's', '▁a', '▁', 'te', 's', 't'], -3.043105125427246),
  (['▁This', '▁', 'i', 's', '▁a', '▁', 'te', 'st'], -2.8475849628448486),
  (['▁', 'This', '▁is', '▁', 'a', '▁', 'te', 'st'], -3.043248176574707),
  (['▁', 'This', '▁is', '▁a', '▁', 't', 'e', 'st'], -2.87727689743042),
  (['▁', 'This', '▁', 'i', 's', '▁', 'a', '▁', 't', 'est'], -3.6284031867980957)]

  >>> sp.decode([284, 47, 11, 4, 15, 400])
  'This is a test'

  >>> sp.decode([[284, 47, 11, 4, 15, 400], [151, 88, 21, 887]])
  ['This is a test', 'Hello world']

  >>> proto = sp.decode([284, 47, 11, 4, 15, 400], out_type='immutable_proto')
  >>> proto.text
  'This is a test'

  >>> sp.decode(['▁', 'This', '▁', 'is', '▁a', '▁', 't', 'e', 'st'])
  'This is a test'

  >>> sp.decode([['▁This', '▁is', '▁a', '▁', 't', 'est'], ['▁He', 'll', 'o', '▁world']])
  ['This is a test', 'Hello world']

  >>> sp.get_piece_size()
  1000

  >>> sp.id_to_piece(2)
  '</s>'

  >>> sp.id_to_piece([2, 3, 4])
  ['</s>', '\r', '▁']

  >>> sp.piece_to_id('<s>')
  1

  >>> sp.piece_to_id(['</s>', '\r', '▁'])
  [2, 3, 4]

  >>> len(sp)
  1000

  >>> sp['</s>']
  2
  ```


  Training is performed by passing parameters of [spm_train](https://github.com/google/sentencepiece#train-sentencepiece-model) to  SentencePieceTrainer.train() function.

  ```
  >>> import sentencepiece as spm
  >>> spm.SentencePieceTrainer.train(input='test/botchan.txt', model_prefix='m', vocab_size=1000, user_defined_symbols=['foo', 'bar'])
  sentencepiece_trainer.cc(73) LOG(INFO) Starts training with :
  trainer_spec {
    input: test/botchan.txt
    .. snip
  unigram_model_trainer.cc(500) LOG(INFO) EM sub_iter=1 size=1188 obj=10.2839 num_tokens=32182 num_tokens/piece=27.0892
  unigram_model_trainer.cc(500) LOG(INFO) EM sub_iter=0 size=1100 obj=10.4269 num_tokens=33001 num_tokens/piece=30.0009
  unigram_model_trainer.cc(500) LOG(INFO) EM sub_iter=1 size=1100 obj=10.4069 num_tokens=33002 num_tokens/piece=30.0018
  trainer_interface.cc(595) LOG(INFO) Saving model: m.model
  trainer_interface.cc(619) LOG(INFO) Saving vocabs: m.vocab
  >>>
  ```


  Sentencepiece trainer can receive any iterable object to feed training sentences. You can also pass a file object (instance with write() method) to emit the output model to any devices. These features are useful to run sentencepiece on environment that have limited access to the local file system (e.g., Google colab.)

  ```
  import urllib.request
  import io
  import sentencepiece as spm


  model = io.BytesIO()
  with urllib.request.urlopen(
      'https://raw.githubusercontent.com/google/sentencepiece/master/data/botchan.txt'
  ) as response:
    spm.SentencePieceTrainer.train(
        sentence_iterator=response, model_writer=model, vocab_size=1000)






  sp = spm.SentencePieceProcessor(model_proto=model.getvalue())
  print(sp.encode('this is test'))
  ```


pkgId: 48d8d765e543cbfe43ceded16c4a182b04c750a720a62ac2e60de9dac0aeb65a
name: python-sentry-sdk
arch: src
version: 1.19.1
epoch: 0
release: 1
summary: Python client for Sentry (https://sentry.io)
url: https://github.com/getsentry/sentry-python
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a6aaf891-2870-4908-80c2-3742f7c8afbe
location_href: 00009068-python-sentry-sdk/python-sentry-sdk-1.19.1-1.src.rpm
checksum_type: sha256
description:
  ```bash
  pip install --upgrade sentry-sdk
  ```

  ```python
  import sentry_sdk
  sentry_sdk.init(
      "https://12927b5f211046b575ee51fd8b1ac34f@o1.ingest.sentry.io/1",
      
      
      
      traces_sample_rate=1.0,
  )
  ```

  ```python
  from sentry_sdk import capture_message
  capture_message("Hello World")  # Will create an event in Sentry.
  raise ValueError()  # Will also create an event in Sentry.
  ```
  - To learn more about how to use the SDK [refer to our docs](https://docs.sentry.io/platforms/python/)
  - Are you coming from raven-python? [Use this migration guide](https://docs.sentry.io/platforms/python/migration/)
  - To learn about internals use the [API Reference](https://getsentry.github.io/sentry-python/)

  (If you want to create a new integration have a look at the [Adding a new integration checklist](CONTRIBUTING.md#adding-a-new-integration-checklist).)
  - [Django](https://docs.sentry.io/platforms/python/guides/django/)
  - [Flask](https://docs.sentry.io/platforms/python/guides/flask/)
  - [Bottle](https://docs.sentry.io/platforms/python/guides/bottle/)
  - [AWS Lambda](https://docs.sentry.io/platforms/python/guides/aws-lambda/)
  - [Google Cloud Functions](https://docs.sentry.io/platforms/python/guides/gcp-functions/)
  - [WSGI](https://docs.sentry.io/platforms/python/guides/wsgi/)
  - [ASGI](https://docs.sentry.io/platforms/python/guides/asgi/)
  - [Starlette](https://docs.sentry.io/platforms/python/guides/starlette/)
  - [FastAPI](https://docs.sentry.io/platforms/python/guides/fastapi/)
  - [AIOHTTP](https://docs.sentry.io/platforms/python/guides/aiohttp/)
  - [RQ (Redis Queue)](https://docs.sentry.io/platforms/python/guides/rq/)
  - [Celery](https://docs.sentry.io/platforms/python/guides/celery/)
  - [Chalice](https://docs.sentry.io/platforms/python/guides/chalice/)
  - [Falcon](https://docs.sentry.io/platforms/python/guides/falcon/)
  - [Quart](https://docs.sentry.io/platforms/python/guides/quart/)
  - [Sanic](https://docs.sentry.io/platforms/python/guides/sanic/)
  - [Tornado](https://docs.sentry.io/platforms/python/guides/tornado/)
  - [Tryton](https://docs.sentry.io/platforms/python/guides/tryton/)
  - [Pyramid](https://docs.sentry.io/platforms/python/guides/pyramid/)
  - [Logging](https://docs.sentry.io/platforms/python/guides/logging/)
  - [Apache Airflow](https://docs.sentry.io/platforms/python/guides/airflow/)
  - [Apache Beam](https://docs.sentry.io/platforms/python/guides/beam/)
  - [Apache Spark](https://docs.sentry.io/platforms/python/guides/pyspark/)

  The old `raven-python` client has entered maintenance mode and was moved [here](https://github.com/getsentry/raven-python).
  If you're using `raven-python`, we recommend you to migrate to this new SDK. You can find the benefits of migrating and how to do it in our [migration guide](https://docs.sentry.io/platforms/python/migration/).

  Please refer to [CONTRIBUTING.md](CONTRIBUTING.md).

  If you need help setting up or configuring the Python SDK (or anything else in the Sentry universe) please head over to the [Sentry Community on Discord](https://discord.com/invite/Ww9hbqr). There is a ton of great people in our Discord community ready to help you!

  - [![Documentation](https://img.shields.io/badge/documentation-sentry.io-green.svg)](https://docs.sentry.io/quickstart/)
  - [![Forum](https://img.shields.io/badge/forum-sentry-green.svg)](https://forum.sentry.io/c/sdks)
  - [![Discord](https://img.shields.io/discord/621778831602221064)](https://discord.gg/Ww9hbqr)
  - [![Stack Overflow](https://img.shields.io/badge/stack%20overflow-sentry-green.svg)](http://stackoverflow.com/questions/tagged/sentry)
  - [![Twitter Follow](https://img.shields.io/twitter/follow/getsentry?label=getsentry&style=social)](https://twitter.com/intent/follow?screen_name=getsentry)

  Licensed under the MIT license, see [`LICENSE`](LICENSE)


pkgId: b55dffacc3831837573eab6212423cb443b7b5395a79da23d1bf523522d47e3b
name: python-seqdiag
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: seqdiag generates sequence-diagram image from text
url: http://blockdiag.com/
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5947e4c7-fcd7-4e14-bce1-c62e8c96ce6e
location_href: 00005061-python-seqdiag/python-seqdiag-3.0.0-1.src.rpm
checksum_type: sha256
description:
  * Generate sequence-diagram from dot like text (basic feature).
  * Multilingualization for node-label (utf-8 only).
  You can get some examples and generated images on
  `blockdiag.com <http://blockdiag.com/en/seqdiag/index.html>`__ .


pkgId: fbbb4691b3243918fa6fe739f5b21acd457a35284955fe842dd6b92a2d2431a7
name: python-seqeval
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: Testing framework for sequence labeling
url: https://github.com/chakki-works/seqeval
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ffc8ecbd-bc28-4543-ba7f-f12e6756da6e
location_href: 00010298-python-seqeval/python-seqeval-1.2.2-1.src.rpm
checksum_type: sha256
description:
  seqeval is a Python framework for sequence labeling evaluation.
  seqeval can evaluate the performance of chunking tasks such as named-entity recognition, part-of-speech tagging, semantic role labeling and so on.

  This is well-tested by using the Perl script [conlleval](https://www.clips.uantwerpen.be/conll2002/ner/bin/conlleval.txt),
  which can be used for measuring the performance of a system that has processed the CoNLL-2000 shared task data.



  seqeval supports following schemes:

  - IOB1
  - IOB2
  - IOE1
  - IOE2
  - IOBES(only in strict mode)
  - BILOU(only in strict mode)

  and following metrics:

  | metrics  | description  |
  |---|---|
  | accuracy_score(y\_true, y\_pred)  | Compute the accuracy.  |
  | precision_score(y\_true, y\_pred)  | Compute the precision.  |
  | recall_score(y\_true, y\_pred)  | Compute the recall.  |
  | f1_score(y\_true, y\_pred)  | Compute the F1 score, also known as balanced F-score or F-measure.  |
  | classification_report(y\_true, y\_pred, digits=2)  | Build a text report showing the main classification metrics. `digits` is number of digits for formatting output floating point values. Default value is `2`. |



  seqeval supports the two evaluation modes. You can specify the following mode to each metrics:

  - default
  - strict

  The default mode is compatible with [conlleval](https://www.clips.uantwerpen.be/conll2002/ner/bin/conlleval.txt). If you want to use the default mode, you don't need to specify it:

  ```python
  >>> from seqeval.metrics import accuracy_score
  >>> from seqeval.metrics import classification_report
  >>> from seqeval.metrics import f1_score
  >>> y_true = [['O', 'O', 'O', 'B-MISC', 'I-MISC', 'I-MISC', 'O'], ['B-PER', 'I-PER', 'O']]
  >>> y_pred = [['O', 'O', 'B-MISC', 'I-MISC', 'I-MISC', 'I-MISC', 'O'], ['B-PER', 'I-PER', 'O']]
  >>> f1_score(y_true, y_pred)
  0.50
  >>> classification_report(y_true, y_pred)
                precision    recall  f1-score   support

          MISC       0.00      0.00      0.00         1
           PER       1.00      1.00      1.00         1

     micro avg       0.50      0.50      0.50         2
     macro avg       0.50      0.50      0.50         2
  weighted avg       0.50      0.50      0.50         2
  ```

  In strict mode, the inputs are evaluated according to the specified schema. The behavior of the strict mode is different from the default one which is designed to simulate conlleval. If you want to use the strict mode, please specify `mode='strict'` and `scheme` arguments at the same time:

  ```python
  >>> from seqeval.scheme import IOB2
  >>> classification_report(y_true, y_pred, mode='strict', scheme=IOB2)
                precision    recall  f1-score   support

          MISC       0.00      0.00      0.00         1
           PER       1.00      1.00      1.00         1

     micro avg       0.50      0.50      0.50         2
     macro avg       0.50      0.50      0.50         2
  weighted avg       0.50      0.50      0.50         2
  ```

  A minimum case to explain differences between the default and strict mode:

  ```python
  >>> from seqeval.metrics import classification_report
  >>> from seqeval.scheme import IOB2
  >>> y_true = [['B-NP', 'I-NP', 'O']]
  >>> y_pred = [['I-NP', 'I-NP', 'O']]
  >>> classification_report(y_true, y_pred)
                precision    recall  f1-score   support
            NP       1.00      1.00      1.00         1
     micro avg       1.00      1.00      1.00         1
     macro avg       1.00      1.00      1.00         1
  weighted avg       1.00      1.00      1.00         1
  >>> classification_report(y_true, y_pred, mode='strict', scheme=IOB2)
                precision    recall  f1-score   support
            NP       0.00      0.00      0.00         1
     micro avg       0.00      0.00      0.00         1
     macro avg       0.00      0.00      0.00         1
  weighted avg       0.00      0.00      0.00         1
  ```



  To install seqeval, simply run:

  ```bash
  pip install seqeval
  ```



  [MIT](https://github.com/chakki-works/seqeval/blob/master/LICENSE)



  ```tex
  @misc{seqeval,
    title={{seqeval}: A Python framework for sequence labeling evaluation},
    url={https://github.com/chakki-works/seqeval},
    note={Software available from https://github.com/chakki-works/seqeval},
    author={Hiroki Nakayama},
    year={2018},
  }
  ```


pkgId: 1f835463f1be9ec65beaf5fba7da5b5767ca3c9c66d53815f6dbdc1e2524b85f
name: python-serpent
arch: src
version: 1.41
epoch: 0
release: 1
summary: Serialization based on ast.literal_eval
url: https://github.com/irmen/Serpent
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8f867b51-29f4-40e3-bc69-b15b58fa5f7f
location_href: 00005062-python-serpent/python-serpent-1.41-1.src.rpm
checksum_type: sha256
description:
  Serpent is a simple serialization library based on ast.literal_eval.

  Because it only serializes literals and recreates the objects using ast.literal_eval(),
  the serialized data is safe to transport to other machines (over the network for instance)
  and de-serialize it there.

  *There is also a Java and a .NET (C#) implementation available. This allows for easy data transfer between the various ecosystems.
  You can get the full source distribution, a Java .jar file, and a .NET assembly dll.*
  The java library can be obtained from Maven central (groupid ``net.razorvine`` artifactid ``serpent``),
  and the .NET assembly can be obtained from Nuget.org (package ``Razorvine.Serpent``).


  **API**

  - ``ser_bytes = serpent.dumps(obj, indent=False, module_in_classname=False):``      # serialize obj tree to bytes
  - ``obj = serpent.loads(ser_bytes)``     # deserialize bytes back into object tree
  - You can use ``ast.literal_eval`` yourself to deserialize, but ``serpent.deserialize``
    works around a few corner cases. See source for details.

  Serpent is more sophisticated than a simple repr() + literal_eval():

  - it serializes directly to bytes (utf-8 encoded), instead of a string, so it can immediately be saved to a file or sent over a socket
  - it encodes byte-types as base-64 instead of inefficient escaping notation that repr would use (this does mean you have
    to base-64 decode these strings manually on the receiving side to get your bytes back.
    You can use the serpent.tobytes utility function for this.)
  - it contains a few custom serializers for several additional Python types such as uuid, datetime, array and decimal
  - it tries to serialize unrecognised types as a dict (you can control this with __getstate__ on your own types)
  - it can create a pretty-printed (indented) output for readability purposes
  - it outputs the keys of sets and dicts in alphabetical order (when pretty-printing)
  - it works around a few quirks of ast.literal_eval() on the various Python implementations

  Serpent allows comments in the serialized data (because it is just Python source code).
  Serpent can't serialize object graphs (when an object refers to itself); it will then crash with a ValueError pointing out the problem.

  Works with Python 3 recent versions.

  **FAQ**

  - Why not use XML? Answer: because XML.
  - Why not use JSON? Answer: because JSON is quite limited in the number of datatypes it supports, and you can't use comments in a JSON file.
  - Why not use pickle? Answer: because pickle has security problems.
  - Why not use ``repr()``/``ast.literal_eval()``? See above; serpent is a superset of this and provides more convenience.
    Serpent provides automatic serialization mappings for types other than the builtin primitive types.
    ``repr()`` can't serialize these to literals that ``ast.literal_eval()`` understands.
  - Why not a binary format? Answer: because binary isn't readable by humans.
  - But I don't care about readability. Answer: doesn't matter, ``ast.literal_eval()`` wants a literal string, so that is what we produce.
  - But I want better performance. Answer: ok, maybe you shouldn't use serpent in this case. Find an efficient binary protocol (protobuf?)
  - Why only Python, Java and C#/.NET, but no bindings for insert-favorite-language-here? Answer: I don't speak that language.
    Maybe you could port serpent yourself?
  - Where is the source?  It's on Github: https://github.com/irmen/Serpent
  - Can I use it everywhere?  Sure, as long as you keep the copyright and disclaimer somewhere. See the LICENSE file.

  **Demo**

  .. code:: python

   
   import ast
   import uuid
   import datetime
   import pprint
   import serpent


   class DemoClass:
       def __init__(self):
           self.i=42
           self.b=False

   data = {
       "names": ["Harry", "Sally", "Peter"],
       "big": 2**200,
       "colorset": { "red", "green" },
       "id": uuid.uuid4(),
       "timestamp": datetime.datetime.now(),
       "class": DemoClass(),
       "unicode": "€"
   }

   
   ser = serpent.dumps(data, indent=True)
   open("data.serpent", "wb").write(ser)

   print("Serialized form:")
   print(ser.decode("utf-8"))

   
   data = serpent.load(open("data.serpent", "rb"))
   print("Data:")
   pprint.pprint(data)

   
   ser_string = open("data.serpent", "r", encoding="utf-8").read()
   data2 = ast.literal_eval(ser_string)

   assert data2==data


  When you run this it prints:

  .. code:: python

   Serialized form:
   
   {
     'big': 1606938044258990275541962092341162602522202993782792835301376,
     'class': {
       '__class__': 'DemoClass',
       'b': False,
       'i': 42
     },
     'colorset': {
       'green',
       'red'
     },
     'id': 'e461378a-201d-4844-8119-7c1570d9d186',
     'names': [
       'Harry',
       'Sally',
       'Peter'
     ],
     'timestamp': '2013-04-02T00:23:00.924000',
     'unicode': '€'
   }
   Data:
   {'big': 1606938044258990275541962092341162602522202993782792835301376,
    'class': {'__class__': 'DemoClass', 'b': False, 'i': 42},
    'colorset': {'green', 'red'},
    'id': 'e461378a-201d-4844-8119-7c1570d9d186',
    'names': ['Harry', 'Sally', 'Peter'],
    'timestamp': '2013-04-02T00:23:00.924000',
    'unicode': '€'}


pkgId: f45eeae7d69331e774a14fcaeea58c7c162fd2eb395ae719aa75c2800fc9c741
name: python-serverless-wsgi
arch: src
version: 3.0.2
epoch: 0
release: 1
summary: Amazon AWS API Gateway WSGI wrapper
url: https://github.com/logandk/serverless-wsgi
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7e418360-e5bd-4905-99c1-1d6247a372ff
location_href: 00013866-python-serverless-wsgi/python-serverless-wsgi-3.0.2-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://logandk.github.io/serverless-wsgi/assets/header.svg">
  </p>

  [![npm package](https://nodei.co/npm/serverless-wsgi.svg?downloads=true&downloadRank=true&stars=true)](https://nodei.co/npm/serverless-wsgi/)

  [![serverless](http://public.serverless.com/badges/v3.svg)](http://www.serverless.com)
  [![Build Status](https://travis-ci.org/logandk/serverless-wsgi.svg?branch=master)](https://travis-ci.org/logandk/serverless-wsgi)
  [![Coverage Status](https://codecov.io/gh/logandk/serverless-wsgi/branch/master/graph/badge.svg)](https://codecov.io/gh/logandk/serverless-wsgi)
  [![Dependency Status](https://david-dm.org/logandk/serverless-wsgi.svg)](https://david-dm.org/logandk/serverless-wsgi)
  [![Dev Dependency Status](https://david-dm.org/logandk/serverless-wsgi/dev-status.svg)](https://david-dm.org/logandk/serverless-wsgi?type=dev)

  A Serverless Framework plugin to build your deploy Python WSGI applications using Serverless. Compatible
  WSGI application frameworks include Flask, Django and Pyramid - for a complete list, see:
  http://wsgi.readthedocs.io/en/latest/frameworks.html.



  - Transparently converts API Gateway and ALB requests to and from standard WSGI requests
  - Supports anything you'd expect from WSGI such as redirects, cookies, file uploads etc.
  - Automatically downloads Python packages that you specify in `requirements.txt` and deploys them along with your application
  - Convenient `wsgi serve` command for serving your application locally during development
  - Includes CLI commands for remote execution of Python code (`wsgi exec`), shell commands (`wsgi command`), Flask CLI commands (`wsgi flask`) and Django management commands (`wsgi manage`)
  - Supports both APIGatewayV1 and APIGatewayV2 payloads



  ```
  sls plugin install -n serverless-wsgi
  ```

  This will automatically add the plugin to `package.json` and the plugins section of `serverless.yml`.



  <p align="center">
    <img src="https://logandk.github.io/serverless-wsgi/assets/hello-world.svg">
  </p>

  This example assumes that you have intialized your application as `app` inside `api.py`.

  ```
  project
  ├── api.py
  ├── requirements.txt
  └── serverless.yml
  ```



  A regular Flask application.

  ```python
  from flask import Flask
  app = Flask(__name__)


  @app.route("/cats")
  def cats():
      return "Cats"


  @app.route("/dogs/<id>")
  def dog(id):
      return "Dog"
  ```



  Load the plugin and set the `custom.wsgi.app` configuration in `serverless.yml` to the
  module path of your Flask application.

  All functions that will use WSGI need to have `wsgi_handler.handler` set as the Lambda handler and
  use the default `lambda-proxy` integration for API Gateway. This configuration example treats
  API Gateway as a transparent proxy, passing all requests directly to your Flask application,
  and letting the application handle errors, 404s etc.

  _Note: The WSGI handler was called `wsgi.handler` earlier, but was renamed to `wsgi_handler.handler`
  in `1.7.0`. The old name is still supported but using it will cause a deprecation warning._

  ```yaml
  service: example

  provider:
    name: aws
    runtime: python3.6

  plugins:
    - serverless-wsgi

  functions:
    api:
      handler: wsgi_handler.handler
      events:
        - http: ANY /
        - http: ANY /{proxy+}

  custom:
    wsgi:
      app: api.app
  ```



  Add Flask to the application bundle.

  ```
  Flask==1.0.2
  ```



  Simply run the serverless deploy command as usual:

  ```
  $ sls deploy
  Serverless: Using Python specified in "runtime": python3.6
  Serverless: Packaging Python WSGI handler...
  Serverless: Packaging required Python packages...
  Serverless: Linking required Python packages...
  Serverless: Packaging service...
  Serverless: Excluding development dependencies...
  Serverless: Unlinking required Python packages...
  Serverless: Uploading CloudFormation file to S3...
  Serverless: Uploading artifacts...
  Serverless: Uploading service .zip file to S3 (864.57 KB)...
  Serverless: Validating template...
  Serverless: Updating Stack...
  Serverless: Checking Stack update progress...
  ..............
  Serverless: Stack update finished...
  ```



  Set `custom.wsgi.app` in `serverless.yml` according to your WSGI callable:

  - For Pyramid, use [make_wsgi_app](http://docs.pylonsproject.org/projects/pyramid/en/latest/api/config.html#pyramid.config.Configurator.make_wsgi_app) to intialize the callable
  - Django is configured for WSGI by default, set the callable to `<project_name>.wsgi.application`. See https://docs.djangoproject.com/en/1.10/howto/deployment/wsgi/ for more information.





  You'll need to include any packages that your application uses in the bundle
  that's deployed to AWS Lambda. This plugin helps you out by doing this automatically,
  as long as you specify your required packages in a `requirements.txt` file in the root
  of your Serverless service path:

  ```
  Flask==1.0.2
  requests==2.21.0
  ```

  For more information, see https://pip.pypa.io/en/latest/user_guide/#requirements-files.

  The `serverless-wsgi` plugin itself depends on `werkzeug` and will package it automatically,
  even if `werkzeug` is not present in your `requirements.txt`.

  You can use the requirement packaging functionality of _serverless-wsgi_ without the WSGI
  handler itself by including the plugin in your `serverless.yml` configuration, without specifying
  the `custom.wsgi.app` setting. This will omit the WSGI handler from the package, but include
  any requirements specified in `requirements.txt`.

  If you don't want to use automatic requirement packaging you can set `custom.wsgi.packRequirements` to false:

  ```yaml
  custom:
    wsgi:
      app: api.app
      packRequirements: false
  ```

  In order to pass additional arguments to `pip` when installing requirements, the `pipArgs` configuration
  option is available:

  ```yaml
  custom:
    wsgi:
      app: api.app
      pipArgs: --no-deps
  ```

  For a more advanced approach to packaging requirements, consider using https://github.com/UnitedIncome/serverless-python-requirements.
  When the `serverless-python-requirements` is added to `serverless.yml`, the `packRequirements` option
  is set to `false` by default.

  If you have `packRequirements` set to `false`, or if you use `serverless-python-requirements`, remember to add
  `werkzeug` explicitly in your `requirements.txt`.



  Python is used for packaging requirements and serving the app when invoking `sls wsgi serve`. By
  default, the current runtime setting is expected to be the name of the Python binary in `PATH`,
  for instance `python3.6`. If this is not the name of your Python binary, override it using the
  `pythonBin` option:

  ```yaml
  custom:
    wsgi:
      app: api.app
      pythonBin: python3
  ```



  <p align="center">
    <img src="https://logandk.github.io/serverless-wsgi/assets/serve.svg">
  </p>

  For convenience, a `sls wsgi serve` command is provided to run your WSGI application
  locally. This command requires the `werkzeug` Python package to be installed,
  and acts as a simple wrapper for starting werkzeug's built-in HTTP server.

  By default, the server will start on port 5000.
  (Note: macOS [reserves port 5000](https://twitter.com/mitsuhiko/status/1462734023164416009)
  for AirPlay by default, see below for instructions on changing the port.)

  ```
  $ sls wsgi serve
   * Running on http://localhost:5000/ (Press CTRL+C to quit)
   * Restarting with stat
   * Debugger is active!
  ```

  Configure the port using the `-p` parameter:

  ```
  $ sls wsgi serve -p 8000
   * Running on http://localhost:8000/ (Press CTRL+C to quit)
   * Restarting with stat
   * Debugger is active!
  ```

  When running locally, an environment variable named `IS_OFFLINE` will be set to `True`.
  So, if you want to know when the application is running locally, check `os.environ["IS_OFFLINE"]`.



  <p align="center">
    <img src="https://logandk.github.io/serverless-wsgi/assets/command.svg">
  </p>

  The `wsgi exec` command lets you execute Python code remotely:

  ```
  $ sls wsgi exec -c "import math; print((1 + math.sqrt(5)) / 2)"
  1.618033988749895

  $ cat count.py
  for i in range(3):
      print(i)

  $ sls wsgi exec -f count.py
  0
  1
  2
  ```

  The `wsgi command` command lets you execute shell commands remotely:

  ```
  $ sls wsgi command -c "pwd"
  /var/task

  $ cat script.sh

  echo "dlrow olleh" | rev

  $ sls wsgi command -f script.sh
  hello world
  ```

  The `wsgi flask` command lets you execute [Flask CLI custom commands](http://flask.pocoo.org/docs/latest/cli/#custom-commands) remotely:

  ```
  $ sls wsgi flask -c "my command"
  Hello world!
  ```

  The `wsgi manage` command lets you execute Django management commands remotely:

  ```
  $ sls wsgi manage -c "check --list-tags"
  admin
  caches
  database
  models
  staticfiles
  templates
  urls
  ```

  All commands have `local` equivalents that let you run commands through `sls invoke local` rather
  than `sls invoke`, i.e. on the local machine instead of through Lambda. The `local` commands (`sls wsgi command local`,
  `sls wsgi exec local`, `sls wsgi flask local` and `sls wsgi manage local`) take the same arguments
  as their remote counterparts documented above.



  If you'd like to be explicit about which routes and HTTP methods should pass through to your
  application, see the following example:

  ```yaml
  service: example

  provider:
    name: aws
    runtime: python3.6

  plugins:
    - serverless-wsgi

  functions:
    api:
      handler: wsgi_handler.handler
      events:
        - http:
            path: cats
            method: get
            integration: lambda-proxy
        - http:
            path: dogs/{id}
            method: get
            integration: lambda-proxy

  custom:
    wsgi:
      app: api.app
  ```



  If you use custom domain names with API Gateway, you might have a base path that is
  at the beginning of your path, such as the stage (`/dev`, `/stage`, `/prod`). In this case, set
  the `API_GATEWAY_BASE_PATH` environment variable to let `serverless-wsgi` know.
  E.g, if you deploy your WSGI application to https://mydomain.com/api/myservice,
  set `API_GATEWAY_BASE_PATH` to `api/myservice` (no `/` first).

  The example below uses the [serverless-domain-manager](https://github.com/amplify-education/serverless-domain-manager)
  plugin to handle custom domains in API Gateway:

  ```yaml
  service: example

  provider:
    name: aws
    runtime: python3.6
    environment:
      API_GATEWAY_BASE_PATH: ${self:custom.customDomain.basePath}

  plugins:
    - serverless-wsgi
    - serverless-domain-manager

  functions:
    api:
      handler: wsgi_handler.handler
      events:
        - http: ANY /
        - http: ANY {proxy+}

  custom:
    wsgi:
      app: api.app
    customDomain:
      basePath: ${opt:stage}
      domainName: mydomain.name.com
      stage: ${opt:stage}
      createRoute53Record: true
  ```

  **Note**: The **API_GATEWAY_BASE_PATH** configuration is only needed when using the payload V1. In the V2, the path does not have the **basePath** in the beginning.



  If you're configuring CloudFront manually in front of your API and setting
  the Path in the CloudFront Origin to include your stage name, you'll need
  to strip it out from the path supplied to WSGI. This is so that your app
  doesn't generate URLs starting with `/production`.

  Pass the `STRIP_STAGE_PATH=yes` environment variable to your application
  to set this:

  ```yaml
  service: example

  provider:
    name: aws
    runtime: python3.6
    environment:
      STRIP_STAGE_PATH: yes
  ```



  In order to accept file uploads from HTML forms, make sure to add `multipart/form-data` to
  the list of content types with _Binary Support_ in your API Gateway API. The
  [serverless-apigw-binary](https://github.com/maciejtreder/serverless-apigw-binary)
  Serverless plugin can be used to automate this process.

  Keep in mind that, when building Serverless applications, uploading
  [directly to S3](http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingHTTPPOST.html)
  from the browser is usually the preferred approach.



  The raw context and event from AWS Lambda are both accessible through the WSGI
  request. The following example shows how to access them when using Flask:

  ```python
  from flask import Flask, request
  app = Flask(__name__)


  @app.route("/")
  def index():
      print(request.environ['serverless.context'])
      print(request.environ['serverless.event'])
  ```

  For more information on these objects, read the documentation on [events](https://docs.aws.amazon.com/lambda/latest/dg/lambda-services.html)
  and the [invocation context](https://docs.aws.amazon.com/lambda/latest/dg/python-context.html).



  By default, all MIME types starting with `text/` and the following whitelist are sent
  through API Gateway in plain text. All other MIME types will have their response body
  base64 encoded (and the `isBase64Encoded` API Gateway flag set) in order to be
  delivered by API Gateway as binary data (remember to add any binary MIME types that
  you're using to the _Binary Support_ list in API Gateway).

  This is the default whitelist of plain text MIME types:

  - `application/json`
  - `application/javascript`
  - `application/xml`
  - `application/vnd.api+json`
  - `image/svg+xml`

  In order to add additional plain text MIME types to this whitelist, use the
  `textMimeTypes` configuration option:

  ```yaml
  custom:
    wsgi:
      app: api.app
      textMimeTypes:
        - application/custom+json
        - application/vnd.company+json
  ```



  Common ways to keep lambda functions warm include [scheduled events](https://serverless.com/framework/docs/providers/aws/events/schedule/)
  and the [WarmUP plugin](https://github.com/FidelLimited/serverless-plugin-warmup). Both these event sources
  are supported by default and will be ignored by `serverless-wsgi`.



  If you have several functions in `serverless.yml` and want to organize them in
  directories, e.g.:

  ```
  project
  ├── web
  │   ├── api.py
  │   └── requirements.txt
  ├── serverless.yml
  └── another_function.py
  ```

  In this case, tell `serverless-wsgi` where to find the handler by prepending the
  directory:

  ```yaml
  service: example

  provider:
    name: aws
    runtime: python3.6

  plugins:
    - serverless-wsgi

  functions:
    api:
      handler: wsgi_handler.handler
      events:
        - http: ANY /
        - http: ANY {proxy+}

    another_function:
      handler: another_function.handler

  custom:
    wsgi:
      app: web/api.app
  ```

  Requirements will now be installed into `web/`, rather than at in the service root directory.

  The same rule applies when using the `individually: true` flag in the `package` settings, together
  with the `module` option provided by `serverless-python-requirements`. In that case, both the requirements
  and the WSGI handler will be installed into `web/`, if the function is configured with `module: "web"`.



  The AWS API Gateway to WSGI mapping module is available on PyPI in the
  `serverless-wsgi` package.

  Use this package if you need to deploy Python Lambda functions to handle
  API Gateway events directly, without using the Serverless framework.

  ```
  pip install serverless-wsgi
  ```

  Initialize your WSGI application and in your Lambda event handler, call
  the request mapper:

  ```python
  import app  # Replace with your actual application
  import serverless_wsgi






  def handler(event, context):
      return serverless_wsgi.handle_request(app.app, event, context)
  ```



  Thanks to [Zappa](https://github.com/Miserlou/Zappa), which has been both the
  inspiration and source of several implementations that went into this project.

  Thanks to [chalice](https://github.com/awslabs/chalice) for the
  requirement packaging implementation.


pkgId: 6b1defbf021d3d0a1748455e68285348f0a61b3b5a44a69ae0b57563def448da
name: python-setproctitle
arch: src
version: 1.3.2
epoch: 0
release: 1
summary: A Python module to customize the process title
url: https://github.com/dvarrazzo/py-setproctitle
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3696e355-8db6-4761-91b6-5184ee60aaff
location_href: 00005065-python-setproctitle/python-setproctitle-1.3.2-1.src.rpm
checksum_type: sha256
description:
  The ``setproctitle`` module allows a process to change its title (as displayed
  by system tools such as ``ps``, ``top`` or MacOS Activity Monitor).
  Changing the title is mostly useful in multi-process systems, for example
  when a master process is forked: changing the children's title allows to
  identify the task each process is busy with.  The technique is used by
  PostgreSQL_ and the `OpenSSH Server`_ for example.
  The procedure is hardly portable across different systems.  PostgreSQL provides
  a good `multi-platform implementation`__:  this package was born as a wrapper
  around PostgreSQL code.
  - `Homepage <https://github.com/dvarrazzo/py-setproctitle>`__
  - `Download <http://pypi.python.org/pypi/setproctitle/>`__
  - `Bug tracker <https://github.com/dvarrazzo/py-setproctitle/issues>`__


pkgId: 5a42440d1febd39b7f5650b1b722b9a848996a68329e00899385d786512e47ad
name: python-setproctitle-debuginfo
arch: x86_64
version: 1.3.2
epoch: 0
release: 1
summary: Debug information for package python-setproctitle
url: https://github.com/dvarrazzo/py-setproctitle
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-3696e355-8db6-4761-91b6-5184ee60aaff
rpm_sourcerpm: python-setproctitle-1.3.2-1.src.rpm
location_href: 00005065-python-setproctitle/python-setproctitle-debuginfo-1.3.2-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-setproctitle.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 3f22b0f3bfd238e284cec766242719b69223239c63b41ac0a7a26bd495bea6d8
name: python-setproctitle-debugsource
arch: x86_64
version: 1.3.2
epoch: 0
release: 1
summary: Debug sources for package python-setproctitle
url: https://github.com/dvarrazzo/py-setproctitle
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-3696e355-8db6-4761-91b6-5184ee60aaff
rpm_sourcerpm: python-setproctitle-1.3.2-1.src.rpm
location_href: 00005065-python-setproctitle/python-setproctitle-debugsource-1.3.2-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-setproctitle.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 51b95846022dbb37c0f3d087c9849e2ecc33420b0cf4f03cf40450210b2fdeac
name: python-setuptools-git
arch: src
version: 1.2
epoch: 0
release: 1
summary: Setuptools revision control system plugin for Git
url: https://github.com/msabramo/setuptools-git
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3e66c484-8646-4980-9024-98840c501bcc
location_href: 00009405-python-setuptools-git/python-setuptools-git-1.2-1.src.rpm
checksum_type: sha256
description:
  This is a plugin for setuptools that enables git integration. Once
  installed, Setuptools can be told to include in a package distribution
  all the files tracked by git. This is an alternative to explicit
  inclusion specifications with ``MANIFEST.in``.
  A package distribution here refers to a package that you create using
  setup.py, for example::
    $> python setup.py sdist
    $> python setup.py bdist_rpm
    $> python setup.py bdist_egg
  This package was formerly known as gitlsfiles. The name change is the
  result of an effort by the setuptools plugin developers to provide a
  uniform naming convention.


pkgId: fc03adc78c3c83ca76c003c7edf1bdf2df14696e2c0ea51bc0dc837263ba5400
name: python-setuptools-scm-git-archive
arch: src
version: 1.4
epoch: 0
release: 1
summary: setuptools_scm plugin for git archives
url: https://github.com/Changaco/setuptools_scm_git_archive/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dc9ff4de-5e1c-4ea0-9926-e93a8cb98e1a
location_href: 00005070-python-setuptools_scm_git_archive/python-setuptools-scm-git-archive-1.4-1.src.rpm
checksum_type: sha256
description:
  Change the contents of the ``.git_archival.txt`` file in the root directory of your repository from::
      ref-names: $Format:%D$
  to::
      node: $Format:%H$
      node-date: $Format:%cI$
      describe-name: $Format:$
      ref-names: $Format:%D$
  Remove ``setuptools_scm_git_archive`` from your project's dependencies (e.g. the
  ``setup_requires`` list in your ``setup.py`` file).


pkgId: 2c16cd3e34aba9f44c52498950650c5e448758779cbd563c71c600066a26422d
name: python-setuptools_hg
arch: src
version: 0.4
epoch: 0
release: 1
summary: Setuptools/distribute plugin for finding files under Mercurial version control.
url: http://bitbucket.org/jezdez/setuptools_hg/
rpm_license: GPL2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5052044f-18b2-4b3a-8821-619d763f1548
location_href: 00005068-python-setuptools_hg/python-setuptools_hg-0.4-1.src.rpm
checksum_type: sha256
description:
  setuptools_hg is a plugin for setuptools/distribute to enable it to find
  files under the Mercurial version control system.
  It uses the Mercurial Python library by default and falls back to use the
  command line programm `hg(1)`_. That's especially useful inside virtualenvs
  that don't have access to the system wide installed Mercurial lib (e.g. when
  created with ``--no-site-packages``).
    You can read about the hooks used by setuptool_hg in the setuptools_ or
    distribute_ documentation. It basically returns a list of files that are
    under Mercurial version control when running the ``setup`` function, e.g. if
    you create a source and binary distribution. It's a simple yet effective way
    of not having to define package data (non-Python files) manually in MANIFEST
    templates (``MANIFEST.in``).
  Usage
  *****
  Here's an example of a setup.py that uses setuptools_hg::
      from setuptools import setup, find_packages
      setup(
          name="HelloWorld",
          version="0.1",
          packages=find_packages(),
          setup_requires=["setuptools_hg"],
      )
  If you run this setup.py setuptools will automatically download setuptools_hg
  to the directory where the setup.py is located at (and won't install it
  anywhere else) to get all package data files from the Mercurial repository.
  Options
  *******
  Set the ``HG_SETUPTOOLS_FORCE_CMD`` environment variable before running
  setup.py if you want to enforce the use of the hg command.
  """
  CHANGES
  *******


pkgId: 290ab744562740d576c9b730cfbc28ab298d081153a1af5c978e1b1afa0e2b10
name: python-sexpdata
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: S-expression parser for Python
url: https://github.com/jd-boyd/sexpdata
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-34ce0ba1-f155-45eb-9863-69a8b743d4eb
location_href: 00005071-python-sexpdata/python-sexpdata-1.0.0-1.src.rpm
checksum_type: sha256
description:
  `sexpdata` is a simple S-expression parser/serializer.  It has
  simple `load` and `dump` functions like `pickle`, `json` or `PyYAML`
  module.
  >>> from sexpdata import loads, dumps
  >>> loads('("a" "b")')
  ['a', 'b']
  >>> print(dumps(['a', 'b']))
  ("a" "b")
  You can install `sexpdata` from PyPI_::
    pip install sexpdata
  Links:
  * `Documentation (at Read the Docs) <http://sexpdata.readthedocs.org/>`_
  * `Repository (at GitHub) <https://github.com/jd-boyd/sexpdata>`_
  * `Issue tracker (at GitHub) <https://github.com/jd-boyd/sexpdata/issues>`_
  * `PyPI <http://pypi.python.org/pypi/sexpdata>`_
  * `Travis CI <https://travis-ci.org/#!/jd-boyd/sexpdata>`_


pkgId: 02af6a2b03b7dae74a5c124b53d05fb9663ec9c3f97d6f1d9f2751e46ee12ccf
name: python-sgp4
arch: src
version: 2.21
epoch: 0
release: 1
summary: Track Earth satellites given TLE data, using up-to-date 2020 SGP4 routines.
url: https://github.com/brandon-rhodes/python-sgp4
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dc46c421-0603-47d3-a54e-827fddb3b92c
location_href: 00011007-python-sgp4/python-sgp4-2.21-1.src.rpm
checksum_type: sha256
description:
  This library uses the same function names as the official C++ code, to
  help users who may already be familiar with SGP4 in other languages.
  Here is how to compute the x,y,z position and velocity for the
  International Space Station at 12:50:19 on 29 June 2000:
  >>> from sgp4.api import Satrec
  >>>
  >>> s = '1 25544U 98067A   19343.69339541  .00001764  00000-0  38792-4 0  9991'
  >>> t = '2 25544  51.6439 211.2001 0007417  17.6667  85.6398 15.50103472202482'
  >>> satellite = Satrec.twoline2rv(s, t)
  >>>
  >>> jd, fr = 2458827, 0.362605
  >>> e, r, v = satellite.sgp4(jd, fr)
  >>> e
  0
  >>> print(r)  # True Equator Mean Equinox position (km)
  (-6102.44..., -986.33..., -2820.31...)
  >>> print(v)  # True Equator Mean Equinox velocity (km/s)
  (-1.45..., -5.52..., 5.10...)
  As input, you can provide either:
  * A simple floating-point Julian Date for ``jd`` and the value 0.0 for
    ``fr``, if you are happy with the precision of a 64-bit floating point
    number.  Note that modern Julian Dates are greater than 2,450,000
    which means that nearly half of the precision of a 64-bit float will
    be consumed by the whole part that specifies the day.  The remaining
    digits will provide a precision for the fraction of around 20.1 µs.
    This should be no problem for the accuracy of your result — satellite
    positions usually off by a few kilometers anyway, far less than a
    satellite moves in 20.1 µs — but if you run a solver that dives down
    into the microseconds while searching for a rising or setting time,
    the solver might be bothered by the 20.1 µs plateau between each jump
    in the satellite’s position.
  * Or, you can provide a coarse date ``jd`` plus a very precise fraction
    ``fr`` that supplies the rest of the value.  The Julian Date for which
    the satellite position is computed is the sum of the two values.  One
    common practice is to provide the whole number as ``jd`` and the
    fraction as ``fr``; another is to have ``jd`` carry the fraction 0.5
    since UTC midnight occurs halfway through each Julian Date.  Either
    way, splitting the value allows a solver to run all the way down into
    the nanoseconds and still see SGP4 respond smoothly to tiny date
    adjustments with tiny changes in the resulting satellite position.
  Here is how to intrepret the results:
  * ``e`` will be a non-zero error code if the satellite position could
    not be computed for the given date.  You can ``from sgp4.api import
    SGP4_ERRORS`` to access a dictionary mapping error codes to error
    messages explaining what each code means.
  * ``r`` measures the satellite position in **kilometers** from the
    center of the earth in the idiosyncratic True Equator Mean Equinox
    coordinate frame used by SGP4.
  * ``v`` velocity is the rate at which the position is changing,
    expressed in **kilometers per second**.
  If your application does not natively handle Julian dates, you can
  compute ``jd`` and ``fr`` from calendar dates using ``jday()``.
  >>> from sgp4.api import jday
  >>> jd, fr = jday(2019, 12, 9, 12, 0, 0)
  >>> jd
  2458826.5
  >>> fr
  0.5


