# packages

pkgId: d9db2596a524470ea11f1dc475cd9ebba4f7e24d38acf4ac95bc5bbc2624c8e7
name: python-spiceypy
arch: src
version: 5.1.2
epoch: 0
release: 1
summary: A Python Wrapper for the NAIF CSPICE Toolkit
url: https://github.com/AndrewAnnex/SpiceyPy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-18616f5d-2e7c-4f06-a979-ea169f874245
location_href: 00013552-python-spiceypy/python-spiceypy-5.1.2-1.src.rpm
checksum_type: sha256
description:
  SpiceyPy is a Python wrapper for the NAIF C SPICE Toolkit (N66), written using ctypes.
  +------------------------+-------------------+--------+-----------------+------------+--------------+
  | Continuous Integration | Code Coverage     | Docs   | Chat            |  Citation  |  Code Style  |
  +========================+===================+========+=================+============+==============+
  | |Github Build Status|  | |Coverage Status| | |Docs| | |Join the chat| | |JOSS|     |  |Black|     |
  +------------------------+-------------------+--------+-----------------+------------+--------------+


pkgId: bacc9c598143ad446c8a90f292995fba4d12a58e313a542c5045f4c56e8da7b0
name: python-spiceypy-debuginfo
arch: aarch64
version: 5.1.2
epoch: 0
release: 1
summary: Debug information for package python-spiceypy
url: https://github.com/AndrewAnnex/SpiceyPy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-18616f5d-2e7c-4f06-a979-ea169f874245
rpm_sourcerpm: python-spiceypy-5.1.2-1.src.rpm
location_href: 00013552-python-spiceypy/python-spiceypy-debuginfo-5.1.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-spiceypy.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 499f937f9cbbae1be6250f40b51c8ba00d20dab221a4b1bc87e29c87040bd286
name: python-spiceypy-debugsource
arch: aarch64
version: 5.1.2
epoch: 0
release: 1
summary: Debug sources for package python-spiceypy
url: https://github.com/AndrewAnnex/SpiceyPy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-18616f5d-2e7c-4f06-a979-ea169f874245
rpm_sourcerpm: python-spiceypy-5.1.2-1.src.rpm
location_href: 00013552-python-spiceypy/python-spiceypy-debugsource-5.1.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-spiceypy.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 773fdcfdd8850cad6eefa7b63737fa436e27c360e9e7859b9247996883b12bc1
name: python-spidev
arch: src
version: 3.6
epoch: 0
release: 1
summary: Python bindings for Linux SPI access through spidev
url: http://github.com/doceme/py-spidev
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-427b5662-56bb-41a6-997a-cc723a2f753a
location_href: 00005185-python-spidev/python-spidev-3.6-1.src.rpm
checksum_type: sha256
description:
  This project contains a python module for interfacing with SPI devices from user space via the spidev linux kernel driver.
  All code is MIT licensed unless explicitly stated otherwise.


pkgId: cd2365827517bb3f1e9064a65cfdbbcb4051b80b10be024f7b24c84fd2653823
name: python-spinners
arch: src
version: 0.0.24
epoch: 0
release: 1
summary: Spinners for terminals
url: https://github.com/manrajgrover/py-spinners
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c683c8f2-51bb-40fa-8c7e-e85c914535ad
location_href: 00010938-python-spinners/python-spinners-0.0.24-1.src.rpm
checksum_type: sha256
description:
  More than 60 spinners for terminal, this is python port of amazing node library cli-spinners. Find the documentation here: https://github.com/manrajgrover/py-spinners.


pkgId: e71eee5b9fec3d4a53494456566e25bb2f99b8d791717c7fc93de96b54004a67
name: python-spotify_tensorflow
arch: src
version: 0.7.7
epoch: 0
release: 1
summary: Spotify-specific helpers for TensorFlow
url: https://github.com/spotify/spotify-tensorflow
rpm_license: Apache-2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fe7a509d-7a2d-4c0e-b1f2-58908db40e65
location_href: 00010765-python-spotify-tensorflow/python-spotify_tensorflow-0.7.7-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://img.shields.io/circleci/project/github/spotify/spotify-tensorflow/master.svg)](https://circleci.com/gh/spotify/spotify-tensorflow)
  [![Coverage](https://img.shields.io/codecov/c/github/spotify/spotify-tensorflow/master.svg?style=flat)](https://codecov.io/github/spotify/spotify-tensorflow?branch=master)
  [![GitHub license](https://img.shields.io/github/license/spotify/spotify-tensorflow.svg)](./LICENSE)
  [![PyPI version](https://badge.fury.io/py/spotify_tensorflow.svg)](https://badge.fury.io/py/spotify_tensorflow)



  Provide Spotify specific TensorFlow helpers.



   * tf.data integration with [Featran](https://github.com/spotify/featran)
   * common Dataset API to read:
     * TFRecord datasets as tf.Tensor
     * TFRecord datasets as Pandas DataFrame
     * TFRecord datasets as python dict
   * tf.Graph freezing utilities
   * TensorFlow integration with [Luigi](https://github.com/spotify/luigi)



  Check examples in the [examples directory](https://github.com/spotify/spotify-tensorflow/tree/master/examples),
  currently they include:

   * sklearn training via Pandas DataFrame dataset
   * XGBoost training via tf.Example dataset
   * TensorFlow training via tf.Example dataset

  To run the examples:

  ```sh
  $ pip install -e .[examples]
  $ bin/run-examples
  ```



  This project uses `tox`.

  ```sh
  $ pip install tox
  ```

  To see all `testenv`'s:

  ```sh
  $ tox -l
  mypy
  lint
  examples-py27
  examples-py35
  test-py27
  test-py35
  upload-coverage
  license
  ```

  To run the tests:

  ```
  tox -e test
  ```

  To release:

  ```
  git commit --allow-empty -m "Release x.y.z"
  git tag x.y.z
  git push --tags  origin master
  ```

  Then upload to pypi:

  ```
  python setup.py sdist upload -r pypi
  ```


pkgId: 85b525da4481cdc2bde42f0be71ec3672013985b653d6ddc4061674ad09ff0db
name: python-spotinst-agent-2
arch: src
version: 2.0.10
epoch: 0
release: 1
url: https://github.com/spotinst/spotinst-spectrum-agent
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ef3dd28d-a898-474a-a2d3-3b1ed45d61f9
location_href: 00011215-python-spotinst-agent-2/python-spotinst-agent-2-2.0.10-1.src.rpm
checksum_type: sha256
summary:
  Spectrum instance spotinst-agent that is able to run remote scripts, collect data, deploy applications and more.

description:
  Spotinst Agent executor provides a mechanism to run remote shutdown scripts on machine using polling architecture.
  Note:
  The agent must have token to communicate with spotinst API.
  The credentials ini that holds the token file must be located at: '/root/.spotinst/credentials'


pkgId: b1004d5e2c4615b4d8276d52334ed727951831bb522cbc2761bedf9c6e535c2f
name: python-spotinst-sdk
arch: src
version: 1.0.56
epoch: 0
release: 1
summary: A Python SDK for Spotinst
url: https://github.com/spotinst/spotinst-sdk-python
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c9daba9c-80ab-496b-b28a-166eb7658ef2
location_href: 00011050-python-spotinst-sdk/python-spotinst-sdk-1.0.56-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/spotinst/spotinst-sdk-python.svg?branch=master)](https://travis-ci.org/spotinst/spotinst-sdk-python)
  [![Coverage Status](https://coveralls.io/repos/github/spotinst/spotinst-sdk-python/badge.svg?branch=master)](https://coveralls.io/github/spotinst/spotinst-sdk-python?branch=master)
  [![Python 2.7](https://img.shields.io/badge/python-2.7-blue.svg)](https://www.python.org/downloads/release/python-270/)
  [![Python 3.6](https://img.shields.io/badge/python-3.6-blue.svg)](https://www.python.org/downloads/release/python-360/)



  The official Spotinst SDK for the Python programming language.



  Version 2 for the Spotinst Python SDK will be moving from the `v2` branch to the `master` branch very soon. The current `master` will move to it's own `v1` branch and eventually be deprecated. Version 2 introduces some breaking changes from v1 and will require updates when switching over. Luckily this process should be easy and is completely explained on the [v2 branch in this repository](https://github.com/spotinst/spotinst-sdk-python/tree/v2). Both `v1` and `v2` will be released as `spotinst-sdk` and `spotinst-sdk2` respectively, to prevent any auto version upgrades.



  - [Installation](#installation)
  - [Authentication](#authentication)
  - [Documentation](#documentation)
  - [Getting Help](#getting-help)
  - [Community](#community)
  - [License](#license)



  ```bash
  pip install --upgrade spotinst-sdk
  ```



  The mechanism in which the SDK looks for credentials is to search through a list of possible locations and stop as soon as it finds credentials. The order in which the SDK searches for credentials is:

  1. Passing credentials as parameters when creating a `SpotinstClient` object:

  ```python
  session = SpotinstClient(auth_token='foo', account_id='bar')
  ```

  2. Environment variables:

  ```sh
  export SPOTINST_TOKEN=foo
  export SPOTINST_ACCOUNT=bar
  ```

  3. Shared credentials file:

  - The shared credentials file has a default location of `~/.spotinst/credentials`. This file is an INI formatted file with section names corresponding to profiles. With each section, two configuration variables can be specified: `token`, `account`. These are the only supported values in the shared credential file.

  - Below is a minimal example of the shared credentials file:

  ```ini
  [default]
  token   = foo
  account = bar
  ```

  - The shared credentials file also supports the concept of profiles. Profiles represent logical groups of configuration. The shared credential file can have multiple profiles:

  ```ini
  [default]
  token   = foo
  account = bar

  [dev]
  token   = foo2
  account = bar2

  [prod]
  token   = foo3
  account = bar3
  ```

  - You can configure your Spot credentials using the `spotctl configure` command. For more information, see the `spotctl` [Getting Started](https://github.com/spotinst/spotctl#getting-started).

  - To maintain compatibility with previous SDK versions, the file can also be in YAML format:

  ```yaml
  default:
    token: foo
    account: bar

  dev:
    token: foo2
    account: bar2

  prod:
    token: foo3
    account: bar3
  ```

  - You can change the location of the credentials file and the profile used by setting the `SPOTINST_SHARED_CREDENTIALS_FILE` and/or `SPOTINST_PROFILE` environment variables:

  ```sh
  export SPOTINST_SHARED_CREDENTIALS_FILE=/path/to/credentials_file
  export SPOTINST_PROFILE=dev
  ```

  - Passing the credentials file location and the profile used as parameters when creating a `SpotinstClient` object:

  ```python
  session = SpotinstClient(credentials_file='/path/to/credentials_file', profile='dev')
  ```



  For a comprehensive documentation, check out the [API documentation](https://help.spot.io/).

  - [Endpoints](docs/endpoints)
  - [Classes](docs/classes)
  - [Examples](docs/examples)



  We use GitHub issues for tracking bugs and feature requests. Please use these community resources for getting help:

  - Ask a question on [Stack Overflow](https://stackoverflow.com/) and tag it with [spotinst-sdk-python](https://stackoverflow.com/questions/tagged/spotinst-sdk-python/).
  - Join our Spotinst community on [Slack](http://slack.spot.io/).
  - Open an [issue](https://github.com/spotinst/spotinst-sdk-python/issues/new/).



  - [Slack](http://slack.spot.io/)
  - [Twitter](https://twitter.com/spot_hq/)



  Code is licensed under the [Apache License 2.0](LICENSE). See [NOTICE.md](NOTICE.md) for complete details, including software and third-party licenses and permissions.


pkgId: 1989f26b3902b011480c1abfd850a363ae02db6ac0b229982a0ae2f101152524
name: python-spotipy
arch: src
version: 2.23.0
epoch: 0
release: 1
summary: A light weight Python library for the Spotify Web API
url: https://spotipy.readthedocs.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dcbc2410-9ed5-4956-81e9-d56382386546
location_href: 00010408-python-spotipy/python-spotipy-2.23.0-1.src.rpm
checksum_type: sha256
description:
  ![Tests](https://github.com/plamere/spotipy/workflows/Tests/badge.svg?branch=master) [![Documentation Status](https://readthedocs.org/projects/spotipy/badge/?version=latest)](https://spotipy.readthedocs.io/en/latest/?badge=latest)



  Spotipy's full documentation is online at [Spotipy Documentation](http://spotipy.readthedocs.org/).



  ```bash
  pip install spotipy
  ```

  alternatively, for Windows users

  ```bash
  py -m pip install spotipy
  ```

  or upgrade

  ```bash
  pip install spotipy --upgrade
  ```



  A full set of examples can be found in the [online documentation](http://spotipy.readthedocs.org/) and in the [Spotipy examples directory](https://github.com/plamere/spotipy/tree/master/examples).

  To get started, install spotipy and create an app on https://developers.spotify.com/.
  Add your new ID and SECRET to your environment:



  ```python
  import spotipy
  from spotipy.oauth2 import SpotifyClientCredentials

  sp = spotipy.Spotify(auth_manager=SpotifyClientCredentials(client_id="YOUR_APP_CLIENT_ID",
                                                             client_secret="YOUR_APP_CLIENT_SECRET"))

  results = sp.search(q='weezer', limit=20)
  for idx, track in enumerate(results['tracks']['items']):
      print(idx, track['name'])
  ```



  A redirect URI must be added to your application at [My Dashboard](https://developer.spotify.com/dashboard/applications) to access user authenticated features.

  ```python
  import spotipy
  from spotipy.oauth2 import SpotifyOAuth

  sp = spotipy.Spotify(auth_manager=SpotifyOAuth(client_id="YOUR_APP_CLIENT_ID",
                                                 client_secret="YOUR_APP_CLIENT_SECRET",
                                                 redirect_uri="YOUR_APP_REDIRECT_URI",
                                                 scope="user-library-read"))

  results = sp.current_user_saved_tracks()
  for idx, item in enumerate(results['items']):
      track = item['track']
      print(idx, track['artists'][0]['name'], " – ", track['name'])
  ```



  For common questions please check our [FAQ](FAQ.md).

  You can ask questions about Spotipy on
  [Stack Overflow](http://stackoverflow.com/questions/ask).
  Don’t forget to add the *Spotipy* tag, and any other relevant tags as well, before posting.

  If you have suggestions, bugs or other issues specific to this library,
  file them [here](https://github.com/plamere/spotipy/issues).
  Or just send a pull request.


pkgId: d3752595f4537ac7c2e09e5f77e6b8ca8077c729ab45d18c515d9703219f6e3f
name: python-spring-config-client
arch: src
version: 0.2
epoch: 0
release: 1
summary: A client for Spring Config Server
url: https://realbucksavage.github.io/spring-config-client
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-81e3a264-7e0b-42da-b221-9e4bb3531985
location_href: 00013192-python-spring-config-client/python-spring-config-client-0.2-1.src.rpm
checksum_type: sha256
description:
  A Python client for [Spring Config Server](https://spring.io/projects/spring-cloud-config).

  This library is inspired by [amenezes/config-client](https://github.com/amenezes/config-client) and is essentially a toned-down fork that I customized to fit my own needs.



  - [x] Provide a basic client
  - [x] Provide basic authentication
  - [ ] Add support for CloudFoundry



  Install using `pip`

  ```shell
  $ pip install spring-config-client
  ```



  The very basic usage of this library looks like this:

  ```python
  from spring_config import ClientConfigurationBuilder
  from spring_config.client import SpringConfigClient

  config = ClientConfigurationBuilder().app_name("test-application").build()

  c = SpringConfigClient(config)
  c.get_config()
  ```

  By default, `ClientConfigurationBuilder` builds a `ClientConfiguration` object with server address and application profile set to `http://localhost:8888` and `development`. These can be changed like this:

  Here are some examples:

  ```python

  config = (
      ClientConfigurationBuilder()
      .app_name("test-application")
      .address("http://someserver.com")
      .build()
  )


  config = (
      ClientConfigurationBuilder()
      .app_name("test-application")
      .address("http://someserver.com")
      .profile("production")
      .build()
  )
  ```



  If your configuration server requires to use basic authentication, you can create the client configuration like this:

  ```python
  from spring_config import ClientConfigurationBuilder

  config = (
      ClientConfigurationBuilder()
      .app_name("test-application")
      .authentication(("username", "password"))
      .build()
  )
  ```



  The `ClientConfigurationBuilder` allow controlling these parameters.

  - Application Name : `app_name("some-app")` - Default `None`, required.
  - Server Address : `address("http://some-server")` - Default `http://localhost:8888`, optional.
  - Profile : `profile("production")` - Default `development`, optional.
  - Branch : `branch("devel/0.1")` - Default `master`, optional.



  Please use the [issues section](https://github.com/realbucksavage/spring-config-client/issues) to request new features and I will try to take out my time to work on them. Contributions in any sorts are always welcome :)


pkgId: 7d67c957eda362e8df93861be04f810f2ff9162ce7c0e09d507688e01a1e06ce
name: python-spur
arch: src
version: 0.3.22
epoch: 0
release: 1
summary: Run commands and manipulate files locally or over SSH using the same interface
url: http://github.com/mwilliamson/spur.py
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a9c53566-b5a5-42f4-94f8-c5786c3370d6
location_href: 00005187-python-spur/python-spur-0.3.22-1.src.rpm
checksum_type: sha256
description:
  To run echo locally:
      import spur
      shell = spur.LocalShell()
      result = shell.run(["echo", "-n", "hello"])
      print(result.output) # prints hello
  Executing the same command over SSH uses the same interface -- the only
  difference is how the shell is created:
      import spur
      shell = spur.SshShell(hostname="localhost", username="bob", password="password1")
      with shell:
          result = shell.run(["echo", "-n", "hello"])
      print(result.output) # prints hello


pkgId: 1a3a70c47539093954bf8ced0dc33b071e2f720379c9a0bb1bb4d4a7d991901e
name: python-spyking-circus
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Fast spike sorting by template matching
url: http://spyking-circus.rtfd.org
rpm_license: License :: OSI Approved :: CeCILL-2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f118dabe-e89f-4f84-aef3-2b439b9ccf69
location_href: 00005190-python-spyking-circus/python-spyking-circus-1.1.0-1.src.rpm
checksum_type: sha256
description:
  *A fast and scalable solution for spike sorting of large-scale extracellular recordings*
  SpyKING CIRCUS is a python code to allow fast spike sorting on multi channel recordings.
  A publication on the algorithm can be found at https://elifesciences.org/articles/34518
  It has been tested on datasets coming from *in vitro* retina
  with 252 electrodes MEA, from *in vivo* hippocampus with tetrodes, *in vivo* and *in vitro* cortex
  data with 30 and up to 4225 channels, with good results. Synthetic tests on these data show
  that cells firing at more than 0.5Hz can be detected, and their spikes recovered with error
  rates at around 1%, even resolving overlapping spikes and synchronous firing. It seems to
  be compatible with optogenetic stimulation, based on experimental data obtained in the retina.
  SpyKING CIRCUS is currently still under development. Please do not hesitate to report issues with the issue tracker
  * Documentation can be found at http://spyking-circus.rtfd.org
  * A Google group can be found at http://groups.google.com/forum/#!forum/spyking-circus-users
  * A bug tracker can be found at https://github.com/spyking-circus/spyking-circus/issues
  * Open source ground-truth datasets used in the paper https://zenodo.org/record/1205233#.WrTFtXXwaV4


pkgId: 7b8e34390105bef46a08c91442c8eac6cf95a3be9db07a55b21705b7a4f25a11
name: python-sqlacodegen
arch: src
version: 2.3.0.post1
epoch: 0
release: 1
summary: Automatic model code generator for SQLAlchemy
url: https://pypi.org/project/sqlacodegen/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a5d03f16-baa8-4303-a587-8a3215a9dd9b
location_href: 00005192-python-sqlacodegen/python-sqlacodegen-2.3.0.post1-1.src.rpm
checksum_type: sha256
description:
  * Supports SQLAlchemy 0.8.x - 1.3.x
  * Produces declarative code that almost looks like it was hand written
  * Produces `PEP 8`_ compliant code
  * Accurately determines relationships, including many-to-many, one-to-one
  * Automatically detects joined table inheritance
  * Excellent test coverage


pkgId: 47fb8ade567e2739e139a92d4382739810584b9023e1c20bfec91c3086d224bc
name: python-sqlakeyset
arch: src
version: 2.0.1681021882
epoch: 0
release: 1
summary: offset-free paging for sqlalchemy
url: https://github.com/djrobstep/sqlakeyset
rpm_license: Unlicense
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5a31dc8d-3c48-437d-a547-0ea6f696c7e8
location_href: 00012517-python-sqlakeyset/python-sqlakeyset-2.0.1681021882-1.src.rpm
checksum_type: sha256
description:
  sqlakeyset implements keyset-based paging for SQLAlchemy (both ORM and core). **Now with full SQLAlchemy 2 support and type hints!**
  This library is tested with PostgreSQL, MariaDB/MySQL and SQLite. It should work with many other SQLAlchemy-supported databases, too; but caveat emptor - you should verify the results are correct.
  **Notice:** In accordance with Python end-of-life dates, we've stopped supporting Python versions earlier than 3.7. If you really need it, the latest version to support Python 2 is 0.1.1559103842 and Python 3.4 is 1.0.1679209451, but you'll miss out on all the latest features and bugfixes from the latest version. You should be upgrading anyway!


pkgId: 6bd8f8d73fd3edc58345e67ddd6656a1952ec75d7bb5f3a27ee98287eafd2a31
name: python-sqlalchemy-filters
arch: src
version: 0.12.0
epoch: 0
release: 1
summary: A library to filter SQLAlchemy queries.
url: https://github.com/juliotrigo/sqlalchemy-filters
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-acb4c7ad-b23a-4e17-b53f-97ecd07d3b32
location_href: 00005194-python-sqlalchemy-filters/python-sqlalchemy-filters-0.12.0-1.src.rpm
checksum_type: sha256
description:
      Filter, sort and paginate SQLAlchemy query objects. Ideal for
      exposing these actions over a REST API.


pkgId: f08882af0e0903367a58538881cbe68d028500ac2566001b3ceedaf95aed1acb
name: python-sqlalchemy-migrate
arch: src
version: 0.13.0
epoch: 0
release: 1
summary: Database schema migration for SQLAlchemy
url: http://www.openstack.org/
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3c729ec0-3459-4f22-aefa-822481c8786d
location_href: 00010716-python-sqlalchemy-migrate/python-sqlalchemy-migrate-0.13.0-1.src.rpm
checksum_type: sha256
description:
  Fork from http://code.google.com/p/sqlalchemy-migrate/ to get it working with
  SQLAlchemy 0.8.
  Inspired by Ruby on Rails' migrations, Migrate provides a way to deal with
  database schema changes in `SQLAlchemy <http://sqlalchemy.org>`_ projects.
  Migrate extends SQLAlchemy to have database changeset handling. It provides a
  database change repository mechanism which can be used from the command line as
  well as from inside python code.


pkgId: ca4f44fe729d5640779b0b34b5ce3d248d9144a7e26755e6b2637eaca4c2a7bf
name: python-sqlalchemy-stubs
arch: src
version: 0.4
epoch: 0
release: 1
summary: SQLAlchemy stubs and mypy plugin
url: https://github.com/dropbox/sqlalchemy-stubs
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-04489300-f823-4033-8a9f-7c8ba938ec63
location_href: 00010140-python-sqlalchemy-stubs/python-sqlalchemy-stubs-0.4-1.src.rpm
checksum_type: sha256
description:
  This package contains type stubs and mypy plugin to provide more precise
  static types and type inference for SQLAlchemy framework. SQLAlchemy uses
  dynamic Python features that are hard to understand by static type checkers,
  this is why the plugin is needed in addition to type stubs.

  Currently, some basic use cases like inferring model field types are supported.
  The final goal is to be able to get precise types for most common patterns.



  ```
  pip install sqlalchemy-stubs
  ```

  Important: you need to enable the plugin in your mypy config file:
  ```
  [mypy]
  plugins = sqlmypy
  ```


pkgId: b28fb9936777a67ee8ccd43533b697c43ace17d2ea3fa364a92e427191f14cec
name: python-sqlalchemy-trino
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Trino dialect for SQLAlchemy
url: https://github.com/dungdm93/sqlalchemy-trino
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-31ad2899-fd97-423b-b73c-327ba5d0e785
location_href: 00013292-python-sqlalchemy-trino/python-sqlalchemy-trino-0.5.0-1.src.rpm
checksum_type: sha256
description:
  `sqlalchemy-trino` was developed as _[Trino](https://trino.io/) (f.k.a PrestoSQL) dialect for SQLAlchemy._
  Since trinodb/trino-python-client#81, all code of `sqlalchemy-trino` is donated and merged into upstream project.
  So now, this project is no longer active and consider as deprecated.

  Trino version 352 and higher

  The driver can either be installed through PyPi or from the source code.

  ```bash
  pip install sqlalchemy-trino
  ```

  ```bash
  pip install git+https://github.com/dungdm93/sqlalchemy-trino
  ```

  To connect from SQLAlchemy to Trino, use connection string (URL) following this pattern:
  ```
  trino://<username>:<password>@<host>:<port>/catalog/[schema]
  ```

  You can pass the JWT token via either `connect_args` or the query string
  parameter `accessToken`:
  ```Python
  from sqlalchemy.engine import create_engine
  from trino.auth import JWTAuthentication

  engine = create_engine(
    'trino://<username>@<host>:<port>/',
    connect_args={'auth': JWTAuthentication('a-jwt-token')},
  )

  engine = create_engine(
    'trino://<username>@<host>:<port>/?accessToken=a-jwt-token',
  )
  ```
  **Notice**: When using username and password, it will connect to Trino over TLS
  connection automatically.

  It supports user impersonation with username and password based authentication only.
  You can pass the session user (a.k.a., the user that will be impersonated) via
  either [`connect_args`](https://docs.sqlalchemy.org/en/13/core/engines.html#sqlalchemy.create_engine.params.connect_args)
  or the query string parameter `sessionUser`:
  ```Python
  from sqlalchemy.engine import create_engine

  engine = create_engine(
    'trino://<username>:<password>@<host>:<port>/',
    connect_args={'user': 'user-to-be-impersonated'},
  )

  engine = create_engine(
    'trino://<username>:<password>@<host>:<port>/?sessionUser=user-to-be-impersonated',
  )
  ```

  ```python
  import pandas as pd
  from pandas import DataFrame
  import sqlalchemy_trino
  from sqlalchemy.engine import Engine, Connection
  def trino_pandas_write(engine: Engine):
      df: DataFrame = pd.read_csv("tests/data/population.csv")
      df.to_sql(con=engine, schema="default", name="abcxyz", method="multi", index=False)
      print(df)
  def trino_pandas_read(engine: Engine):
      connection: Connection = engine.connect()
      df = pd.read_sql("SELECT * FROM public.foobar", connection)
      print(df)
  ```
  **Note**: in `df.to_sql` following params is required:
  * `index=False` because index is not supported in Trino.
  * `method="multi"`: currently `method=None` (default) is not working because Trino dbapi is not support [`executemany`](https://github.com/trinodb/trino-python-client/blob/77adbc48cd5061b2c55e56225d67dd7822284b73/trino/dbapi.py#L410-L411) yet


pkgId: c3551e5ddabc417ea75d09f1855b184ef317c950b57d1bcf66c0e1bf0dd0d310
name: python-sqlite-utils
arch: src
version: 3.30
epoch: 0
release: 1
summary: CLI tool and Python utility functions for manipulating SQLite databases
url: https://github.com/simonw/sqlite-utils
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3725576d-094e-4d84-9a66-040a9251a5d8
location_href: 00011521-python-sqlite-utils/python-sqlite-utils-3.30-1.src.rpm
checksum_type: sha256
description:
         1      4  Cleo
         2      2  Pancakes
  You can import JSON data into a new database table like this:
      $ curl https://api.github.com/repos/simonw/sqlite-utils/releases \
          | sqlite-utils insert releases.db releases - --pk id
  Or for data in a CSV file:
      $ sqlite-utils insert dogs.db dogs dogs.csv --csv
  `sqlite-utils memory` lets you import CSV or JSON data into an in-memory database and run SQL queries against it in a single command:
      $ cat dogs.csv | sqlite-utils memory - "select name, age from stdin"
  See the [full CLI documentation](https://sqlite-utils.datasette.io/en/stable/cli.html) for comprehensive coverage of many more commands.

  You can also `import sqlite_utils` and use it as a Python library like this:
  ```python
  import sqlite_utils
  db = sqlite_utils.Database("demo_database.db")

  db["dogs"].insert_all([
      {"id": 1, "age": 4, "name": "Cleo"},
      {"id": 2, "age": 2, "name": "Pancakes"}
  ], pk="id")
  ```
  Check out the [full library documentation](https://sqlite-utils.datasette.io/en/stable/python-api.html) for everything else you can do with the Python library.

  * [Datasette](https://datasette.io/): A tool for exploring and publishing data
  * [csvs-to-sqlite](https://github.com/simonw/csvs-to-sqlite): Convert CSV files into a SQLite database
  * [db-to-sqlite](https://github.com/simonw/db-to-sqlite): CLI tool for exporting a MySQL or PostgreSQL database as a SQLite file
  * [dogsheep](https://dogsheep.github.io/): A family of tools for personal analytics, built on top of `sqlite-utils`


pkgId: 2cdefffa8c501013eda7e7a83b88ee88eeb897c187db5784ce020bf47bd6521c
name: python-sqlmodel
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: SQLModel, SQL databases in Python, designed for simplicity, compatibility, and robustness.
url: https://github.com/tiangolo/sqlmodel
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9fc05ccf-07b6-4af6-b4a5-891d2787fe6c
location_href: 00014228-python-sqlmodel/python-sqlmodel-0.0.8-1.src.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://sqlmodel.tiangolo.com" target="_blank">https://sqlmodel.tiangolo.com</a>


pkgId: 7a52f1e2c841ba35350f1310676e9c281b9fda6f38d148ae986dde61ac8a92a3
name: python-sqlparams
arch: src
version: 5.1.0
epoch: 0
release: 1
summary: Convert between various DB API 2.0 parameter styles.
url: https://pypi.org/project/sqlparams/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4d5566c3-91d5-43a9-b6ba-b55350be8eb2
location_href: 00011922-python-sqlparams/python-sqlparams-5.1.0-1.src.rpm
checksum_type: sha256
description:
  *sqlparams* is a utility package for converting between various SQL
  parameter styles. This can simplify the use of SQL parameters in queries by
  allowing the use of named parameters where only ordinal are supported. Some
  `Python DB API 2.0`_ compliant modules only support the ordinal *qmark* or
  *format* style parameters (e.g., `pyodbc`_ only supports *qmark*). This
  package provides a helper class, `SQLParams`_, that is used to convert
  from any parameter style (*qmark*, *numeric*, *named*, *format*, *pyformat*;
  and the non-standard *numeric_dollar* and *named_dollar*), and have them
  safely converted to the desired parameter style.


pkgId: 638735ac7784909f520452009c858806f06f7060abbace0d6f87b0888834f000
name: python-sqlparse
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: A non-validating SQL parser.
url: https://github.com/andialbrecht/sqlparse
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3f73b321-c428-4141-8406-29e13b55d06c
location_href: 00005198-python-sqlparse/python-sqlparse-0.4.3-1.src.rpm
checksum_type: sha256
description:
  |buildstatus|_
  |coverage|_
  |docs|_
  |packageversion|_
  sqlparse is a non-validating SQL parser for Python.
  It provides support for parsing, splitting and formatting SQL statements.
  The module is compatible with Python 3.5+ and released under the terms of the
  `New BSD license <https://opensource.org/licenses/BSD-3-Clause>`_.
  Visit the project page at https://github.com/andialbrecht/sqlparse for
  further information about this project.


pkgId: 6929fa65048cfbc0452077988187fcdec0b66cad0acb29476f75777016cef490
name: python-srvlookup
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Service lookup using DNS SRV records
url: https://github.com/gmr/srvlookup
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-900b9df3-775b-4458-993d-b415a2340f4c
location_href: 00014356-python-srvlookup/python-srvlookup-3.0.0-1.src.rpm
checksum_type: sha256
description:
  A small wrapper for dnspython to return SRV records for a given host, protocol,
  and domain name as a list of namedtuples.
  |Version| |Status| |Coverage| |License|


pkgId: ab66b99b9ff033a2db614abffda031dc7c0d1d253d4187d5fb17b42e47336092
name: python-ssdeep
arch: src
version: 3.4
epoch: 0
release: 1
summary: Python wrapper for the ssdeep library
url: http://github.com/DinoTools/python-ssdeep
rpm_license: LGPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-45c31cfe-0699-44c7-84dc-d6feab406a4d
location_href: 00005199-python-ssdeep/python-ssdeep-3.4-1.src.rpm
checksum_type: sha256
description:
  This is a straightforward Python wrapper for `ssdeep by Jesse Kornblum`_, which is a library for computing context
  triggered piecewise hashes (CTPH). Also called fuzzy hashes, CTPH can match inputs that have homologies. Such inputs
  have sequences of identical bytes in the same order, although bytes in between these sequences may be different in both
  content and length.


pkgId: 5059857606409c590a656bb8a80e7d045643468a516b9689476aaad8e659234e
name: python-ssdp
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Python asyncio library for Simple Service Discovery Protocol (SSDP).
url: https://pypi.org/project/ssdp/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-01d8c424-e86c-4ff7-b35f-a94ef8ffc695
location_href: 00005201-python-ssdp/python-ssdp-1.1.1-1.src.rpm
checksum_type: sha256
description:
  Python asyncio library for Simple Service Discovery Protocol (SSDP).

  SSDP is a UPnP substandard. For more information see:
  https://en.wikipedia.org/wiki/Simple_Service_Discovery_Protocol



  ```bash
  python3 -m pip install ssdp
  ```



  ```python
  import asyncio
  import socket

  import ssdp


  class MyProtocol(ssdp.SimpleServiceDiscoveryProtocol):

      def response_received(self, response, addr):
          print(response, addr)

      def request_received(self, request, addr):
          print(request, addr)


  loop = asyncio.get_event_loop()
  connect = loop.create_datagram_endpoint(MyProtocol, family=socket.AF_INET)
  transport, protocol = loop.run_until_complete(connect)

  notify = ssdp.SSDPRequest('NOTIFY')
  notify.sendto(transport, (MyProtocol.MULTICAST_ADDRESS, 1982))

  try:
      loop.run_forever()
  except KeyboardInterrupt:
      pass

  transport.close()
  loop.close()
  ```



  The `examples <examples/>`\_ directory contains examples on how to use
  this library.


pkgId: 5d5c7ebba919b34d66df1746ab8611b53c23b39bfb0a428f8277f7750b19f1f2
name: python-ssh2-python
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Bindings for libssh2 C library
url: https://github.com/ParallelSSH/ssh2-python
rpm_license: LGPLv2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-96b8be8b-82d0-43b4-aaa3-44ef684dfed3
location_href: 00005204-python-ssh2-python/python-ssh2-python-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Super fast SSH2 protocol library. ``ssh2-python`` provides Python bindings for `libssh2`_.
  Installation
  ______________
  Binary wheel packages are provided for Linux, OSX and Windows, all Python versions. Wheel packages have **no dependencies**.
  ``pip`` may need to be updated to be able to install binary wheel packages - ``pip install -U pip``.
     pip install ssh2-python
  For from source installation instructions, including building against system provided libssh2, `see documentation <https://ssh2-python.readthedocs.io/en/latest/installation.html#installation-from-source>`_.
  Who Should Use This
  ___________________
  Most developers will want to use the `high level clients <https://parallel-ssh.readthedocs.io/en/latest/quickstart.html#single-host-client>`_
  in `parallel-ssh <https://github.com/ParallelSSH/parallel-ssh>`_
  based on this library.
  This library provides bindings to the low-level libssh2 C-API. It is *not* high level, nor easy to use. A *lot* of code
  would need to be written to use this library that is already provided by `parallel-ssh`.
  Use `parallel-ssh <https://github.com/ParallelSSH/parallel-ssh>`_ unless *really* sure using a C-API is what is wanted.
  API Feature Set
  ________________
  At this time all of the `libssh2`_ API has been implemented up to the libssh2 version in the repository. Please report any missing implementation.
  Complete example scripts for various operations can be found in the `examples directory`_.
  In addition, as ``ssh2-python`` is a thin wrapper of ``libssh2`` with Python semantics, `its code examples <https://libssh2.org/examples/>`_ can be ported straight over to Python with only minimal changes.
  Examples
  _____________
  See `examples directory <https://github.com/ParallelSSH/ssh2-python/tree/master/examples>`_  for complete examples.
  Again, most developers will want to use `parallel-ssh <https://github.com/ParallelSSH/parallel-ssh>`_ rather than this
  library directly.


pkgId: 04fe084f8ce90b374204d30d6d0ec2b7b5a4bfec1bf7c90fc8b7bd30d91557ae
name: python-sslyze
arch: src
version: 5.1.3
epoch: 0
release: 1
summary: Fast and powerful SSL/TLS scanning library.
url: https://github.com/nabla-c0d3/sslyze
rpm_license: AGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-942b9ac3-3a77-4c1e-8f96-89d4b100c93c
location_href: 00012075-python-sslyze/python-sslyze-5.1.3-1.src.rpm
checksum_type: sha256
description:
  ![Run Tests](https://github.com/nabla-c0d3/sslyze/workflows/Run%20Tests/badge.svg)
  [![Downloads](https://pepy.tech/badge/sslyze/month)](https://pepy.tech/project/sslyze)
  [![PyPI version](https://img.shields.io/pypi/v/sslyze.svg)](https://pypi.org/project/sslyze/)
  [![Python version](https://img.shields.io/pypi/pyversions/sslyze.svg)](https://pypi.org/project/sslyze/)
  SSLyze is a fast and powerful SSL/TLS scanning tool and Python library.
  SSLyze can analyze the SSL/TLS configuration of a server by connecting to it, in order to ensure that it uses strong
  encryption settings (certificate, cipher suites, elliptic curves, etc.), and that it is not vulnerable to known TLS
  attacks (Heartbleed, ROBOT, OpenSSL CCS injection, etc.).


pkgId: efc7b83afba3e1e6c259910ac16ca6ae9451ecc1b38747595b28909dc11a513b
name: python-ssm-cache
arch: src
version: 2.10
epoch: 0
release: 1
summary: AWS System Manager Parameter Store caching client for Python
url: https://github.com/alexcasalboni/ssm-cache-python
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1b61dccc-d775-4461-befe-d8171e5fe9d3
location_href: 00010942-python-ssm-cache/python-ssm-cache-2.10-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/alexcasalboni/ssm-cache-python.svg?branch=master)](https://travis-ci.org/alexcasalboni/ssm-cache-python)
  [![Coverage Status](https://coveralls.io/repos/github/alexcasalboni/ssm-cache-python/badge.svg)](https://coveralls.io/github/alexcasalboni/ssm-cache-python)
  [![PyPI version](https://badge.fury.io/py/ssm-cache.svg)](https://badge.fury.io/py/ssm-cache)
  [![GitHub license](https://img.shields.io/github/license/alexcasalboni/ssm-cache-python.svg)](https://github.com/alexcasalboni/ssm-cache-python/blob/master/LICENSE)
  [![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://GitHub.com/alexcasalboni/ssm-cache-python/graphs/commit-activity)
  [![GitHub issues](https://img.shields.io/github/issues/alexcasalboni/ssm-cache-python.svg)](https://github.com/alexcasalboni/ssm-cache-python/issues)
  [![Open Source Love svg2](https://badges.frapsoft.com/os/v2/open-source.svg?v=103)](https://github.com/ellerbrock/open-source-badges/)
  [![GitHub stars](https://img.shields.io/github/stars/alexcasalboni/ssm-cache-python.svg)](https://github.com/alexcasalboni/ssm-cache-python/stargazers)
  This module wraps the AWS Parameter Store and adds a caching and grouping layer with max-age invalidation.
  You can use this module with AWS Lambda to read and refresh parameters and secrets. Your IAM role will require `ssm:GetParameters` permissions (optionally, also `kms:Decrypt` if you use `SecureString` params).

  Install the module with `pip`:
  ```bash
  pip install ssm-cache
  ```


  A single parameter, configured by name.
  ```python
  from ssm_cache import SSMParameter
  param = SSMParameter('my_param_name')
  value = param.value
  ```

  You can configure the `max_age` in seconds, after which the values will be automatically refreshed.
  ```python
  from ssm_cache import SSMParameter
  param_1 = SSMParameter('param_1', max_age=300)  # 5 min
  value_1 = param.value
  param_2 = SSMParameter('param_2', max_age=3600)  # 1 hour
  value_2 = param_2.value
  ```

  You can configure more than one parameter to be fetched/cached/decrypted as a group.
  ```python
  from ssm_cache import SSMParameterGroup
  group = SSMParameterGroup(max_age=300)
  param_1 = group.parameter('param_1')
  param_2 = group.parameter('param_2')
  value_1 = param_1.value
  value_2 = param_2.value
  ```

  You can fetch/cache a group of parameters under a given prefix. Optionally, the group itself could have its own base path.
  ```python
  from ssm_cache import SSMParameterGroup
  group = SSMParameterGroup(base_path="/Foo")
  foo_bar = group.parameter('/Bar')  # will fetch /Foo/Bar
  baz_params = group.parameters('/Baz')  # will fetch /Foo/Baz/1 and /Foo/Baz/2
  assert len(group) == 3
  ```
  Note: you can call `group.parameters(...)` multiple times. If caching is enabled, the group's cache will expire when the firstly fetched parameters expire.

  You can filter by parameter `Type` and KMS `KeyId`, either building the filter object manually or using a class-based approach (which provides some additional checks before invoking the API).
  ```python
  from ssm_cache import SSMParameterGroup
  from ssm_cache.filters import SSMFilterType
  group = SSMParameterGroup()

  params = group.parameters(
      path="/Foo/Bar",
      filters=[{
          'Key': 'Type',
          'Option': 'Equals',
          'Values': ['StringList']
      }],
  )

  params = group.parameters(
      path="/Foo/Bar",
      filters=[SSMFilterType().value('StringList')],  # will validate allowed value(s)
  )
  ```

  You can disable recursion when fetching parameters via prefix.
  ```python
  from ssm_cache import SSMParameterGroup
  group = SSMParameterGroup()

  params = group.parameters(
      path="/Foo",
      recursive=False,
  )
  ```

  `StringList` parameters ([documentation here](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ssm-parameter.html#cfn-ssm-parameter-type)) are automatically converted to Python lists with no additional configuration.
  ```python
  from ssm_cache import SSMParameter

  twitter_params = SSMParameter('my_twitter_api_keys')
  key, secret, access_token, access_token_secret = twitter_params.value
  ```

  You can manually force a refresh on a parameter or parameter group.
  Note that if a parameter is part of a group, the refresh operation will involve the entire group.
  ```python
  from ssm_cache import SSMParameter
  param = SSMParameter('my_param_name')
  value = param.value
  param.refresh()
  new_value = param.value
  ```
  ```python
  from ssm_cache import SSMParameterGroup
  group = SSMParameterGroup()
  param_1 = group.parameter('param_1')
  param_2 = group.parameter('param_2')
  value_1 = param_1.value
  value_2 = param_2.value
  group.refresh()
  new_value_1 = param_1.value
  new_value_2 = param_2.value
  param_1.refresh()
  new_new_value_1 = param_1.value
  new_new_value_2 = param_2.value # one parameter refreshes the whole group
  ```

  Decryption is enabled by default, but you can explicitly disable it (works for `SSMParameter` and `SSMGroup`).
  ```python
  from ssm_cache import SSMParameter
  param = SSMParameter('my_param_name', with_decryption=False)
  value = param.value
  ```

  You can read [AWS Secrets Manager](https://aws.amazon.com/secrets-manager/) secrets transparently by using the `SecretsManagerParameter` class, which comes with the same interface of `SSMParameter` and performs some additional prefixing and validation.
  ```python
  from ssm_cache import SecretsManagerParameter
  secret = SecretsManagerParameter('my_secret_name')
  value = secret.value
  ```
  Secrets can be added to a `SSMParameterGroup` as well, although no group prefix will be applied.
  ```python
  from ssm_cache import SSMParameterGroup
  group = SSMParameterGroup()
  param = group.parameter('my_param')
  secret = group.secret('my_secret')
  param_value = param.value
  secret_value = secret.value
  ```

  SSM Parameter Store supports version selectors ([documentation here](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-paramstore-versions.html)).
  By default, the latest version is fetched if you don't specify it.
  Here is how you can retrieve a specific parameter version:
  ```python
  from ssm_cache import SSMParameter
  param = SSMParameter('my_param_name:2')
  value = param.value
  ```
  Please note that invoking `param.refresh()` will not fetch newer versions. This is the intended behavior, as version selection should be used only when you need a specific parameter version.
  If you don't specify any version, you can always read the current version of a parameter. In this case, invoking `param.refresh()` will invoke the new version.
  ```python
  from ssm_cache import SSMParameter
  param = SSMParameter('my_param_name')
  print(param.version)  # will print an int
  ```

  Your [AWS Lambda](https://aws.amazon.com/lambda/) code will look similar to the following snippet.
  ```python
  from ssm_cache import SSMParameter, SecretsManagerParameter
  param = SSMParameter('my_param_name')
  secret = SecretsManagerParameter('my_secret_name')
  def lambda_handler(event, context):
      dbname = param.value
      password = secret.value
      return 'Hello from Lambda with dbname %s and password %s' % (dbname, password)
  ```

  You may want to explicitly refresh the parameter cache when you believe the cached value expired.
  In the example below, we refresh the parameter value when an `InvalidCredentials` exception is detected (see the [decorator utility](#decorator-utility) for a simpler version!).
  ```python
  from ssm_cache import SSMParameter
  from my_db_lib import Client, InvalidCredentials  # pseudo-code
  param = SSMParameter('my_db_password')
  my_db_client = Client(password=param.value)
  def read_record(is_retry=False):
      try:
          return my_db_client.read_record()
      except InvalidCredentials:
          if not is_retry:  # avoid infinite recursion
              param.refresh()  # force parameter refresh
              my_db_client = Client(password=param.value)  # re-configure db client
              return read_record(is_retry=True)  # let's try again :)
  def lambda_handler(event, context):
      return {
          'record': read_record(),
      }
  ```

  The retry logic shown above can be simplified with the decorator method provided by each `SSMParameter` and `SSMParameterGroup` object.
  The `@refresh_on_error` decorator will intercept errors (or a specific `error_class`, if given), refresh the parameters values, and attempt to re-call the decorated function. Optionally, you can provide a `callback` argument to implement your own logic (in the example below, to create a new db client with the new password).
  ```python
  from ssm_cache import SSMParameter
  from my_db_lib import Client, InvalidCredentials  # pseudo-code
  param = SSMParameter('my_db_password')
  my_db_client = Client(password=param.value)
  def on_error_callback():
      my_db_client = Client(password=param.value)
  @param.refresh_on_error(InvalidCredentials, on_error_callback)
  def read_record(is_retry=False):
      return my_db_client.read_record()
  def lambda_handler(event, context):
      return {
          'record': read_record(),
      }
  ```
  The `refresh_on_error` decorator supports the following arguments:
  * **error_class** (default: `Exception`)
  * **error_callback** (default: `None`)
  * **retry_argument** (default: `"is_retry"`)

  If you want to replace the default `boto3` SSM client, `SSMParameter` allows you to call `set_ssm_client` and provide your own `boto3` client or even a custom object. Note that such custom object will need to implement two methods: `get_parameters` and `get_parameters_by_path`.
  For example, here's how you could inject a Placebo client for local tests:
  ```python
  import placebo, boto3
  from ssm_cache import SSMParameter

  session = boto3.Session()

  pill = placebo.attach(session, data_path=PLACEBO_PATH)
  pill.playback()

  client = session.client('ssm')

  SSMParameter.set_ssm_client(client)
  ```

  Clone this repository, create a virtualenv and install all the dev dependencies:
  ```bash
  git clone https://github.com/alexcasalboni/ssm-cache-python.git
  cd ssm-cache-python
  virtualenv env
  source env/bin/activate
  pip install -r requirements-dev.txt
  ```
  You can run tests with `nose`:
  ```bash
  nosetests
  ```
  Generate a coverage report:
  ```bash
  nosetests --with-coverage --cover-erase --cover-html --cover-package=ssm_cache
  open cover/index.html
  ```
  Run pylint:
  ```bash
  pylint ssm_cache
  ```
  Note: when you open a new PR, GitHub will run tests on multiple Python environments and verify the new coverage for you, but we highly recommend you run these tasks locally as well before submitting new code.

  * **version 2.10**: exclude tests folder from site-packages
  * **version 2.9**: bugfix, versioning support, tests with Python 3.7
  * **version 2.8**: bugfix, new tests, fixed Travis build config
  * **version 2.7**: support for AWS Secrets Manager integration
  * **version 2.5**: hierarchical parameters, filters, and non-recursiveness support
  * **version 2.3**: StringList parameters support (auto-conversion)
  * **version 2.2**: client replacement and boto3/botocore minimum requirements
  * **version 2.1**: group refresh bugfix
  * **version 2.0**: new interface, `SSMParameterGroup` support
  * **version 1.3**: Python3 support
  * **version 1.0**: initial release

  * [You should use SSM Parameter Store over Lambda env variables](https://hackernoon.com/you-should-use-ssm-parameter-store-over-lambda-env-variables-5197fc6ea45b) by Yan Cui (similar Node.js implementation)
  * [AWS System Manager Parameter Store doc](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-paramstore.html)


pkgId: 7a759f2a91bca8c274428e6be0c181497b2b1c93a3c2787b44b27aef55581b96
name: python-ssm-parameter-store
arch: src
version: 19.11.0
epoch: 0
release: 1
summary: Simple Python wrapper for getting values from AWS Systems Manager Parameter Store
url: http://github.com/christippett/ssm-parameter-store
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-512bca9b-4a38-4c42-8afd-c8b8c4869e5d
location_href: 00011414-python-ssm-parameter-store/python-ssm-parameter-store-19.11.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/ssm-parameter-store.svg)](https://pypi.python.org/pypi/ssm-parameter-store)
  [![Build status](https://img.shields.io/travis/christippett/ssm-parameter-store.svg)](https://travis-ci.org/christippett/ssm-parameter-store)
  [![Coverage](https://img.shields.io/coveralls/github/christippett/ssm-parameter-store.svg)](https://coveralls.io/github/christippett/ssm-parameter-store?branch=master)
  [![Python versions](https://img.shields.io/pypi/pyversions/ssm-parameter-store.svg)](https://pypi.python.org/pypi/ssm-parameter-store)
  [![Github license](https://img.shields.io/github/license/christippett/ssm-parameter-store.svg)](https://github.com/christippett/ssm-parameter-store)


pkgId: 29771f0ea1485f80b45ec4bdacc0afbbca9826cc52a99eace16e5b1731228144
name: python-sss
arch: src
version: 1.2
epoch: 0
release: 1
url: https://bitbucket.org/brunobord/sss/
rpm_license: WTFPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5e102647-2bf7-437b-a013-6d06557d47b8
location_href: 00005206-python-sss/python-sss-1.2-1.src.rpm
checksum_type: sha256
summary:
  Simple Scrum System is a basic Django-based Scrum-like project manager. It takes advantage of the automagic admin contrib site.


pkgId: 41ce1f4506dd9946e02038bc43b7eb777ce4abf16f6b8780241e589fad20d80a
name: python-stackprinter
arch: src
version: 0.2.10
epoch: 0
release: 1
summary: Debug-friendly stack traces, with variable values and semantic highlighting
url: https://github.com/cknd/stackprinter
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1dfedcbd-3c81-430c-85e0-93599837e53f
location_href: 00005209-python-stackprinter/python-stackprinter-0.2.10-1.src.rpm
checksum_type: sha256
description:
  <img src="https://raw.githubusercontent.com/cknd/stackprinter/master/darkbg.png" width="500">

  [![build](https://github.com/cknd/stackprinter/actions/workflows/build.yml/badge.svg?branch=master)](https://github.com/cknd/stackprinter/actions/workflows/build.yml)



  This is a more helpful version of Python's built-in exception message: It shows more code context and the current values of nearby variables. That answers many of the questions I'd ask an interactive debugger: Where in the code was the crash, what's in the relevant variables, and why was _that_ function called with _those_ arguments. It either prints to the console or gives you a string for logging.

  ```bash
  pip3 install stackprinter
  ```

  ```
  Traceback (most recent call last):
    File "demo.py", line 12, in <module>
      dangerous_function(somelist + anotherlist)
    File "demo.py", line 6, in dangerous_function
      return sorted(blub, key=lambda xs: sum(xs))
    File "demo.py", line 6, in <lambda>
      return sorted(blub, key=lambda xs: sum(xs))
  TypeError: unsupported operand type(s) for +: 'int' and 'str'
  ```


  ```
  File demo.py, line 12, in <module>
      9        somelist = [[1,2], [3,4]]
      10       anotherlist = [['5', 6]]
      11       spam = numpy.zeros((3,3))
  --> 12       dangerous_function(somelist + anotherlist)
      13   except:
      ..................................................
       somelist = [[1, 2, ], [3, 4, ], ]
       anotherlist = [['5', 6, ], ]
       spam = 3x3 array([[0. 0. 0.]
                         [0. 0. 0.]
                         [0. 0. 0.]])
      ..................................................

  File demo.py, line 6, in dangerous_function
      5    def dangerous_function(blub):
  --> 6        return sorted(blub, key=lambda xs: sum(xs))
      ..................................................
       blub = [[1, 2, ], [3, 4, ], ['5', 6, ], ]
      ..................................................

  File demo.py, line 6, in <lambda>
      3
      4
      5    def dangerous_function(blub):
  --> 6        return sorted(blub, key=lambda xs: sum(xs))
      7
      ..................................................
       xs = ['5', 6, ]
      ..................................................

  TypeError: unsupported operand type(s) for +: 'int' and 'str'
  ```
  I rarely use this locally instead of a real debugger, but it helps me sleep when my code runs somewhere where the only debug tool is a log file (though it's not a fully-grown [error monitoring system](https://sentry.io/welcome/)).

  By default, it tries to be somewhat polite about screen space, showing only a few source lines & the function header, and only the variables _that appear in those lines_, and using only (?) 500 characters per variable. You can [configure](https://github.com/cknd/stackprinter/blob/master/stackprinter/__init__.py#L28-L149) exactly how verbose things should be.

  It outputs plain text normally, which is good for log files. There's also a color mode for some reason 🌈, with a few different color schemes for light and dark backgrounds. (The colors [track different variables](https://medium.com/@brianwill/making-semantic-highlighting-useful-9aeac92411df) instead of the language syntax.)

  <img src="https://raw.githubusercontent.com/cknd/stackprinter/master/notebook.png" width="500">




  To replace the default python crash printout, call `set_excepthook()` somewhere once. Afterwards, any uncaught exception will be printed with an extended traceback (to stderr, by default). You could also [make this permanent for your python installation](#making-it-stick).

  ```python
  import stackprinter
  stackprinter.set_excepthook(style='darkbg2')  # for jupyter notebooks try style='lightbg'
  ```

  For more control, call [`show()`](https://github.com/cknd/stackprinter/blob/master/stackprinter/__init__.py#L166-L183) or [`format()`](https://github.com/cknd/stackprinter/blob/master/stackprinter/__init__.py#L28-L149) inside an `except` block. `show()` prints to stderr, `format()` returns a string, for custom logging.

  ```python
  try:
      something()
  except:
      
      stackprinter.show()

      
      logger.error(stackprinter.format())
  ```
  Or pass specific exceptions explicitly:
  ```python
  try:
      something()
  except RuntimeError as exc:
      tb = stackprinter.format(exc)
      logger.error('The front fell off.\n' + tb)
  ```



  `format()`, `show()` and `set_excepthook()` accept a common set of keyword args. They allow you to tweak the formatting, hide certain variables by name, skip variables in calls within certain files, and some other stuff.

  ```python
  try:
      something()
  except RuntimeError as exc:
      stackprinter.show(exc, suppressed_vars=[r".*secret.*"],
                             suppressed_paths=[r"lib/python.*/site-packages/boringstuff"],
                             truncate_vals=9001,
                             style="darkbg2")
  ```
  For all the options [see the docstring of `format()`](https://github.com/cknd/stackprinter/blob/master/stackprinter/__init__.py#L28-L149).



  With a bit of extra plumbing you can log errors like this via the normal `logging` methods, without having to import `stackprinter` at the site of the logging call. So you can continue to write nice and simple error handlers like so...

  ```python
  logger = logging.getLogger()
  try:
      nothing = {}
      dangerous_function(nothing.get("something"))
  except:
      logger.exception('My hovercraft is full of eels.')
  ```
  ...but still get annotated tracebacks in the resulting log.
  ```
  2022-04-02 16:16:40,905 ERROR: My hovercraft is full of eels.
    ┆ File "demo_logging.py", line 56, in <module>
    ┆     54   try:
    ┆     55       nothing = {}
    ┆ --> 56       dangerous_function(nothing.get("something"))
    ┆     57   except:
    ┆     ..................................................
    ┆      nothing = {}
    ┆     ..................................................
    ┆
    ┆ File "demo_logging.py", line 52, in dangerous_function
    ┆     51   def dangerous_function(something):
    ┆ --> 52       return something + 1
    ┆     ..................................................
    ┆      something = None
    ┆     ..................................................
    ┆
    ┆ TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'
  ```

  You can get this by adding a [custom formatter](https://docs.python.org/3/howto/logging-cookbook.html#customized-exception-formatting) to the logger before using it:

  ```python
  import logging
  import stackprinter

  class VerboseExceptionFormatter(logging.Formatter):
      def formatException(self, exc_info):
          msg = stackprinter.format(exc_info)
          lines = msg.split('\n')
          lines_indented = ["  ┆ " + line + "\n" for line in lines]
          msg_indented = "".join(lines_indented)
          return msg_indented

  def configure_logger(logger_name=None):
      fmt = 's s: s'
      formatter = VerboseExceptionFormatter(fmt)

      handler = logging.StreamHandler()
      handler.setFormatter(formatter)

      logger = logging.getLogger(logger_name)
      logger.addHandler(handler)

  configure_logger("some_logger")
  ```
  See [demo_logging.py](https://github.com/cknd/stackprinter/blob/master/demo_logging.py) for a runnable example.


  To see your own thread's current call stack, call `show` or `format` anywhere outside of exception handling.

  ```python
  stackprinter.show() # or format()
  ```


  To inspect the call stack of any other running thread:

  ```python
  thread = threading.Thread(target=something)
  thread.start()

  stackprinter.show(thread) # or format(thread)
  ```



  To permanently replace the crash message for your python installation, you *could* put a file `sitecustomize.py` into the `site-packages` directory under one of the paths revealed by `python -c "import site; print(site.PREFIXES)"`, with contents like this:

  ```python
      
      import stackprinter
      stackprinter.set_excepthook(style='darkbg2')
  ```

  That would give you colorful tracebacks automatically every time, even in the REPL.

  (You could do a similar thing for IPython, [but they have their own method](https://ipython.readthedocs.io/en/stable/interactive/tutorial.html?highlight=startup#configuration), where the file goes into `~/.ipython/profile_default/startup` instead, and also I don't want to talk about what this module does to set an excepthook under IPython.)



  For now, the documentation consists only of some fairly detailed docstrings, [e.g. those of `format()`](https://github.com/cknd/stackprinter/blob/master/stackprinter/__init__.py#L28-L149)



  This displays variable values as they are _at the time of formatting_. In
  multi-threaded programs, variables can change while we're busy walking
  the stack & printing them. So, if nothing seems to make sense, consider that
  your exception and the traceback messages are from slightly different times.
  Sadly, there is no responsible way to freeze all other threads as soon
  as we want to inspect some thread's call stack (...or is there?)



  Basically, this is a frame formatter. For each [frame on the call stack](https://en.wikipedia.org/wiki/Call_stack), it grabs the source code to find out which source lines reference which variables. Then it displays code and variables in the neighbourhood of the last executed line.

  Since this already requires a map of where each variable occurs in the code, it was difficult not to also implement the whole semantic highlighting color thing seen in the screenshots. The colors are ANSI escape codes now, but it should be fairly straightforward™ to render the underlying data without any 1980ies terminal technology. Say, a foldable and clickable HTML page with downloadable pickled variables. For now you'll have to pipe the ANSI strings through [ansi2html](https://github.com/ralphbean/ansi2html/) or something.

  The format and everything is inspired by the excellent [`ultratb`](https://ipython.readthedocs.io/en/stable/api/generated/IPython.core.ultratb.html) in IPython. One day I'd like to contribute the whole "find out which variables in `locals` and `globals` are nearby in the source and print only those" machine over there, after trimming its complexity a bit.



  More for curiosity than anything else, you can watch a piece of code execute step-by-step, printing a trace of all calls & returns 'live' as they are happening. Slows everything down though, of course.
  ```python
  with stackprinter.TracePrinter(style='darkbg2'):
      dosomething()
  ```

  or
  ```python
  tp = stackprinter.TracePrinter(style='darkbg2')
  tp.enable()
  dosomething()

  tp.disable()
  ```
  <img src="https://raw.githubusercontent.com/cknd/stackprinter/master/trace.png" width="300">


pkgId: 12055189db53a55d052eebf93ad1b139f6f252f60499ba37c0ffcbf2fbf4cced
name: python-statsmodels
arch: src
version: 0.13.5
epoch: 0
release: 1
summary: Statistical computations and models for Python
url: https://www.statsmodels.org/
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-edf72ee6-9644-451f-b802-c09d28b3ee51
location_href: 00005213-python-statsmodels/python-statsmodels-0.13.5-1.src.rpm
checksum_type: sha256
description:
  statsmodels is a Python package that provides a complement to scipy for
  statistical computations including descriptive statistics and estimation
  and inference for statistical models.


pkgId: d384d25e2168342e0476efb128c01c0cae8b165019672de9c629188a4666ce9a
name: python-stdiomask
arch: src
version: 0.0.6
epoch: 0
release: 1
url: https://github.com/asweigart/stdiomask
rpm_license: GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d7c438e7-0af9-4c32-8a52-84572233d8cc
location_href: 00005216-python-stdiomask/python-stdiomask-0.0.6-1.src.rpm
checksum_type: sha256
summary:
  A cross-platform Python module for entering passwords to a stdio terminal and displaying a **** mask, which getpass cannot do.

description:
  A cross-platform Python module for entering passwords to a stdio terminal and displaying a **** mask, which getpass cannot do.


pkgId: 767d5f510a4818eb9ae5f431c1910a7aa987b337cf1115e5b24b8a5c8b5247a8
name: python-stdlib-list
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: A list of Python Standard Libraries (2.6-7, 3.2-9).
url: https://github.com/jackmaney/python-stdlib-list
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ea1d9551-9c9b-46a4-ba6e-9b66146a756d
location_href: 00005217-python-stdlib-list/python-stdlib-list-0.8.0-1.src.rpm
checksum_type: sha256
description:
  This package includes lists of all of the standard libraries for Python 2.6, 2.7, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.8, and 3.9 along with the code for scraping the official Python docs to get said lists.


pkgId: 2e7e8dfa7814b76b1172366dcc8698cc63f3296334d3cbf31765245d47f37c66
name: python-stegano
arch: src
version: 0.11.1
epoch: 0
release: 1
summary: A pure Python Steganography module.
url: https://sr.ht/~cedric/stegano
rpm_license: GPL-3.0-or-later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6f06a557-8133-41d0-a64d-7061940cf23e
location_href: 00012471-python-stegano/python-stegano-0.11.1-1.src.rpm
checksum_type: sha256
description:
  [![builds.sr.ht status](https://builds.sr.ht/~cedric/stegano.svg)](https://builds.sr.ht/~cedric/stegano)
  [![Workflow](https://github.com/cedricbonhomme/Stegano/workflows/Python%20application/badge.svg?style=flat-square)](https://github.com/cedricbonhomme/Stegano/actions?query=workflow%3A%22Python+application%22)

  [Stegano](https://sr.ht/~cedric/stegano), a pure Python Steganography
  module.

  Steganography is the art and science of writing hidden messages in such a way
  that no one, apart from the sender and intended recipient, suspects the
  existence of the message, a form of security through obscurity. Consequently,
  functions provided by Stegano only hide messages, without encryption.
  Steganography is often used with cryptography.

  For reporting issues, visit the tracker here:
  https://todo.sr.ht/~cedric/stegano





  ```bash
  $ poetry install stegano
  ```

  You will be able to use Stegano in your Python programs.

  If you only want to install Stegano as a command line tool:

  ```bash
  $ pipx install stegano
  ```

  pipx installs scripts (system wide available) provided by Python packages into
  separate virtualenvs to shield them from your system and each other.




  A [tutorial](https://stegano.readthedocs.io) is available.




  If you want to use Stegano in your Python program you just have to import the
  appropriate steganography technique. For example:

  ```python
  >>> from stegano import lsb
  >>> secret = lsb.hide("./tests/sample-files/Lenna.png", "Hello World")
  >>> secret.save("./Lenna-secret.png")
  >>>
  >>> clear_message = lsb.reveal("./Lenna-secret.png")
  ```






  ```bash
  $ stegano-lsb hide -i ./tests/sample-files/Lenna.png -m "Secret Message" -o Lena1.png
  $ stegano-lsb reveal -i Lena1.png
  Secret Message
  ```




  ```bash
  $ stegano-lsb hide -i ./tests/sample-files/Lenna.png -m 'Secret Message' --generator eratosthenes -o Lena2.png
  ```

  The message will be scattered in the picture, following a set described by the
  Sieve of Eratosthenes. Other sets are available. You can also use your own
  generators.

  This will make a steganalysis more complicated.




  ```bash
  $ python -m unittest discover -v
  ```

  Running the static type checker:

  ```bash
  $ mypy stegano
  ```




  Contributions are welcome. If you want to contribute to Stegano I highly
  recommend you to install it in a Python virtual environment with poetry.




  This software is licensed under
  [GNU General Public License version 3](https://www.gnu.org/licenses/gpl-3.0.html)

  Copyright (C) 2010-2022 [Cédric Bonhomme](https://www.cedricbonhomme.org)

  For more information, [the list of authors and contributors](CONTRIBUTORS.md) is available.


pkgId: 954aafcce9e53b497dba2ac4463481e7e0defc4210e1422fae0f8ce01f8952ef
name: python-stem
arch: src
version: 1.8.1
epoch: 0
release: 1
url: https://stem.torproject.org/
rpm_license: LGPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4566ac6d-5baf-405a-87ba-5bd7c88a3148
location_href: 00005219-python-stem/python-stem-1.8.1-1.src.rpm
checksum_type: sha256
summary:
  Stem is a Python controller library that allows applications to interact with Tor (https://www.torproject.org/).

description:
  To install you can either use...
    pip install stem
    python3 setup.py install
  After that, give some `tutorials <https://stem.torproject.org/tutorials.html>`_ a try! For questions or to discuss project ideas we're available on `irc <https://www.torproject.org/about/contact.html.en#irc>`_ and the `tor-dev@ email list <https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-dev>`_.


pkgId: 8b6594d5b93c925301a37d115a7a06ef50c5272f64dc743449935b7574e47ebd
name: python-stestr
arch: src
version: 4.0.1
epoch: 0
release: 1
summary: A parallel Python test runner built around subunit
url: http://stestr.readthedocs.io/en/latest/
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e73a9514-9bed-4c53-bb95-716f07d06f22
location_href: 00005223-python-stestr/python-stestr-4.0.1-1.src.rpm
checksum_type: sha256
description:
  * Read this in other languages: `English`_, `日本語`_
  * You can see the full rendered docs at: http://stestr.readthedocs.io/en/latest/
  * The code of the project is on Github: https://github.com/mtreinish/stestr
      Python 2. Support for Python 2.7 was dropped in stestr release 3.0.0.


pkgId: 2d6b01e08a5a89447492ee42246d087dffd99876488d1a0711e35b1d8baa4111
name: python-stix2
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: Produce and consume STIX 2 JSON content
url: https://oasis-open.github.io/cti-documentation/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-47087268-fbd4-4c45-88fe-7c581bd3ab1c
location_href: 00013654-python-stix2/python-stix2-3.0.1-1.src.rpm
checksum_type: sha256
description:
  This is an `OASIS TC Open Repository <https://www.oasis-open.org/resources/open-repositories/>`__.
  See the `Governance <#governance>`__ section for more information.
  This repository provides Python APIs for serializing and de-serializing STIX2
  JSON content, along with higher-level APIs for common tasks, including data
  markings, versioning, and for resolving STIX IDs across multiple data sources.
  For more information, see `the documentation <https://stix2.readthedocs.io/>`__ on ReadTheDocs.


pkgId: 3523a6fe382f1d7c96ff3ded6a02c9faa9ea0590253c89cc314f2d59e19b4352
name: python-stldecompose
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: A Python implementation of seasonal trend with Loess (STL) time series decomposition
url: https://github.com/jrmontag/STLDecompose
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-88156c6b-5b1e-4fd8-ac77-d32d10345449
location_href: 00011343-python-stldecompose/python-stldecompose-0.0.5-1.src.rpm
checksum_type: sha256
description:
  This is a relatively naive Python implementation of a seasonal and trend decomposition using Loess smoothing. Commonly referred to as an "STL decomposition", Cleveland's 1990 paper is the canonical reference.
  This implementation is a variation of (and takes inspiration from) the implementation of the ``seasonal_decompose`` method `in statsmodels <http://www.statsmodels.org/stable/generated/statsmodels.tsa.seasonal.seasonal_decompose.html#statsmodels.tsa.seasonal.seasonal_decompose>`_. In this implementation, the trend component is calculated by substituting a configurable `Loess regression <https://en.wikipedia.org/wiki/Local_regression>`_ for the convolutional method used in ``seasonal_decompose``. It also extends the existing ``DecomposeResult`` from ``statsmodels`` to allow for forecasting based on the calculated decomposition.


pkgId: bac4ede245e4753e68a314a330f9f3a694243285edc065d50b0af70d938a4a13
name: python-stompest
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: STOMP library for Python including a synchronous client.
url: https://github.com/nikipore/stompest
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b3e865d7-e396-43f6-8eda-96cdc8d27e64
location_href: 00005226-python-stompest/python-stompest-2.3.0-1.src.rpm
checksum_type: sha256
description:
  `stompest <https://github.com/nikipore/stompest/>`_ is a full-featured `STOMP <http://stomp.github.com/>`_ `1.0 <http://stomp.github.com//stomp-specification-1.0.html>`_, `1.1 <http://stomp.github.com//stomp-specification-1.1.html>`_, and `1.2 <http://stomp.github.com//stomp-specification-1.2.html>`_ implementation for Python 2.7 and Python 3 (versions 3.3 and higher), with optional TLS/SSL support.
  The STOMP client in this package is dead simple: It does not assume anything about your concurrency model (thread vs process) or force you to use it any particular way. It gets out of your way and lets you do what you want. The package also consists of a generic set of components each of which you may use independently to roll your own STOMP client:
  * a wire-level STOMP frame parser and compiler,
  * a faithful implementation of the syntax of the STOMP protocol with a simple stateless function API,
  * a generic implementation of the STOMP session state semantics, such as protocol version negotiation at connect time, transaction and subscription handling (including a generic subscription replay scheme which may be used to reconstruct the session's subscription state after a forced disconnect),
  * and a `failover transport <http://activemq.apache.org/failover-transport-reference.html>`_ URI scheme akin to the one used in ActiveMQ.
  This package is thoroughly unit tested and production hardened for the functionality used by the current maintainer and by `Mozes <http://www.mozes.com/>`_ -- persistent queueing on `ActiveMQ <http://activemq.apache.org/>`_. Minor enhancements may be required to use this STOMP adapter with other brokers.


pkgId: 42d0a512f55e4ef95d45991ec09391e57fb66bfb0caf683eb5b4ebef9349108c
name: python-stone
arch: src
version: 3.3.1
epoch: 0
release: 1
summary: Stone is an interface description language (IDL) for APIs.
url: https://github.com/dropbox/stone
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8c84b8a3-e294-4387-8bca-2d75645be4be
location_href: 00005229-python-stone/python-stone-3.3.1-1.src.rpm
checksum_type: sha256
description:
  Install stone using ``pip``::
      $ pip install --user stone
  This will install a script ``stone`` to your PATH that can be run from the
  command line::
      $ stone -h


pkgId: c584d7f002327bc415934d1b067aef325616458d252b1feadb7d6e78dc58fd84
name: python-streamlink
arch: src
version: 5.3.1
epoch: 0
release: 1
url: https://github.com/streamlink/streamlink
rpm_license: Simplified BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e3d905f6-49eb-42ed-a99a-50ba54bc9385
location_href: 00005231-python-streamlink/python-streamlink-5.3.1-1.src.rpm
checksum_type: sha256
summary:
  Streamlink is a command-line utility that extracts streams from various services and pipes them into a video player of choice.

description:
  <h1 align="center"><a href="https://streamlink.github.io/">Streamlink<br><img height="150" alt="Streamlink" src="https://raw.githubusercontent.com/streamlink/streamlink/master/icon.svg"></a></h1>

  <p align="center">
    <a href="https://streamlink.github.io/install.html"><img alt="Supported Python versions" src="https://img.shields.io/pypi/pyversions/streamlink.svg?style=flat-square&maxAge=86400"></a>
    <a href="https://streamlink.github.io/changelog.html"><img alt="Latest release" src="https://img.shields.io/github/release/streamlink/streamlink.svg?style=flat-square&maxAge=86400"></a>
    <a href="https://github.com/streamlink/streamlink"><img alt="License" src="https://img.shields.io/github/license/streamlink/streamlink.svg?style=flat-square&maxAge=86400"></a>
    <a href="https://github.com/streamlink/streamlink/issues"><img alt="Open issues" src="https://img.shields.io/github/issues/streamlink/streamlink.svg?style=flat-square&maxAge=86400"></a>
    <a href="https://github.com/streamlink/streamlink/actions?query=event%3Apush"><img alt="Build status" src="https://img.shields.io/github/actions/workflow/status/streamlink/streamlink/main.yml?branch=master&event=push&style=flat-square&maxAge=86400"></a>
    <a href="https://codecov.io/github/streamlink/streamlink?branch=master"><img alt="Overall code coverage" src="https://img.shields.io/codecov/c/github/streamlink/streamlink.svg?branch=master&style=flat-square&maxAge=86400"></a>
  </p>

  <p align="center">
    A Python library and command-line interface which pipes streams from various services into a video player.<br>
    Avoid resource-heavy and unoptimized websites, and still enjoy streamed content.
  </p>

  <p align="center">
    Streamlink was forked in 2016 from the abandoned <em>Livestreamer</em> project.
  </p>




  Please take a look at the documentation for different ways of installing Streamlink:

  - [Windows][streamlink-installation-windows]
  - [macOS][streamlink-installation-macos]
  - [Linux and BSD][streamlink-installation-linux-and-bsd]
  - [PyPI package and source code][streamlink-installation-pypi-source]




  Streamlink is built on top of a plugin system which allows support for new services to be added easily.

  Most of the popular streaming services are supported, such as:

  - [Twitch](https://www.twitch.tv)
  - [YouTube](https://www.youtube.com)
  - [Livestream](https://livestream.com)
  - [Dailymotion](https://www.dailymotion.com)

  ... and many more. A list of all plugins currently included can be found on the [plugins page][streamlink-plugins].




  After installing, simply run:

  ```sh
  streamlink "STREAMURL" best
  ```

  The default behavior of Streamlink is to play back streams in the [VLC player][player-vlc], but a lot of other options and output methods are available, such as writing the stream to the filesystem, reading stream metadata, etc.

  For more in-depth usage, please refer to the [CLI documentation][streamlink-documentation-cli].

  An [API guide][streamlink-documentation-apiguide] and [API reference][streamlink-documentation-apiref] is available for Python implementors of Streamlink.




  All contributions are welcome.
  Feel free to open a new thread on the issue tracker or submit a new pull request.
  Please read [CONTRIBUTING.md][contributing] first. Thanks!




  If you think that Streamlink is useful and if you want to keep the project alive, then please consider supporting its maintainers by sending a small and optionally recurring tip via the [available options][support].
  Your support is very much appreciated, thank you!


    [streamlink-installation-windows]: https://streamlink.github.io/install.html#windows
    [streamlink-installation-macos]: https://streamlink.github.io/install.html#macos
    [streamlink-installation-linux-and-bsd]: https://streamlink.github.io/install.html#linux-and-bsd
    [streamlink-installation-pypi-source]: https://streamlink.github.io/install.html#pypi-package-and-source-code
    [streamlink-documentation-cli]: https://streamlink.github.io/cli.html
    [streamlink-documentation-apiguide]: https://streamlink.github.io/api_guide.html
    [streamlink-documentation-apiref]: https://streamlink.github.io/api.html
    [streamlink-plugins]: https://streamlink.github.io/plugins.html
    [player-vlc]: https://www.videolan.org/vlc/
    [contributing]: https://github.com/streamlink/streamlink/blob/master/CONTRIBUTING.md
    [support]: https://streamlink.github.io/latest/donate.html


pkgId: e5b7ba518cbb1df888ca77f9cae6ee6c7e2587a33c651fab1e500ac691fffba2
name: python-strictyaml
arch: src
version: 1.6.2
epoch: 0
release: 1
summary: Strict, typed YAML parser
url: http://hitchdev.com/strictyaml
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e4f29b4f-2458-4273-9c25-8a39fe85fb08
location_href: 00005233-python-strictyaml/python-strictyaml-1.6.2-1.src.rpm
checksum_type: sha256
description:
  StrictYAML is a [type-safe](https://en.wikipedia.org/wiki/Type_safety) YAML parser
  that parses and validates a [restricted subset](https://hitchdev.com/strictyaml/features-removed) of the [YAML](https://hitchdev.com/strictyaml/what-is-yaml)
  specification.

  Priorities:

  - Beautiful API
  - Refusing to parse [the ugly, hard to read and insecure features of YAML](https://hitchdev.com/strictyaml/features-removed) like [the Norway problem](https://hitchdev.com/strictyaml/why/implicit-typing-removed).
  - Strict validation of markup and straightforward type casting.
  - Clear, readable exceptions with **code snippets** and **line numbers**.
  - Acting as a near-drop in replacement for pyyaml, ruamel.yaml or poyo.
  - Ability to read in YAML, make changes and write it out again with comments preserved.
  - [Not speed](https://hitchdev.com/strictyaml/why/speed-not-a-priority), currently.


  Simple example:

  ```yaml

  name: Ford Prefect
  age: 42
  possessions:
  - Towel

  ```


  ```python
  from strictyaml import load, Map, Str, Int, Seq, YAMLError

  ```





  Default parse result:


  ```python
  >>> load(yaml_snippet)
  YAML({'name': 'Ford Prefect', 'age': '42', 'possessions': ['Towel']})
  ```



  All data is string, list or OrderedDict:


  ```python
  >>> load(yaml_snippet).data
  {'name': 'Ford Prefect', 'age': '42', 'possessions': ['Towel']}
  ```



  Quickstart with schema:


  ```python
  from strictyaml import load, Map, Str, Int, Seq, YAMLError

  schema = Map({"name": Str(), "age": Int(), "possessions": Seq(Str())})

  ```





  42 is now parsed as an integer:


  ```python
  >>> person = load(yaml_snippet, schema)
  >>> person.data
  {'name': 'Ford Prefect', 'age': 42, 'possessions': ['Towel']}
  ```



  A YAMLError will be raised if there are syntactic problems, violations of your schema or use of disallowed YAML features:

  ```yaml

  name: Ford Prefect
  age: 42

  ```






  For example, a schema violation:


  ```python
  try:
      person = load(yaml_snippet, schema)
  except YAMLError as error:
      print(error)

  ```

  ```yaml
  while parsing a mapping
    in "<unicode string>", line 1, column 1:
      
       ^ (line: 1)
  required key(s) 'possessions' not found
    in "<unicode string>", line 3, column 1:
      age: '42'
      ^ (line: 3)
  ```





  If parsed correctly:


  ```python
  from strictyaml import load, Map, Str, Int, Seq, YAMLError, as_document

  schema = Map({"name": Str(), "age": Int(), "possessions": Seq(Str())})

  ```





  You can modify values and write out the YAML with comments preserved:


  ```python
  person = load(yaml_snippet, schema)
  person['age'] = 43
  print(person.as_yaml())

  ```

  ```yaml

  name: Ford Prefect
  age: 43
  possessions:
  - Towel
  ```





  As well as look up line numbers:


  ```python
  >>> person = load(yaml_snippet, schema)
  >>> person['possessions'][0].start_line
  5
  ```



  And construct YAML documents from dicts or lists:


  ```python
  print(as_document({"x": 1}).as_yaml())

  ```

  ```yaml
  x: 1
  ```









  ```sh
  $ pip install strictyaml
  ```




  There are a number of formats and approaches that can achieve more or
  less the same purpose as StrictYAML. I've tried to make it the best one.
  Below is a series of documented justifications:

  - [Why avoid using environment variables as configuration?](https://hitchdev.com/strictyaml/why-not/environment-variables-as-config)
  - [Why not use HJSON?](https://hitchdev.com/strictyaml/why-not/hjson)
  - [Why not HOCON?](https://hitchdev.com/strictyaml/why-not/hocon)
  - [Why not use INI files?](https://hitchdev.com/strictyaml/why-not/ini)
  - [Why not use JSON Schema for validation?](https://hitchdev.com/strictyaml/why-not/json-schema)
  - [Why not JSON for simple configuration files?](https://hitchdev.com/strictyaml/why-not/json)
  - [Why not JSON5?](https://hitchdev.com/strictyaml/why-not/json5)
  - [Why not use the YAML 1.2 standard? - we don't need a new standard!](https://hitchdev.com/strictyaml/why-not/ordinary-yaml)
  - [Why not use kwalify with standard YAML to validate my YAML?](https://hitchdev.com/strictyaml/why-not/pykwalify)
  - [Why not use Python's schema library (or similar) for validation?](https://hitchdev.com/strictyaml/why-not/python-schema)
  - [Why not use SDLang?](https://hitchdev.com/strictyaml/why-not/sdlang)
  - [What is wrong with TOML?](https://hitchdev.com/strictyaml/why-not/toml)
  - [Why shouldn't I just use Python code for configuration?](https://hitchdev.com/strictyaml/why-not/turing-complete-code)
  - [Why not use XML for configuration or DSLs?](https://hitchdev.com/strictyaml/why-not/xml)





  How to:

  - [Build a YAML document from scratch in code](https://hitchdev.com/strictyaml/using/alpha/howto/build-yaml-document)
  - [Either/or schema validation of different, equally valid different kinds of YAML](https://hitchdev.com/strictyaml/using/alpha/howto/either-or-validation)
  - [Labeling exceptions](https://hitchdev.com/strictyaml/using/alpha/howto/label-exceptions)
  - [Merge YAML documents](https://hitchdev.com/strictyaml/using/alpha/howto/merge-yaml-documents)
  - [Revalidate an already validated document](https://hitchdev.com/strictyaml/using/alpha/howto/revalidation)
  - [Reading in YAML, editing it and writing it back out](https://hitchdev.com/strictyaml/using/alpha/howto/roundtripping)
  - [Get line numbers of YAML elements](https://hitchdev.com/strictyaml/using/alpha/howto/what-line)
  - [Parsing YAML without a schema](https://hitchdev.com/strictyaml/using/alpha/howto/without-a-schema)


  Compound validators:

  - [Fixed length sequences (FixedSeq)](https://hitchdev.com/strictyaml/using/alpha/compound/fixed-length-sequences)
  - [Mappings combining defined and undefined keys (MapCombined)](https://hitchdev.com/strictyaml/using/alpha/compound/map-combined)
  - [Mappings with arbitrary key names (MapPattern)](https://hitchdev.com/strictyaml/using/alpha/compound/map-pattern)
  - [Mapping with defined keys and a custom key validator (Map)](https://hitchdev.com/strictyaml/using/alpha/compound/mapping-with-slug-keys)
  - [Using a YAML object of a parsed mapping](https://hitchdev.com/strictyaml/using/alpha/compound/mapping-yaml-object)
  - [Mappings with defined keys (Map)](https://hitchdev.com/strictyaml/using/alpha/compound/mapping)
  - [Optional keys with defaults (Map/Optional)](https://hitchdev.com/strictyaml/using/alpha/compound/optional-keys-with-defaults)
  - [Validating optional keys in mappings (Map)](https://hitchdev.com/strictyaml/using/alpha/compound/optional-keys)
  - [Sequences of unique items (UniqueSeq)](https://hitchdev.com/strictyaml/using/alpha/compound/sequences-of-unique-items)
  - [Sequence/list validator (Seq)](https://hitchdev.com/strictyaml/using/alpha/compound/sequences)
  - [Updating document with a schema](https://hitchdev.com/strictyaml/using/alpha/compound/update)


  Scalar validators:

  - [Boolean (Bool)](https://hitchdev.com/strictyaml/using/alpha/scalar/boolean)
  - [Parsing comma separated items (CommaSeparated)](https://hitchdev.com/strictyaml/using/alpha/scalar/comma-separated)
  - [Datetimes (Datetime)](https://hitchdev.com/strictyaml/using/alpha/scalar/datetime)
  - [Decimal numbers (Decimal)](https://hitchdev.com/strictyaml/using/alpha/scalar/decimal)
  - [Email and URL validators](https://hitchdev.com/strictyaml/using/alpha/scalar/email-and-url)
  - [Empty key validation](https://hitchdev.com/strictyaml/using/alpha/scalar/empty)
  - [Enumerated scalars (Enum)](https://hitchdev.com/strictyaml/using/alpha/scalar/enum)
  - [Floating point numbers (Float)](https://hitchdev.com/strictyaml/using/alpha/scalar/float)
  - [Hexadecimal Integers (HexInt)](https://hitchdev.com/strictyaml/using/alpha/scalar/hexadecimal-integer)
  - [Integers (Int)](https://hitchdev.com/strictyaml/using/alpha/scalar/integer)
  - [Validating strings with regexes (Regex)](https://hitchdev.com/strictyaml/using/alpha/scalar/regular-expressions)
  - [Parsing strings (Str)](https://hitchdev.com/strictyaml/using/alpha/scalar/string)


  Restrictions:

  - [Disallowed YAML](https://hitchdev.com/strictyaml/using/alpha/restrictions/disallowed-yaml)
  - [Duplicate keys](https://hitchdev.com/strictyaml/using/alpha/restrictions/duplicate-keys)
  - [Dirty load](https://hitchdev.com/strictyaml/using/alpha/restrictions/loading-dirty-yaml)





  There are some design decisions in StrictYAML which are controversial
  and/or not obvious. Those are documented here:

  - [What is wrong with duplicate keys?](https://hitchdev.com/strictyaml/why/duplicate-keys-disallowed)
  - [What is wrong with explicit tags?](https://hitchdev.com/strictyaml/why/explicit-tags-removed)
  - [What is wrong with flow-style YAML?](https://hitchdev.com/strictyaml/why/flow-style-removed)
  - [The Norway Problem - why StrictYAML refuses to do implicit typing and so should you](https://hitchdev.com/strictyaml/why/implicit-typing-removed)
  - [What is wrong with node anchors and references?](https://hitchdev.com/strictyaml/why/node-anchors-and-references-removed)
  - [Why does StrictYAML not parse direct representations of Python objects?](https://hitchdev.com/strictyaml/why/not-parse-direct-representations-of-python-objects)
  - [Why does StrictYAML only parse from strings and not files?](https://hitchdev.com/strictyaml/why/only-parse-strings-not-files)
  - [Why is parsing speed not a high priority for StrictYAML?](https://hitchdev.com/strictyaml/why/speed-not-a-priority)
  - [What is syntax typing?](https://hitchdev.com/strictyaml/why/syntax-typing-bad)
  - [Why does StrictYAML make you define a schema in Python - a Turing-complete language?](https://hitchdev.com/strictyaml/why/turing-complete-schema)





  - @wwoods
  - @chrisburr
  - @jnichols0



  - @eulores
  - @WaltWoods
  - @ChristopherGS
  - @gvx
  - @AlexandreDecan
  - @lots0logs
  - @tobbez
  - @jaredsampson
  - @BoboTIG

  StrictYAML also includes code from [ruamel.yaml](https://yaml.readthedocs.io/en/latest/), Copyright Anthon van der Neut.



  - Before writing any code, please read the tutorial on [contributing to hitchdev libraries](https://hitchdev.com/approach/contributing-to-hitch-libraries/).
  - Before writing any code, if you're proposing a new feature, please raise it on github. If it's an existing feature / bug, please comment and briefly describe how you're going to implement it.
  - All code needs to come accompanied with a story that exercises it or a modification to an existing story. This is used both to test the code and build the documentation.


pkgId: 90c5614b5078538fd65ca041f8fe82df055a3caddbb49094c8013267e8e385d1
name: python-stringcase
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: String case converter.
url: https://github.com/okunishinishi/python-stringcase
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-169cac9a-427f-486d-b046-a839c59e3e47
location_href: 00009300-python-stringcase/python-stringcase-1.2.0-1.src.rpm
checksum_type: sha256
description:
  Convert string cases between camel case, pascal case, snake case etc...
  |build_status_badge| |coverage_badge| |pypi_version_badge|


pkgId: 3d9cbc835180c0030777867bccd11fa508887f570e0c21bc9572dc02eec961da
name: python-strsim
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: A library implementing different string similarity and distance measures
url: https://github.com/luozhouyang/python-string-similarity
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-332ccfd2-2860-44f1-ad83-1a3a5d51a94c
location_href: 00011583-python-strsim/python-strsim-0.0.3-1.src.rpm
checksum_type: sha256
description:
  **Python3.5 implementation of [tdebatty/java-string-similarity](https://github.com/tdebatty/java-string-similarity)**


  A library implementing different string similarity and distance measures. A dozen of algorithms (including Levenshtein edit distance and sibblings, Jaro-Winkler, Longest Common Subsequence, cosine similarity etc.) are currently implemented. Check the summary table below for the complete list...

  * [Download](#download)
  * [Overview](#overview)
  * [Normalized, metric, similarity and distance](#normalized-metric-similarity-and-distance)
  * [Shingles (n-gram) based similarity and distance](#shingles-n-gram-based-similarity-and-distance)
  * [Levenshtein](#levenshtein)
  * [Normalized Levenshtein](#normalized-levenshtein)
  * [Weighted Levenshtein](#weighted-levenshtein)
  * [Damerau-Levenshtein](#damerau-levenshtein)
  * [Optimal String Alignment](#optimal-string-alignment)
  * [Jaro-Winkler](#jaro-winkler)
  * [Longest Common Subsequence](#longest-common-subsequence)
  * [Metric Longest Common Subsequence](#metric-longest-common-subsequence)
  * [N-Gram](#n-gram)
  * [Shingle (n-gram) based algorithms](#shingle-n-gram-based-algorithms)
    * [Q-Gram](#shingle-n-gram-based-algorithms)
    * [Cosine similarity](#shingle-n-gram-based-algorithms)
    * [Jaccard index](#shingle-n-gram-based-algorithms)
    * [Sorensen-Dice coefficient](#shingle-n-gram-based-algorithms)
  * [Experimental](#experimental)
    * [SIFT4](#sift4)
  * [Users](#users)




  From pypi:

  ```bash
  pip install strsim
  ```

  or clone this repository:

  ```bash
  git clone https://github.com/luozhouyang/python-string-similarity
  cd python-string-similarity
  pip install -r requirements.txt
  ```



  The main characteristics of each implemented algorithm are presented below. The "cost" column gives an estimation of the computational cost to compute the similarity between two strings of length m and n respectively.

  |  									|  						| Normalized? 	| Metric?	| Type    | Cost | Typical usage |
  | --------					|-------			|-------------	|-------- | ------  | ---- | ---   |
  | [Levenshtein](#levenshtein)		|distance 				| No 			| Yes 		|         | O(m*n) <sup>1</sup> |  |
  | [Normalized Levenshtein](#normalized-levenshtein)	|distance<br>similarity	| Yes 			| No 		| 	      | O(m*n) <sup>1</sup> |  |
  | [Weighted Levenshtein](#weighted-levenshtein)		|distance 				| No 			| No 		| 	      | O(m*n) <sup>1</sup> | OCR |
  | [Damerau-Levenshtein](#damerau-levenshtein) <sup>3</sup> 	|distance 				| No 			| Yes 		| 	      | O(m*n) <sup>1</sup> |  |
  | [Optimal String Alignment](#optimal-string-alignment) <sup>3</sup> |distance | No 			| No 		| 	      | O(m*n) <sup>1</sup> |  |
  | [Jaro-Winkler](#jaro-winkler) 		|similarity<br>distance	| Yes  			| No 		| 	      | O(m*n) | typo correction |
  | [Longest Common Subsequence](#longest-common-subsequence) 		|distance 				| No 			| No 		| 	      | O(m*n) <sup>1,2</sup> | diff utility, GIT reconciliation |
  | [Metric Longest Common Subsequence](#metric-longest-common-subsequence) |distance   			| Yes 			| Yes  		| 	      | O(m*n) <sup>1,2</sup> |  |
  | [N-Gram](#n-gram)	 				|distance				| Yes  			| No 		| 	      | O(m*n) |  |
  | [Q-Gram](#q-gram) 				|distance  			 	| No  			| No 		| Profile | O(m+n) |  |
  | [Cosine similarity](#cosine-similarity) 				|similarity<br>distance | Yes  			| No  		| Profile | O(m+n) |  |
  | [Jaccard index](#jaccard-index)				|similarity<br>distance | Yes  			| Yes  		| Set	  | O(m+n) |  |
  | [Sorensen-Dice coefficient](#sorensen-dice-coefficient) 	|similarity<br>distance | Yes 			| No 		| Set	  | O(m+n) |  |

  [1] In this library, Levenshtein edit distance, LCS distance and their sibblings are computed using the **dynamic programming** method, which has a cost O(m.n). For Levenshtein distance, the algorithm is sometimes called **Wagner-Fischer algorithm** ("The string-to-string correction problem", 1974). The original algorithm uses a matrix of size m x n to store the Levenshtein distance between string prefixes.

  If the alphabet is finite, it is possible to use the **method of four russians** (Arlazarov et al. "On economic construction of the transitive closure of a directed graph", 1970) to speedup computation. This was published by Masek in 1980 ("A Faster Algorithm Computing String Edit Distances"). This method splits the matrix in blocks of size t x t. Each possible block is precomputed to produce a lookup table. This lookup table can then be used to compute the string similarity (or distance) in O(nm/t). Usually, t is choosen as log(m) if m > n. The resulting computation cost is thus O(mn/log(m)). This method has not been implemented (yet).

  [2] In "Length of Maximal Common Subsequences", K.S. Larsen proposed an algorithm that computes the length of LCS in time O(log(m).log(n)). But the algorithm has a memory requirement O(m.n²) and was thus not implemented here.

  [3] There are two variants of Damerau-Levenshtein string distance: Damerau-Levenshtein with adjacent transpositions (also sometimes called unrestricted Damerau–Levenshtein distance) and Optimal String Alignment (also sometimes called restricted edit distance). For Optimal String Alignment, no substring can be edited more than once.


  Although the topic might seem simple, a lot of different algorithms exist to measure text similarity or distance. Therefore the library defines some interfaces to categorize them.



  - StringSimilarity : Implementing algorithms define a similarity between strings (0 means strings are completely different).
  - NormalizedStringSimilarity : Implementing algorithms define a similarity between 0.0 and 1.0, like Jaro-Winkler for example.
  - StringDistance : Implementing algorithms define a distance between strings (0 means strings are identical), like Levenshtein for example. The maximum distance value depends on the algorithm.
  - NormalizedStringDistance : This interface extends StringDistance. For implementing classes, the computed distance value is between 0.0 and 1.0. NormalizedLevenshtein is an example of NormalizedStringDistance.

  Generally, algorithms that implement NormalizedStringSimilarity also implement NormalizedStringDistance, and similarity = 1 - distance. But there are a few exceptions, like N-Gram similarity and distance (Kondrak)...


  The MetricStringDistance interface : A few of the distances are actually metric distances, which means that verify the triangle inequality d(x, y) <= d(x,z) + d(z,y). For example, Levenshtein is a metric distance, but NormalizedLevenshtein is not.

  A lot of nearest-neighbor search algorithms and indexing structures rely on the triangle inequality.


  A few algorithms work by converting strings into sets of n-grams (sequences of n characters, also sometimes called k-shingles). The similarity or distance between the strings is then the similarity or distance between the sets.

  Some of them, like jaccard, consider strings as sets of shingles, and don't consider the number of occurences of each shingle. Others, like cosine similarity, work using what is sometimes called the profile of the strings, which takes into account the number of occurences of each shingle.

  For these algorithms, another use case is possible when dealing with large datasets:
  1. compute the set or profile representation of all the strings
  2. compute the similarity between sets or profiles


  The Levenshtein distance between two words is the minimum number of single-character edits (insertions, deletions or substitutions) required to change one word into the other.

  It is a metric string distance. This implementation uses dynamic programming (Wagner–Fischer algorithm), with only 2 rows of data. The space requirement is thus O(m) and the algorithm runs in O(m.n).

  ```python
  from similarity.levenshtein import Levenshtein

  levenshtein = Levenshtein()
  print(levenshtein.distance('My string', 'My $string'))
  print(levenshtein.distance('My string', 'My $string'))
  print(levenshtein.distance('My string', 'My $string'))

  ```



  This distance is computed as levenshtein distance divided by the length of the longest string. The resulting value is always in the interval [0.0 1.0] but it is not a metric anymore!

  The similarity is computed as 1 - normalized distance.

  ```python
  from similarity.normalized_levenshtein import NormalizedLevenshtein

  normalized_levenshtein = NormalizedLevenshtein()
  print(normalized_levenshtein.distance('My string', 'My $string'))
  print(normalized_levenshtein.distance('My string', 'My $string'))
  print(normalized_levenshtein.distance('My string', 'My $string'))

  print(normalized_levenshtein.similarity('My string', 'My $string'))
  print(normalized_levenshtein.similarity('My string', 'My $string'))
  print(normalized_levenshtein.similarity('My string', 'My $string'))

  ```


  An implementation of Levenshtein that allows to define different weights for different character substitutions.

  This algorithm is usually used for optical character recognition (OCR) applications. For OCR, the cost of substituting P and R is lower then the cost of substituting P and M for example because because from and OCR point of view P is similar to R.

  It can also be used for keyboard typing auto-correction. Here the cost of substituting E and R is lower for example because these are located next to each other on an AZERTY or QWERTY keyboard. Hence the probability that the user mistyped the characters is higher.

  ```python
  from similarity.weighted_levenshtein import WeightedLevenshtein
  from similarity.weighted_levenshtein import CharacterSubstitutionInterface

  class CharacterSubstitution(CharacterSubstitutionInterface):
      def cost(self, c0, c1):
          if c0=='t' and c1=='r':
              return 0.5
          return 1.0

  weighted_levenshtein = WeightedLevenshtein(CharacterSubstitution())
  print(weighted_levenshtein.distance('String1', 'String2'))

  ```


  Similar to Levenshtein, Damerau-Levenshtein distance with transposition (also sometimes calls unrestricted Damerau-Levenshtein distance) is the minimum number of operations needed to transform one string into the other, where an operation is defined as an insertion, deletion, or substitution of a single character, or a **transposition of two adjacent characters**.

  It does respect triangle inequality, and is thus a metric distance.

  This is not to be confused with the optimal string alignment distance, which is an extension where no substring can be edited more than once.

  ```python
  from similarity.damerau import Damerau

  damerau = Damerau()
  print(damerau.distance('ABCDEF', 'ABDCEF'))
  print(damerau.distance('ABCDEF', 'BACDFE'))
  print(damerau.distance('ABCDEF', 'ABCDE'))
  print(damerau.distance('ABCDEF', 'BCDEF'))
  print(damerau.distance('ABCDEF', 'ABCGDEF'))
  print(damerau.distance('ABCDEF', 'POIU'))

  ```

  Will produce:

  ```
  1.0
  2.0
  1.0
  1.0
  1.0
  6.0
  ```


  The Optimal String Alignment variant of Damerau–Levenshtein (sometimes called the restricted edit distance) computes the number of edit operations needed to make the strings equal under the condition that **no substring is edited more than once**, whereas the true Damerau–Levenshtein presents no such restriction.
  The difference from the algorithm for Levenshtein distance is the addition of one recurrence for the transposition operations.

  Note that for the optimal string alignment distance, the triangle inequality does not hold and so it is not a true metric.

  ```python
  from similarity.optimal_string_alignment import OptimalStringAlignment

  optimal_string_alignment = OptimalStringAlignment()
  print(optimal_string_alignment.distance('CA', 'ABC'))

  ```

  Will produce:

  ```
  3.0
  ```


  Jaro-Winkler is a string edit distance that was developed in the area of record linkage (duplicate detection) (Winkler, 1990). The Jaro–Winkler distance metric is designed and best suited for short strings such as person names, and to detect typos.

  Jaro-Winkler computes the similarity between 2 strings, and the returned value lies in the interval [0.0, 1.0].
  It is (roughly) a variation of Damerau-Levenshtein, where the substitution of 2 close characters is considered less important then the substitution of 2 characters that a far from each other.

  The distance is computed as 1 - Jaro-Winkler similarity.

  ```python
  from similarity.jarowinkler import JaroWinkler

  jarowinkler = JaroWinkler()
  print(jarowinkler.similarity('My string', 'My tsring'))
  print(jarowinkler.similarity('My string', 'My ntrisg'))

  ```

  will produce:

  ```
  0.9740740740740741
  0.8962962962962963
  ```



  The longest common subsequence (LCS) problem consists in finding the longest subsequence common to two (or more) sequences. It differs from problems of finding common substrings: unlike substrings, subsequences are not required to occupy consecutive positions within the original sequences.

  It is used by the diff utility, by Git for reconciling multiple changes, etc.

  The LCS distance between strings X (of length n) and Y (of length m) is n + m - 2 |LCS(X, Y)|
  min = 0
  max = n + m

  LCS distance is equivalent to Levenshtein distance when only insertion and deletion is allowed (no substitution), or when the cost of the substitution is the double of the cost of an insertion or deletion.

  This class implements the dynamic programming approach, which has a space requirement O(m.n), and computation cost O(m.n).

  In "Length of Maximal Common Subsequences", K.S. Larsen proposed an algorithm that computes the length of LCS in time O(log(m).log(n)). But the algorithm has a memory requirement O(m.n²) and was thus not implemented here.

  ```python
  from similarity.longest_common_subsequence import LongestCommonSubsequence

  lcs = LongestCommonSubsequence()

  print(lcs.distance('AGCAT', 'GAC'))

  print(lcs.distance('AGCAT', 'AGCT'))

  ```


  Distance metric based on Longest Common Subsequence, from the notes "An LCS-based string metric" by Daniel Bakkelund.
  http://heim.ifi.uio.no/~danielry/StringMetric.pdf

  The distance is computed as 1 - |LCS(s1, s2)| / max(|s1|, |s2|)

  ```python
  from similarity.metric_lcs import MetricLCS

  metric_lcs = MetricLCS()
  s1 = 'ABCDEFG'
  s2 = 'ABCDEFHJKL'




  print(metric_lcs.distance(s1, s2))




  print(metric_lcs.distance('ABDEF', 'ABDIF'))

  ```

  will produce:

  ```
  0.4
  0.19999999999999996
  ```




  Normalized N-Gram distance as defined by Kondrak, "N-Gram Similarity and Distance", String Processing and Information Retrieval, Lecture Notes in Computer Science Volume 3772, 2005, pp 115-126.

  http://webdocs.cs.ualberta.ca/~kondrak/papers/spire05.pdf

  The algorithm uses affixing with special character '\n' to increase the weight of first characters. The normalization is achieved by dividing the total similarity score the original length of the longest word.

  In the paper, Kondrak also defines a similarity measure, which is not implemented (yet).

  ```python
  from similarity.ngram import NGram

  twogram = NGram(2)
  print(twogram.distance('ABCD', 'ABTUIO'))

  s1 = 'Adobe CreativeSuite 5 Master Collection from cheap 4zp'
  s2 = 'Adobe CreativeSuite 5 Master Collection from cheap d1x'
  fourgram = NGram(4)
  print(fourgram.distance(s1, s2))

  ```


  A few algorithms work by converting strings into sets of n-grams (sequences of n characters, also sometimes called k-shingles). The similarity or distance between the strings is then the similarity or distance between the sets.

  The cost for computing these similarities and distances is mainly domnitated by k-shingling (converting the strings into sequences of k characters). Therefore there are typically two use cases for these algorithms:

  Directly compute the distance between strings:

  ```python
  from similarity.qgram import QGram

  qgram = QGram(2)
  print(qgram.distance('ABCD', 'ABCE'))

  ```

  Or, for large datasets, pre-compute the profile of all strings. The similarity can then be computed between profiles:

  ```python
  from similarity.cosine import Cosine

  cosine = Cosine(2)
  s0 = 'My first string'
  s1 = 'My other string...'
  p0 = cosine.get_profile(s0)
  p1 = cosine.get_profile(s1)
  print(cosine.similarity_profiles(p0, p1))

  ```

  Pay attention, this only works if the same KShingling object is used to parse all input strings !



  Q-gram distance, as defined by Ukkonen in "Approximate string-matching with q-grams and maximal matches"
  http://www.sciencedirect.com/science/article/pii/0304397592901434

  The distance between two strings is defined as the L1 norm of the difference of their profiles (the number of occurences of each n-gram): SUM( |V1_i - V2_i| ). Q-gram distance is a lower bound on Levenshtein distance, but can be computed in O(m + n), where Levenshtein requires O(m.n)



  The similarity between the two strings is the cosine of the angle between these two vectors representation, and is computed as V1 . V2 / (|V1| * |V2|)

  Distance is computed as 1 - cosine similarity.


  Like Q-Gram distance, the input strings are first converted into sets of n-grams (sequences of n characters, also called k-shingles), but this time the cardinality of each n-gram is not taken into account. Each input string is simply a set of n-grams. The Jaccard index is then computed as |V1 inter V2| / |V1 union V2|.

  Distance is computed as 1 - similarity.
  Jaccard index is a metric distance.


  Similar to Jaccard index, but this time the similarity is computed as 2 * |V1 inter V2| / (|V1| + |V2|).

  Distance is computed as 1 - similarity.




  SIFT4 is a general purpose string distance algorithm inspired by JaroWinkler and Longest Common Subsequence. It was developed to produce a distance measure that matches as close as possible to the human perception of string distance. Hence it takes into account elements like character substitution, character distance, longest common subsequence etc. It was developed using experimental testing, and without theoretical background.

  **Not implemented yet**




  * [StringSimilarity.NET](https://github.com/feature23/StringSimilarity.NET) a .NET port of java-string-similarity

  Use java-string-similarity in your project and want it to be mentioned here? Don't hesitate to drop me a line!


pkgId: 6083a0675120a95720ef83e97f7595092e6fa90d65c3d6284ee043c8338f99ad
name: python-structlog-sentry
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Sentry integration for structlog
url: https://github.com/kiwicom/structlog-sentry
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5935e1c8-6953-43ed-ad36-0dba2b9b3e3f
location_href: 00012174-python-structlog-sentry/python-structlog-sentry-2.0.0-1.src.rpm
checksum_type: sha256
description:
  | What          | Where                                         |
  | ------------- | --------------------------------------------- |
  | Documentation | <https://github.com/kiwicom/structlog-sentry> |
  | Maintainer    | @kiwicom/platform                             |

  Based on <https://gist.github.com/hynek/a1f3f92d57071ebc5b91>



  Install the package with [pip](https://pip.pypa.io/):

  ```
  pip install structlog-sentry
  ```



  This module is intended to be used with `structlog` like this:

  ```python
  import sentry_sdk
  import structlog
  from structlog_sentry import SentryProcessor


  sentry_sdk.init()  # pass dsn in argument or via SENTRY_DSN env variable

  structlog.configure(
      processors=[
          structlog.stdlib.add_logger_name,  # optional, but before SentryProcessor()
          structlog.stdlib.add_log_level,  # required before SentryProcessor()
          SentryProcessor(event_level=logging.ERROR),
      ],
      logger_factory=...,
      wrapper_class=...,
  )


  log = structlog.get_logger()
  ```

  Do not forget to add the `structlog.stdlib.add_log_level` and optionally the
  `structlog.stdlib.add_logger_name` processors before `SentryProcessor`. The
  `SentryProcessor` class takes the following arguments:

  - `level` Events of this or higher levels will be reported as Sentry
    breadcrumbs. Dfault is `logging.INFO`.
  - `event_level` Events of this or higher levels will be reported to Sentry
    as events. Default is `logging.WARNING`.
  - `active` A flag to make this processor enabled/disabled.
  - `as_context` Send `event_dict` as extra info to Sentry. Default is `True`.
  - `tag_keys` A list of keys. If any if these keys appear in `event_dict`,
    the key and its corresponding value in `event_dict` will be used as Sentry
    event tags. use `"__all__"` to report all key/value pairs of event as tags.
  - `ignore_loggers` A list of logger names to ignore any events from.
  - `verbose` Report the action taken by the logger in the `event_dict`.
    Default is `False`.
  - `hub` Optionally specify `sentry_sdk.Hub`.

  Now events are automatically captured by Sentry with `log.error()`:

  ```python
  try:
      1/0
  except ZeroDivisionError:
      log.error("zero divsiion")

  try:
      resp = requests.get(f"https://api.example.com/users/{user_id}/")
      resp.raise_for_status()
  except RequestException:
      log.error("request error", user_id=user_id)
  ```

  This won't automatically collect `sys.exc_info()` along with the message, if you want
  to enable this behavior, just pass `exc_info=True`.

  When you want to use structlog's built-in
  [`format_exc_info`](http://www.structlog.org/en/stable/api.html#structlog.processors.format_exc_info)
  processor, make that the `SentryProcessor` comes *before* `format_exc_info`!
  Otherwise, the `SentryProcessor` won't have an `exc_info` to work with, because
  it's removed from the event by `format_exc_info`.

  Logging calls with no `sys.exc_info()` are also automatically captured by Sentry
  either as breadcrumbs (if configured by the `level` argument) or as events:

  ```python
  log.info("info message", scope="accounts")
  log.warning("warning message", scope="invoices")
  log.error("error message", scope="products")
  ```

  If you do not want to forward a specific logs into Sentry, you can pass the
  `sentry_skip=True` optional argument to logger methods, like this:

  ```python
  log.error("error message", sentry_skip=True)
  ```



  You can set some or all of key/value pairs of structlog `event_dict` as sentry `tags`:

  ```python
  structlog.configure(
      processors=[
          structlog.stdlib.add_logger_name,
          structlog.stdlib.add_log_level,
          SentryProcessor(level=logging.ERROR, tag_keys=["city", "timezone"]),
      ],...
  )

  log.error("error message", city="Tehran", timezone="UTC+3:30", movie_title="Some title")
  ```

  this will report the error and the sentry event will have **city** and **timezone** tags.
  If you want to have all event data as tags, create the `SentryProcessor` with `tag_keys="__all__"`.

  ```python
  structlog.configure(
      processors=[
          structlog.stdlib.add_logger_name,
          structlog.stdlib.add_log_level,
          SentryProcessor(level=logging.ERROR, tag_keys="__all__"),
      ],...
  )
  ```



  By default `SentryProcessor` will send `event_dict` key/value pairs as contextual info to sentry.
  Sometimes you may want to skip this, specially when sending the `event_dict` as sentry tags:

  ```python
  structlog.configure(
      processors=[
          structlog.stdlib.add_logger_name,
          structlog.stdlib.add_log_level,
          SentryProcessor(level=logging.ERROR, as_context=False, tag_keys="__all__"),
      ],...
  )
  ```



  If you want to ignore specific loggers from being processed by the `SentryProcessor` just pass
  a list of loggers when instantiating the processor:

  ```python
  structlog.configure(
      processors=[
          structlog.stdlib.add_logger_name,
          structlog.stdlib.add_log_level,
          SentryProcessor(level=logging.ERROR, ignore_loggers=["some.logger"]),
      ],...
  )
  ```



  If you want to configure `structlog` to format the output as **JSON** (maybe for
  [elk-stack](https://www.elastic.co/elk-stack)) you have to disable standard logging
  integration in Sentry SDK by passing the `LoggingIntegration(event_level=None, level=None)`
  instance to `sentry_sdk.init` method. This prevents duplication of an event reported to sentry:

  ```python
  from sentry_sdk.integrations.logging import LoggingIntegration


  INTEGRATIONS = [
      
      LoggingIntegration(event_level=None, level=None),
  ]

  sentry_sdk.init(integrations=INTEGRATIONS)
  ```

  This integration tells `sentry_sdk` to *ignore* standard logging and captures the events manually.



  To run all tests:

  ```
  tox
  ```



  Create a merge request and tag @kiwicom/platform  for review.


pkgId: 1d19b34dfd8d7ab2cce99b0eb2f3817d5447d18e15107179a00f28861f342a58
name: python-stuf
arch: src
version: 0.9.16
epoch: 0
release: 1
url: https://bitbucket.org/lcrees/stuf
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3424794c-5d3d-4dda-8f2f-8101d345a04f
location_href: 00005236-python-stuf/python-stuf-0.9.16-1.src.rpm
checksum_type: sha256
summary:
  Normal, default, ordered, chained, restricted, counter, and frozen dictionaries with attribute-style access.

description:
  A collection of Python dictionary types that support attribute-style access.
  Includes *defaultdict*,  *OrderedDict*, restricted, *ChainMap*, *Counter*, and
  frozen implementations plus miscellaneous utilities for writing Python software.


pkgId: fe57df72bd0336910189230bfb4f866d48d03655a021b519f0dda000498479a1
name: python-style
arch: src
version: 1.1.6
epoch: 0
release: 1
summary: 🌈 Terminal string styling
url: https://github.com/lmittmann/style
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d8fefbe4-a342-42fc-90de-6482964821e3
location_href: 00012489-python-style/python-style-1.1.6-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |PyPI version|
  **style** is a simple terminal string styling package. Its API is a port of the popular
  `chalk <https://github.com/chalk/chalk>`__ package for javascript.


pkgId: 5e783fef80201a090ccc27d887f6fd313f642754e0644c05adbae88860e75238
name: python-subarulink
arch: src
version: 0.7.5
epoch: 0
release: 1
summary: A package for interacting with Subaru Starlink Remote Services API.
url: https://github.com/G-Two/subarulink
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c9923cf9-5aee-46d9-bc8b-99da4e962e57
location_href: 00005237-python-subarulink/python-subarulink-0.7.5-1.src.rpm
checksum_type: sha256
description:
  A python package for interacting with [Subaru STARLINK](https://www.subaru.com/owners/starlink/safety-security.html) remote vehicle services to obtain information about a vehicle as well as actuate exposed features such as locks, horn, lights and remote start. This package requires an active subscription to Subaru's STARLINK service, which is currently only available in the United States and Canada.

  This package was developed primarily for enabling [Home Assistant](https://www.home-assistant.io/) integration, however it may also be used for standalone applications.  A basic python console application is included as an example.

  This package supports Subaru STARLINK equipped vehicles with active service plans. A [MySubaru](https://www.mysubaru.com) account must be setup prior to using this package. The features available will depend on the model year and type of service plan (Safety Plus or Safety/Security Plus).


  | Model Year   | Safety Plus | Security Plus |
  |--------------|-------------|---------------|
  | 2016-2018    |  No Support | Remote Lock/Unlock <br> Remote Horn and/or Lights <br> Remote Vehicle Locator <br> Odometer (updated every 500 miles)
  | 2019+        |  Tire Pressure# <br> Fuel Economy# <br> Fuel Range# <br> Odometer#     |Remote Lock/Unlock <br> Remote Horn and/or Lights <br> Remote Vehicle Locator <br> Remote Engine Start w/ Climate Control <br> PHEV Start Charge* <br> Door/Window Status** <br> Tire Pressure <br> Fuel Economy <br> Fuel Range <br> Odometer

  \# Unclear how often this is updated <br>
  \* Plug-In hybrid only <br>
  \*\* Support varies by model

  **NOTE:**  This project was developed based upon analysis of the official MySubaru Android app. Subaru has no official public API; therefore, this library may stop working at any time without warning.  Use at your own risk.




  There is a Home Assistant [custom component](https://github.com/G-Two/homeassistant-subaru) that uses this package and allows users to add Subaru STARLINK integration to their Home Assistant instance.

  In addition, as of 2021.3, Home Assistant Core includes the [Subaru integration](https://www.home-assistant.io/integrations/subaru/) that uses this package. Due to the required incremental additions required by Home Assistant Core, only the sensor and lock platforms are supported at this time. Additional PRs are pending to add full functionality. Users that desire the most recent features should continue using the custom component.


  To use this module's included standalone console application or include the package in an application, install from PyPI:

      $ pip install subarulink

  For API documentation, see [DEVELOPERS.md](DEVELOPERS.md)


  The PyPI installation includes a basic console application.  The application can either be run interactively or used to issue a single command.  The single command function requires a working config file to function properly (config file is automatically created during the first interactive run).  Note that not all exposed functions are supported by all vehicles. Consult your subscription details to determine which commands apply to your vehicle.

  ```
  usage: subarulink [-h] [-i] [-c CONFIG_FILE] [-v {0,1,2}]
             {status,lock,unlock,lights,horn,locate,remote_start,remote_stop,charge}
             ...

  optional arguments:
    -h, --help            show this help message and exit
    -i, --interactive     interactive mode
    -c CONFIG_FILE, --config CONFIG_FILE
                          specify config file (default is ~/.config/subarulink/subarulink.cfg
    -v {0,1,2}, --verbosity {0,1,2}
                          verbosity level: 0=error[default] 1=info 2=debug

  command:
    execute single command and exit

    {status,lock,unlock,lights,horn,locate,remote_start,remote_stop,charge}
      status              get vehicle status information
      lock                lock doors
      unlock              unlock doors
      lights              turn on lights
      horn                sound horn
      locate              locate vehicle
      remote_start        remote engine start
      remote_stop         remote engine stop
      charge              start PHEV charging
  ```
  STARLINK accounts with multiple vehicles will need to specify the VIN for single commands.  This can be done in two ways:
  - Set a default VIN while in interactive mode, which will be saved to the configuration file and used for all single commands
  - Specify a VIN from the command line with --vin.  This will override the default VIN in the configuration file
  Accounts with only one vehicle do not need to specify a VIN


  A JSON file is used for configuration. A user provided file can be passed to the CLI via the `--config`. If no config file is provided, two default locations are searched for. First is `~/.subarulink.cfg` and if that is not found, `$XDG_CONFIG_HOME/subarulink/subarulink.cfg` will be used.



  Aggressively polling the vehicle location with subarulink.Controller.update(vin) may discharge the auxiliary battery (in a PHEV).  Intermittent (every 2 hours) use isn't a problem, but polling at 5 minute intervals will drain the auxiliary battery fully after a few consecutive non-driving days.  The vehicle does report the auxiliary battery voltage with every update, so this can be avoided.

  Effects of aggressive polling on the battery of a gasoline-only vehicle are unknown.


  Sensor data is only sent by the vehicle during certain events (e.g. engine shutdown or a user requested location update) and should not be relied on to indicate a vehicle's real time status. If more recent data is desired, then the user must initiate a location update which will update the data for all sensors (exception: tire pressures will only be updated if the vehicle is in motion).


  Options exposed by the API don't necessarily represent the remote capability of the vehicle. Selecting options not supported by your vehicle will either be ignored or cause the remote command to fail.

  Known examples include:
  - Crosstreks with front heated seats cannot be activated remotely. The option is ignored by the telematics provider and/or vehicle.
  - Crosstrek PHEVs do not support `climateZoneFrontAirVolume = AUTO` or `climateZoneFrontAirMode = AUTO`. Selecting these will cause the command to fail at the telematics gateway or the vehicle.

  Best practice is to create presets in the official mobile app or website to ensure they are compatible with your vehicle. Any presets created through official means are automatically available to this package.


  The data returned by the Subaru API is sometimes invalid. The returned data is checked for erroneous values.  If they are invalid, the local cache will retain the last sane value.


  Some of the fields that would be useful are always reported back as "UNKNOWN".  Examples include door lock state, window state (on some vehicles), etc.


  - Inspired by the [teslajsonpy](https://github.com/zabuldon/teslajsonpy) package
  - Thanks to all the Subaru owners that have provided feedback and data from their vehicles


  - The most recent "g3" telematics generation appears to support more functions (e.g. tailgate unlocking and more useful sensor data). If you have a newer vehicle, please post debug logs (after sanitizing personal info) in the discussion area or open a new issue to ensure this package uses all the data that is provided by your vehicle.
  - Feature additions and code quality contributions are always welcome.


pkgId: 466db20e88ab33bc8f93b94a6051f3dbee3f687a5c2d5d06f551f1800b18d79b
name: python-subprocess32
arch: src
version: 3.5.4
epoch: 0
release: 1
summary: A backport of the subprocess module from Python 3 for use on 2.x.
url: https://github.com/google/python-subprocess32
rpm_license: PSF license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b1105979-975c-4f72-8dd5-5bddf080bfef
location_href: 00009467-python-subprocess32/python-subprocess32-3.5.4-1.src.rpm
checksum_type: sha256
description:
  This is a backport of the subprocess standard library module from
  Python 3.2 - 3.5 for use on Python 2.

  It includes bugfixes and some new features.  On POSIX systems it is
  guaranteed to be reliable when used in threaded applications.
  It includes timeout support from Python 3.3 and the run() API from 3.5
  but otherwise matches 3.2's API.

  It has not been tested by the author on Windows.

  On Python 3, it merely redirects the subprocess32 name to subprocess.


pkgId: 040e5b9045d9295bff4e6cc36d9a6d5202a992bfd549fb888962b974bd669f73
name: python-subunit
arch: src
version: 0.0.0a0
epoch: 0
release: 1
summary: Python implementation of subunit test streaming protocol
url: http://launchpad.net/subunit
rpm_license: Apache-2.0 or BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b8352c8c-a1dc-491c-8674-865778dc8e72
location_href: 00010656-python-subunit/python-subunit-0.0.0a0-1.src.rpm
checksum_type: sha256
description:
  Subunit is a streaming protocol for test results.
  There are two major revisions of the protocol. Version 1 was trivially human
  readable but had significant defects as far as highly parallel testing was
  concerned - it had no room for doing discovery and execution in parallel,
  required substantial buffering when multiplexing and was fragile - a corrupt
  byte could cause an entire stream to be misparsed. Version 1.1 added
  encapsulation of binary streams which mitigated some of the issues but the
  core remained.
  Version 2 shares many of the good characteristics of Version 1 - it can be
  embedded into a regular text stream (e.g. from a build system) and it still
  models xUnit style test execution. It also fixes many of the issues with
  Version 1 - Version 2 can be multiplexed without excessive buffering (in
  time or space), it has a well defined recovery mechanism for dealing with
  corrupted streams (e.g. where two processes write to the same stream
  concurrently, or where the stream generator suffers a bug).
  More details on both protocol version s can be found in the 'Protocol' section
  of this document.
  Subunit comes with command line filters to process a subunit stream and
  language bindings for python, C, C++ and shell. Bindings are easy to write
  for other languages.
  A number of useful things can be done easily with subunit:
   * Test aggregation: Tests run separately can be combined and then
     reported/displayed together. For instance, tests from different languages
     can be shown as a seamless whole, and tests running on multiple machines
     can be aggregated into a single stream through a multiplexer.
   * Test archiving: A test run may be recorded and replayed later.
   * Test isolation: Tests that may crash or otherwise interact badly with each
     other can be run seperately and then aggregated, rather than interfering
     with each other or requiring an adhoc test->runner reporting protocol.
   * Grid testing: subunit can act as the necessary serialisation and
     deserialiation to get test runs on distributed machines to be reported in
     real time.
  Subunit supplies the following filters:
   * tap2subunit - convert perl's TestAnythingProtocol to subunit.
   * subunit2csv - convert a subunit stream to csv.
   * subunit2disk - export a subunit stream to files on disk.
   * subunit2pyunit - convert a subunit stream to pyunit test results.
   * subunit2gtk - show a subunit stream in GTK.
   * subunit2junitxml - convert a subunit stream to JUnit's XML format.
   * subunit-diff - compare two subunit streams.
   * subunit-filter - filter out tests from a subunit stream.
   * subunit-ls - list info about tests present in a subunit stream.
   * subunit-stats - generate a summary of a subunit stream.
   * subunit-tags - add or remove tags from a stream.


pkgId: 3ca5509bcda2f6079702e8c4a2ac77b159f0304e9783ffabb831e2822eb0d5b0
name: python-subvertpy
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: Alternative Python bindings for Subversion
url: https://jelmer.uk/subvertpy
rpm_license: LGPLv2.1 or later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1a419225-11f5-4600-b688-8b7b14061b13
location_href: 00005240-python-subvertpy/python-subvertpy-0.11.0-1.src.rpm
checksum_type: sha256
description:
  subvertpy covers more of the APIs than python-svn. It provides a more
  "Pythonic" API than python-subversion, which wraps the Subversion C API pretty
  much directly. Neither provide a hookable server-side.


pkgId: 5074fcc0b739c4568e98eb7061d3047fa6eb669dbd925f1d55b93c1736f668d1
name: python-suds-py3
arch: src
version: 1.4.5.0
epoch: 0
release: 1
summary: Lightweight SOAP client
url: https://github.com/cackharot/suds-py3
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0d899ab3-c03a-431c-9ffe-639c7d6b5582
location_href: 00009977-python-suds-py3/python-suds-py3-1.4.5.0-1.src.rpm
checksum_type: sha256
description:
  The "suds-p3" is a lightweight soap-based client for python3
      licensed under LGPL. This is a mirror of http://svn.fedorahosted.org/svn/suds/trunk/
      supporting Python3 and some fixes.


pkgId: 6eb19a8b34d1a78fe4c855f620709590e4a14c92c477be9b3ed8c754f0b5715c
name: python-suntime
arch: src
version: 1.2.5
epoch: 0
release: 1
summary: Simple sunset and sunrise time calculation python library
url: https://github.com/SatAgro/suntime
rpm_license: LGPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bc2c09f8-38c0-4e4e-b93f-b98f9efda2d7
location_href: 00009636-python-suntime/python-suntime-1.2.5-1.src.rpm
checksum_type: sha256
description:
  Simple sunset and sunrise time calculation python library.



  Using pip:

      pip3 install suntime

  Or download and type:

      python3 setup.py install



  You can use the library to get UTC and local time sunrise and sunset times typing:

  ```python3
  import datetime
  from suntime import Sun, SunTimeException

  latitude = 51.21
  longitude = 21.01

  sun = Sun(latitude, longitude)


  today_sr = sun.get_sunrise_time()
  today_ss = sun.get_sunset_time()
  print('Today at Warsaw the sun raised at {} and get down at {} UTC'.
        format(today_sr.strftime('%H:%M'), today_ss.strftime('%H:%M')))


  abd = datetime.date(2014, 10, 3)
  abd_sr = sun.get_local_sunrise_time(abd)
  abd_ss = sun.get_local_sunset_time(abd)
  print('On {} the sun at Warsaw raised at {} and get down at {}.'.
        format(abd, abd_sr.strftime('%H:%M'), abd_ss.strftime('%H:%M')))


  latitude = 87.55
  longitude = 0.1
  sun = Sun(latitude, longitude)
  try:
      abd_sr = sun.get_local_sunrise_time(abd)
      abd_ss = sun.get_local_sunset_time(abd)
      print('On {} at somewhere in the north the sun raised at {} and get down at {}.'.
            format(abd, abd_sr.strftime('%H:%M'), abd_ss.strftime('%H:%M')))
  except SunTimeException as e:
      print("Error: {0}.".format(e))
  ```



  Copyright © 2019 SatAgro Sp. z o.o. and contributors:

  * Krzysztof Stopa ([kstopa](https://github.com/kstopa))
  * Andrey Kobyshev ([yokotoka](https://github.com/yokotoka))
  * Matthias ([palto42](https://github.com/plato42))
  * Hadrien Bertrand ([hbertrand](https://github.com/hbertrand))


  This file is part of SunTime library for python (SunTime).

  SunTime is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or any later version.

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

  You should have received a copy of the GNU Lesser General Public License along with CAMS tools. If not, see http://www.gnu.org/licenses/.


pkgId: 315888e1a0652415b3aa6defa1748de097aa286b51cc15d5b49d456a6f7573a8
name: python-superlance
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: superlance plugins for supervisord
url: https://github.com/Supervisor/superlance
rpm_license: BSD-derived (http://www.repoze.org/LICENSE.txt)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-810f15e5-be84-4915-858a-8196f5a8e95a
location_href: 00012841-python-superlance/python-superlance-2.0.0-1.src.rpm
checksum_type: sha256
description:
  Superlance is a package of plugin utilities for monitoring and controlling
  processes that run under `supervisor <http://supervisord.org>`_.
  Please see ``docs/index.rst`` for complete documentation.


pkgId: bed122af368bc2e8e997949cd0a59c72ade7b2f01b030b759400ffa365e4ade7
name: python-supermercado
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Supercharged mercantile
url: https://github.com/mapbox/supermercado
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a0eb7dca-3cb5-435c-be0b-3cbb2bada4e9
location_href: 00010870-python-supermercado/python-supermercado-0.2.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/mapbox/supermercado.svg?branch=master)](https://travis-ci.org/mapbox/supermercado) [![codecov.io](https://codecov.io/github/mapbox/supermercado/coverage.svg?token=qkqtUNdabO&branch=master)](https://codecov.io/github/mapbox/supermercado?branch=master)
  `supermercado` extends the functionality of [`mercantile`](https://github.com/mapbox/mercantile) with additional commands


pkgId: 33e06369f6a3428de45c7ff27efb59db6b5036e01b4ea94a8bab857841c53583
name: python-supersmoother
arch: src
version: 0.4
epoch: 0
release: 1
summary: Python implementation of Friedman's Supersmoother
url: http://github.com/jakevdp/supersmoother
rpm_license: BSD 3-clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5f2ed812-0cc9-42aa-bec8-5c60894df5eb
location_href: 00005242-python-supersmoother/python-supersmoother-0.4-1.src.rpm
checksum_type: sha256
description:
  This is an efficient implementation of Friedman's SuperSmoother based in
  Python. It makes use of numpy for fast numerical computation.
  For more information, see the github project page:
  http://github.com/jakevdp/supersmoother


pkgId: 28fb5f68fc1de1c5c46f042c954cf384060b746da1ac7419ece63093d15b537e
name: python-supervisor
arch: src
version: 4.2.5
epoch: 0
release: 1
summary: A system for controlling process state under UNIX
url: http://supervisord.org/
rpm_license: BSD-derived (http://www.repoze.org/LICENSE.txt)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7d920936-962a-4713-b2ae-5a9c6aae9b74
location_href: 00009698-python-supervisor/python-supervisor-4.2.5-1.src.rpm
checksum_type: sha256
description:
  Supervisor is a client/server system that allows its users to
  control a number of processes on UNIX-like operating systems.


pkgId: 72eb503c84fa840e0da9df9e44310cac50b35c59cd6d6ddbe2a59ecf47a965e5
name: python-sure
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: utility belt for automated testing in python for python
url: http://github.com/gabrielfalcao/sure
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-29de2d6f-e346-4557-8a03-975f06775c18
location_href: 00011119-python-sure/python-sure-2.0.1-1.src.rpm
checksum_type: sha256
description:
  An idiomatic testing library for python with powerful and flexible assertions, created by `Gabriel Falcão <https://github.com/gabrielfalcao>`_.
  Sure's developer experience is inspired and modeled after `RSpec Expectations
  <http://rspec.info/documentation/3.5/rspec-expectations/>`_ and
  `should.js <https://github.com/shouldjs/should.js>`_.


pkgId: 210e220b0dcd154072b594860c2d8f2f2d8b205053b07a2672cc9131f4a4d2b9
name: python-sushy
arch: src
version: 4.4.2
epoch: 0
release: 1
summary: Sushy is a small Python library to communicate with Redfish based systems
url: https://docs.openstack.org/sushy/latest/
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-26c66b41-eeb6-4552-aadd-cdb1f219b3c4
location_href: 00005243-python-sushy/python-sushy-4.4.2-1.src.rpm
checksum_type: sha256
description:
  Sushy is a Python library to communicate with `Redfish`_ based systems.
  The goal of the library is to be extremely simple, small, have as few
  dependencies as possible and be very conservative when dealing with BMCs
  by issuing just enough requests to it (BMCs are very flaky).
  Therefore, the scope of the library has been limited to what is supported
  by the `OpenStack Ironic <https://wiki.openstack.org/wiki/Ironic>`_
  project. As the project grows and more features from `Redfish`_ are
  needed we can expand Sushy to fulfill those requirements.
  * Free software: Apache license
  * Includes Redfish registry files licensed under
      Creative Commons Attribution 4.0 License:
      https://creativecommons.org/licenses/by/4.0/
  * Documentation: https://docs.openstack.org/sushy/latest/
  * Usage: https://docs.openstack.org/sushy/latest/reference/usage.html
  * Source: https://opendev.org/openstack/sushy
  * Bugs: https://storyboard.openstack.org/#!/project/960


pkgId: d5778ad51d7303988a70def48527389d47d95fd267830566d26408cf984a9884
name: python-svg.path
arch: src
version: 6.2
epoch: 0
release: 1
summary: SVG path objects and parser
url: https://github.com/regebro/svg.path
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-50646314-f0e1-4de7-8982-932b7c0c59da
location_href: 00005246-python-svg-path/python-svg.path-6.2-1.src.rpm
checksum_type: sha256
description:
  svg.path is a collection of objects that implement the different path
  commands in SVG, and a parser for SVG path definitions.


pkgId: 7043f3f3423c80648149088706c41d2820201342a1394a27c1aa04f14a1ec125
name: python-svgwrite
arch: src
version: 1.4.3
epoch: 0
release: 1
summary: A Python library to create SVG drawings.
url: http://github.com/mozman/svgwrite.git
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d4bc1cb6-aa1e-489f-95ce-0921d398a2ab
location_href: 00005247-python-svgwrite/python-svgwrite-1.4.3-1.src.rpm
checksum_type: sha256
description:
  This package is inactive! No new features will be added, there will
  be no change of behavior, just bugfixes will be merged.


pkgId: 002f46140582a27c7b53e8b42987e961f2e158d42b70a195b65d94ed260a24a6
name: python-sword
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: A fast, sharp, Python C extension for data mining.
url: https://github.com/jweinst1/sword
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-19712c46-530e-44d2-abae-3fc65abdeb41
location_href: 00005250-python-sword/python-sword-0.0.3-1.src.rpm
checksum_type: sha256
description:
  *A Fast Data Mining C Library for Python*



  `sword` is a Python C Extension for making data mining and data searching super fast. It's designed to
  give you amazing performance in the comfort and simplicity of Python. `sword` offers a wide array of tools
  to parse and search tabular data, csv, xml, and much more.



  `sword` is still in the active development phase. It currently supports some CSV functionality. More detailed
  and rich features will be released in coming patch releases.




  `sword` currently provides the following functions:





  This function reads a single CSV row from a string, and returns a tuple containing:

  * The list containing the row elements.
  * The remaining unread string.

  *Example:*

  ```py
  >>> import sword
  >>> sword.csv_read_row("54.7,32.6,54.7\n")
  ([b'54.7', b'32.6', b'54.7'], b'\n')
  ```



  Counts the number of rows in a CSV-string

  *Exmaple:*

  ```py
  >>> import sword
  >>> sword.csv_count_rows("1,2\n3,4\n5,5,5,5\n")
  3
  ```




  Counts the number of columns in a CSv-string

  *Example:*

  ```py
  >>> import sword
  >>> sword.csv_count_cols("1,2,3,4\n")
  4
  ```


pkgId: 821d70add8884e931e6021986a751ae70bcb0f2702ac0a602603a9e694315c08
name: python-sybil
arch: src
version: 4.0.1
epoch: 0
release: 1
summary: Automated testing for the examples in your code and documentation.
url: https://github.com/simplistix/sybil
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4a602640-b784-4982-ace5-3cfedc8c84ae
location_href: 00005251-python-sybil/python-sybil-4.0.1-1.src.rpm
checksum_type: sha256
description:
  |CircleCI|_ |Docs|_
  This library provides a way to check examples in your code and documentation by parsing
  them from their source and evaluating the parsed examples as part of
  your normal test run. Integration is provided for the main Python test
  runners.
  The `documentation <https://sybil.readthedocs.io/>`__ is the best place to start.


pkgId: 3e7cdd617fd346c7225942b4539041603cfa0fba6c23965a0d09924161210970
name: python-sympy
arch: src
version: 1.11.1
epoch: 0
release: 1
summary: Computer algebra system (CAS) in Python
url: https://sympy.org
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-749f8e79-14bd-41d4-8085-031df98822f1
location_href: 00005252-python-sympy/python-sympy-1.11.1-1.src.rpm
checksum_type: sha256
description:
  [![pypi version](https://img.shields.io/pypi/v/sympy.svg)](https://pypi.python.org/pypi/sympy)
  [![Build status](https://secure.travis-ci.org/sympy/sympy.svg?branch=master)](https://travis-ci.org/sympy/sympy)
  [![Join the chat at https://gitter.im/sympy/sympy](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/sympy/sympy?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
  [![Zenodo Badge](https://zenodo.org/badge/18918/sympy/sympy.svg)](https://zenodo.org/badge/latestdoi/18918/sympy/sympy)
  [![Downloads](https://pepy.tech/badge/sympy/month)](https://pepy.tech/project/sympy)
  [![GitHub Issues](https://img.shields.io/badge/issue_tracking-github-blue.svg)](https://github.com/sympy/sympy/issues)
  [![Git Tutorial](https://img.shields.io/badge/PR-Welcome-%23FF8300.svg?)](https://git-scm.com/book/en/v2/GitHub-Contributing-to-a-Project)
  [![Powered by NumFocus](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](https://numfocus.org)
  [![Commits since last release](https://img.shields.io/github/commits-since/sympy/sympy/latest.svg?longCache=true&style=flat-square&logo=git&logoColor=fff)](https://github.com/sympy/sympy/releases)

  [![SymPy Banner](https://github.com/sympy/sympy/raw/master/banner.svg)](https://sympy.org/)


  See the [AUTHORS](AUTHORS) file for the list of authors.

  And many more people helped on the SymPy mailing list, reported bugs,
  helped organize SymPy's participation in the Google Summer of Code, the
  Google Highly Open Participation Contest, Google Code-In, wrote and
  blogged about SymPy...

  License: New BSD License (see the [LICENSE](LICENSE) file for details) covers all
  files in the sympy repository unless stated otherwise.

  Our mailing list is at
  <https://groups.google.com/forum/?fromgroups#!forum/sympy>.

  We have a community chat at [Gitter](https://gitter.im/sympy/sympy). Feel
  free to ask us anything there. We have a very welcoming and helpful
  community.



  The recommended installation method is through Anaconda,
  <https://www.anaconda.com/download/>

  You can also get the latest version of SymPy from
  <https://pypi.python.org/pypi/sympy/>

  To get the git version do

      $ git clone https://github.com/sympy/sympy.git

  For other options (tarballs, debs, etc.), see
  <https://docs.sympy.org/dev/install.html>.



  For in-depth instructions on installation and building the
  documentation, see the [SymPy Documentation Style Guide](https://docs.sympy.org/dev/documentation-style-guide.html).

  Everything is at:

  <https://docs.sympy.org/>

  You can generate everything at the above site in your local copy of
  SymPy by:

      $ cd doc
      $ make html

  Then the docs will be in <span class="title-ref">\_build/html</span>. If
  you don't want to read that, here is a short usage:

  From this directory, start Python and:

  ``` python
  >>> from sympy import Symbol, cos
  >>> x = Symbol('x')
  >>> e = 1/cos(x)
  >>> print(e.series(x, 0, 10))
  1 + x**2/2 + 5*x**4/24 + 61*x**6/720 + 277*x**8/8064 + O(x**10)
  ```

  SymPy also comes with a console that is a simple wrapper around the
  classic python console (or IPython when available) that loads the SymPy
  namespace and executes some common commands for you.

  To start it, issue:

      $ bin/isympy

  from this directory, if SymPy is not installed or simply:

      $ isympy

  if SymPy is installed.



  SymPy has a hard dependency on the [mpmath](http://mpmath.org/) library
  (version \>= 0.19). You should install it first, please refer to the
  mpmath installation guide:

  <https://github.com/fredrik-johansson/mpmath#1-download--installation>

  To install SymPy using PyPI, run the following command:

      $ pip install sympy

  To install SymPy using Anaconda, run the following command:

      $ conda install -c anaconda sympy

  To install SymPy from GitHub source, first clone SymPy using `git`:

      $ git clone https://github.com/sympy/sympy.git

  Then, in the `sympy` repository that you cloned, simply run:

      $ python setup.py install

  See <https://docs.sympy.org/dev/install.html> for more information.



  We welcome contributions from anyone, even if you are new to open
  source. Please read our [Introduction to Contributing](https://github.com/sympy/sympy/wiki/Introduction-to-contributing)
  page and the [SymPy Documentation Style Guide](https://docs.sympy.org/dev/documentation-style-guide.html). If you
  are new and looking for some way to contribute, a good place to start is
  to look at the issues tagged [Easy to Fix](https://github.com/sympy/sympy/issues?q=is%3Aopen+is%3Aissue+label%3A%22Easy+to+Fix%22).

  Please note that all participants in this project are expected to follow
  our Code of Conduct. By participating in this project you agree to abide
  by its terms. See [CODE\_OF\_CONDUCT.md](CODE_OF_CONDUCT.md).



  To execute all tests, run:

      $./setup.py test

  in the current directory.

  For the more fine-grained running of tests or doctests, use `bin/test`
  or respectively `bin/doctest`. The master branch is automatically tested
  by Travis CI.

  To test pull requests, use
  [sympy-bot](https://github.com/sympy/sympy-bot).



  The parser and lexer were generated with the [ANTLR4](http://antlr4.org)
  toolchain in `sympy/parsing/latex/_antlr` and checked into the repo.
  Presently, most users should not need to regenerate these files, but
  if you plan to work on this feature, you will need the `antlr4`
  command-line tool (and you must ensure that it is in your `PATH`).
  One way to get it is:

      $ conda install -c conda-forge antlr=4.10.1

  Alternatively, follow the instructions on the ANTLR website and download
  the `antlr-4.10.1-complete.jar`. Then export the `CLASSPATH` as instructed
  and instead of creating `antlr4` as an alias, make it an executable file
  with the following contents:
  ``` bash

  java -jar /usr/local/lib/antlr-4.10.1-complete.jar "$@"
  ```

  After making changes to `sympy/parsing/latex/LaTeX.g4`, run:

      $ ./setup.py antlr



  To clean everything (thus getting the same tree as in the repository):

      $ ./setup.py clean

  You can also clean things with git using:

      $ git clean -Xdf

  which will clear everything ignored by `.gitignore`, and:

      $ git clean -df

  to clear all untracked files. You can revert the most recent changes in
  git with:

      $ git reset --hard

  WARNING: The above commands will all clear changes you may have made,
  and you will lose them forever. Be sure to check things with `git
  status`, `git diff`, `git clean -Xn`, and `git clean -n` before doing any
  of those.



  Our issue tracker is at <https://github.com/sympy/sympy/issues>. Please
  report any bugs that you find. Or, even better, fork the repository on
  GitHub and create a pull request. We welcome all changes, big or small,
  and we will help you make the pull request if you are new to git (just
  ask on our mailing list or Gitter Channel). If you further have any queries, you can find answers
  on Stack Overflow using the [sympy](https://stackoverflow.com/questions/tagged/sympy) tag.



  SymPy was started by Ondřej Čertík in 2005, he wrote some code during
  the summer, then he wrote some more code during summer 2006. In February
  2007, Fabian Pedregosa joined the project and helped fix many things,
  contributed documentation, and made it alive again. 5 students (Mateusz
  Paprocki, Brian Jorgensen, Jason Gedge, Robert Schwarz, and Chris Wu)
  improved SymPy incredibly during summer 2007 as part of the Google
  Summer of Code. Pearu Peterson joined the development during the summer
  2007 and he has made SymPy much more competitive by rewriting the core
  from scratch, which has made it from 10x to 100x faster. Jurjen N.E. Bos
  has contributed pretty-printing and other patches. Fredrik Johansson has
  written mpmath and contributed a lot of patches.

  SymPy has participated in every Google Summer of Code since 2007. You
  can see <https://github.com/sympy/sympy/wiki#google-summer-of-code> for
  full details. Each year has improved SymPy by bounds. Most of SymPy's
  development has come from Google Summer of Code students.

  In 2011, Ondřej Čertík stepped down as lead developer, with Aaron
  Meurer, who also started as a Google Summer of Code student, taking his
  place. Ondřej Čertík is still active in the community but is too busy
  with work and family to play a lead development role.

  Since then, a lot more people have joined the development and some
  people have also left. You can see the full list in doc/src/aboutus.rst,
  or online at:

  <https://docs.sympy.org/dev/aboutus.html#sympy-development-team>

  The git history goes back to 2007 when development moved from svn to hg.
  To see the history before that point, look at
  <https://github.com/sympy/sympy-old>.

  You can use git to see the biggest developers. The command:

      $ git shortlog -ns

  will show each developer, sorted by commits to the project. The command:

      $ git shortlog -ns --since="1 year"

  will show the top developers from the last year.



  To cite SymPy in publications use

  > Meurer A, Smith CP, Paprocki M, Čertík O, Kirpichev SB, Rocklin M,
  > Kumar A, Ivanov S, Moore JK, Singh S, Rathnayake T, Vig S, Granger BE,
  > Muller RP, Bonazzi F, Gupta H, Vats S, Johansson F, Pedregosa F, Curry
  > MJ, Terrel AR, Roučka Š, Saboo A, Fernando I, Kulal S, Cimrman R,
  > Scopatz A. (2017) SymPy: symbolic computing in Python. *PeerJ Computer
  > Science* 3:e103 <https://doi.org/10.7717/peerj-cs.103>

  A BibTeX entry for LaTeX users is

  ``` bibtex
  @article{10.7717/peerj-cs.103,
   title = {SymPy: symbolic computing in Python},
   author = {Meurer, Aaron and Smith, Christopher P. and Paprocki, Mateusz and \v{C}ert\'{i}k, Ond\v{r}ej and Kirpichev, Sergey B. and Rocklin, Matthew and Kumar, Amit and Ivanov, Sergiu and Moore, Jason K. and Singh, Sartaj and Rathnayake, Thilina and Vig, Sean and Granger, Brian E. and Muller, Richard P. and Bonazzi, Francesco and Gupta, Harsh and Vats, Shivam and Johansson, Fredrik and Pedregosa, Fabian and Curry, Matthew J. and Terrel, Andy R. and Rou\v{c}ka, \v{S}t\v{e}p\'{a}n and Saboo, Ashutosh and Fernando, Isuru and Kulal, Sumith and Cimrman, Robert and Scopatz, Anthony},
   year = 2017,
   month = Jan,
   keywords = {Python, Computer algebra system, Symbolics},
   abstract = {
              SymPy is an open-source computer algebra system written in pure Python. It is built with a focus on extensibility and ease of use, through both interactive and programmatic applications. These characteristics have led SymPy to become a popular symbolic library for the scientific Python ecosystem. This paper presents the architecture of SymPy, a description of its features, and a discussion of select submodules. The supplementary material provides additional examples and further outlines details of the architecture and features of SymPy.
           },
   volume = 3,
   pages = {e103},
   journal = {PeerJ Computer Science},
   issn = {2376-5992},
   url = {https://doi.org/10.7717/peerj-cs.103},
   doi = {10.7717/peerj-cs.103}
  }
  ```

  SymPy is BSD licensed, so you are free to use it whatever you like, be
  it academic, commercial, creating forks or derivatives, as long as you
  copy the BSD statement if you redistribute it (see the LICENSE file for
  details). That said, although not required by the SymPy license, if it
  is convenient for you, please cite SymPy when using it in your work and
  also consider contributing all your changes back, so that we can
  incorporate it and all of us will benefit in the end.


pkgId: d4cda2a518d5338daa65bae1222d88408275c2a95111d80f6dafd64161cb1083
name: python-sysv-ipc
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: System V IPC primitives (semaphores, shared memory and message queues) for Python
url: http://semanchuk.com/philip/sysv_ipc/
rpm_license: http://creativecommons.org/licenses/BSD/
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0347feae-d3d7-4a5f-878e-d5057156bc9a
location_href: 00005255-python-sysv_ipc/python-sysv-ipc-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Sysv_ipc gives Python programs access to System V semaphores, shared memory
  and message queues. Most (all?) Unixes (including OS X) support System V IPC.
  Windows+Cygwin 1.7 might also work.

  Sample code is included.

  sysv_ipc is free software (free as in speech and free as in beer) released
  under a 3-clause BSD license. Complete licensing information is available in
  the LICENSE file.

  You might also be interested in the similar POSIX IPC module at:
  http://semanchuk.com/philip/posix_ipc/


pkgId: 06285ffb8ee8d19a643178d40c09c7736031ada0896164d9dc5ebdd4f6a52182
name: python-tableauserverclient
arch: src
version: 0.25
epoch: 0
release: 1
summary: A Python module for working with the Tableau Server REST API.
url: https://pypi.org/project/tableauserverclient/
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1fa174dc-828b-42eb-ab39-9f5336a9f8b1
location_href: 00009276-python-tableauserverclient/python-tableauserverclient-0.25-1.src.rpm
checksum_type: sha256
description:
  [![Tableau Supported](https://img.shields.io/badge/Support%20Level-Tableau%20Supported-53bd92.svg)](https://www.tableau.com/support-levels-it-and-developer-tools) [![Build Status](https://github.com/tableau/server-client-python/actions/workflows/run-tests.yml/badge.svg)](https://github.com/tableau/server-client-python/actions)
  [![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Ftableau%2Fserver-client-python.svg?type=shield)](https://app.fossa.com/projects/git%2Bgithub.com%2Ftableau%2Fserver-client-python?ref=badge_shield)

  Use the Tableau Server Client (TSC) library to increase your productivity as you interact with the Tableau Server REST API. With the TSC library you can do almost everything that you can do with the REST API, including:

  * Publish workbooks and data sources.
  * Create users and groups.
  * Query projects, sites, and more.

  This repository contains Python source code for the library and sample files showing how to use it. As of May 2022, Python versions 3.7 and up are supported.

  To see sample code that works directly with the REST API (in Java, Python, or Postman), visit the [REST API Samples](https://github.com/tableau/rest-api-samples) repo.

  For more information on installing and using TSC, see the documentation:
  <https://tableau.github.io/server-client-python/docs/>




  [![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Ftableau%2Fserver-client-python.svg?type=large)](https://app.fossa.com/projects/git%2Bgithub.com%2Ftableau%2Fserver-client-python?ref=badge_large)

rpm_license:
  The MIT License (MIT)  Copyright (c) 2022 Tableau  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: 8ee2eab9880800ac947602886de8e9d6b293dc04bd0393182d8a3fa209256e75
name: python-tabledata
arch: src
version: 1.3.1
epoch: 0
release: 1
url: https://github.com/thombashi/tabledata
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8adee559-bacd-45c8-812e-6d6bb2fe0658
location_href: 00012316-python-tabledata/python-tabledata-1.3.1-1.src.rpm
checksum_type: sha256
summary:
  tabledata is a Python library to represent tabular data. Used for pytablewriter/pytablereader/SimpleSQLite/etc.

description:
  `tabledata <https://github.com/thombashi/tabledata>`__ is a Python library to represent tabular data. Used for pytablewriter/pytablereader/SimpleSQLite/etc.


pkgId: b6e593132093939ad8a599344561088c633d2c4c77e1a60d60cc722f6a18f85a
name: python-tables
arch: src
version: 3.8.0
epoch: 0
release: 1
summary: Hierarchical datasets for Python
url: https://www.pytables.org
rpm_license: BSD 3-Clause License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dc8052a2-a684-4b42-9c70-5ba4e30ae294
location_href: 00005256-python-tables/python-tables-3.8.0-1.src.rpm
checksum_type: sha256
description:
  PyTables is a package for managing hierarchical datasets and
  designed to efficiently cope with extremely large amounts of
  data. PyTables is built on top of the HDF5 library and the
  NumPy package and features an object-oriented interface
  that, combined with C-code generated from Cython sources,
  makes of it a fast, yet extremely easy to use tool for
  interactively save and retrieve large amounts of data.


pkgId: 3c8c0a3ffc84d28544a227e0c0762e1215cc21cf8db688a511ec71852ddc5350
name: python-tableschema
arch: src
version: 1.20.2
epoch: 0
release: 1
summary: A utility library for working with Table Schema in Python
url: https://github.com/frictionlessdata/tableschema-py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0633eafc-9c54-4158-bf83-022bf606326b
location_href: 00010742-python-tableschema/python-tableschema-1.20.2-1.src.rpm
checksum_type: sha256
description:
  [![Travis](https://travis-ci.org/frictionlessdata/tableschema-py.svg?branch=master)](https://travis-ci.org/frictionlessdata/tableschema-py)
  [![Coveralls](http://img.shields.io/coveralls/frictionlessdata/tableschema-py.svg?branch=master)](https://coveralls.io/r/frictionlessdata/tableschema-py?branch=master)
  [![PyPi](https://img.shields.io/pypi/v/tableschema.svg)](https://pypi.python.org/pypi/tableschema)
  [![Github](https://img.shields.io/badge/github-master-brightgreen)](https://github.com/frictionlessdata/tableschema-py)
  [![Gitter](https://img.shields.io/gitter/room/frictionlessdata/chat.svg)](https://gitter.im/frictionlessdata/chat)

  A Python implementation of the [Table Schema](http://specs.frictionlessdata.io/table-schema/) standard.

  > **[Important Notice]** We have released [Frictionless Framework](https://github.com/frictionlessdata/frictionless-py). This framework provides improved `tableschema` functionality extended to be a complete data solution. The change in not breaking for the existing software so no actions are required. Please read the [Migration Guide](https://framework.frictionlessdata.io/docs/development/migration) from `tableschema` to Frictionless Framework.
  > - we continue to bug-fix `tableschema@1.x` in this [repository](https://github.com/frictionlessdata/tableschema-py) as well as it's available on [PyPi](https://pypi.org/project/tableschema/) as it was before
  > - please note that `frictionless@3.x` version's API, we're working on at the moment, is not stable
  > - we will release `frictionless@4.x` by the end of 2020 to be the first SemVer/stable version



  - `Table` to work with data tables described by Table Schema
  - `Schema` representing Table Schema
  - `Field` representing Table Schema field
  - `validate` to validate Table Schema
  - `infer` to infer Table Schema from data
  - built-in command-line interface to validate and infer schemas
  - storage/plugins system to connect tables to different storage backends like SQL Database



  <!--TOC-->

    - [Getting Started](#getting-started)
      - [Installation](#installation)
    - [Documentation](#documentation)
      - [Introduction](#introduction)
      - [Working with Table](#working-with-table)
      - [Working with Schema](#working-with-schema)
      - [Working with Field](#working-with-field)
    - [API Reference](#api-reference)
      - [`cli`](#cli)
      - [`Table`](#table)
      - [`Schema`](#schema)
      - [`Field`](#field)
      - [`Storage`](#storage)
      - [`validate`](#validate)
      - [`infer`](#infer)
      - [`FailedCast`](#failedcast)
      - [`DataPackageException`](#datapackageexception)
      - [`TableSchemaException`](#tableschemaexception)
      - [`LoadError`](#loaderror)
      - [`ValidationError`](#validationerror)
      - [`CastError`](#casterror)
      - [`IntegrityError`](#integrityerror)
      - [`UniqueKeyError`](#uniquekeyerror)
      - [`RelationError`](#relationerror)
      - [`UnresolvedFKError`](#unresolvedfkerror)
      - [`StorageError`](#storageerror)
    - [Experimental](#experimental)
    - [Contributing](#contributing)
    - [Changelog](#changelog)

  <!--TOC-->





  The package uses semantic versioning. It means that major versions  could include breaking changes. It's highly recommended to specify `tableschema` version range in your `setup/requirements` file e.g. `tableschema>=1.0,<2.0`.

  ```bash
  $ pip install tableschema
  ```





  Let's start with a simple example:

  ```python
  from tableschema import Table


  table = Table('path.csv', schema='schema.json')


  print(table.schema.descriptor)


  for keyed_row in table.iter(keyed=True):
      print(keyed_row)
  ```



  A table is a core concept in a tabular data world. It represents data with metadata (Table Schema). Let's see how we can use it in practice.

  Consider we have some local csv file. It could be inline data or from a remote link - all supported by the `Table` class (except local files for in-brower usage of course). But say it's `data.csv` for now:

  ```csv
  city,location
  london,"51.50,-0.11"
  paris,"48.85,2.30"
  rome,N/A
  ```

  Let's create and read a table instance. We use the static `Table.load` method and the `table.read` method with the `keyed` option to get an array of keyed rows:

  ```python
  table = Table('data.csv')
  table.headers # ['city', 'location']
  table.read(keyed=True)





  ```

  As we can see, our locations are just strings. But they should be geopoints. Also, Rome's location is not available, but it's just a string `N/A` instead of `None`. First we have to infer Table Schema:

  ```python
  table.infer()
  table.schema.descriptor




  table.read(keyed=True)

  ```

  Let's fix the "not available" location. There is a `missingValues` property in Table Schema specification. As a first try we set `missingValues` to `N/A` in `table.schema.descriptor`. The schema descriptor can be changed in-place, but all changes should also be committed using `table.schema.commit()`:

  ```python
  table.schema.descriptor['missingValues'] = 'N/A'
  table.schema.commit()
  table.schema.valid # false
  table.schema.errors

  ```

  As a good citizens we've decided to check our schema descriptor's validity. And it's not valid! We should use an array for the `missingValues` property. Also, don't forget to include "empty string" as a valid missing value:

  ```python
  table.schema.descriptor['missingValues'] = ['', 'N/A']
  table.schema.commit()
  table.schema.valid # true
  ```

  All good. It looks like we're ready to read our data again:

  ```python
  table.read(keyed=True)





  ```

  Now we see that:
  - locations are arrays with numeric latitude and longitude
  - Rome's location is a native Python `None`

  And because there are no errors after reading, we can be sure that our data is valid against our schema. Let's save it:

  ```python
  table.schema.save('schema.json')
  table.save('data.csv')
  ```

  Our `data.csv` looks the same because it has been stringified back to `csv` format. But now we have `schema.json`:

  ```json
  {
      "fields": [
          {
              "name": "city",
              "type": "string",
              "format": "default"
          },
          {
              "name": "location",
              "type": "geopoint",
              "format": "default"
          }
      ],
      "missingValues": [
          "",
          "N/A"
      ]
  }

  ```

  If we decide to improve it even more we could update the schema file and then open it again. But now providing a schema path:

  ```python
  table = Table('data.csv', schema='schema.json')

  ```

  As already mentioned a given schema can be used to *validate* data (see the [Schema](#schema) section for schema specification details). In default mode invalid data rows immediately trigger an [exception](#exceptions) in the `table.iter()`/`table.write()` methods.

  Suppose this schema-invalid local file `invalid_data.csv`:
  ```csv
  key,value
  zero,0
  one,not_an_integer
  two,2
  ```

  We're going to validate the data against the following schema:
  ```python
  table = Table(
      'invalid_data.csv',
      schema={'fields': [{'name': 'key'}, {'name': 'value', 'type': 'integer'}]})
  ```

  Iterating over the data triggers an exception due to the failed cast of `'not_an_integer'` to `int`:
  ```python
  for row in table.iter():
      print(row)




  ```

  Hint: The row number count starts with 1 and also includes header lines.

  (Note: You can optionally switch off `iter()`/`read()` value casting using the cast parameter, see reference below.)

  By providing a custom exception handler (a callable) to those methods you can treat occurring exceptions at your own discretion, i.e. to "fail late" and e.g. gather a validation report on the whole data:

  ```python
  errors = []
  def exc_handler(exc, row_number=None, row_data=None, error_data=None):
      errors.append((exc, row_number, row_data, error_data))

  for row in table.iter(exc_handler=exc_handler):
      print(row)





  print(errors)





  ```

  Note that

  - Data rows are yielded even though the data is schema-invalid; this is due to our custom expression handler choosing not to raise exceptions (but rather collect them in the errors list).
  - Data field values that can't get casted properly (if `iter()`/`read()` cast parameter is set to True, which is the default) are wrapped into a `FailedCast` "value holder". This allows for distinguishing uncasted values from successfully casted values on the data consumer side. `FailedCast` instances can only get yielded when custom exception handling is in place.
  - The custom exception handler callable must support a function signature as specified in the `iter()`/`read()` sections of the `Table` class API reference.



  A model of a schema with helpful methods for working with the schema and supported data. Schema instances can be initialized with a schema source as a url to a JSON file or a JSON object. The schema is initially validated (see [validate](#validate) below). By default validation errors will be stored in `schema.errors` but in a strict mode it will be instantly raised.

  Let's create a blank schema. It's not valid because `descriptor.fields` property is required by the [Table Schema](http://specs.frictionlessdata.io/table-schema/) specification:

  ```python
  schema = Schema()
  schema.valid # false
  schema.errors

  ```

  To avoid creating a schema descriptor by hand we will use a `schema.infer` method to infer the descriptor from given data:

  ```python
  schema.infer([
    ['id', 'age', 'name'],
    ['1','39','Paul'],
    ['2','23','Jimmy'],
    ['3','36','Jane'],
    ['4','28','Judy'],
  ])
  schema.valid # true
  schema.descriptor





  ```

  Now we have an inferred schema and it's valid. We can cast data rows against our schema. We provide a string input which will be cast correspondingly:

  ```python
  schema.cast_row(['5', '66', 'Sam'])

  ```

  But if we try provide some missing value to the `age` field, the cast will fail because the only valid "missing" value is an empty string. Let's update our schema:

  ```python
  schema.cast_row(['6', 'N/A', 'Walt'])

  schema.descriptor['missingValues'] = ['', 'N/A']
  schema.commit()
  schema.cast_row(['6', 'N/A', 'Walt'])

  ```

  We can save the schema to a local file, and resume work on it at any time by loading it from that file:

  ```python
  schema.save('schema.json')
  schema = Schema('schema.json')
  ```



  ```python
  from tableschema import Field


  field = Field({'name': 'name', 'type': 'number'})


  field.cast_value('12345') # -> 12345
  ```

  Data values can be cast to native Python objects with a Field instance. Type instances can be initialized with [field descriptors](https://specs.frictionlessdata.io/table-schema/). This allows formats and constraints to be defined.

  Casting a value will check the value is of the expected type, is in the correct format, and complies with any constraints imposed by a schema. E.g. a date value (in ISO 8601 format) can be cast with a DateType instance. Values that can't be cast will raise an `InvalidCastError` exception.

  Casting a value that doesn't meet the constraints will raise a `ConstraintError` exception.




  ```python
  cli()
  ```
  Command-line interface

  ```
  Usage: tableschema [OPTIONS] COMMAND [ARGS]...

  Options:
    --help  Show this message and exit.

  Commands:
    infer     Infer a schema from data.
    info      Return info on this version of Table Schema
    validate  Validate that a supposed schema is in fact a Table Schema.
  ```



  ```python
  Table(self,
        source,
        schema=None,
        strict=False,
        post_cast=[],
        storage=None,
        **options)
  ```
  Table representation

  __Arguments__
  - __source (str/list[])__: data source one of:
      - local file (path)
      - remote file (url)
      - array of arrays representing the rows
  - __schema (any)__: data schema in all forms supported by `Schema` class
  - __strict (bool)__: strictness option to pass to `Schema` constructor
  - __post_cast (function[])__: list of post cast processors
  - __storage (None)__: storage name like `sql` or `bigquery`
  - __options (dict)__: `tabulator` or storage's options

  __Raises__
  - `TableSchemaException`: raises on any error




  Table's SHA256 hash if it's available.

  If it's already read using e.g. `table.read`, otherwise returns `None`.
  In the middle of an iteration it returns hash of already read contents

  __Returns__

  `str/None`: SHA256 hash




  Table's headers is available

  __Returns__

  `str[]`: headers




  Returns schema class instance if available

  __Returns__

  `Schema`: schema




  Table's size in BYTES if it's available

  If it's already read using e.g. `table.read`, otherwise returns `None`.
  In the middle of an iteration it returns size of already read contents

  __Returns__

  `int/None`: size in BYTES




  ```python
  table.iter(keyed=False,
             extended=False,
             cast=True,
             integrity=False,
             relations=False,
             foreign_keys_values=False,
             exc_handler=None)
  ```
  Iterates through the table data and emits rows cast based on table schema.

  __Arguments__


      keyed (bool):
          yield keyed rows in a form of `{header1: value1, header2: value2}`
          (default is false; the form of rows is `[value1, value2]`)

      extended (bool):
          yield extended rows in a for of `[rowNumber, [header1, header2], [value1, value2]]`
          (default is false; the form of rows is `[value1, value2]`)

      cast (bool):
          disable data casting if false
          (default is true)

      integrity (dict):
          dictionary in a form of `{'size': <bytes>, 'hash': '<sha256>'}`
          to check integrity of the table when it's read completely.
          Both keys are optional.

      relations (dict):
          dictionary of foreign key references in a form
          of `{resource1: [{field1: value1, field2: value2}, ...], ...}`.
          If provided, foreign key fields will checked and resolved
          to one of their references (/!\ one-to-many fk are not completely resolved).

      foreign_keys_values (dict):
          three-level dictionary of foreign key references optimized
          to speed up validation process in a form of
          `{resource1: {(fk_field1, fk_field2): {(value1, value2): {one_keyedrow}, ... }}}`.
          If not provided but relations is true, it will be created
          before the validation process by *index_foreign_keys_values* method

      exc_handler (func):
          optional custom exception handler callable.
          Can be used to defer raising errors (i.e. "fail late"), e.g.
          for data validation purposes. Must support the signature below

  __Custom exception handler__


  ```python
  def exc_handler(exc, row_number=None, row_data=None, error_data=None):
      '''Custom exception handler (example)

      
          exc(Exception):
              Deferred exception instance
          row_number(int):
              Data row number that triggers exception exc
          row_data(OrderedDict):
              Invalid data row source data
          error_data(OrderedDict):
              Data row source data field subset responsible for the error, if
              applicable (e.g. invalid primary or foreign key fields). May be
              identical to row_data.
      '''
      
  ```

  __Raises__
  - `TableSchemaException`: base class of any error
  - `CastError`: data cast error
  - `IntegrityError`: integrity checking error
  - `UniqueKeyError`: unique key constraint violation
  - `UnresolvedFKError`: unresolved foreign key reference error

  __Returns__

  `Iterator[list]`: yields rows




  ```python
  table.read(keyed=False,
             extended=False,
             cast=True,
             limit=None,
             integrity=False,
             relations=False,
             foreign_keys_values=False,
             exc_handler=None)
  ```
  Read the whole table and return as array of rows

  > It has the same API as `table.iter` except for

  __Arguments__
  - __limit (int)__: limit count of rows to read and return

  __Returns__

  `list[]`: returns rows




  ```python
  table.infer(limit=100,
              confidence=0.75,
              missing_values=[''],
              guesser_cls=None,
              resolver_cls=None)
  ```
  Infer a schema for the table.

  It will infer and set Table Schema to `table.schema` based on table data.

  __Arguments__
  - __limit (int)__: limit rows sample size
  - __confidence (float)__: how many casting errors are allowed (as a ratio, between 0 and 1)
  - __missing_values (str[])__: list of missing values (by default `['']`)
  - __guesser_cls (class)__: you can implement inferring strategies by
           providing type-guessing and type-resolving classes [experimental]
  - __resolver_cls (class)__: you can implement inferring strategies by
           providing type-guessing and type-resolving classes [experimental]

  __Returns__

  `dict`: Table Schema descriptor




  ```python
  table.save(target, storage=None, **options)
  ```
  Save data source to file locally in CSV format with `,` (comma) delimiter

  > To save schema use `table.schema.save()`

  __Arguments__
  - __target (str)__: saving target (e.g. file path)
  - __storage (None/str)__: storage name like `sql` or `bigquery`
  - __options (dict)__: `tabulator` or storage options

  __Raises__
  - `TableSchemaException`: raises an error if there is saving problem

  __Returns__

  `True/Storage`: returns true or storage instance




  ```python
  table.index_foreign_keys_values(relations)
  ```
  Creates a three-level dictionary of foreign key references

  We create them optimized to speed up validation process in a form of
  `{resource1: {(fk_field1, fk_field2): {(value1, value2): {one_keyedrow}, ... }}}`.

  For each foreign key of the schema it will iterate through the corresponding
  `relations['resource']` to create an index (i.e. a dict) of existing values
  for the foreign fields and store on keyed row for each value combination.

  The optimization relies on the indexation of possible values for one foreign key
  in a hashmap to later speed up resolution.

  This method is public to allow creating the index once to apply it
  on multiple tables charing the same schema
  (typically [grouped resources in datapackage](https://github.com/frictionlessdata/datapackage-py#group))

  __Notes__

  - the second key of the output is a tuple of the foreign fields,
      a proxy identifier of the foreign key
  - the same relation resource can be indexed multiple times
      as a schema can contain more than one Foreign Keys
      pointing to the same resource

  __Arguments__
  - __relations (dict)__:
          dict of foreign key references in a form of
          `{resource1: [{field1: value1, field2: value2}, ...], ...}`.
          It must contain all resources pointed in the foreign keys schema definition.

  __Returns__

  `dict`:
          returns a three-level dictionary of foreign key references
          optimized to speed up validation process in a form of
          `{resource1: {(fk_field1, fk_field2): {(value1, value2): {one_keyedrow}, ... }}})`



  ```python
  Schema(self, descriptor={}, strict=False)
  ```
  Schema representation

  __Arguments__
  - __descriptor (str/dict)__: schema descriptor one of:
          - local path
          - remote url
          - dictionary
  - __strict (bool)__: flag to specify validation behaviour:
          - if false, errors will not be raised but instead collected in `schema.errors`
          - if true, validation errors are raised immediately

  __Raises__
  - `TableSchemaException`: raise any error that occurs during the process




  Schema's descriptor

  __Returns__

  `dict`: descriptor




  Validation errors

  Always empty in strict mode.

  __Returns__

  `Exception[]`: validation errors




  Schema's field names

  __Returns__

  `str[]`: an array of field names




  Schema's fields

  __Returns__

  `Field[]`: an array of field instances




  Schema's foreign keys

  __Returns__

  `dict[]`: foreign keys




  Schema's field names

  __Returns__

  `str[]`: an array of field names




  Schema's missing values

  __Returns__

  `str[]`: missing values




  Schema's primary keys

  __Returns__

  `str[]`: primary keys




  Validation status

  Always true in strict mode.

  __Returns__

  `bool`: validation status




  ```python
  schema.get_field(name)
  ```
  Get schema's field by name.

  > Use `table.update_field` if you want to modify the field descriptor

  __Arguments__
  - __name (str)__: schema field name

  __Returns__

  `Field/None`: `Field` instance or `None` if not found




  ```python
  schema.get_field(name)
  ```
  Get schema's field by name.

  > Use `table.update_field` if you want to modify the field descriptor

  __Arguments__
  - __name (str)__: schema field name

  __Returns__

  `Field/None`: `Field` instance or `None` if not found




  ```python
  schema.add_field(descriptor)
  ```
  Add new field to schema.

  The schema descriptor will be validated with newly added field descriptor.

  __Arguments__
  - __descriptor (dict)__: field descriptor

  __Raises__
  - `TableSchemaException`: raises any error that occurs during the process

  __Returns__

  `Field/None`: added `Field` instance or `None` if not added




  ```python
  schema.update_field(name, update)
  ```
  Update existing descriptor field by name

  __Arguments__
  - __name (str)__: schema field name
  - __update (dict)__: update to apply to field's descriptor

  __Returns__

  `bool`: true on success and false if no field is found to be modified




  ```python
  schema.remove_field(name)
  ```
  Remove field resource by name.

  The schema descriptor will be validated after field descriptor removal.

  __Arguments__
  - __name (str)__: schema field name

  __Raises__
  - `TableSchemaException`: raises any error that occurs during the process

  __Returns__

  `Field/None`: removed `Field` instances or `None` if not found




  ```python
  schema.cast_row(row, fail_fast=False, row_number=None, exc_handler=None)
  ```
  Cast row based on field types and formats.

  __Arguments__
  - __row (any[]__: data row as an array of values

  __Returns__

  `any[]`: returns cast data row




  ```python
  schema.infer(rows,
               headers=1,
               confidence=0.75,
               guesser_cls=None,
               resolver_cls=None)
  ```
  Infer and set `schema.descriptor` based on data sample.

  __Arguments__
  - __rows (list[])__: array of arrays representing rows.
  - __headers (int/str[])__: data sample headers (one of):
        - row number containing headers (`rows` should contain headers rows)
        - array of headers (`rows` should NOT contain headers rows)
  - __confidence (float)__: how many casting errors are allowed (as a ratio, between 0 and 1)
  - __guesser_cls (class)__: you can implement inferring strategies by
           providing type-guessing and type-resolving classes [experimental]
  - __resolver_cls (class)__: you can implement inferring strategies by
           providing type-guessing and type-resolving classes [experimental]

  __Returns__

  `dict`: Table Schema descriptor




  ```python
  schema.commit(strict=None)
  ```
  Update schema instance if there are in-place changes in the descriptor.

  __Example__


  ```python
  from tableschema import Schema
  descriptor = {'fields': [{'name': 'my_field', 'title': 'My Field', 'type': 'string'}]}
  schema = Schema(descriptor)
  print(schema.get_field('my_field').descriptor['type']) # string


  schema.descriptor['fields'][0]['type'] = 'number'

  schema.update_field('my_field', {'title': 'My Pretty Field'}) # True


  print(schema.get_field('my_field').descriptor['type']) # string
  print(schema.get_field('my_field').descriptor['title']) # My Field


  schema.commit()
  print(schema.get_field('my_field').descriptor['type']) # number
  print(schema.get_field('my_field').descriptor['title']) # My Pretty Field

  ```

  __Arguments__
  - __strict (bool)__: alter `strict` mode for further work

  __Raises__
  - `TableSchemaException`: raises any error that occurs during the process

  __Returns__

  `bool`: true on success and false if not modified




  ```python
  schema.save(target, ensure_ascii=True)
  ```
  Save schema descriptor to target destination.

  __Arguments__
  - __target (str)__: path where to save a descriptor

  __Raises__
  - `TableSchemaException`: raises any error that occurs during the process

  __Returns__

  `bool`: true on success




  ```python
  Field(self, descriptor, missing_values=[''], schema=None)
  ```
  Field representaion

  __Arguments__
  - __descriptor (dict)__: schema field descriptor
  - __missingValues (str[])__: an array with string representing missing values

  __Raises__
  - `TableSchemaException`: raises any error that occurs during the process




  Field constraints

  __Returns__

  `dict`: dict of field constraints




  Fields's descriptor

  __Returns__

  `dict`: descriptor




  Field format

  __Returns__

  `str`: field format




  Field's missing values

  __Returns__

  `str[]`: missing values




  Field name

  __Returns__

  `str`: field name




  Whether field is required

  __Returns__

  `bool`: true if required




  Returns a schema instance if the field belongs to some schema

  __Returns__

  `Schema`: field's schema




  Field type

  __Returns__

  `str`: field type




  ```python
  field.cast_value(value, constraints=True)
  ```
  Cast given value according to the field type and format.

  __Arguments__
  - __value (any)__: value to cast against field
  - __constraints (boll/str[])__: gets constraints configuration
          - it could be set to true to disable constraint checks
          - it could be an Array of constraints to check e.g. ['minimum', 'maximum']

  __Raises__
  - `TableSchemaException`: raises any error that occurs during the process

  __Returns__

  `any`: returns cast value




  ```python
  field.test_value(value, constraints=True)
  ```
  Test whether value is compliant to the field.

  __Arguments__
  - __value (any)__: value to cast against field
  - __constraints (bool/str[])__: constraints configuration

  __Returns__

  `bool`: returns if value is compliant to the field



  ```python
  Storage(self, **options)
  ```
  Storage factory/interface

  __For users__


  > Use `Storage.connect` to instantiate a storage

  For instantiation of concrete storage instances,
  `tableschema.Storage` provides a unified factory method `connect`
  (which uses the plugin system under the hood):

  ```python

  from tableschema import Storage

  storage = Storage.connect('sql', **options)
  storage.create('bucket', descriptor)
  storage.write('bucket', rows)
  storage.read('bucket')
  ```

  __For integrators__


  The library includes interface declaration to implement tabular `Storage`.
  This interface allow to use different data storage systems like SQL
  with `tableschema.Table` class (load/save) as well as on the data package level:

  ![Storage](https://raw.githubusercontent.com/frictionlessdata/tableschema-py/master/data/storage.png)

  An implementor must follow `tableschema.Storage` interface
  to write his own storage backend. Concrete storage backends
  could include additional functionality specific to conrete storage system.
  See `plugins` below to know how to integrate custom storage plugin into your workflow.




  Return list of storage bucket names.

  A `bucket` is a special term which has almost the same meaning as `table`.
  You should consider `bucket` as a `table` stored in the `storage`.

  __Raises__
  - `exceptions.StorageError`: raises on any error

  __Returns__

  `str[]`: return list of bucket names




  ```python
  storage.connect(name, **options)
  ```
  Create tabular `storage` based on storage name.

  > This method is statis: `Storage.connect()`

  __Arguments__
  - __name (str)__: storage name like `sql`
  - __options (dict)__: concrete storage options

  __Raises__
  - `StorageError`: raises on any error

  __Returns__

  `Storage`: returns `Storage` instance




  ```python
  storage.create(bucket, descriptor, force=False)
  ```
  Create one/multiple buckets.

  __Arguments__
  - __bucket (str/list)__: bucket name or list of bucket names
  - __descriptor (dict/dict[])__: schema descriptor or list of descriptors
  - __force (bool)__: whether to delete and re-create already existing buckets

  __Raises__
  - `exceptions.StorageError`: raises on any error




  ```python
  storage.delete(bucket=None, ignore=False)
  ```
  Delete one/multiple/all buckets.

  __Arguments__
  - __bucket (str/list/None)__: bucket name or list of bucket names to delete.
          If `None`, all buckets will be deleted
  - __descriptor (dict/dict[])__: schema descriptor or list of descriptors
  - __ignore (bool)__: don't raise an error on non-existent bucket deletion

  __Raises__
  - `exceptions.StorageError`: raises on any error




  ```python
  storage.describe(bucket, descriptor=None)
  ```
  Get/set bucket's Table Schema descriptor

  __Arguments__
  - __bucket (str)__: bucket name
  - __descriptor (dict/None)__: schema descriptor to set

  __Raises__
  - `exceptions.StorageError`: raises on any error

  __Returns__

  `dict`: returns Table Schema descriptor




  ```python
  storage.iter(bucket)
  ```
  Return an iterator of typed values based on the schema of this bucket.

  __Arguments__
  - __bucket (str)__: bucket name

  __Raises__
  - `exceptions.StorageError`: raises on any error

  __Returns__

  `list[]`: yields data rows




  ```python
  storage.read(bucket)
  ```
  Read typed values based on the schema of this bucket.

  __Arguments__
  - __bucket (str)__: bucket name
  __Raises__
  - `exceptions.StorageError`: raises on any error
  __Returns__

  `list[]`: returns data rows




  ```python
  storage.write(bucket, rows)
  ```
  This method writes data rows into `storage`.

  It should store values of unsupported types as strings internally (like csv does).

  __Arguments__
  - __bucket (str)__: bucket name
  - __rows (list[])__: data rows to write

  __Raises__
  - `exceptions.StorageError`: raises on any error



  ```python
  validate(descriptor)
  ```
  Validate descriptor

  __Arguments__
  - __dict__: descriptor

  __Raises__
  - `ValidationError`: on validation errors

  __Returns__

  `bool`: True



  ```python
  infer(source,
        headers=1,
        limit=100,
        confidence=0.75,
        missing_values=[''],
        guesser_cls=None,
        resolver_cls=None,
        **options)
  ```
  Infer source schema.

  __Arguments__
  - __source (any)__: source as path, url or inline data
  - __headers (int/str[])__: headers rows number or headers list
  - __confidence (float)__: how many casting errors are allowed (as a ratio, between 0 and 1)
  - __missing_values (str[])__: list of missing values (by default `['']`)
  - __guesser_cls (class)__: you can implement inferring strategies by
          providing type-guessing and type-resolving classes [experimental]
  - __resolver_cls (class)__: you can implement inferring strategies by
          providing type-guessing and type-resolving classes [experimental]

  __Raises__
  - `TableSchemaException`: raises any error that occurs during the process

  __Returns__

  `dict`: returns schema descriptor



  ```python
  FailedCast(self, value)
  ```
  Wrap an original data field value that failed to be properly casted.

  FailedCast allows for further processing/yielding values but still be able
  to distinguish uncasted values on the consuming side.

  Delegates attribute access and the basic rich comparison methods to the
  underlying object. Supports default user-defined classes hashability i.e.
  is hashable based on object identity (not based on the wrapped value).

  __Arguments__
  - __value (any)__: value



  ```python
  DataPackageException(self, message, errors=[])
  ```
  Base class for all DataPackage/TableSchema exceptions.

  If there are multiple errors, they can be read from the exception object:

  ```python
  try:
      
  except DataPackageException as exception:
      if exception.multiple:
          for error in exception.errors:
              
  ```




  List of nested errors

  __Returns__

  `DataPackageException[]`: list of nested errors




  Whether it's a nested exception

  __Returns__

  `bool`: whether it's a nested exception




  ```python
  TableSchemaException(self, message, errors=[])
  ```
  Base class for all TableSchema exceptions.



  ```python
  LoadError(self, message, errors=[])
  ```
  All loading errors.



  ```python
  ValidationError(self, message, errors=[])
  ```
  All validation errors.



  ```python
  CastError(self, message, errors=[])
  ```
  All value cast errors.



  ```python
  IntegrityError(self, message, errors=[])
  ```
  All integrity errors.



  ```python
  UniqueKeyError(self, message, errors=[])
  ```
  Unique key constraint violation (CastError subclass)



  ```python
  RelationError(self, message, errors=[])
  ```
  All relations errors.



  ```python
  UnresolvedFKError(self, message, errors=[])
  ```
  Unresolved foreign key reference error (RelationError subclass).



  ```python
  StorageError(self, message, errors=[])
  ```
  All storage errors.



  > This API is experimental and can be changed/removed in the future

  There is an experimental environment variable `TABLESCHEMA_PRESERVE_MISSING_VALUES` which, if it is set, affects how data casting works.

  By default, missing values are resolved to `None` values. When this flag is set, missing values are passed through as it is. For example:

  > missing_values.py

  ```python
  from tableschema import Field

  field = Field({'type': 'number'}, missing_values=['-'])
  print(field.cast_value('3'))
  print(field.cast_value('-'))
  ```

  Running this script in different modes:

  ```bash
  $ python missing_values.py
  3
  None
  $ TABLESCHEMA_PRESERVE_MISSING_VALUES=1 python missing_values.py
  3
  -
  ```

  The flags affects all the library's APIs and software built on top of `tableschema`. For example, Data Package Pipelines:

  ```bash
  $ TABLESCHEMA_PRESERVE_MISSING_VALUES=1 dpp run ./my_pipeline
  ```



  > The project follows the [Open Knowledge International coding standards](https://github.com/okfn/coding-standards).

  Recommended way to get started is to create and activate a project virtual environment.
  To install package and development dependencies into active environment:

  ```bash
  $ make install
  ```

  To run tests with linting and coverage:

  ```bash
  $ make test
  ```



  Here described only breaking and the most important changes. The full changelog and documentation for all released versions can be found in the nicely formatted [commit history](https://github.com/frictionlessdata/tableschema-py/commits/master).



  - Added --json flag to the CLI (#287)



  - Deduplicate field names if guessing in infer



  - Publish `field.ERROR/cast_function/check_functions`



  - Added `schema.missing_values` and `field.missing_values`



  - Fixed the way we parse `geopoint`:
      - as a string it can be in 3 forms ("default", "array", "object") BUT
      - as native object it can only be a list/tuple



  - Added an experimental `TABLESCHEMA_PRESERVE_MISSING_VALUES` environment variable flag



  - Allow providing custom guesser and resolver to `table.infer` and `infer`



  - Added `missing_values` argument to the `infer` function (#269)



  - Support optional custom exception handling for table.iter/read (#259)



  - Added `preserve_missing_values` parameter to `field.cast_value`



  - Added an ability to check table's integrity while reading



  - Implemented the `table.size` and `table.hash` properties



  - Added `table.index_foreign_keys_values` and improved foreign key checks performance



  - Added `field.schema` property



  - In `strict` mode raise an exception if there are problems in field construction



  - Allow providing custom guesser and resolver to schema infer



  - Added `schema.update_field` method



  - Support datetime with no time for date casting



  - Support floats like 1.0 for integer casting



  - Added the `confidence` parameter to `infer`



  - The library has been rebased on the Frictionless Data specs v1 - https://frictionlessdata.io/specs/table-schema/


pkgId: 4fa5398e3a4db6469a2a303ef8a5a8453a30215b480c603185e36b47944e6e8d
name: python-tablib
arch: src
version: 3.3.0
epoch: 0
release: 1
summary: Format agnostic tabular data library (XLS, JSON, YAML, CSV)
url: https://tablib.readthedocs.io
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d0152907-65bd-4cd9-87c9-9544f89786b7
location_href: 00005257-python-tablib/python-tablib-3.3.0-1.src.rpm
checksum_type: sha256
description:
  [![Jazzband](https://jazzband.co/static/img/badge.svg)](https://jazzband.co/)
  [![PyPI version](https://img.shields.io/pypi/v/tablib.svg)](https://pypi.org/project/tablib/)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/tablib.svg)](https://pypi.org/project/tablib/)
  [![PyPI downloads](https://img.shields.io/pypi/dm/tablib.svg)](https://pypistats.org/packages/tablib)
  [![GitHub Actions status](https://github.com/jazzband/tablib/workflows/Test/badge.svg)](https://github.com/jazzband/tablib/actions)
  [![codecov](https://codecov.io/gh/jazzband/tablib/branch/master/graph/badge.svg)](https://codecov.io/gh/jazzband/tablib)
  [![GitHub](https://img.shields.io/github/license/jazzband/tablib.svg)](LICENSE)

      _____         ______  ___________ ______
      __  /_______ ____  /_ ___  /___(_)___  /_
      _  __/_  __ `/__  __ \__  / __  / __  __ \
      / /_  / /_/ / _  /_/ /_  /  _  /  _  /_/ /
      \__/  \__,_/  /_.___/ /_/   /_/   /_.___/


  Tablib is a format-agnostic tabular dataset library, written in Python.

  Output formats supported:

  - Excel (Sets + Books)
  - JSON (Sets + Books)
  - YAML (Sets + Books)
  - Pandas DataFrames (Sets)
  - HTML (Sets)
  - Jira (Sets)
  - TSV (Sets)
  - ODS (Sets)
  - CSV (Sets)
  - DBF (Sets)

  Note that tablib *purposefully* excludes XML support. It always will. (Note: This is a
  joke. Pull requests are welcome.)

  Tablib documentation is graciously hosted on https://tablib.readthedocs.io

  It is also available in the ``docs`` directory of the source distribution.

  Make sure to check out [Tablib on PyPI](https://pypi.org/project/tablib/)!



  Please see the [contributing guide](https://github.com/jazzband/tablib/blob/master/.github/CONTRIBUTING.md).








  - Add support for Python 3.11 (#525).
  - ODS export: integers/floats/decimals are exported as numbers (#527).





  - Support solo CR in text input imports (#518).





  - Dropped Python 3.6 support (#513).



  - Corrected order of arguments to a regex call in `safe_xlsx_sheet_title` (#510).





  - Add support for Python 3.10 (#504).
  - The csv, xls, and xlsx formats gained support for the `skip_lines` keyword
    argument for their `import_set()` method to be able to skip the nth first
    lines of a read file (#497).



  - Avoided mutable parameter defaults (#494).
  - Specify build backend for editable installs (#501).
  - Doubled sample size passed to `csv.Sniffer()` in `_csv.detect()` (#503).





  - Dropped Python 3.5 support.
  - JSON-exported data is no longer forced to ASCII characters.
  - YAML-exported data is no longer forced to ASCII characters.



  - Added Python 3.9 support.
  - Added read_only option to xlsx file reader (#482).



  - Prevented crash in rst export with only-space strings (#469).





  - The `Row.lpush/rpush` logic was reversed. `lpush` was appending while `rpush`
    and `append` were prepending. This was fixed (reversed behavior). If you
    counted on the broken behavior, please update your code (#453).



  - Fixed minimal openpyxl dependency version to 2.6.0 (#457).
  - Dates from xls files are now read as Python datetime objects (#373).
  - Allow import of "ragged" xlsx files (#465).



  - When importing an xlsx file, Tablib will now read cell values instead of formulas (#462).





  - Upcoming breaking change in Tablib 2.0.0: the `Row.lpush/rpush` logic is reversed.
    `lpush` is appending while `rpush` and `append` are prepending. The broken behavior
    will remain in Tablib 1.x and will be fixed (reversed) in Tablib 2.0.0 (#453). If you
    count on the broken behavior, please update your code when you upgrade to Tablib 2.x.



  - Tablib is now able to import CSV content where not all rows have the same
    length. Missing columns on any line receive the empty string (#226).





  - Dropped Python 2 support
  - Dependencies are now all optional. To install `tablib` as before with all
    possible supported formats, run `pip install tablib[all]`



  - Formats can now be dynamically registered through the
    `tablib.formats.registry.refister` API (#256).
  - Tablib methods expecting data input (`detect_format`, `import_set`,
    `Dataset.load`, `Databook.load`) now accepts file-like objects in addition
    to raw strings and bytestrings (#440).



  - Fixed a crash when exporting an empty string with the ReST format (#368)
  - Error cells from imported .xls files contain now the error string (#202)





  - The 0.14.x series will be the last to support Python 2



  - Dropped Python 3.4 support



  - Added Python 3.7 and 3.8 support
  - The project is now maintained by the Jazzband team, https://jazzband.co
  - Improved format autodetection and added autodetection for the odf format.
  - Added search to all documentation pages
  - Open xlsx workbooks in read-only mode (#316)
  - Unpin requirements
  - Only install backports.csv on Python 2



  - Fixed `DataBook().load` parameter ordering (first stream, then format).
  - Fixed a regression for xlsx exports where non-string values were forced to
    strings (#314)
  - Fixed xlsx format detection (which was often detected as `xls` format)



  - Added reStructuredText output capability (#336)
  - Added Jira output capability
  - Stopped calling openpyxl deprecated methods (accessing cells, removing sheets)
    (openpyxl minimal version is now 2.4.0)
  - Fixed a circular dependency issue in JSON output (#332)
  - Fixed Unicode error for the CSV export on Python 2 (#215)
  - Removed usage of optional `ujson` (#311)
  - Dropped Python 3.3 support



  - Favor `Dataset.export(<format>)` over `Dataset.<format>` syntax in docs
  - Make Panda dependency optional



  - Add initial Panda DataFrame support
  - Dropped Python 2.6 support



  - Use `yaml.safe_load` for importing yaml.



  - Use built-in `json` package if available
  - Support Python 3.5+ in classifiers



  - Fixed textual representation for Dataset with no headers
  - Handle decimal types



  - Release fix.





  - Fix export only formats.
  - Fix for xlsx output.





  - Fixed packaging error on Python 3.






  - Added LaTeX table export format (`Dataset.latex`).
  - Support for dBase (DBF) files (`Dataset.dbf`).



  - New import/export interface (`Dataset.export()`, `Dataset.load()`).
  - CSV custom delimiter support (`Dataset.export('csv', delimiter='$')`).
  - Adding ability to remove duplicates to all rows in a dataset (`Dataset.remove_duplicates()`).
  - Added a mechanism to avoid `datetime.datetime` issues when serializing data.
  - New `detect_format()` function (mostly for internal use).
  - Update the vendored unicodecsv to fix `None` handling.
  - Only freeze the headers row, not the headers columns (xls).



  - `detect()` function removed.



  - Fix XLSX import.
  - Bugfix for `Dataset.transpose().transpose()`.




  * Unicode Column Headers
  * ALL the bugfixes!



  * Bugfixes



  * Bugfixes



  * Dataset API Changes
  * `stack_rows` => `stack`, `stack_columns` => `stack_cols`
  * column operations have their own methods now (`append_col`, `insert_col`)
  * List-style `pop()`
  * Redis-style `rpush`, `lpush`, `rpop`, `lpop`, `rpush_col`, and `lpush_col`



  * OpenDocument Spreadsheet support (.ods)
  * Full Unicode TSV support




  * Full XLSX Support!
  * Pickling Bugfix
  * Compat Module




  * `seperators` renamed to `separators`
  * Full unicode CSV support




  * Python 3.1, Python 3.2 Support (same code base!)
  * Formatter callback support
  * Various bug fixes





  * Python 2.5 Support!
  * Tox Testing for 2.5, 2.6, 2.7
  * AnyJSON Integrated
  * OrderedDict support
  * Caved to community pressure (spaces)




  * Databook duplication leak fix.
  * HTML Table output.
  * Added column sorting.




  * Transpose method added to Datasets.
  * New frozen top row in Excel output.
  * Pickling support for Datasets and Rows.
  * Support for row/column stacking.




  * Minor reference shadowing bugfix.




  * Massive documentation update!
  * Tablib.org!
  * Row tagging and Dataset filtering!
  * Column insert/delete support
  * Column append API change (header required)
  * Internal Changes (Row object and use thereof)




  * New import system. All dependencies attempt to load from site-packages,
    then fallback on tenderized modules.




  * Updated XLS output: Only wrap if '\\n' in cell.




  * Ability to append new column passing a callable
    as the value that will be applied to every row.




  * Added alignment wrapping to written cells.
  * Added separator support to XLS.




  * Packaging Fix




  * New format plugin system!
  * Imports! ELEGANT Imports!
  * Tests. Lots of tests.




  * Reverting methods back to properties.
  * Windows bug compensated in documentation.




  * Renamed DataBook Databook for consistency.
  * Export properties changed to methods (XLS filename / StringIO bug).
  * Optional Dataset.xls(path='filename') support (for writing on windows).
  * Added utf-8 on the worksheet level.




  * Updated unicode export for XLS.
  * More exhaustive unit tests.




  * Added Dataset.append() support for columns.




  * Fixed Dataset.append() error on empty dataset.
  * Updated Dataset.headers property w/ validation.
  * Added Testing Fixtures.



  * Packaging hotfixes.




  * Public Release.
  * Export Support for XLS, JSON, YAML, and CSV.
  * DataBook Export for XLS, JSON, and YAML.
  * Python Dict Property Support.


pkgId: 4d5f5b0e5419dc71fee8b5a9e7af8d6be46bff649c3659f0a8f93e4cefd0a60a
name: python-tabulate
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: Pretty-print tabular data
url: https://github.com/astanin/python-tabulate
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bd3480c6-dbbc-4974-ab8b-549b4bd8cb33
location_href: 00005258-python-tabulate/python-tabulate-0.9.0-1.src.rpm
checksum_type: sha256
description:
  Pretty-print tabular data in Python, a library and a command-line
  utility.
  The main use cases of the library are:
  -   printing small tables without hassle: just one function call,
      formatting is guided by the data itself
  -   authoring tabular data for lightweight plain-text markup: multiple
      output formats suitable for further editing or transformation
  -   readable presentation of mixed textual and numeric data: smart
      column alignment, configurable number formatting, alignment by a
      decimal point


pkgId: 1efc52974c71adfe285ab7b3a0b32fa9d1517b20e0a5b4b14356eee174bf0ea1
name: python-tabulator
arch: src
version: 1.53.5
epoch: 0
release: 1
summary: Consistent interface for stream reading and writing tabular data (csv/xls/json/etc)
url: https://github.com/frictionlessdata/tabulator-py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-612ec42f-60c5-49fa-b67e-54c9ebc76609
location_href: 00010323-python-tabulator/python-tabulator-1.53.5-1.src.rpm
checksum_type: sha256
description:
  [![Travis](https://img.shields.io/travis/frictionlessdata/tabulator-py/master.svg)](https://travis-ci.org/frictionlessdata/tabulator-py)
  [![Coveralls](http://img.shields.io/coveralls/frictionlessdata/tabulator-py.svg?branch=master)](https://coveralls.io/r/frictionlessdata/tabulator-py?branch=master)
  [![PyPi](https://img.shields.io/pypi/v/tabulator.svg)](https://pypi.python.org/pypi/tabulator)
  [![Github](https://img.shields.io/badge/github-master-brightgreen)](https://github.com/frictionlessdata/tabulator-py)
  [![Gitter](https://img.shields.io/gitter/room/frictionlessdata/chat.svg)](https://gitter.im/frictionlessdata/chat)

  A library for reading and writing tabular data (csv/xls/json/etc).

  > **[Important Notice]** We have released [Frictionless Framework](https://github.com/frictionlessdata/frictionless-py). This framework is logical continuation of `tabulator` that was extended to be a complete data solution. The change in not breaking for the existing software so no actions are required. Please read the [Migration Guide](https://framework.frictionlessdata.io/docs/development/migration) from `tabulator` to Frictionless Framework.
  > - we continue to bug-fix `tabulator@1.x` in this [repository](https://github.com/frictionlessdata/tabulator-py) as well as it's available on [PyPi](https://pypi.org/project/tabulator/) as it was before
  > - please note that `frictionless@3.x` version's API, we're working on at the moment, is not stable
  > - we will release `frictionless@4.x` by the end of 2020 to be the first SemVer/stable version



  - **Supports most common tabular formats**: CSV, XLS, ODS, JSON, Google Sheets, SQL, and others. See complete list [below](#supported-file-formats).
  - **Loads local and remote data**: Supports HTTP, FTP and S3.
  - **Low memory usage**: Only the current row is kept in memory, so you can
    large datasets.
  - **Supports compressed files**: Using ZIP or GZIP algorithms.
  - **Extensible**: You can add support for custom file formats and loaders (e.g.
    FTP).



  <!--TOC-->

    - [Getting started](#getting-started)
      - [Installation](#installation)
      - [Running on CLI](#running-on-cli)
      - [Running on Python](#running-on-python)
    - [Documentation](#documentation)
      - [Working with Stream](#working-with-stream)
      - [Supported schemes](#supported-schemes)
      - [Supported file formats](#supported-file-formats)
      - [Custom file sources and formats](#custom-file-sources-and-formats)
    - [API Reference](#api-reference)
      - [`cli`](#cli)
      - [`Stream`](#stream)
      - [`Loader`](#loader)
      - [`Parser`](#parser)
      - [`Writer`](#writer)
      - [`validate`](#validate)
      - [`TabulatorException`](#tabulatorexception)
      - [`SourceError`](#sourceerror)
      - [`SchemeError`](#schemeerror)
      - [`FormatError`](#formaterror)
      - [`EncodingError`](#encodingerror)
      - [`CompressionError`](#compressionerror)
      - [`IOError`](#ioerror)
      - [`LoadingError`](#loadingerror)
      - [`HTTPError`](#httperror)
    - [Contributing](#contributing)
    - [Changelog](#changelog)

  <!--TOC-->





  ```bash
  $ pip install tabulator
  ```



  Tabulator ships with a simple CLI called `tabulator` to read tabular data. For
  example:

  ```bash
  $ tabulator https://github.com/frictionlessdata/tabulator-py/raw/4c1b3943ac98be87b551d87a777d0f7ca4904701/data/table.csv.gz
  id,name
  1,english
  2,中国人
  ```

  You can see all supported options by running `tabulator --help`.



  ```python
  from tabulator import Stream

  with Stream('data.csv', headers=1) as stream:
      stream.headers # [header1, header2, ..]
      for row in stream:
          print(row)  # [value1, value2, ..]
  ```

  You can find other examples in the [examples][examples-dir] directory.



  In the following sections, we'll walk through some usage examples of
  this library. All examples were tested with Python 3.6, but should
  run fine with Python 3.3+.



  The `Stream` class represents a tabular stream. It takes the file path as the
  `source` argument. For example:

  ```
  <scheme>://path/to/file.<format>
  ```

  It uses this path to determine the file format (e.g. CSV or XLS) and scheme
  (e.g. HTTP or postgresql). It also supports format extraction from URLs like `http://example.com?format=csv`. If necessary, you also can define these explicitly.

  Let's try it out. First, we create a `Stream` object passing the path to a CSV file.

  ```python
  import tabulator

  stream = tabulator.Stream('data.csv')
  ```

  At this point, the file haven't been read yet. Let's open the stream so we can
  read the contents.

  ```python
  try:
      stream.open()
  except tabulator.TabulatorException as e:
      pass  # Handle exception
  ```

  This will open the underlying data stream, read a small sample to detect the
  file encoding, and prepare the data to be read. We catch
  `tabulator.TabulatorException` here, in case something goes wrong.

  We can now read the file contents. To iterate over each row, we do:

  ```python
  for row in stream.iter():
      print(row)  # [value1, value2, ...]
  ```

  The `stream.iter()` method will return each row data as a list of values. If
  you prefer, you could call `stream.iter(keyed=True)` instead, which returns a
  dictionary with the column names as keys. Either way, this method keeps only a
  single row in memory at a time. This means it can handle handle large files
  without consuming too much memory.

  If you want to read the entire file, use `stream.read()`. It accepts the same
  arguments as `stream.iter()`, but returns all rows at once.

  ```python
  stream.reset()
  rows = stream.read()
  ```

  Notice that we called `stream.reset()` before reading the rows. This is because
  internally, tabulator only keeps a pointer to its current location in the file.
  If we didn't reset this pointer, we would read starting from where we stopped.
  For example, if we ran `stream.read()` again, we would get an empty list, as
  the internal file pointer is at the end of the file (because we've already read
  it all). Depending on the file location, it might be necessary to download the
  file again to rewind (e.g. when the file was loaded from the web).

  After we're done, close the stream with:

  ```python
  stream.close()
  ```

  The entire example looks like:

  ```python
  import tabulator

  stream = tabulator.Stream('data.csv')
  try:
      stream.open()
  except tabulator.TabulatorException as e:
      pass  # Handle exception

  for row in stream.iter():
      print(row)  # [value1, value2, ...]

  stream.reset()  # Rewind internal file pointer
  rows = stream.read()

  stream.close()
  ```

  It could be rewritten to use Python's context manager interface as:

  ```python
  import tabulator

  try:
      with tabulator.Stream('data.csv') as stream:
          for row in stream.iter():
              print(row)

          stream.reset()
          rows = stream.read()
  except tabulator.TabulatorException as e:
      pass
  ```

  This is the preferred way, as Python closes the stream automatically, even if some exception was thrown along the way.

  The full API documentation is available as docstrings in the [Stream source code][stream.py].



  By default, tabulator considers that all file rows are values (i.e. there is no
  header).

  ```python
  with Stream([['name', 'age'], ['Alex', 21]]) as stream:
    stream.headers # None
    stream.read() # [['name', 'age'], ['Alex', 21]]
  ```

  If you have a header row, you can use the `headers` argument with the its row
  number (starting from 1).

  ```python

  with Stream([['name', 'age'], ['Alex', 21]], headers=1) as stream:
    stream.headers # ['name', 'age']
    stream.read() # [['Alex', 21]]
  ```

  You can also pass a lists of strings to define the headers explicitly:

  ```python
  with Stream([['Alex', 21]], headers=['name', 'age']) as stream:
    stream.headers # ['name', 'age']
    stream.read() # [['Alex', 21]]
  ```

  Tabulator also supports multiline headers for the `xls` and `xlsx` formats.

  ```python
  with Stream('data.xlsx', headers=[1, 3], fill_merged_cells=True) as stream:
    stream.headers # ['header from row 1-3']
    stream.read() # [['value1', 'value2', 'value3']]
  ```



  You can specify the file encoding (e.g. `utf-8` and `latin1`) via the `encoding`
  argument.

  ```python
  with Stream(source, encoding='latin1') as stream:
    stream.read()
  ```

  If this argument isn't set, Tabulator will try to infer it from the data. If you
  get a `UnicodeDecodeError` while loading a file, try setting the encoding to
  `utf-8`.



  Tabulator supports both ZIP and GZIP compression methods. By default it'll infer from the file name:

  ```python
  with Stream('http://example.com/data.csv.zip') as stream:
    stream.read()
  ```

  You can also set it explicitly:

  ```python
  with Stream('data.csv.ext', compression='gz') as stream:
    stream.read()
  ```
  **Options**

  - **filename**: filename in zip file to process (default is first file)



  The `Stream` class raises `tabulator.exceptions.FormatError` if it detects HTML
  contents. This helps avoiding the relatively common mistake of trying to load a
  CSV file inside an HTML page, for example on GitHub.

  You can disable this behaviour using the `allow_html` option:

  ```python
  with Stream(source_with_html, allow_html=True) as stream:
    stream.read() # no exception on open
  ```



  To detect the file's headers, and run other checks like validating that the file
  doesn't contain HTML, Tabulator reads a sample of rows on the `stream.open()`
  method. This data is available via the `stream.sample` property. The number of
  rows used can be defined via the `sample_size` parameters (defaults to 100).

  ```python
  with Stream(two_rows_source, sample_size=1) as stream:
    stream.sample # only first row
    stream.read() # first and second rows
  ```

  You can disable this by setting `sample_size` to zero. This way, no data will be
  read on `stream.open()`.



  Tabulator needs to read a part of the file to infer its encoding. The
  `bytes_sample_size` arguments controls how many bytes will be read for this
  detection (defaults to 10000).

  ```python
  source = 'data/special/latin1.csv'
  with Stream(source) as stream:
      stream.encoding # 'iso8859-2'
  ```

  You can disable this by setting `bytes_sample_size` to zero, in which case it'll
  use the machine locale's default encoding.



  When `True`, tabulator will ignore columns that have blank headers (defaults to
  `False`).

  ```python

  source = 'text://header1,,header3\nvalue1,value2,value3'
  with Stream(source, format='csv', headers=1) as stream:
      stream.headers # ['header1', '', 'header3']
      stream.read(keyed=True) # {'header1': 'value1', '': 'value2', 'header3': 'value3'}


  source = 'text://header1,,header3\nvalue1,value2,value3'
  with Stream(source, format='csv', headers=1, ignore_blank_headers=True) as stream:
      stream.headers # ['header1', 'header3']
      stream.read(keyed=True) # {'header1': 'value1', 'header3': 'value3'}
  ```



  The option is similar to the `ignore_blank_headers`. It removes arbitrary columns from the data based on the corresponding column names:

  ```python

  source = 'text://header1,header2,header3\nvalue1,value2,value3'
  with Stream(source, format='csv', headers=1, ignore_listed_headers=['header2']) as stream:
      assert stream.headers == ['header1', 'header3']
      assert stream.read(keyed=True) == [
          {'header1': 'value1', 'header3': 'value3'},
      ]


  source = 'text://header1,header2,header3\nvalue1,value2,value3'
  with Stream(source, format='csv', headers=1, ignore_not_listed_headers=['header2']) as stream:
      assert stream.headers == ['header2']
      assert stream.read(keyed=True) == [
          {'header2': 'value2'},
      ]
  ```



  When `True`, all rows' values will be converted to strings (defaults to
  `False`). `None` values will be converted to empty strings.

  ```python

  with Stream([['string', 1, datetime.datetime(2017, 12, 1, 17, 00)]]) as stream:
    stream.read() # [['string', 1, datetime.dateime(2017, 12, 1, 17, 00)]]


  with Stream([['string', 1]], force_strings=True) as stream:
    stream.read() # [['string', '1', '2017-12-01 17:00:00']]
  ```



  When `True`, don't raise an exception when parsing a malformed row, but simply
  return an empty row. Otherwise, tabulator raises
  `tabulator.exceptions.SourceError` when a row can't be parsed. Defaults to `False`.

  ```python

  with Stream([[1], 'bad', [3]]) as stream:
    stream.read() # raises tabulator.exceptions.SourceError


  with Stream([[1], 'bad', [3]], force_parse=True) as stream:
    stream.read() # [[1], [], [3]]
  ```



  List of row numbers and/or strings to skip.
  If it's a string, all rows that begin with it will be skipped (e.g. '#' and '//').
  If it's the empty string, all rows that begin with an empty column will be skipped.

  ```python
  source = [['John', 1], ['Alex', 2], ['#Sam', 3], ['Mike', 4], ['John', 5]]
  with Stream(source, skip_rows=[1, 2, -1, '#']) as stream:
    stream.read() # [['Mike', 4]]
  ```

  If the `headers` parameter is also set to be an integer, it will use the first not skipped row as a headers.

  ```python
  source = [['#comment'], ['name', 'order'], ['John', 1], ['Alex', 2]]
  with Stream(source, headers=1, skip_rows=['#']) as stream:
    stream.headers # [['name', 'order']]
    stream.read() # [['Jogn', 1], ['Alex', 2]]
  ```



  List of functions that can filter or transform rows after they are parsed. These
  functions receive the `extended_rows` containing the row's number, headers
  list, and the row values list. They then process the rows, and yield or discard
  them, modified or not.

  ```python
  def skip_odd_rows(extended_rows):
      for row_number, headers, row in extended_rows:
          if not row_number % 2:
              yield (row_number, headers, row)

  def multiply_by_two(extended_rows):
      for row_number, headers, row in extended_rows:
          doubled_row = list(map(lambda value: value * 2, row))
          yield (row_number, headers, doubled_row)

  rows = [
    [1],
    [2],
    [3],
    [4],
  ]
  with Stream(rows, post_parse=[skip_odd_rows, multiply_by_two]) as stream:
    stream.read() # [[4], [8]]
  ```

  These functions are applied in order, as a simple data pipeline. In the example
  above, `multiply_by_two` just sees the rows yielded by `skip_odd_rows`.



  The methods `stream.iter()` and `stream.read()` accept the `keyed` and
  `extended` flag arguments to modify how the rows are returned.

  By default, every row is returned as a list of its cells values:

  ```python
  with Stream([['name', 'age'], ['Alex', 21]]) as stream:
    stream.read() # [['Alex', 21]]
  ```

  With `keyed=True`, the rows are returned as dictionaries, mapping the column names to their values in the row:

  ```python
  with Stream([['name', 'age'], ['Alex', 21]]) as stream:
    stream.read(keyed=True) # [{'name': 'Alex', 'age': 21}]
  ```

  And with `extended=True`, the rows are returned as a tuple of `(row_number,
  headers, row)`, there `row_number` is the current row number (starting from 1),
  `headers` is a list with the headers names, and `row` is a list with the rows
  values:

  ```python
  with Stream([['name', 'age'], ['Alex', 21]]) as stream:
    stream.read(extended=True) # (1, ['name', 'age'], ['Alex', 21])
  ```





  It loads data from AWS S3. For private files you should provide credentials supported by the `boto3` library, for example, corresponding environment variables. Read more about [configuring `boto3`](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html).

  ```python
  stream = Stream('s3://bucket/data.csv')
  ```

  **Options**

  - **s3\_endpoint\_url** - the endpoint URL to use. By default it's `https://s3.amazonaws.com`. For complex use cases, for example, `goodtables`'s runs on a data package this option can be provided as an environment variable `S3_ENDPOINT_URL`.



  The default scheme, a file in the local filesystem.

  ```python
  stream = Stream('data.csv')
  ```



  > In Python 2, `tabulator` can't stream remote data sources because of a limitation in the underlying libraries. The whole data source will be loaded to the memory. In Python 3 there is no such problem and remote files are streamed.

  ```python
  stream = Stream('https://example.com/data.csv')
  ```

  **Options**

  - **http\_session** - a `requests.Session` object. Read more in the [requests docs][requests-session].
  - **http\_stream** - Enables or disables HTTP streaming, when possible (enabled by default). Disable it if you'd like to preload the whole file into memory.
  - **http\_timeout** - This timeout will be used for a `requests` session construction.



  The source is a file-like Python object.


  ```python
  with open('data.csv') as fp:
      stream = Stream(fp)
  ```



  The source is a string containing the tabular data. Both `scheme` and `format`
  must be set explicitly, as it's not possible to infer them.

  ```python
  stream = Stream(
      'name,age\nJohn, 21\n',
      scheme='text',
      format='csv'
  )
  ```



  In this section, we'll describe the supported file formats, and their respective
  configuration options and operations. Some formats only support read operations,
  while others support both reading and writing.



  ```python
  stream = Stream('data.csv', delimiter=',')
  ```

  **Options**

  It supports all options from the Python CSV library. Check [their
  documentation][pydoc-csv] for more information.



  > Tabulator is unable to stream `xls` files, so the entire file is loaded in
  > memory. Streaming is supported for `xlsx` files.

  ```python
  stream = Stream('data.xls', sheet=1)
  ```

  **Options**

  - **sheet**: Sheet name or number (starting from 1).
  - **workbook_cache**: An empty dictionary to handle workbook caching. If provided, `tabulator` will fill the dictionary with `source: tmpfile_path` pairs for remote workbooks. Each workbook will be downloaded only once and all the temporary files will be deleted on the process exit. Defauts: None
  - **fill_merged_cells**: if `True` it will unmerge and fill all merged cells by
    a visible value. With this option enabled the parser can't stream data and
    load the whole document into memory.
  - **preserve_formatting**: if `True` it will try to preserve text formatting of numeric and temporal cells returning it as strings according to how it looks in a spreadsheet (EXPERIMETAL)
  - **adjust_floating_point_error**: if `True` it will correct the Excel behaviour regarding floating point numbers



  > This format is not included to package by default. To use it please install `tabulator` with an `ods` extras: `$ pip install tabulator[ods]`

  Source should be a valid Open Office document.

  ```python
  stream = Stream('data.ods', sheet=1)
  ```

  **Options**

  - **sheet**: Sheet name or number (starting from 1)



  A publicly-accessible Google Spreadsheet.

  ```python
  stream = Stream('https://docs.google.com/spreadsheets/d/<id>?usp=sharing')
  stream = Stream('https://docs.google.com/spreadsheets/d/<id>edit#gid=<gid>')
  ```



  Any database URL supported by [sqlalchemy][sqlalchemy].

  ```python
  stream = Stream('postgresql://name:pass@host:5432/database', table='data')
  ```

  **Options**

  - **table (required)**: Database table name
  - **order_by**: SQL expression for row ordering (e.g. `name DESC`)



  > This format is not included to package by default. You can enable it by
  > installing tabulator using `pip install tabulator[datapackage]`.

  A [Tabular Data Package][tdp].

  ```python
  stream = Stream('datapackage.json', resource=1)
  ```

  **Options**

  - **resource**: Resource name or index (starting from 0)



  Either a list of lists, or a list of dicts mapping the column names to their
  respective values.

  ```python
  stream = Stream([['name', 'age'], ['John', 21], ['Alex', 33]])
  stream = Stream([{'name': 'John', 'age': 21}, {'name': 'Alex', 'age': 33}])
  ```



  JSON document containing a list of lists, or a list of dicts mapping the column
  names to their respective values (see the `inline` format for an example).

  ```python
  stream = Stream('data.json', property='key1.key2')
  ```

  **Options**

  - **property**: JSON Path to the property containing the tabular data. For example, considering the JSON `{"response": {"data": [...]}}`, the `property` should be set to `response.data`.
  - **keyed** (write): Save as array of arrays (default) or as array of dicts (keyed).



  ```python
  stream = Stream('data.ndjson')
  ```



  ```python
  stream = Stream('data.tsv')
  ```




  > This format is not included to package by default. To use it please install `tabulator` with the `html` extra: `$ pip install tabulator[html]`

  An HTML table element residing inside an HTML document.

  Supports simple tables (no merged cells) with any legal combination of the td, th, tbody & thead elements.

  Usually `foramt='html'` would need to be specified explicitly as web URLs don't always use the `.html` extension.

  ```python
  stream = Stream('http://example.com/some/page.aspx', format='html' selector='.content .data table#id1', raw_html=True)
  ```

  **Options**

  - **selector**: CSS selector for specifying which `table` element to extract. By default it's `table`, which takes the first `table` element in the document. If empty, will assume the entire page is the table to be extracted (useful with some Excel formats).

  - **raw_html**: False (default) to extract the textual contents of each cell. True to return the inner html without modification.



  Tabulator is written with extensibility in mind, allowing you to add support for
  new tabular file formats, schemes (e.g. ssh), and writers (e.g. MongoDB). There
  are three components that allow this:

  * Loaders
    * Loads a stream from some location (e.g. ssh)
  * Parsers
    * Parses a stream of tabular data in some format (e.g. xls)
  * Writers
    * Writes tabular data to some destination (e.g. MongoDB)

  In this section, we'll see how to write custom classes to extend any of these components.



  You can add support for a new scheme (e.g. ssh) by creating a custom loader.
  Custom loaders are implemented by inheriting from the `Loader` class, and
  implementing its methods. This loader can then be used by `Stream` to load data
  by passing it via the `custom_loaders={'scheme': CustomLoader}` argument.

  The skeleton of a custom loader looks like:

  ```python
  from tabulator import Loader

  class CustomLoader(Loader):
    options = []

    def __init__(self, bytes_sample_size, **options):
        pass

    def load(self, source, mode='t', encoding=None):
        

  with Stream(source, custom_loaders={'custom': CustomLoader}) as stream:
    stream.read()
  ```

  You can see examples of how the loaders are implemented by looking in the
  `tabulator.loaders` module.



  You can add support for a new file format by creating a custom parser. Similarly
  to custom loaders, custom parsers are implemented by inheriting from the
  `Parser` class, and implementing its methods. This parser can then be used by
  `Stream` to parse data by passing it via the `custom_parsers={'format':
  CustomParser}` argument.

  The skeleton of a custom parser looks like:

  ```python
  from tabulator import Parser

  class CustomParser(Parser):
      options = []

      def __init__(self, loader, force_parse, **options):
          self.__loader = loader

      def open(self, source, encoding=None):
          

      def close(self):
          

      def reset(self):
          

      @property
      def closed(self):
          return False

      @property
      def extended_rows(self):
          

  with Stream(source, custom_parsers={'custom': CustomParser}) as stream:
    stream.read()
  ```

  You can see examples of how parsers are implemented by looking in the
  `tabulator.parsers` module.



  You can add support to write files in a specific format by creating a custom
  writer. The custom writers are implemented by inheriting from the base `Writer`
  class, and implementing its methods. This writer can then be used by `Stream` to
  write data via the `custom_writers={'format': CustomWriter}` argument.

  The skeleton of a custom writer looks like:

  ```python
  from tabulator import Writer

  class CustomWriter(Writer):
    options = []

    def __init__(self, **options):
        pass

    def write(self, source, target, headers=None, encoding=None):
        

  with Stream(source, custom_writers={'custom': CustomWriter}) as stream:
    stream.save(target)
  ```

  You can see examples of how parsers are implemented by looking in the
  `tabulator.writers` module.




  ```python
  cli(source, limit, **options)
  ```
  Command-line interface

  ```
  Usage: tabulator [OPTIONS] SOURCE

  Options:
    --headers INTEGER
    --scheme TEXT
    --format TEXT
    --encoding TEXT
    --limit INTEGER
    --sheet TEXT/INTEGER (excel)
    --fill-merged-cells BOOLEAN (excel)
    --preserve-formatting BOOLEAN (excel)
    --adjust-floating-point-error BOOLEAN (excel)
    --table TEXT (sql)
    --order_by TEXT (sql)
    --resource TEXT/INTEGER (datapackage)
    --property TEXT (json)
    --keyed BOOLEAN (json)
    --version          Show the version and exit.
    --help             Show this message and exit.
  ```



  ```python
  Stream(self,
         source,
         headers=None,
         scheme=None,
         format=None,
         encoding=None,
         compression=None,
         allow_html=False,
         sample_size=100,
         bytes_sample_size=10000,
         ignore_blank_headers=False,
         ignore_listed_headers=None,
         ignore_not_listed_headers=None,
         multiline_headers_joiner=' ',
         multiline_headers_duplicates=False,
         force_strings=False,
         force_parse=False,
         pick_rows=None,
         skip_rows=None,
         pick_fields=None,
         skip_fields=None,
         pick_columns=None,
         skip_columns=None,
         post_parse=[],
         custom_loaders={},
         custom_parsers={},
         custom_writers={},
         **options)
  ```
  Stream of tabular data.

  This is the main `tabulator` class. It loads a data source, and allows you
  to stream its parsed contents.

  __Arguments__


      source (str):
          Path to file as ``<scheme>://path/to/file.<format>``.
          If not explicitly set, the scheme (file, http, ...) and
          format (csv, xls, ...) are inferred from the source string.

      headers (Union[int, List[int], List[str]], optional):
          Either a row
          number or list of row numbers (in case of multi-line headers) to be
          considered as headers (rows start counting at 1), or the actual
          headers defined a list of strings. If not set, all rows will be
          treated as containing values.

      scheme (str, optional):
          Scheme for loading the file (file, http, ...).
          If not set, it'll be inferred from `source`.

      format (str, optional):
          File source's format (csv, xls, ...). If not
          set, it'll be inferred from `source`. inferred

      encoding (str, optional):
          Source encoding. If not set, it'll be inferred.

      compression (str, optional):
          Source file compression (zip, ...). If not set, it'll be inferred.

      pick_rows (List[Union[int, str, dict]], optional):
          The same as `skip_rows` but it's for picking rows instead of skipping.

      skip_rows (List[Union[int, str, dict]], optional):
          List of row numbers, strings and regex patterns as dicts to skip.
          If a string, it'll skip rows that their first cells begin with it e.g. '#' and '//'.
          To skip only completely blank rows use `{'type': 'preset', 'value': 'blank'}`
          To provide a regex pattern use  `{'type': 'regex', 'value': '^#'}`
          For example: `skip_rows=[1, '# comment', {'type': 'regex', 'value': '^# (regex|comment)'}]`

      pick_fields (str[]):
          When passed, ignores all columns with headers
          that the given list DOES NOT include

      skip_fields (str[]):
          When passed, ignores all columns with headers
          that the given list includes. If it contains an empty string it will skip
          empty headers

      sample_size (int, optional):
          Controls the number of sample rows used to
          infer properties from the data (headers, encoding, etc.). Set to
          ``0`` to disable sampling, in which case nothing will be inferred
          from the data. Defaults to ``config.DEFAULT_SAMPLE_SIZE``.

      bytes_sample_size (int, optional):
          Same as `sample_size`, but instead
          of number of rows, controls number of bytes. Defaults to
          ``config.DEFAULT_BYTES_SAMPLE_SIZE``.

      allow_html (bool, optional):
          Allow the file source to be an HTML page.
          If False, raises ``exceptions.FormatError`` if the loaded file is
          an HTML page. Defaults to False.

      multiline_headers_joiner (str, optional):
          When passed, it's used to join multiline headers
          as `<passed-value>.join(header1_1, header1_2)`
          Defaults to ' ' (space).

      multiline_headers_duplicates (bool, optional):
          By default tabulator will exclude a cell of a miltilne header from joining
          if it's exactly the same as the previous seen value in this field.
          Enabling this option will force duplicates inclusion
          Defaults to False.

      force_strings (bool, optional):
          When True, casts all data to strings.
          Defaults to False.

      force_parse (bool, optional):
          When True, don't raise exceptions when
          parsing malformed rows, simply returning an empty value. Defaults
          to False.

      post_parse (List[function], optional):
          List of generator functions that
          receives a list of rows and headers, processes them, and yields
          them (or not). Useful to pre-process the data. Defaults to None.

      custom_loaders (dict, optional):
          Dictionary with keys as scheme names,
          and values as their respective ``Loader`` class implementations.
          Defaults to None.

      custom_parsers (dict, optional):
          Dictionary with keys as format names,
          and values as their respective ``Parser`` class implementations.
          Defaults to None.

      custom_loaders (dict, optional):
          Dictionary with keys as writer format
          names, and values as their respective ``Writer`` class
          implementations. Defaults to None.

      **options (Any, optional): Extra options passed to the loaders and parsers.




  Returns True if the underlying stream is closed, False otherwise.

  __Returns__

  `bool`: whether closed




  Stream's compression ("no" if no compression)

  __Returns__

  `str`: compression




  Stream's encoding

  __Returns__

  `str`: encoding




  Path's format

  __Returns__

  `str`: format




  Path's fragment

  __Returns__

  `str`: fragment




  Returns the SHA256 hash of the read chunks if available

  __Returns__

  `str/None`: SHA256 hash




  Headers

  __Returns__

  `str[]/None`: headers if available




  Returns the stream's rows used as sample.

  These sample rows are used internally to infer characteristics of the
  source file (e.g. encoding, headers, ...).

  __Returns__

  `list[]`: sample




  Path's scheme

  __Returns__

  `str`: scheme




  Returns the BYTE count of the read chunks if available

  __Returns__

  `int/None`: BYTE count




  Source

  __Returns__

  `any`: stream source




  ```python
  stream.open()
  ```
  Opens the stream for reading.

  __Raises:__

      TabulatorException: if an error




  ```python
  stream.close()
  ```
  Closes the stream.



  ```python
  stream.reset()
  ```
  Resets the stream pointer to the beginning of the file.



  ```python
  stream.iter(keyed=False, extended=False)
  ```
  Iterate over the rows.

  Each row is returned in a format that depends on the arguments `keyed`
  and `extended`. By default, each row is returned as list of their
  values.

  __Arguments__
  - __keyed (bool, optional)__:
          When True, each returned row will be a
          `dict` mapping the header name to its value in the current row.
          For example, `[{'name': 'J Smith', 'value': '10'}]`. Ignored if
          ``extended`` is True. Defaults to False.
  - __extended (bool, optional)__:
          When True, returns each row as a tuple
          with row number (starts at 1), list of headers, and list of row
          values. For example, `(1, ['name', 'value'], ['J Smith', '10'])`.
          Defaults to False.

  __Raises__
  - `exceptions.TabulatorException`: If the stream is closed.

  __Returns__

  `Iterator[Union[List[Any], Dict[str, Any], Tuple[int, List[str], List[Any]]]]`:
          The row itself. The format depends on the values of `keyed` and
          `extended` arguments.




  ```python
  stream.read(keyed=False, extended=False, limit=None)
  ```
  Returns a list of rows.

  __Arguments__
  - __keyed (bool, optional)__: See :func:`Stream.iter`.
  - __extended (bool, optional)__: See :func:`Stream.iter`.
  - __limit (int, optional)__:
          Number of rows to return. If None, returns all rows. Defaults to None.

  __Returns__

  `List[Union[List[Any], Dict[str, Any], Tuple[int, List[str], List[Any]]]]`:
          The list of rows. The format depends on the values of `keyed`
          and `extended` arguments.



  ```python
  stream.save(target, format=None, encoding=None, **options)
  ```
  Save stream to the local filesystem.

  __Arguments__
  - __target (str)__: Path where to save the stream.
  - __format (str, optional)__:
          The format the stream will be saved as. If
          None, detects from the ``target`` path. Defaults to None.
  - __encoding (str, optional)__:
          Saved file encoding. Defaults to ``config.DEFAULT_ENCODING``.
  - __**options__: Extra options passed to the writer.

  __Returns__

  `count (int?)`: Written rows count if available
  Building index...
  Started generating documentation...


  ```python
  Loader(self, bytes_sample_size, **options)
  ```
  Abstract class implemented by the data loaders

  The loaders inherit and implement this class' methods to add support for a
  new scheme (e.g. ssh).

  __Arguments__
  - __bytes_sample_size (int)__: Sample size in bytes
  - __**options (dict)__: Loader options







  ```python
  loader.load(source, mode='t', encoding=None)
  ```
  Load source file.

  __Arguments__
  - __source (str)__: Path to tabular source file.
  - __mode (str, optional)__:
          Text stream mode, `t` (text) or `b` (binary).  Defaults to `t`.
  - __encoding (str, optional)__:
          Source encoding. Auto-detect by default.

  __Returns__

  `Union[TextIO, BinaryIO]`: I/O stream opened either as text or binary.



  ```python
  Parser(self, loader, force_parse, **options)
  ```
  Abstract class implemented by the data parsers.

  The parsers inherit and implement this class' methods to add support for a
  new file type.

  __Arguments__
  - __loader (tabulator.Loader)__: Loader instance to read the file.
  - __force_parse (bool)__:
          When `True`, the parser yields an empty extended
          row tuple `(row_number, None, [])` when there is an error parsing a
          row. Otherwise, it stops the iteration by raising the exception
          `tabulator.exceptions.SourceError`.
  - __**options (dict)__: Loader options




  Flag telling if the parser is closed.

  __Returns__

  `bool`: whether closed




  Encoding

  __Returns__

  `str`: encoding




  Returns extended rows iterator.

  The extended rows are tuples containing `(row_number, headers, row)`,

  __Raises__
  - `SourceError`:
          If `force_parse` is `False` and
          a row can't be parsed, this exception will be raised.
          Otherwise, an empty extended row is returned (i.e.
          `(row_number, None, [])`).

  Returns:
      Iterator[Tuple[int, List[str], List[Any]]]:
          Extended rows containing
          `(row_number, headers, row)`, where `headers` is a list of the
          header names (can be `None`), and `row` is a list of row
          values.







  ```python
  parser.open(source, encoding=None)
  ```
  Open underlying file stream in the beginning of the file.

  The parser gets a byte or text stream from the `tabulator.Loader`
  instance and start emitting items.

  __Arguments__
  - __source (str)__: Path to source table.
  - __encoding (str, optional)__: Source encoding. Auto-detect by default.

  __Returns__

      None




  ```python
  parser.close()
  ```
  Closes underlying file stream.



  ```python
  parser.reset()
  ```
  Resets underlying stream and current items list.

  After `reset()` is called, iterating over the items will start from the beginning.


  ```python
  Writer(self, **options)
  ```
  Abstract class implemented by the data writers.

  The writers inherit and implement this class' methods to add support for a
  new file destination.

  __Arguments__
  - __**options (dict)__: Writer options.







  ```python
  writer.write(source, target, headers, encoding=None)
  ```
  Writes source data to target.

  __Arguments__
  - __source (str)__: Source data.
  - __target (str)__: Write target.
  - __headers (List[str])__: List of header names.
  - __encoding (str, optional)__: Source file encoding.

  __Returns__

  `count (int?)`: Written rows count if available



  ```python
  validate(source, scheme=None, format=None)
  ```
  Check if tabulator is able to load the source.

  __Arguments__
  - __source (Union[str, IO])__: The source path or IO object.
  - __scheme (str, optional)__: The source scheme. Auto-detect by default.
  - __format (str, optional)__: The source file format. Auto-detect by default.

  __Raises__
  - `SchemeError`: The file scheme is not supported.
  - `FormatError`: The file format is not supported.

  __Returns__

  `bool`: Whether tabulator is able to load the source file.



  ```python
  TabulatorException()
  ```
  Base class for all tabulator exceptions.



  ```python
  SourceError()
  ```
  The source file could not be parsed correctly.



  ```python
  SchemeError()
  ```
  The file scheme is not supported.



  ```python
  FormatError()
  ```
  The file format is unsupported or invalid.



  ```python
  EncodingError()
  ```
  Encoding error



  ```python
  CompressionError()
  ```
  Compression error



  ```python
  IOError()
  ```
  Local loading error



  ```python
  LoadingError()
  ```
  Local loading error



  ```python
  HTTPError()
  ```
  Remote loading error



  > The project follows the [Open Knowledge International coding standards](https://github.com/okfn/coding-standards).

  Recommended way to get started is to create and activate a project virtual environment.
  To install package and development dependencies into active environment:

  ```bash
  $ make install
  ```

  To run tests with linting and coverage:

  ```bash
  $ make test
  ```

  To run tests without Internet:

  ```
  $ pytest -m 'not remote
  ```



  Here described only breaking and the most important changes. The full changelog and documentation for all released versions could be found in nicely formatted [commit history](https://github.com/frictionlessdata/tabulator-py/commits/master).



  - Add support for raw_html extraction in html parser (#341)



  - Published stream.dialect (works only for csv, for now)



  - Added experimental table discovery options



  - Ensure that headers is always a list of strings



  - Added `workbook_cache` argument for XLSX formats



  - Published `stream.hashing_algorithm` property



  - Added `hashing_algorithm` parameter



  - Fixed multiline headers merging
  - Introduced a `multiline_headers_duplicates` flag



  - HTML format: adds support for empty selector (#321)



  - Exposed `stream.compression`



  - Exposed `stream.source`



  - Exposed format option to the CLI



  - Implemented a `pick_rows` parameter (opposite to `skip_rows`)



  - Implemented `stream.save()` returning count of written rows



  - Implemented JSON writer (#311)



  - Use `chardet` for encoding detection by default. For `cchardet`: `pip install tabulator[cchardet]`. Due to a great deal of problems caused by `ccharted` for non-Linux/Conda installations we're returning back to using `chardet` by default.



  - Raise IOError/HTTPError even a not-existent file has a bad format (#304)



  - Implemented `blank` preset for `skip_rows` (#302)



  - Added `skip/pick_columns` aliases for (#293)



  - Added `multiline_headers_joiner` argument (#291)



  - Added support for regex patterns in `skip_rows` (#290)



  - Added ability to skip columns (#293)



  - Added `xlsx` writer
  - Added `html` reader



  - Added `adjust_floating_point_error` parameter to the `xlsx` parser



  - Implemented the `stream.size` and `stream.hash` properties



  - Added SQL writer



  - Added `http_timeout` argument for the `http/https` format



  - Added `stream.fragment` field showing e.g. Excel sheet's or DP resource's name



  - Added support for the `s3` file scheme (data loading from AWS S3)



  - Added support for compressed file-like objects



  - Added a setter for the `stream.headers` property



  - The `headers` parameter will now use the first not skipped row if the `skip_rows` parameter is provided and there are comments on the top of a data source (see #264)



  - Implemented experimental `preserve_formatting` for xlsx



  - Added support for specifying filename in zip source



  Updated behaviour:
  - For `ods` format the boolean, integer and datetime native types are detected now



  Updated behaviour:
  - For `xls` format the boolean, integer and datetime native types are detected now



  Updated behaviour:
  - Added support for Python 3.7



  New API added:
  - `skip_rows` support for an empty string to skip rows with an empty first column



  New API added:
  - Format will be extracted from URLs like `http://example.com?format=csv`



  Updated behaviour:
  - Now `xls` booleans will be parsed as booleans not integers



  New API added:
  - The `skip_rows` argument now supports negative numbers to skip rows starting from the end



  Updated behaviour:
  - Instead of raising an exception, a `UserWarning` warning will be emitted if an option isn't recognized.



  New API added:
  - Added `http_session` argument for the `http/https` format (it uses `requests` now)
  - Added support for multiline headers: `headers` argument accept ranges like `[1,3]`



  New API added:
  - Added support for compressed files i.e. `zip` and `gz` on Python3
  - The `Stream` constructor now accepts a `compression` argument
  - The `http/https` scheme now accepts a `http_stream` flag



  Improved behaviour:
  - The `headers` argument allows to set the order for keyed sources and cherry-pick values



  New API added:
  - Formats `XLS/XLSX/ODS` supports sheet names passed via the `sheet` argument
  - The `Stream` constructor accepts an `ignore_blank_headers` option



  Improved behaviour:
  - Rebased `datapackage` format on `datapackage@1` library



  New API added:
  - Argument `source` for the `Stream` constructor can be a `pathlib.Path`



  New API added:
  - Argument `bytes_sample_size` for the `Stream` constructor



  Improved behaviour:
  - Updated encoding name to a canonical form



  New API added:
  - `stream.scheme`
  - `stream.format`
  - `stream.encoding`

  Promoted provisional API to stable API:
  - `Loader` (custom loaders)
  - `Parser` (custom parsers)
  - `Writer` (custom writers)
  - `validate`



  Improved behaviour:
  - Autodetect common CSV delimiters



  New API added:
  - Added `fill_merged_cells` option to `xls/xlsx` formats



  New API added:
  - published `Loader/Parser/Writer` API
  - Added `Stream` argument `force_strings`
  - Added `Stream` argument `force_parse`
  - Added `Stream` argument `custom_writers`

  Deprecated API removal:
  - removed `topen` and `Table` - use `Stream` instead
  - removed `Stream` arguments `loader/parser_options` - use `**options` instead

  Provisional API changed:
  - Updated the `Loader/Parser/Writer` API - please use an updated version



  Provisional API added:
  - Unofficial support for `Stream` arguments `custom_loaders/parsers`


  [stream.py]: tabulator/stream.py
  [examples-dir]: examples "Examples"
  [requests-session]: https://docs.puthon-requests.org/en/master/user/advanced/#session-objects
  [pydoc-csv]: https://docs.python.org/3/library/csv.html#dialects-and-formatting-parameters "Python CSV options"
  [sqlalchemy]: https://www.sqlalchemy.org/
  [tdp]: https://frictionlessdata.io/specs/tabular-data-package/ "Tabular Data Package"
  [tabulator.exceptions]: tabulator/exceptions.py "Tabulator Exceptions"


pkgId: 3b838f68888e07bf6856a0b6035e06ea11f499ff2ff4fed314b07bdd14a160c5
name: python-tambo
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: A command line object dispatcher
url: UNKNOWN
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-30a11267-203f-4cf2-848f-5ad9f09e636e
location_href: 00005264-python-tambo/python-tambo-0.4.0-1.src.rpm
checksum_type: sha256
description:
  Use *any* argument parser you want for *each* sub-command. Easily manage each
  command as a self-contained application.


pkgId: 2774647c3f4fd67948e4afe89fd7a2762a8320912e7a6001f4d3e3e66e106851
name: python-tamr-unify-client
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: Python Client for the Tamr API
url: https://tamr-client.readthedocs.io/en/stable/
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-15fe709f-b2d6-48a9-809b-7c6bc5dbdbd6
location_href: 00014094-python-tamr-unify-client/python-tamr-unify-client-1.6.0-1.src.rpm
checksum_type: sha256
description:
  *Quick links:*
  **[Docs](https://tamr-client.readthedocs.io/en/stable/)** |
  **[Contributing](https://tamr-client.readthedocs.io/en/stable/contributor-guide.html)** |


pkgId: 761a9f192f4db618ea3e6e644389bee188d00859011be40205be7d07b0b2a9fe
name: python-tardis-client
arch: src
version: 1.3.3
epoch: 0
release: 1
summary: Python client for tardis.dev - historical tick-level cryptocurrency market data replay API.
url: https://github.com/tardis-dev/python-client
rpm_license: MPL-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-deb46ef0-76ac-4787-9483-0d81e2947510
location_href: 00012782-python-tardis-client/python-tardis-client-1.3.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPi](https://img.shields.io/pypi/v/tardis-client.svg)](https://pypi.org/project/tardis-client/)
  [![Python](https://img.shields.io/pypi/pyversions/tardis-client.svg)](https://pypi.org/project/tardis-client/)
  <a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>

  Python client for [tardis.dev](https://tardis.dev) - historical tick-level cryptocurrency market data replay API.
  Provides fast, high level and developer friendly wrapper for more low level [HTTP API](https://docs.tardis.dev/api#http-api) with local file based caching build in.



  Requires Python 3.7.0+ installed.

  ```sh
  pip install tardis-client
  ```



  ```python
  import asyncio
  from tardis_client import TardisClient, Channel

  async def replay():
      tardis_client = TardisClient()

      
      
      messages = tardis_client.replay(
          exchange="bitmex",
          from_date="2019-06-01",
          to_date="2019-06-02",
          filters=[Channel(name="trade", symbols=["XBTUSD","ETHUSD"]), Channel("orderBookL2", ["XBTUSD"])],
      )

      
      
      
      async for local_timestamp, message in messages:
          
          
          print(message)

  asyncio.run(replay())
  ```

  [![Try on repl.it](https://repl-badge.jajoosam.repl.co/try.png)](https://repl.it/@TardisThad/tardis-python-client-example)



  `tardis-client` package provides `TardisClient` and `Channel` classes.

  ```python
  from tardis_client import TardisClient, Channel
  ```



  Optional client constructor parameters.

  | name                   | type     | default value               | description                                                                                                                                                     |
  | ---------------------- | -------- | --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  | `api_key` (optional)   | `string` | `""`                        | optional `string` containing API key for [tardis.dev](https://tardis.dev) API. If not provided only first day of each month of data is accessible (free access) |
  | `cache_dir` (optional) | `string` | `<os.tmpdir>/.tardis-cache` | optional `string` with path to local dir that will be used as cache location. If not provided default `temp` dir for given OS will be used.                     |

  Example:

  ```python

  tardis_client = TardisClient()


  tardis_client = TardisClient(api_key="YOUR_API_KEY")


  tardis_client = TardisClient(cache_dir="./cache")
  ```

  - ### `tardis_client.clear_cache()`

    Removes local file cache dir and it's contents.

    Example:

    ```python
    tardis_client = TardisClient()

    tardis_client.clear_cache()
    ```

  - ### `tardis_client.replay(exchange, from_date, to_date, filters=[])`

    Replays historical market data messages for given replay arguments.

    Returns [Async Generator](https://rickyhan.com/jekyll/update/2018/01/27/python36.html) with named tuples (`namedtuple("Response", ["local_timestamp", "message"])`).

    - `local_timestamp` is a Python datetime object specyfying when message has been received from the exchange real-time data feed.

    - `message` is Python dict with parsed JSON that has exactly the same format as message provided by particular exchange's real-time data feed.

      

      | name                 | type                              | default value | description                                                                                                                                                                                       |
      | -------------------- | --------------------------------- | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
      | `exchange`           | `string`                          | -             | requested exchange name - Use [/exchanges](https://docs.tardis.dev/api/http#exchanges) API call to get allowed exchanges ids                                                                      |
      | `from_date`          | `string`                          | -             | requested UTC start date of data feed - [valid ISO date string](https://docs.python.org/3/library/datetime.html#datetime.date.fromisoformat), eg: `2019-04-05` or `2019-05-05T00:00:00`           |
      | `to_date`            | `string`                          | -             | requested UTC end date of data feed - [valid ISO date string](https://docs.python.org/3/library/datetime.html#datetime.date.fromisoformat), eg: `2019-04-05` or `2019-05-05T00:00:00`             |
      | `filters` (optional) | [`List[Channel]`](#channel-class) | []            | optional filters of requested data feed. Use [/exchanges/:exchange](https://docs.tardis.dev/api/http#exchanges-exchange) API call to get allowed channel names and symbols for requested exchange |

      

      `Channel` class constructor parameters.

      | name      | type           | description                                                                                                                                         |
      | --------- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
      | `name`    | `string`       | Use [/exchanges/:exchange](https://docs.tardis.dev/api#exchanges-exchange) API call to get allowed channel names and symbols for requested exchange |
      | `symbols` | `List[string]` | Use [/exchanges/:exchange](https://docs.tardis.dev/api#exchanges-exchange) API call to get allowed channel names and symbols for requested exchange |

      ```python
      Channel(name="trade", symbols=["XBTUSD","ETHUSD"])
      Channel("orderBookL2", ["XBTUSD"])
      ```





  `tardis-client` uses Python logging on `DEBUG` level for that purpose. In doubt please create issue in this repository with steps how to reproduce the issue.



  Check out [API docs](https://docs.tardis.dev/api).



  MPL-2.0


pkgId: 2ce652279eb405e85de0ca6e5c65e9eeada3aa583a7bef5f3e10df88909fd0d6
name: python-tardis-dev
arch: src
version: 2.0.0a13
epoch: 0
release: 1
summary: Python client for tardis.dev - historical tick-level cryptocurrency market data replay API.
url: https://github.com/tardis-dev/tardis-python
rpm_license: MPL-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6c6ee3a5-7bec-4b34-8bd4-83c1e6abbed3
location_href: 00013817-python-tardis-dev/python-tardis-dev-2.0.0a13-1.src.rpm
checksum_type: sha256
description:
  [![PyPi](https://img.shields.io/pypi/v/tardis-client.svg)](https://pypi.org/project/tardis-client/)
  [![Python](https://img.shields.io/pypi/pyversions/tardis-client.svg)](https://pypi.org/project/tardis-client/)
  <a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>

  Python client for [tardis.dev](https://tardis.dev) - historical tick-level cryptocurrency market data replay API.
  Provides fast, high level and developer friendly wrapper for more low level [HTTP API](https://docs.tardis.dev/api#http-api) with local file based caching build in.



  Requires Python 3.7.0+ installed.

  ```sh
  pip install tardis-client
  ```



  ```python
  import asyncio
  from tardis_client import TardisClient, Channel

  async def replay():
      tardis_client = TardisClient()

      
      
      messages = tardis_client.replay(
          exchange="bitmex",
          from_date="2019-06-01",
          to_date="2019-06-02",
          filters=[Channel(name="trade", symbols=["XBTUSD","ETHUSD"]), Channel("orderBookL2", ["XBTUSD"])],
      )

      
      
      
      async for local_timestamp, message in messages:
          
          
          print(message)

  asyncio.run(replay())
  ```
  [![Try on repl.it](https://repl-badge.jajoosam.repl.co/try.png)](https://repl.it/@TardisThad/tardis-python-client-example)



  `tardis-client` package provides `TardisClient` and `Channel` classes.

  ```python
  from tardis_client import TardisClient, Channel
  ```



  Optional client constructor parameters.

  | name                   | type     | default value               | description                                                                                                                                                     |
  | ---------------------- | -------- | --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  | `api_key` (optional)   | `string` | `""`                        | optional `string` containing API key for [tardis.dev](https://tardis.dev) API. If not provided only first day of each month of data is accessible (free access) |
  | `cache_dir` (optional) | `string` | `<os.tmpdir>/.tardis-cache` | optional `string` with path to local dir that will be used as cache location. If not provided default `temp` dir for given OS will be used.                     |

  Example:

  ```python

  tardis_client = TardisClient()


  tardis_client = TardisClient(api_key="YOUR_API_KEY")


  tardis_client = TardisClient(cache_dir="./cache")
  ```

  - ### `tardis_client.clear_cache()`

    Removes local file cache dir and it's contents.

    Example:

    ```python
    tardis_client = TardisClient()

    tardis_client.clear_cache()
    ```

  - ### `tardis_client.replay(exchange, from_date, to_date, filters=[])`

    Replays historical market data messages for given replay arguments.

    Returns [Async Generator](https://rickyhan.com/jekyll/update/2018/01/27/python36.html) with named tuples (`namedtuple("Response", ["local_timestamp", "message"])`).

    - `local_timestamp` is a Python datetime object specyfying when message has been received from the exchange real-time data feed.

    - `message` is Python dict with parsed JSON that has exactly the same format as message provided by particular exchange's real-time data feed.

      

      | name                 | type                              | default value | description                                                                                                                                                                                  |
      | -------------------- | --------------------------------- | ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
      | `exchange`           | `string`                          | -             | requested exchange name - see [allowed exchanges](https://github.com/tardis-dev/python-client/blob/master/tardis_client/consts.py#L1) list                                                   |
      | `from_date`          | `string`                          | -             | requested UTC start date of data feed - [valid ISO date string](https://docs.python.org/3/library/datetime.html#datetime.date.fromisoformat), eg: `2019-04-05` or `2019-05-05T00:00:00`      |
      | `to_date`            | `string`                          | -             | requested UTC end date of data feed - [valid ISO date string](https://docs.python.org/3/library/datetime.html#datetime.date.fromisoformat), eg: `2019-04-05` or `2019-05-05T00:00:00`        |
      | `filters` (optional) | [`List[Channel]`](#channel-class) | []            | optional filters of requested data feed. Use [/exchanges/:exchange](https://docs.tardis.dev/api#exchanges-exchange) API call to get allowed channel names and symbols for requested exchange |

      

      `Channel` class constructor parameters.

      | name      | type           | description                                                                                                                                         |
      | --------- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
      | `name`    | `string`       | Use [/exchanges/:exchange](https://docs.tardis.dev/api#exchanges-exchange) API call to get allowed channel names and symbols for requested exchange |
      | `symbols` | `List[string]` | Use [/exchanges/:exchange](https://docs.tardis.dev/api#exchanges-exchange) API call to get allowed channel names and symbols for requested exchange |

      ```python
      Channel(name="trade", symbols=["XBTUSD","ETHUSD"])
      Channel("orderBookL2", ["XBTUSD"])
      ```





  `tardis-client` uses Python logging on `DEBUG` level for that purpose. In doubt please create issue in this repository with steps how to reproduce the issue.



  Check out [API docs](https://docs.tardis.dev/api).



  MPL-2.0


pkgId: abcd30449bf097b14a264a634ce84e42cfcf56edd7b85829dfcf63a00b44063d
name: python-taskipy
arch: src
version: 1.10.4
epoch: 0
release: 1
summary: tasks runner for python projects
url: https://github.com/taskipy/taskipy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-77951f75-89ff-41c2-ba77-31e96ba2bbfc
location_href: 00012419-python-taskipy/python-taskipy-1.10.4-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://github.com/illBeRoy/taskipy/raw/master/logo.svg" width="150" />
  </p>

  - [General](#general)
  - [Requirements](#requirements)
  - [Usage](#usage)
    - [Installation](#installation)
    - [Adding Tasks](#adding-tasks)
    - [Running Tasks](#running-tasks)
    - [Passing Command Line Args to Tasks](#passing-command-line-args-to-tasks)
    - [Composing Tasks](#composing-tasks)
      - [Grouping Subtasks Together](#grouping-subtasks-together)
      - [Pre Task Hook](#pre-task-hook)
      - [Post Task Hook](#post-task-hook)
    - [Using Variables](#using-variables)
      - [String Formatting](#string-formatting)
      - [Always Use Variables](#always-use-variables)
      - [Recursive Variables](#recursive-variables)
    - [Using Taskipy Without Poetry](#using-taskipy-without-poetry)
      - [Installing With PIP](#installing-with-pip)
      - [Running Tasks](#running-tasks-1)
    - [Advanced Use Cases](#advanced-use-cases)
  - [Maintainers :construction:](#maintainers-construction)
  - [Contributors :sparkles:](#contributors-sparkles)



  [![pypi](https://img.shields.io/pypi/v/taskipy?style=flat-square)](https://pypi.org/project/taskipy/)
  [![pypi-downloads](https://img.shields.io/pypi/dm/taskipy?style=flat-square)](https://pypi.org/project/taskipy/)
  [![ci](https://img.shields.io/github/workflow/status/illberoy/taskipy/Taskipy%20Test%20CI?style=flat-square)](https://github.com/illBeRoy/taskipy/actions?query=workflow%3A%22Taskipy+Test+CI%22)
  [![All Contributors](https://img.shields.io/github/all-contributors/illberoy/taskipy?color=orange&style=flat-square)](#contributors-)

  **The complementary task runner for python.**

  Every development pipeline has tasks, such as `test`, `lint` or `publish`. With taskipy, you can define those tasks in one file and run them with a simple command.

  For instance, instead of running the following command:

  ```bash
  python -m unittest tests/test_*.py
  ```

  You can create a task called `test` and simply run:

  ```bash
  poetry run task test
  ```

  Or (if you're not using poetry):

  ```bash
  task test
  ```

  In addition, you can compose tasks and group them together, and also create dependencies between them.

  This project is heavily inspired by npm's [run script command](https://docs.npmjs.com/cli/run-script).



  Python 3.6 or newer.

  Your project directory should include a valid `pyproject.toml` file, as specified in [PEP-518](https://www.python.org/dev/peps/pep-0518/).





  To install taskipy as a dev dependency, simply run:

  ```bash
  poetry add --dev taskipy
  ```



  In your `pyproject.toml` file, add a new section called `[tool.taskipy.tasks]`.

  The section is a key-value map, from the names of the task to the actual command that should be run in the shell.

  There are two ways to define tasks. The easy way is to simply write the command down as a string:

  __pyproject.toml__

  ```toml
  [tool.taskipy.tasks]
  test = "python -m unittest tests/test_*.py"
  lint = "pylint tests taskipy"
  ```

  Alternatively, you can define tasks more explicitly by declaring both the command and a helpful description using an inline table:

  __pyproject.toml__

  ```toml
  [tool.taskipy.tasks]
  test = { cmd = "python -m unittest tests/test_*.py", help = "runs all unit tests" }
  lint = { cmd = "pylint tests taskipy", help = "confirms code style using pylint" }
  ```

  The explicit notation is more verbose, but provides better context to anyone who uses the task.



  In order to run a task, run the following command in your terminal:

  ```bash
  $ poetry run task test
  ```

  You can also list all existing tasks by running the following:

  ```bash
  $ poetry run task --list
  test                python -m unittest tests/test_*.py
  lint                pylint tests taskipy
  ```

  If you declared your task explicitly, you will see the description of the task by the side of the task's name:

  ```bash
  $ poetry run task --list
  test                runs all unit tests
  lint                confirms code style using pylint
  ```



  If you want to pass command line arguments to tasks (positional or named), simply append them to the end of the task command.

  For example, running the above task like this:

  ```bash
  poetry run task test -h
  ```

  Is equivalent to running:

  ```bash
  python -m unittest tests/test_*.py -h
  ```

  And will show unittest's help instead of actually running it.

  > ⚠️ Note: if you are using pre \ post hooks, do notice that arguments are not passed to them, only to the task itself.





  Some tasks are composed of multiple subtasks. Instead of writing plain shell commands and stringing them together, you can break them down into multiple subtasks:

  ```toml
  [tool.taskipy.tasks]
  lint_pylint = "pylint tests taskipy"
  lint_mypy = "mypy tests taskipy"
  ```

  And then create a composite task:

  ```toml
  [tool.taskipy.tasks]
  lint = "task lint_pylint && task lint_mypy"
  lint_pylint = "pylint tests taskipy"
  lint_mypy = "mypy tests taskipy"
  ```



  Tasks might also depend on one another. For example, tests might require some binaries to be built. Take the two following commands, for instance:

  ```toml
  [tool.taskipy.tasks]
  test = "python -m unittest tests/test_*.py"
  build = "make ."
  ```

  You could make tests depend on building, by using the **pretask hook**:

  ```toml
  [tool.taskipy.tasks]
  pre_test = "task build"
  test = "python -m unittest tests/test_*.py"
  build = "make ."
  ```

  The pretask hook looks for `pre_<task_name>` task for a given `task_name`. It will run it before running the task itself. If the pretask fails, then taskipy will exit without running the task itself.



  From time to time, you might want to run a task in conjuction with another. For example, you might want to run linting after a successful test run. Take the two following commands, for instance:

  ```toml
  [tool.taskipy.tasks]
  test = "python -m unittest tests/test_*.py"
  lint = "pylint tests taskipy"
  ```

  You could make tests trigger linting, by using the **posttask hook**:

  ```toml
  [tool.taskipy.tasks]
  test = "python -m unittest tests/test_*.py"
  post_test = "task lint"
  lint = "pylint tests taskipy"
  ```

  The posttask hook looks for `post_<task_name>` task for a given `task_name`. It will run it after running the task itself. If the task failed, then taskipy will not run the posttask hook.



  In some cases, you might find yourself passing the same arguments over and over again. Let us take a look at the following tasks:

  ```toml
  [tool.taskipy.tasks]
  lint = "pylint path/to/my_module"
  black = "black path/to/my_module"
  ```

  As you can see, we provide the same path argument to both `pylint` and `black`.

  In order to encourage DRY and improve your ability to change these values later on, taskipy actually lets you declare and reuse variables in your tasks:

  ```toml
  [tool.taskipy.variables]
  path = "path/to/my_module"

  [tool.taskipy.tasks]
  lint = { cmd = "pylint {path}", use_vars = true }
  black = { cmd = "pylint {path}", use_vars = true }
  ```

  We have made the following changes to our configuration:

  1. We declared variables under `tool.taskipy.variables`
  2. We flagged the relevant task using `use_vars` to note that they should use the variables
  3. We replaced the repeating path with a `{path}` variable



  The formatting of the task commands uses python's own `string.format` method, and therefore supports everything that python's [formatted string literals](https://docs.python.org/3/tutorial/inputoutput.html#formatted-string-literals) let you do.



  Using variables is opt-in, which means that by default commands do **not** use them, and you will have to turn them on a task to task basis.

  If you want to turn on `use_vars` globally, all you need to do is to declare that under taskipy's **settings** table:

  ```toml
  [tool.taskipy.settings]
  use_vars = true

  [tool.taskipy.variables]
  path = "path/to/my_module"

  [tool.taskipy.tasks]
  lint = "pylint {path}"
  black = "black {path}"
  ```



  If we want to use variables within other variables, we can utilize recursive variables. By default, variables are not recursive, but we can specify a variable to be recursive by setting the `recursive` key to `true`.

  ```toml
  [tool.taskipy.settings]
  use_vars = true

  [tool.taskipy.variables]
  src_dir = "src"
  package_dir = { var = "{src_dir}/package", recursive = true }

  [tool.taskipy.tasks]
  echo = "echo {package_dir}"
  ```

  In this example, we could run `task echo` and we would then see `src/package`.



  Taskipy was created with poetry projects in mind, but actually only requires a valid `pyproject.toml` file in your project's directory. As a result, you can use it even eithout poetry:



  Install taskipy on your machine or in your virtualenv using:

  ```bash
  pip install taskipy
  ```



  Head into your project's directory (don't forget to activate virtualenv if you're using one), and run the following command:

  ```bash
  task TASK
  ```

  Where `TASK` is the name of your task.



  If you have a more specific use case, you might not be the first to run into it! Head over to the [ADVANCED_FEATURES](./docs/ADVANCED_FEATURES.md) doc, and look it up.



  <table>
    <tr>
      <td align="center"><a href="https://github.com/illBeRoy"><img src="https://avatars2.githubusercontent.com/u/6681893?v=4" width="100px;" alt=""/><br /><sub><b>Roy Sommer</b></sub></a></td>
    </tr>
  </table>



  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="http://triguba.com"><img src="https://avatars3.githubusercontent.com/u/15860938?v=4" width="100px;" alt=""/><br /><sub><b>Eugene Triguba</b></sub></a><br /><a href="https://github.com/illBeRoy/taskipy/commits?author=eugenetriguba" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/RobinFrcd"><img src="https://avatars0.githubusercontent.com/u/29704178?v=4" width="100px;" alt=""/><br /><sub><b>RobinFrcd</b></sub></a><br /><a href="https://github.com/illBeRoy/taskipy/commits?author=RobinFrcd" title="Code">💻</a></td>
      <td align="center"><a href="http://granitosaurus.rocks"><img src="https://avatars0.githubusercontent.com/u/5476164?v=4" width="100px;" alt=""/><br /><sub><b>Bernardas Ališauskas</b></sub></a><br /><a href="https://github.com/illBeRoy/taskipy/commits?author=Granitosaurus" title="Code">💻</a></td>
    </tr>
  </table>

  <!-- markdownlint-enable -->
  <!-- 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: 83f2ba50f88a7e50ac6c0f8506fc49e31592179ca5fa1be08f40fbe1f615e303
name: python-tasklib
arch: src
version: 2.5.1
epoch: 0
release: 1
summary: Official Taskwarrior library for Python
url: https://github.com/GothenburgBitFactory/tasklib
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-09e1d308-68b3-49b4-92ea-60265ce03ec7
location_href: 00005266-python-tasklib/python-tasklib-2.5.1-1.src.rpm
checksum_type: sha256
description:
  tasklib is a Python library for interacting with taskwarrior_ databases, using
  a queryset API similar to that of Django's ORM.


pkgId: c5e439836ff49d940fde263c045942b82893bc1303da2ca6ab0c24c9b58e89ca
name: python-tasmotadevicecontroller
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: Control Tasmota devices via their web api
url: https://github.com/chaptergy/tasmota-device-controller
rpm_license: GNU General Public License v3 (GPLv3)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1c689d33-3ed2-4587-80c5-7ce0fbd43d18
location_href: 00005267-python-tasmotadevicecontroller/python-tasmotadevicecontroller-0.0.8-1.src.rpm
checksum_type: sha256
description:
  This packag provides async wrappers for Tasmota's web request API.

  Only very few requests are implemented so far! If you need other requests, please have a look at the section [Contributing](#contributing), or create an issue.

  `get` methods return the value of the fetched item, `set` methods return the new set value (so what the `get` method would return after the set). However there are some exceptions like `BLINK` for `setPower()` which always returns `True`, but that should be mentioned in the methods description.

  Since this package was created for a Home Assistant integration, you can check out [that integration](https://github.com/chaptergy/homeassistant-tasmota-switch) for other sample usage.

  Example usage:

  ```py
  import asyncio
  from tasmotadevicecontroller import TasmotaDevice
  from tasmotadevicecontroller import tasmota_types as t

  async def main():
      device = await TasmotaDevice.connect('192.168.10.21')

      
      nameResult = await device.getFriendlyName()
      print(nameResult)  # Returns 'My Tasmota Plug'

      
      getResult = await device.getPower()
      print(getResult)  # Returns True (on)

      
      setResult = await device.setPower(t.PowerType.TOGGLE)
      print(setResult)  # Returns True or False (depending if the device was switched on or off)

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

  ```


  If you want to add new requests, can implement these commands and create a merge request on [GitHub](https://github.com/chaptergy/tasmota-device-controller).

  Almost every command is implemented as one getter method and one setter method. Add your command if possible in the same way inside the `TasmotaDevice` class. Remember to add descriptions to each method. This description can usually be taken from the Tasmota wiki.
  Also, remember to always use `async` `await`!

  If the command takes values from a specific set of values, create an `Enum` inside `tasmota_types.py` for it.


pkgId: a83c430c82c41c530529954e42168cd4fd1eb674d6d8516a28cf2f10cff0a6c5
name: python-tbats
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: BATS and TBATS for time series forecasting
url: https://github.com/intive-DataScience/tbats
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b9c83cbc-b44b-41bc-9bfc-eff2908783ce
location_href: 00012678-python-tbats/python-tbats-1.1.2-1.src.rpm
checksum_type: sha256
description:
  Package provides BATS and TBATS time series forecasting methods described in:

  > De Livera, A.M., Hyndman, R.J., & Snyder, R. D. (2011), Forecasting time series with complex seasonal patterns using exponential smoothing, Journal of the American Statistical Association, 106(496), 1513-1527.




  From pypi:

  ```bash
  pip install tbats
  ```

  Import via:

  ```python
  from tbats import BATS, TBATS
  ```



  ```python
  from tbats import TBATS
  import numpy as np



  if __name__ == '__main__':
      np.random.seed(2342)
      t = np.array(range(0, 160))
      y = 5 * np.sin(t * 2 * np.pi / 7) + 2 * np.cos(t * 2 * np.pi / 30.5) + \
          ((t / 20) ** 1.5 + np.random.normal(size=160) * t / 50) + 10

      
      estimator = TBATS(seasonal_periods=[14, 30.5])

      
      fitted_model = estimator.fit(y)

      
      y_forecasted = fitted_model.forecast(steps=14)

      
      print(fitted_model.summary())
  ```

  Reading model details

  ```python

  print(fitted_model.y_hat) # in sample prediction
  print(fitted_model.resid) # in sample residuals
  print(fitted_model.aic)


  print(fitted_model.params.alpha)
  print(fitted_model.params.beta)
  print(fitted_model.params.x0)
  print(fitted_model.params.components.use_box_cox)
  print(fitted_model.params.components.seasonal_harmonics)
  ```

  See **examples** directory for more details.



  BATS and TBATS tries multitude of models under the hood and **may appear slow when fitting** to long time series. In order to speed it up you can start with constrained model search space. It is recommended to run it without Box-Cox transformation and ARMA errors modelling that are the slowest model elements:

  ```python

  estimator = TBATS(
      seasonal_periods=[14, 30.5],
      use_arma_errors=False,  # shall try only models without ARMA
      use_box_cox=False  # will not use Box-Cox
  )
  fitted_model = estimator.fit(y)
  ```

  In some environment configurations parallel computation of models freezes. Reason for this is unclear yet. If **the process appears to be stuck** you can try running it on a single core:

  ```python
  estimator = TBATS(
      seasonal_periods=[14, 30.5],
      n_jobs=1
  )
  fitted_model = estimator.fit(y)
  ```



  Building package:

  ```bash
  pip install -e .[dev]
  ```

  Unit and integration tests:

  ```bash
  pytest test/
  ```

  R forecast package comparison tests. Those DO NOT RUN with default test command, you need R and forecast package installed:
  ```bash
  pytest test_R/
  ```



  Python implementation is meant to be as much as possible equivalent to R implementation in forecast package.

  - BATS in R https://www.rdocumentation.org/packages/forecast/versions/8.4/topics/bats
  - TBATS in R: https://www.rdocumentation.org/packages/forecast/versions/8.4/topics/tbats


pkgId: 3fc67de25b720d2672dcdce7bd93c94ab3e11d6a8b0b3f123c33ab001d50bfce
name: python-tbtrim
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: A utility to trim Python traceback information.
url: https://github.com/gousaiyang/tbtrim
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8d75c6da-5759-4dff-9829-57b94dad63dc
location_href: 00005269-python-tbtrim/python-tbtrim-0.3.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Downloads](https://pepy.tech/badge/tbtrim)](https://pepy.tech/count/tbtrim)
  [![PyPI - Version](https://img.shields.io/pypi/v/tbtrim.svg)](https://pypi.org/project/tbtrim)
  [![PyPI - Format](https://img.shields.io/pypi/format/tbtrim.svg)](https://pypi.org/project/tbtrim)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/tbtrim.svg)](https://pypi.org/project/tbtrim)
  [![PyPI - Status](https://img.shields.io/pypi/status/tbtrim.svg)](https://pypi.org/project/tbtrim)
  [![Travis CI - Status](https://img.shields.io/travis/gousaiyang/tbtrim.svg)](https://travis-ci.org/gousaiyang/tbtrim)
  ![License](https://img.shields.io/github/license/gousaiyang/tbtrim.svg)

  `tbtrim` is a utility to trim Python traceback information. By assigning user-refined [`sys.excepthook`](https://docs.python.org/3/library/sys.html#sys.excepthook), one can easily customize the behavior after an exception is raise and uncaught, and just before the interpreter prints out the given traceback and exception to `sys.stderr`.

  In a more human-readable way, `tbtrim` is to let you handle the last words of a program when it exits because of an exception.



  Simply run the following to install the current version from PyPI:

  ```shell
  $ pip install tbtrim
  ```

  Or install the latest version from the git repository:

  ```shell
  git clone https://github.com/gousaiyang/tbtrim.git
  cd tbtrim
  pip install -e .

  git pull
  ```



  > **set_trim_rule**(*predicate*, *target*=BaseException, *exclude*=None, *strict*=False, *exception*=None)

  Set the rule for trimming traceback (will set `sys.excepthook` and `threading.excepthook` if available).

  You can determine whether to start trimming traceback items based on the filename (using `predicate`), and can choose to trim traceback only for some certain exceptions (using `target` and `exclude`).

  **Args:**

  - **predicate** (*function*): a function which takes one `str` parameter (the filename of a traceback item) and returns `bool` (returning `True` indicates that this traceback item and the following items should be trimmed)
  - **target** (*class_or_tuple*): an exception or a tuple of exceptions may be given to trim traceback only for those exceptions
  - **exclude** (*class_or_tuple*): an exception or a tuple of exceptions may be given to exclude them from traceback trimming
  - **strict** (*bool*): indicate whether to check an exception against `target` and `exclude` in a strict mode (setting `True` uses `is` to check, `False` uses `issubclass` to check)
  - **exception** (*class_or_tuple*): this is a deprecated alias of `exclude`, retained for backward compatibility

  > **clear_trim_rule**()

  Clear the rule for trimming traceback (restore the excepthooks).


pkgId: 307dfd4eeba064921e978449977c94bb1ffe4510bdf402fea3dd6304672cfc25
name: python-tdigest
arch: src
version: 0.5.2.2
epoch: 0
release: 1
summary: T-Digest data structure
url: https://github.com/CamDavidsonPilon/tdigest
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-146f0c0f-1dd4-48ea-86d1-b758c451c851
location_href: 00010987-python-tdigest/python-tdigest-0.5.2.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/tdigest.svg)](https://badge.fury.io/py/tdigest)
  [![Build Status](https://travis-ci.org/CamDavidsonPilon/tdigest.svg?branch=master)](https://travis-ci.org/CamDavidsonPilon/tdigest)


  This is a Python implementation of Ted Dunning's [t-digest](https://github.com/tdunning/t-digest) data structure. The t-digest data structure is designed around computing accurate estimates from either streaming data, or distributed data. These estimates are percentiles, quantiles, trimmed means, etc. Two t-digests can be added, making the data structure ideal for map-reduce settings, and can be serialized into much less than 10kB (instead of storing the entire list of data).

  See a blog post about it here: [Percentile and Quantile Estimation of Big Data: The t-Digest](http://dataorigami.net/blogs/napkin-folding/19055451-percentile-and-quantile-estimation-of-big-data-the-t-digest)



  *tdigest* is compatible with both Python 2 and Python 3.

  ```
  pip install tdigest
  ```





  ```
  from tdigest import TDigest
  from numpy.random import random

  digest = TDigest()
  for x in range(5000):
      digest.update(random())

  print(digest.percentile(15))  # about 0.15, as 0.15 is the 15th percentile of the Uniform(0,1) distribution
  ```



  ```
  another_digest = TDigest()
  another_digest.batch_update(random(5000))
  print(another_digest.percentile(15))
  ```



  ```
  sum_digest = digest + another_digest
  sum_digest.percentile(30)  # about 0.3
  ```



  You can use the to_dict() method to turn a TDigest object into a standard Python dictionary.
  ```
  digest = TDigest()
  digest.update(1)
  digest.update(2)
  digest.update(3)
  print(digest.to_dict())
  ```
  Or you can get only a list of Centroids with `centroids_to_list()`.
  ```
  digest.centroids_to_list()
  ```

  Similarly, you can restore a Python dict of digest values with `update_from_dict()`. Centroids are merged with any existing ones in the digest.
  For example, make a fresh digest and restore values from a python dictionary.
  ```
  digest = TDigest()
  digest.update_from_dict({'K': 25, 'delta': 0.01, 'centroids': [{'c': 1.0, 'm': 1.0}, {'c': 1.0, 'm': 2.0}, {'c': 1.0, 'm': 3.0}]})
  ```

  K and delta values are optional, or you can provide only a list of centroids with `update_centroids_from_list()`.
  ```
  digest = TDigest()
  digest.update_centroids([{'c': 1.0, 'm': 1.0}, {'c': 1.0, 'm': 2.0}, {'c': 1.0, 'm': 3.0}])
  ```

  If you want to serialize with other tools like JSON, you can first convert to_dict().
  ```
  json.dumps(digest.to_dict())
  ```

  Alternatively, make a custom encoder function to provide as default to the standard json module.
  ```
  def encoder(digest_obj):
      return digest_obj.to_dict()
  ```
  Then pass the encoder function as the default parameter.
  ```
  json.dumps(digest, default=encoder)
  ```




  `TDigest.`

   - `update(x, w=1)`: update the tdigest with value `x` and weight `w`.
   - `batch_update(x, w=1)`: update the tdigest with values in array `x` and weight `w`.
   - `compress()`: perform a compression on the underlying data structure that will shrink the memory footprint of it, without hurting accuracy. Good to perform after adding many values.
   - `percentile(p)`: return the `p`th percentile. Example: `p=50` is the median.
   - `cdf(x)`: return the CDF the value `x` is at.
   - `trimmed_mean(p1, p2)`: return the mean of data set without the values below and above the `p1` and `p2` percentile respectively.
   - `to_dict()`: return a Python dictionary of the TDigest and internal Centroid values.
   - `update_from_dict(dict_values)`: update from serialized dictionary values into the TDigest object.
   - `centroids_to_list()`: return a Python list of the TDigest object's internal Centroid values.
   - `update_centroids_from_list(list_values)`: update Centroids from a python list.


pkgId: 27467ae74c1634eeb882510859214d7d144976eca73a42f960bc1d365c22f079
name: python-teamcity-messages
arch: src
version: 1.32
epoch: 0
release: 1
url: https://github.com/JetBrains/teamcity-messages
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-03e5387f-629e-4fce-bba5-1b4380c5a166
location_href: 00011312-python-teamcity-messages/python-teamcity-messages-1.32-1.src.rpm
checksum_type: sha256
summary:
  Send test results to TeamCity continuous integration server from unittest, nose, py.test, twisted trial, behave (Python 2.6+)

description:
  |  |jb_project| |license| |pypi_version|
  |  |versions| |teamcity_ci|
  This package integrates Python with the
  `TeamCity <http://www.jetbrains.com/teamcity/>`__ Continuous Integration
  (CI) server. It allows sending `"service
  messages" <https://confluence.jetbrains.com/display/TCDL/Build+Script+Interaction+with+TeamCity>`__
  from Python code. Additionally, it provides integration with the
  following testing frameworks and tools:
  -  `py.test <http://pytest.org/>`__
  -  `nose <https://nose.readthedocs.org/>`__
  -  `Django <https://docs.djangoproject.com/en/1.8/topics/testing/advanced/#other-testing-frameworks>`__
  -  `unittest (Python standard
     library) <https://docs.python.org/2/library/unittest.html>`__
  -  `Trial (Twisted) <http://twistedmatrix.com/trac/wiki/TwistedTrial>`__
  -  `Flake8 <https://flake8.readthedocs.org/>`__
  -  `Behave <https://behave.readthedocs.io/>`__
  -  `PyLint <https://www.pylint.org/>`__


pkgId: b6c87587b02af4f6b6cc93094efd3ceb85c175e84cac6b7fb294d5c9aa9fc529
name: python-telebot
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: A Telegram bot library, with simple route decorators.
url: https://github.com/KyleJamesWalker/telebot
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e59d4824-41a7-4a9e-a102-4badd92972af
location_href: 00011263-python-telebot/python-telebot-0.0.5-1.src.rpm
checksum_type: sha256
description:
  Note: This is not `pyTelegramBotAPI <https://github.com/eternnoir/pyTelegramBotAPI>`_, but do to often confusion I have included
  it within this package.  So if you accidentally install this instead of `pyTelegramBotAPI <https://github.com/eternnoir/pyTelegramBotAPI>`_
  the examples, etc will still work.
  This originally was telegram bot library, with simple route decorators, and will now
  be imported as telebot_router, to separate `pyTelegramBotAPI <https://github.com/eternnoir/pyTelegramBotAPI>`_ and this package from
  collision.
  Currently a work in progress, doesn't do much now, but will register and send messages.
  Example Setup
  ^^^^^^^^^^^^^
   from telebot_router import TeleBot
   app = TeleBot(__name__)
   @app.route('/command ?(.*)')
   def example_command(message, cmd):
       chat_dest = message['chat']['id']
       msg = "Command Recieved: {}".format(cmd)
       app.send_message(chat_dest, msg)
   @app.route('(?!/).+')
   def parrot(message):
      chat_dest = message['chat']['id']
      user_msg = message['text']
      msg = "Parrot Says: {}".format(user_msg)
      app.send_message(chat_dest, msg)
   if __name__ == '__main__':
       app.config['api_key'] = 'xxxxxxxx:enterYourBotKeyHereToTest'
       app.poll(debug=True)


pkgId: c25485b142899cfc22b023a0724a4818725236c9a1f9db6ac6c26fbc419c0ac4
name: python-telegraph
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Telegraph API wrapper
url: https://github.com/python273/telegraph
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3a20e3c4-31ba-49e1-bce8-e41e5f219d65
location_href: 00010698-python-telegraph/python-telegraph-2.2.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/telegraph.svg)](https://pypi.python.org/pypi/telegraph)
  ![Python Versions](https://img.shields.io/pypi/pyversions/telegraph.svg)
  ![License](https://img.shields.io/github/license/python273/telegraph.svg)

  Python Telegraph API wrapper

  - [Documentation](https://python-telegraph.readthedocs.io/en/latest/)

  ```bash
  $ python3 -m pip install telegraph

  $ python3 -m pip install 'telegraph[aio]'
  ```


  ```python
  from telegraph import Telegraph

  telegraph = Telegraph()
  telegraph.create_account(short_name='1337')

  response = telegraph.create_page(
      'Hey',
      html_content='<p>Hello, world!</p>'
  )
  print(response['url'])
  ```


  ```python
  import asyncio
  from telegraph.aio import Telegraph

  async def main():
      telegraph = Telegraph()
      print(await telegraph.create_account(short_name='1337'))

      response = await telegraph.create_page(
          'Hey',
          html_content='<p>Hello, world!</p>',
      )
      print(response['url'])


  asyncio.run(main())
  ```


pkgId: c728f485da71857989119db766e70ae503117c73d038f2c7e715348da4b1fd60
name: python-telepath
arch: src
version: 0.3
epoch: 0
release: 1
summary: A library for exchanging data between Python and JavaScript
url: https://github.com/wagtail/telepath
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1f04014a-8c44-4ff3-89eb-76d5c4535863
location_href: 00012549-python-telepath/python-telepath-0.3-1.src.rpm
checksum_type: sha256
description:
  *telepath* is a Django library for exchanging data between Python and JavaScript, allowing you to build apps with rich client-side interfaces while keeping the business logic in server-side code.



  It provides a mechanism for packing structured data, including Python objects, into a JSON-serializable format. This mechanism can be extended to support any Python class, by registering the class with a corresponding JavaScript implementation. The packed data can then be included in an HTTP response, and unpacked in JavaScript to obtain an equivalent data structure to the original. Think of it as [`pickle`](https://docs.python.org/3/library/pickle.html), but with the unpickling happening in the browser.

  Full documentation: https://wagtail.github.io/telepath/


pkgId: 041fc3ed83649de738b37b857b32677df455dddec18371e4d7cdf471e2b0667d
name: python-tempdir
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: Tempdirs are temporary directories, based on tempfile.mkdtemp
url: https://bitbucket.org/another_thomas/tempdir
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2781fba3-4a97-4d06-a890-f9f5bf7cc6ca
location_href: 00005274-python-tempdir/python-tempdir-0.7.1-1.src.rpm
checksum_type: sha256
description:
  Having to manually manage temporary directories is annoying.
  So this class encapsulates temporary directories which just disappear after use,
  including contained directories and files.
  Temporary directories are created with tempfile.mkdtemp and thus save from race conditions.
  Cleanup might not work on windows if files are still opened.


pkgId: d5dfd3813dbdb37c111739ec55c05f1cbe92e5f2aee71f582941247288fdecb5
name: python-tenacity
arch: src
version: 8.2.2
epoch: 0
release: 1
summary: Retry code until it succeeds
url: https://github.com/jd/tenacity
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e82b5b18-7e29-4b77-be70-4c256392fd23
location_href: 00005275-python-tenacity/python-tenacity-8.2.2-1.src.rpm
checksum_type: sha256
description:
  Tenacity is a general-purpose retrying library to simplify the task of adding retry behavior to just about anything.


pkgId: 04e1b9311d1de995cadf7bd3186cf02348b9e7823d70c2b678a131f13d99ad5a
name: python-tensor2tensor
arch: src
version: 1.15.7
epoch: 0
release: 1
summary: Tensor2Tensor
url: http://github.com/tensorflow/tensor2tensor
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d4fbf784-a75c-4e15-8166-f106ad6db13c
location_href: 00010318-python-tensor2tensor/python-tensor2tensor-1.15.7-1.src.rpm
checksum_type: sha256
description:
  Tensor2Tensor, or T2T for short, is a library of deep learning models and datasets designed to make deep learning more accessible and accelerate ML research. T2T was developed by researchers and engineers in the Google Brain team and a community of users. It is now in maintenance mode -- we keep it running and welcome bug-fixes, but encourage users to use the successor library Trax.


pkgId: bed3d65002042c9a099a2868d5664ca081f7ff27351f2ee98f4dadb666e458f4
name: python-tensorflow-datasets
arch: src
version: 4.9.0
epoch: 0
release: 1
summary: tensorflow/datasets is a library of datasets ready to use with TensorFlow.
url: https://github.com/tensorflow/datasets
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bceb6eb5-7155-4e30-a4f7-801221ecf7c2
location_href: 00009447-python-tensorflow-datasets/python-tensorflow-datasets-4.9.0-1.src.rpm
checksum_type: sha256
description:
  tensorflow/datasets is a library of public datasets ready to use with
  TensorFlow. Each dataset definition contains the logic necessary to download and
  prepare the dataset, as well as to read it into a model using the
  `tf.data.Dataset` API.

  Usage outside of TensorFlow is also supported.

  See the README on GitHub for further documentation.


pkgId: ecbe34eaa1da37c851e96064e959fc53de6d24c4f31a2c4169416f58105e28ba
name: python-tensorflowonspark
arch: src
version: 2.2.5
epoch: 0
release: 1
summary: Deep learning with TensorFlow on Apache Spark clusters
url: https://github.com/yahoo/TensorFlowOnSpark
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f3fe9cba-6324-430d-90d3-aefdd1e6ff44
location_href: 00010586-python-tensorflowonspark/python-tensorflowonspark-2.2.5-1.src.rpm
checksum_type: sha256
description:
  <!--
  Copyright 2019 Yahoo Inc.
  Licensed under the terms of the Apache 2.0 license.
  Please see LICENSE file in the project root for terms.
  -->

  > _TensorFlowOnSpark brings scalable deep learning to Apache Hadoop and Apache Spark
  clusters._

  [![Build Status](https://cd.screwdriver.cd/pipelines/6384/badge)](https://cd.screwdriver.cd/pipelines/6384)
  [![Package](https://img.shields.io/badge/package-pypi-blue.svg)](https://pypi.org/project/tensorflowonspark/)
  [![Downloads](https://img.shields.io/pypi/dm/tensorflowonspark.svg)](https://img.shields.io/pypi/dm/tensorflowonspark.svg)
  [![Documentation](https://img.shields.io/badge/Documentation-latest-blue.svg)](https://yahoo.github.io/TensorFlowOnSpark/)

  By combining salient features from the [TensorFlow](https://www.tensorflow.org) deep learning framework with [Apache Spark](http://spark.apache.org) and [Apache Hadoop](http://hadoop.apache.org), TensorFlowOnSpark enables distributed
  deep learning on a cluster of GPU and CPU servers.

  It enables both distributed TensorFlow training and
  inferencing on Spark clusters, with a goal to minimize the amount
  of code changes required to run existing TensorFlow programs on a
  shared grid.  Its Spark-compatible API helps manage the TensorFlow
  cluster with the following steps:

  1. **Startup** - launches the Tensorflow main function on the executors, along with listeners for data/control messages.
  1. **Data ingestion**
     - **InputMode.TENSORFLOW** - leverages TensorFlow's built-in APIs to read data files directly from HDFS.
     - **InputMode.SPARK** - sends Spark RDD data to the TensorFlow nodes via a `TFNode.DataFeed` class.  Note that we leverage the [Hadoop Input/Output Format](https://github.com/tensorflow/ecosystem/tree/master/hadoop) to access TFRecords on HDFS.
  1. **Shutdown** - shuts down the Tensorflow workers and PS nodes on the executors.



  - [Background](#background)
  - [Install](#install)
  - [Usage](#usage)
  - [API](#api)
  - [Contribute](#contribute)
  - [License](#license)



  TensorFlowOnSpark was developed by Yahoo for large-scale distributed
  deep learning on our Hadoop clusters in Yahoo's private cloud.

  TensorFlowOnSpark provides some important benefits (see [our
  blog](https://developer.yahoo.com/blogs/157196317141/))
  over alternative deep learning solutions.
     * Easily migrate existing TensorFlow programs with <10 lines of code change.
     * Support all TensorFlow functionalities: synchronous/asynchronous training, model/data parallelism, inferencing and TensorBoard.
     * Server-to-server direct communication achieves faster learning when available.
     * Allow datasets on HDFS and other sources pushed by Spark or pulled by TensorFlow.
     * Easily integrate with your existing Spark data processing pipelines.
     * Easily deployed on cloud or on-premise and on CPUs or GPUs.



  TensorFlowOnSpark is provided as a pip package, which can be installed on single machines via:
  ```

  pip install tensorflowonspark


  pip install tensorflowonspark==1.4.4
  ```

  For distributed clusters, please see our [wiki site](../../wiki) for detailed documentation for specific environments, such as our getting started guides for [single-node Spark Standalone](https://github.com/yahoo/TensorFlowOnSpark/wiki/GetStarted_Standalone), [YARN clusters](../../wiki/GetStarted_YARN) and [AWS EC2](../../wiki/GetStarted_EC2).  Note: the Windows operating system is not currently supported due to [this issue](https://github.com/yahoo/TensorFlowOnSpark/issues/36).



  To use TensorFlowOnSpark with an existing TensorFlow application, you can follow our [Conversion Guide](../../wiki/Conversion-Guide) to describe the required changes.  Additionally, our [wiki site](../../wiki) has pointers to some presentations which provide an overview of the platform.

  **Note: since TensorFlow 2.x breaks API compatibility with TensorFlow 1.x, the examples have been updated accordingly.  If you are using TensorFlow 1.x, you will need to checkout the `v1.4.4` tag for compatible examples and instructions.**



  [API Documentation](https://yahoo.github.io/TensorFlowOnSpark/) is automatically generated from the code.



  Please join the [TensorFlowOnSpark user group](https://groups.google.com/forum/#!forum/TensorFlowOnSpark-users) for discussions and questions.  If you have a question, please review our [FAQ](../../wiki/Frequently-Asked-Questions) before posting.

  Contributions are always welcome.  For more information, please see our [guide for getting involved](Contributing.md).



  The use and distribution terms for this software are covered by the Apache 2.0 license.
  See [LICENSE](LICENSE) file for terms.


pkgId: ede165458d743d09319378c7f91cf3a9d990f8c5adeefa62562f652b8d1d2b95
name: python-tentaclio
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Unification of data connectors for distributed data tasks
url: https://github.com/octoenergy/tentaclio
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0e49d9c3-02c8-434d-8280-2490acd2930a
location_href: 00010815-python-tentaclio/python-tentaclio-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI status](https://circleci.com/gh/octoenergy/tentaclio/tree/master.png?circle-token=df7aad11367f1ace5bce253b18efb6b21eaa65bc)](https://circleci.com/gh/octoenergy/tentaclio/tree/master)
  [![Documentation Status](https://readthedocs.org/projects/tentaclio/badge/?version=latest)](https://tentaclio.readthedocs.io/en/latest/?badge=latest)

  Python library that simplifies:
  * Handling streams from different protocols such as `file:`, `ftp:`, `sftp:`, `s3:`, ...
  * Opening database connections.
  * Managing the credentials in distributed systems.

  Main considerations in the design:
  * Easy to use: all streams are open via `tentaclio.open`, all database connections through `tentaclio.db`.
  * URLs are the basic resource locator and db connection string.
  * Automagic authentication for protected resources.
  * Extensible: you can add your own handlers for other schemes.
  * Pandas interaction.




  ```python
  import tentaclio
  contents = "👋 🐙"

  with tentaclio.open("ftp://localhost:2021/upload/file.txt", mode="w") as writer:
      writer.write(contents)


  bucket = "s3://my-bucket/octopus/hello.txt"
  with tentaclio.open(bucket) as reader:
      print(reader.read())
  ```


  ```python
  import tentaclio

  tentaclio.copy("/home/constantine/data.csv", "sftp://constantine:tentacl3@sftp.octoenergy.com/uploads/data.csv")
  ```

  ```python
  import tentaclio

  tentaclio.remove("s3://my-bucket/octopus/the-9th-tentacle.txt")
  ```

  ```python
  import tentaclio

  for entry in tentaclio.listdir("s3:://mybucket/path/to/dir"):
      print("Entry", entry)
  ```


  ```python
  import os

  import tentaclio

  print("env ftp credentials", os.getenv("OCTOIO__CONN__OCTOENERGY_FTP"))




  with tentaclio.open("sftp://sftp.octoenergy.com/uploads/data.csv") as reader:
      print(reader.read())
  ```


  ```python
  import os

  import tentaclio

  print("env TENTACLIO__CONN__DB", os.getenv("TENTACLIO__CONN__DB"))




  with tentaclio.db("postgresql://hostname/example") as pg:
      results = pg.query("select * from my_table")
  ```


  ```python
  import pandas as pd  # 🐼🐼
  import tentaclio  # 🐙

  df = pd.DataFrame([[1, 2, 3], [10, 20, 30]], columns=["col_1", "col_2", "col_3"])

  bucket = "s3://my-bucket/data/pandas.csv"

  with tentaclio.open(bucket, mode="w") as writer:  # supports more pandas readers
      df.to_csv(writer, index=False)

  with tentaclio.open(bucket) as reader:
      new_df = pd.read_csv(reader)


  with tentaclio.db(
          connection_info,
          connect_args={'options': '-csearch_path=schema_name'}
      ) as client:
      df.to_sql(
          name='observations', # table name
          con=client.conn,
      )
  ```



  You can get tentaclio using pip

  ```sh
  pip install tentaclio
  ```
  or pipenv
  ```sh
  pipenv install tentaclio
  ```



  Clone this repo and install [pipenv](https://pipenv.readthedocs.io/en/latest/):

  In the `Makefile` you'll find some useful targets for linting, testing, etc. i.e.:
  ```sh
  make test
  ```



  This is how to use `tentaclio` for your daily data ingestion and storing needs.


  In order to open streams to load or store data the universal function is:

  ```python
  import tentaclio

  with tentaclio.open("/path/to/my/file") as reader:
      contents = reader.read()

  with tentaclio.open("s3://bucket/file", mode='w') as writer:
      writer.write(contents)

  ```
  Allowed modes are `r`, `w`, `rb`, and `wb`. You can use `t` instead of `b` to indicate text streams, but that's the default.

  In order to keep tentaclio as light as possible, it only includes `file`, `ftp`, `sftp`, `http` and `https` schemes by default.
  However, many more are easily available by installing extra packages:

  Default:
  * `/local/file`
  * `file:///local/file`
  * `ftp://path/to/file`
  * `sftp://path/to/file`
  * `http://host.com/path/to/resource`
  * `https://host.com/path/to/resource`

  [tentaclio-s3](https://github.com/octoenergy/tentaclio-s3)
  * `s3://bucket/file`

  [tentaclio-gs](https://github.com/octoenergy/tentaclio-gs)
  * `gs://bucket/file`
  * `gsc://bucket/file`

  [tentaclio-gdrive](https://github.com/octoenergy/tentaclio-gdrive)
  * `gdrive:/My Drive/file`
  * `googledrive:/My Drive/file`

  [tentaclio-postgres](https://github.com/octoenergy/tentaclio-postgres)
  * `postgresql://host/database::table` will allow you to write from a csv format into a database with the same column names (note that the table goes after `::` :warning:).


  You can add the credentials for any of the urls in order to access protected resources.


  You can use these readers and writers with pandas functions like:

  ```python
  import pandas as pd
  import tentaclio

  with tentaclio.open("/path/to/my/file") as reader:
      df = pd.read_csv(reader)

  [...]

  with tentaclio.open("s3::/path/to/my/file", mode='w') as writer:
      df.to_parquet(writer)
  ```
  `Readers`, `Writers` and their closeable versions can be used anywhere expecting a file-like object; pandas or pickle are examples of such functions.



  The default behaviour for the `open` context manager in python is to create an empty file when opening
  it in writable mode. This can be annoying if the process that creates the data within the `with` clause
  yields empty dataframes and nothing gets written. This will make Spark and Presto panic.

  To avoid this we can make the stream _empty safe_ so the empty buffer won't be flushed if no writes have been performed so no empty file will be created.


  ```
  with tio.make_empty_safe(tio.open("s3://bucket/file.parquet", mode="wb")) as writer:
      if not df.empty:
          df.to_parquet(writer)
  ```



  Some URL schemes allow listing resources in a pythonnic way:
  ```python
  import tentaclio

  for entry in tentaclio.listdir("s3:://mybucket/path/to/dir"):
      print("Entry", entry)
  ```

  Whereas `listdir` might be convinient we also offer `scandir`, which returns a list of [DirEntry](https://github.com/octoenergy/tentaclio/blob/ddbc28615de4b99106b956556db74a20e4761afe/src/tentaclio/fs/scanner.py#L13)s, and, `walk`. All functions follow as closely as possible their standard library definitions.




  In order to open db connections you can use `tentaclio.db` and have instant access to postgres, sqlite, athena and mssql.

  ```python
  import tentaclio

  [...]

  query = "select 1";
  with tentaclio.db(POSTGRES_TEST_URL) as client:
      result =client.query(query)
  [...]
  ```

  The supported db schemes are:

  Default:
  * `sqlite://`
  * `mssql://`
  * + Any other scheme supported by sqlalchemy.

  [tentaclio-postgres](https://github.com/octoenergy/tentaclio-postgres)
  * `postgresql://`

  [tentaclio-athena](https://github.com/octoenergy/tentaclio-athena)
  * `awsathena+rest://`

  [tentaclio-databricks](https://github.com/octoenergy/tentaclio-databricks)
  * `databricks+thrift://`

  [tentaclio-snowflake](https://github.com/octoenergy/tentaclio-snowflake)
  * `snowflake://`



  For postgres you can set the variable `TENTACLIO__PG_APPLICATION_NAME` and the value will be injected
  when connecting to the database.



  1. Configure credentials by using environmental variables prefixed with `TENTACLIO__CONN__`  (i.e.  `TENTACLIO__CONN__DATA_FTP=sfpt://real_user:132ldsf@ftp.octoenergy.com`).

  2. Open a stream:
  ```python
  with tentaclio.open("sftp://ftp.octoenergy.com/file.csv") as reader:
      reader.read()
  ```
  The credentials get injected into the url.

  3. Open a db client:
  ```python
  import tentaclio

  with tentaclio.db("postgresql://hostname/my_data_base") as client:
      client.query("select 1")
  ```
  Note that `hostname` in the url to be authenticated is a wildcard that will match any hostname. So `authenticate("http://hostname/file.txt")` will be injected to `http://user:pass@octo.co/file.txt` if the credential for `http://user:pass@octo.co/` exists.

  Different components of the URL are set differently:
  - Scheme and path will be set from the URL, and null if missing.
  - Username, password and hostname will be set from the stored credentials.
  - Port will be set from the stored credentials if it exists, otherwise from the URL.
  - Query will be set from the URL if it exists, otherwise from the stored credentials (so it can be
    overriden)



  You can also set a credentials file that looks like:
  ```
  secrets:
      db_1: postgresql://user1:pass1@myhost.com/database_1
      db_2: mssql://user2:pass2@otherhost.com/database_2?driver=ODBC+Driver+17+for+SQL+Server
      ftp_server: ftp://fuser:fpass@ftp.myhost.com
  ```
  And make it accessible to tentaclio by setting the environmental variable `TENTACLIO__SECRETS_FILE`. The actual name of each url is for traceability and has no effect in the functionality.

  (Note that you may need to add `?driver={driver from /usr/local/etc/odbcinst.ini}` for mssql database connection strings; see above example)

  Alternatively you can run `curl https://raw.githubusercontent.com/octoenergy/tentaclio/master/extras/init_tentaclio.sh` to create a secrets file in `~/.tentaclio.yml` and
  automatically configure your environment.



  In order to abstract concrete dependencies from the implementation of data related functions (or in any part of the system really) we use typed [protocols](https://mypy.readthedocs.io/en/latest/protocols.html#simple-user-defined-protocols). This allows a more flexible dependency injection than using subclassing or [more complex approches](http://code.activestate.com/recipes/413268/). This idea is heavily inspired by how this exact thing is done in [go](https://www.youtube.com/watch?v=ifBUfIb7kdo). Learn more about this principle in our [tech blog](https://tech.octopus.energy/news/2019/03/21/python-interfaces-a-la-go.html).


pkgId: a1089ab7672ad2a52c7111db34920d06a335030519ee4b61be048f9fe4fb7fce
name: python-terminaltables
arch: src
version: 3.1.10
epoch: 0
release: 1
summary: Generate simple tables in terminals from a nested list of strings.
url: https://github.com/matthewdeanmartin/terminaltables
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a878928f-248a-4ab5-87ad-5b4d272a20c6
location_href: 00005277-python-terminaltables/python-terminaltables-3.1.10-1.src.rpm
checksum_type: sha256
description:
  Install:
  ```bash
  pip install terminaltables
  ```
  Usage:
  ```python
  from terminaltables import AsciiTable
  table_data = [
      ['Heading1', 'Heading2'],
      ['row1 column1', 'row1 column2'],
      ['row2 column1', 'row2 column2'],
      ['row3 column1', 'row3 column2']
  ]
  table = AsciiTable(table_data)
  print
  table.table
  ```
  ```bash
  +--------------+--------------+
  | Heading1     | Heading2     |
  +--------------+--------------+
  | row1 column1 | row1 column2 |
  | row2 column1 | row2 column2 |
  | row3 column1 | row3 column2 |
  +--------------+--------------+
  ```


pkgId: 0489d98aaab9799d245d1e8e8fca520f7517051a4cb412ff2bfb9d89b55814b3
name: python-terrawrap
arch: src
version: 0.9.23
epoch: 0
release: 1
summary: Set of Python-based CLI tools for working with Terraform configurations
url: https://github.com/amplify-education/terrawrap
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2c55b6a7-6f44-4744-9f1c-f31b43ed2996
location_href: 00011064-python-terrawrap/python-terrawrap-0.9.23-1.src.rpm
checksum_type: sha256
description:
  [![Codacy Badge](https://api.codacy.com/project/badge/Grade/e8bf52c80edf4070a18d8725b1f5f166)](https://app.codacy.com/app/amplify-education/terrawrap?utm_source=github.com&utm_medium=referral&utm_content=amplify-education/terrawrap&utm_campaign=Badge_Grade_Settings)
  [![Codacy Badge](https://api.codacy.com/project/badge/Coverage/ceeb459250dd429f9ca5a497c0e45051)](https://www.codacy.com/app/amplify-education/terrawrap?utm_source=github.com&utm_medium=referral&utm_content=amplify-education/terrawrap&utm_campaign=Badge_Coverage)
  [![Build Status](https://travis-ci.org/amplify-education/terrawrap.svg?branch=master)](https://travis-ci.org/amplify-education/terrawrap)
  [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/amplify-education/terrawrap/master/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/terrawrap.svg)](https://pypi.org/project/terrawrap/)
  [![Python Versions](https://img.shields.io/pypi/pyversions/terrawrap.svg)](https://pypi.python.org/pypi/terrawrap)
  [![Downloads](https://img.shields.io/badge/dynamic/json.svg?label=downloads&url=https%3A%2F%2Fpypistats.org%2Fapi%2Fpackages%2Fterrawrap%2Frecent&query=data.last_month&colorB=brightgreen&suffix=%2FMonth)](https://pypistats.org/packages/terrawrap)



  Set of Python-based CLI tools for working with Terraform configurations in bulk



  Amplify builds innovative and compelling digital educational products that empower teachers and students across the
  country. We have a long history as the leading innovator in K-12 education - and have been described as the best tech
  company in education and the best education company in tech. While others try to shrink the learning experience into
  the technology, we use technology to expand what is possible in real classrooms with real students and teachers.

  Learn more at <https://www.amplify.com>



  -   [Features](#features)

  -   [Goals](#goals)

  -   [Getting Started](#getting-started)
      -   [Prerequisites](#prerequisites)
      -   [Installing](#installing)
      -   [Building From Source](#building-from-source)
      -   [Running Tests](#running-tests)

  -   [Configuration](#configuration)
      -   [.tf_wrapper](#tf_wrapper)
      -   [Plugins](#plugins)
      -   [Autovars](#autovars)
      -   [Backend Configuration](#backend-configuration)

  -   [Commands](#commands)
      -   [tf](#tf)
      -   [plan_check](#plan_check)
      -   [graph_apply](https://github.com/amplify-education/terrawrap/wiki/graph_apply)



  1.  `auto.tfvars` inheritance. Terrawrap makes it easier to share variables between Terraform directories through
      inheritance of `auto.tfvars` files.

  2.  Remote backend generation. Terrawrap makes it easier to work with remote state backends by
      generating configuration for them.

  3.  Repository level plan/apply. Terrawrap provides commands for running plan/apply recursively on a entire
      repository at once.

  4.  Repository level dependency visualization. Terrawrap provides commands for displaying the order of applies in
      human readable output.

  5.  Automatically download third-party Terraform plugins



  1.  Make Terraform DRY for large organizations. A Terraform best practices is to break up Terraform configs
      into many small state files. This leads to an explosion in boilerplate code when using Terraform in large
      organizations with 100s of state files. Terrawrap reduces some boilerplate code by providing `auto.tfvars`
      inheritance and generating backend configurations.

  2.  Make Terraform code easier to manage. Terraform only runs commands on a single directory at a time. This makes
      working with hundreds of terraform directories/state files hard. Terrawrap provides utilities for running
      commands against an entire repository at once instead of one directory at a time.

  3.  All Terraform code should be valid Terraform. Any Terraform code used with Terrawrap should be runnable with
      Terraform by itself without the wrapper. Terrawrap does not provide any new syntax.

  4.  Terrawrap is not a code generator. Generated code is harder to
      read and understand. Code generators tend to lead to leaky abstractions that can be more trouble than they are
      worth. However, Terrawrap does generate remote backend configs as a workaround to Terraform's lack of support for
      variables in backend configs (See <https://github.com/hashicorp/terraform/issues/13022>). We expect this to be
      the only instance of code generation in Terrawrap.





  Terrawrap requires Python 3.7.0 or higher to run.



  This package can be installed using `pip`

  ```sh
  pip3 install terrawrap
  ```

  You should now be able to use the `tf` command.



  For development, `tox>=2.9.1` is recommended.



  Terrawrap uses `tox`. You will need to install tox with `pip install tox`.
  Running `tox` will automatically execute linters as well as the unit tests.

  You can also run them individually with the `-e` argument.

  For example, `tox -e py37-unit` will run the unit tests for python 3.7

  To see all the available options, run `tox -l`.





  Terrawrap can be configured via a `.tf_wrapper` file. The wrapper will walk the provided configuration
  path and look for `.tf_wrapper` files. The files are merged in the order that they are discovered. Consider
  the below example:

  ```text
  foo
  ├── bar
  │   └── .tf_wrapper
  └── .tf_wrapper
  ```

  If there are conflicting configurations between those two `.tf_wrapper` files, the `.tf_wrapper` file in
  `foo/bar` will win.

  The following options are supported in `.tf_wrapper`:

  ```yaml
  configure_backend: True # If true, automatically configure Terraform backends.
  backend_check: True # If true, require this directory to have a terraform backend configured

  envvars:
    <NAME_OF_ENVVAR>:
      source: # The source of the envvar. One of `['ssm', 'text', 'unset']`.
      path: # If the source of the envvar is `ssm`, the SSM Parameter Store path to lookup the value of the environment variable from.
      value: # if the source of the envvar is `text`, the string value to set as the environment variable.
      

  plugins:
      <NAME_OF_PLUGIN>: <plugin url>
  ```



  Terrawrap supports automatically downloading provider plugins by configuring the `.tf_wrapper` file as specified above.
  This is a temporary workaround until Terraform 0.13 is released with built-in support for automatically
  downloading plugins and plugin registries are available for hosting private plugins.

  Terrawrap will first try to download platform specific versions of plugins by downloading them from
  `<plugin url>/<system type>/<architecture type>`. If Terrawrap is unable to download from the platform specific URL
  then it will try to download directly from the given plugin url directly instead.

  For example, the following config on a Mac

  ```yaml
  plugins:
      foo: http://example.com/foo
  ```

  Terrawap will first try to download from `http://example.com/foo/Darwin/x86_64`.
  If that request fails then Terrawrap will try `http://example.com/foo` instead.



  Terrawrap automatically adds `-var-file` arguments to any terraform command by scanning for `*.auto.tfvars`
  files in the directory structure.

  For example, the following command `tf config/foo/bar apply` with the following directory structure:

  ```text
  config
  ├── foo
  |   └── bar
  |   │  ├── baz.tf
  |   │  └── bar.auto.tfvars
  |   └── foo.auto.tfvars
  └── config.auto.tfvars
  ```

  will generate the following command:

  ```bash
  terraform apply -var-file config/config.auto.tfvars \
      -var-file config/foo/foo.auto.tfvars \
      -var-file config/foo/bar/bar.auto.tfvars
  ```



  Terrawrap supports automatically configuring backends by injecting the appropriate `-backend-config`
  args when running `init`

  For example, the Terrawrap command `tf config/foo/bar init` will generate a Terraform command like below if using
  an AWS S3 remote state backend

  ```bash
  terraform init -reconfigure \
      -backend-config=dynamodb_table=<lock table name> \
      -backend-config=encrypt=true \
      -backend-config=key=config/foo/bar.tfstate \
      -backend-config=region=<region name> \
      -backend-config=bucket=<state bucket name> \
      -backend-config=skip_region_validation=true \
      -backend-config=skip_credentials_validation=true
  ```

  Terrawrap configures the backend by looking for `.tf_wrapper` files in the directory structure.
  Either `s3` or `gcs` are supported. See the relevant Terraform documentation for the options available
  for each type of backend:
  <https://www.terraform.io/docs/backends/types/s3.html#configuration-variables>
  <https://www.terraform.io/docs/backends/types/gcs.html#configuration-variables>


  ```yml
  backends:
      s3:
          region:
          role_arn:
          bucket:
          dynamodb_table:
  ```

  | Option Name    | Required | Purpose                                                                              |
  | -------------- | -------- | ------------------------------------------------------------------------------------ |
  | bucket         | Yes      | Name of S3 Bucket                                                                    |
  | region         | Yes      | AWS Region that S3 state bucket and DynamoDB lock table are located in               |
  | dynamodb_table | No       | DynamoDB table to use for state locking. Locking is disable if lock_table is not set |
  | role_arn       | No       | AWS role to assume when reading/writing to S3 bucket and lock table                  |

  The S3 state file key name is generated from the directory name being used to run the terraform command.
  For example, `tf config/foo/bar init` uses a state file with the key `config/foo/bar.tfstate` in S3


  ```yml
  backends:
      gcs:
          bucket:
  ```
  | Option Name    | Required | Purpose                                                                              |
  | -------------- | -------- | ------------------------------------------------------------------------------------ |
  | bucket         | Yes      | Name of GCS Bucket                                                                   |





  `tf <directory> <terraform command>` runs a terraform command for a given directory that contains `*.tf` files.
  Terrawrap automatically includes autovars as described above when running the given command. Any Terraform
  command is supported



  `plan_check <directory>` runs `terraform plan` recursively for all child directories starting at the given directory.
  `plan_check` uses `git` to identify which files have changed compared with the `master` branch. It will then run `plan`
  on any directory that contains `tf` files with the following criteria

  1.  A directory that has files that changed
  2.  A directory that is symlinked to a directory that has files changed
  3.  A directory with symlinked files that are linked to files that changed
  4.  A directory that that uses a Terraform module whose source changed
  5.  A directory with Terraform files that refer to an autovar file that changed



  `backend_check [directory]` verifies that all directories under the given directory that contain `.tf` files
  also have Terraform Backends defined.


pkgId: aea842fdf87d240bd391e4f19a780e73490d5f54ae0a47e1528f246615243b51
name: python-teslajsonpy
arch: src
version: 3.7.4
epoch: 0
release: 1
summary: A library to work with Tesla API.
url: https://github.com/zabuldon/teslajsonpy
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8245ce44-b4a7-440c-b5ea-9e076b9740c8
location_href: 00005278-python-teslajsonpy/python-teslajsonpy-3.7.4-1.src.rpm
checksum_type: sha256
description:
  [![Version status](https://img.shields.io/pypi/status/teslajsonpy)](https://pypi.org/project/teslajsonpy)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![Python version compatibility](https://img.shields.io/pypi/pyversions/teslajsonpy)](https://pypi.org/project/teslajsonpy)
  [![Version on Github](https://img.shields.io/github/v/release/zabuldon/teslajsonpy?include_prereleases&label=GitHub)](https://github.com/zabuldon/teslajsonpy/releases)
  [![Version on PyPi](https://img.shields.io/pypi/v/teslajsonpy)](https://pypi.org/project/teslajsonpy)
  ![PyPI - Downloads](https://img.shields.io/pypi/dd/teslajsonpy)
  ![PyPI - Downloads](https://img.shields.io/pypi/dw/teslajsonpy)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/teslajsonpy)

  Async python module for Tesla API primarily for enabling Home-Assistant.

  **NOTE:** Tesla has no official API; therefore, this library may stop
  working at any time without warning.



  Originally inspired by [this code.](https://github.com/gglockner/teslajson)
  Also thanks to [Tim Dorr](https://tesla-api.timdorr.com/) for documenting the API. Additional repo scaffolding from [simplisafe-python.](https://github.com/bachya/simplisafe-python)



  1.  [Check for open features/bugs](https://github.com/zabuldon/teslajsonpy/issues)
      or [initiate a discussion on one](https://github.com/zabuldon/teslajsonpy/issues/new).
  2.  [Fork the repository](https://github.com/zabuldon/teslajsonpy/fork/new).
  3.  Install the dev environment: `make init`.
  4.  Enter the virtual environment: `poetry shell`
  5.  Code your new feature or bug fix. [Developers Reference](DEVELOPERS.md)
  6.  Write a test that covers your new functionality.
  7.  Update `README.md` with any new documentation.
  8.  Run tests and ensure 100% code coverage for your contribution: `make coverage`
  9.  Ensure you have no linting errors: `make lint`
  10. Ensure you have typed your code correctly: `make typing`
  11. Add yourself to `AUTHORS.md`.
  12. Submit a [pull request](https://github.com/zabuldon/teslajsonpy/pulls)!



  [API docs](https://teslajsonpy.readthedocs.io/en/latest/).



  [Apache-2.0](LICENSE). By providing a contribution, you agree the contribution is licensed under Apache-2.0.
  This code is provided as-is with no warranty. Use at your own risk.


pkgId: 035d9ba602876118cc228928de62ce87e554738412729d9333d5a5680eede0b7
name: python-test-server
arch: src
version: 0.0.42
epoch: 0
release: 1
summary: Server for testing HTTP clients
url: https://pypi.org/project/test-server/
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-afd368bc-cd9a-46bf-bcbc-1691399c8096
location_href: 00005281-python-test_server/python-test-server-0.0.42-1.src.rpm
checksum_type: sha256
description:
  [![Test Status](https://github.com/lorien/test_server/actions/workflows/test.yml/badge.svg)](https://github.com/lorien/test_server/actions/workflows/test.yml)
  [![Code Quality](https://github.com/lorien/test_server/actions/workflows/check.yml/badge.svg)](https://github.com/lorien/test_server/actions/workflows/test.yml)
  [![Type Check](https://github.com/lorien/test_server/actions/workflows/mypy.yml/badge.svg)](https://github.com/lorien/test_server/actions/workflows/mypy.yml)
  [![Test Coverage Status](https://coveralls.io/repos/github/lorien/test_server/badge.svg)](https://coveralls.io/github/lorien/test_server)
  [![Documentation Status](https://readthedocs.org/projects/test_server/badge/?version=latest)](http://user-agent.readthedocs.org)

  Simple HTTP Server for testing HTTP clients.




  Run `pip install -U test_server`




  ```python
  from unittest import TestCase
  import unittest
  from urllib.request import urlopen

  from test_server import TestServer, Response, HttpHeaderStorage


  class UrllibTestCase(TestCase):
     @classmethod
     def setUpClass(cls):
         cls.server = TestServer()
         cls.server.start()

     @classmethod
     def tearDownClass(cls):
         cls.server.stop()

     def setUp(self):
         self.server.reset()

     def test_get(self):
         self.server.add_response(
             Response(
                 data=b"hello",
                 headers={"foo": "bar"},
             )
         )
         self.server.add_response(Response(data=b"zzz"))
         url = self.server.get_url()
         info = urlopen(url)
         self.assertEqual(b"hello", info.read())
         self.assertEqual("bar", info.headers["foo"])
         info = urlopen(url)
         self.assertEqual(b"zzz", info.read())
         self.assertTrue("bar" not in info.headers)


     unittest.main()
  ```

rpm_license:
  The MIT License (MIT)  Copyright (c) 2015-2023, Gregory Petukhov  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: a784967b6d5b5931f3de6bdf0f770d571d0db2f0d897c60b05d275a7607869df
name: python-testcloud
arch: src
version: 0.8.2
epoch: 0
release: 1
summary: A tool to download and boot cloud images locally, with an easy to use API.
url: https://pagure.io/testcloud
rpm_license: GPLv2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a9c78cbe-7b18-48ed-959d-c51a737cf5e9
location_href: 00005282-python-testcloud/python-testcloud-0.8.2-1.src.rpm
checksum_type: sha256
description:
  **testcloud** is a small helper script to download and boot cloud/coreos images
  locally. Testcloud supports wide range of distributions, namely Fedora, Fedora CoreOS,
  CentOS, CentOS Stream, Red Hat Enterprise Linux, Debian and Ubuntu.

  **testcloud** can run either in system mode or in constrained user session mode,
  which is usefull for running it eg. in unprivileged containers.



  The following procedure should only be used to install **testcloud** on
  a production system. For developing purposes, you need a different kind
  of installation which is described in the **Testcloud Development**
  section below.

  To use **testcloud** on a production system:

  1. Install the **testcloud**.

         ```
         $ sudo dnf install testcloud
         ```

  2. Add yourself to the `testcloud group`.

        ```
        $ sudo usermod -a -G testcloud $USER
        ```

  3. Restart your user session to update the group privileges, or use
     `su -` to get a login shell for that particular user where the group
     settings will be updated.

        ```
        $ su -i $USER
        ```

  4. Now, you are ready to use **testcloud**.





  To create a new instance, you will need to provide distribution and version you wish to use or the url of some cloud
  image in the *qcow2* format. If you do not have an image location of
  your own, you can use the image from the **Fedora Cloud** download pages
  (<https://alt.fedoraproject.org/cloud/>).

  To create a new instance with the cloud image, run:

  ```
  $ testcloud instance create <url for qcow2 image> or <distro:version>
  ```

  Some examples how to create an instance with distribution:version shortcut:

  ```

  $ testcloud instance create fedora:latest
  ```

  or, you can skip latest, which is the default value for version:
  ```

  $ testcloud instance create fedora
  ```

  ```

  $ testcloud instance create fedora:rawhide
  ```

  ```

  $ testcloud instance create centos-stream:8
  ```

  ```

  $ testcloud instance create ubuntu:hirsute
  ```

  ```

  $ testcloud instance create debian:11
  ```

  Supported distributions with shortcuts are: Fedora, CentOS, CentOS Stream, Ubuntu and Debian. For other distributions, you can provide link to basically any qcow2 image which has the cloud-init package included.

  Testcloud supports also Vagrant .box files, in a limited manner and currently only for CentOS.

  **testcloud** will download the *qcow2* image and save it in the
  `/var/lib/testcloud/backingstores/<qcow2-filename>`. It will use this
  image a backing store for the newly created instance in
  `/var/tmp/instances/<instance-name>`. When the image has been already
  downloaded, **testcloud** will use the previously download image to
  create the instance.

  To create a new instance with the coreos image, run:

  ```
  $ testcloud instance create fedora-coreos:<stream> or <url for qcow2 image>

  ```

  You will be able to see the instance using the `list` command.

  ```
  $ testcloud instance list
  ```

  Alternatively, the instances can also be viewed and manipulated using
  the **virt-manager** tool.



  Instances can be started and stopped using the `instance` interface of
  the **testcloud**, too:

  1. List all instances to see the correct name of the instance:

         ```
         $ testcloud instance list
         ```

  2. Start the instance:

         ```
         $ testcloud instance start <instance-name>
         ```

  3. Stop the instance:

         ```
         $ testcloud instance stop <instance-name>
         ```

  4. Remove the instance:

         ```
         $ testcloud instance remove <instance-name>
         ```

  Removing the instance only succeeds when the appropriate instance has
  been **stopped** before. However, you can use the `-f` option to force
  removing the instance.



  1. Reboot the instance:

         ```
         $ testcloud instance reboot <instance-name>
         ```

  2. Remove non-existing libvirt VMs from testcloud:

         ```
         $ testcloud instance clean
         ```



  When the cloud/coreos instance is created, **testcloud** will return its IP address
  that you can use to access the running instance via `ssh`. The default *login
  name* is `cloud-user` and the *password* is `passw0rd`. Testcloud will output info how you can connect to any of the Supported Distributions.

  ```
  ssh cloud-user@<instance-IP>
  ```

  The IP address of an instance is also shown when you list the instance
  using the `testcloud instance list` command. You can also control the
  instance using the **virt-manager** , **GNOME Boxes** or any other tool to manage libvirt VMs.



  There are several options (all optional) that can be used to create a
  new instance using **testcloud**.

  -c, \--connection QEMU_URI

  : You can specify uri to qemu you wish to use. For limited environments, you might wish to use *qemu:///session*. Remote connections other than *qemu:///session* and *qemu:///system* (like qemu+ssh,...) are known to be problematic.

  \--ram RAM

  : To set the amount of RAM that will be available to the virtual
      machine (in MiB).

  \--vcpus VCPUS

  : To set the amount of VCPUS that will be available to the virtual
      machine.

  \--no-graphic

  : This turns off the graphical display of the virtual machine.

  \--vnc

  : To open a VNC connection at the `:1` display of the instance.

  -n, \--name NAME

  : To specify a custom name for you instance.

  \--timeout TIMEOUT

  : A time (in seconds) to wait for boot to complete. Setting to 0
      (default) will disable this functionality.

  \--disksize DISKSIZE

  : To set the disk size of the virtual machine (in GiB)

  There are several additional options that can be used to create a
  new Coreos instance using **testcloud**.

  \--bu_file BU_FILE

  : To provide a bu_file you want to use

  \--ign_file IGN_FILE

  : To provide an ign_file you want to use

  \--ssh_path

  : To provide ssh pubkey path



  The default configuration should work for many people but those defaults
  can be overridden through the use of a `settings.py` file containing the
  values to use when overriding default settings. The example file in
  `conf/settings-example.py` shows the possible configuration values which
  can be changed.

  Note that in order for those new values to be picked up, the filename
  must be `settings.py` and that file must live in one of the following
  locations:

  * `conf/settings.py` in the git checkout
  * `~/.config/testcloud/settings.py`
  * `/etc/testcloud/settings.py`

  For example, if you wanted to set up an ssh accessible root account that
  uses an ssh key as the authentification method, you could provide the
  following to the `~/.config/testcloud/settings.py`:

  ```yaml
  USER_DATA = """#cloud-config
  users:
      - default
      - name: root
        password: %s
        chpasswd: { expire: False }
        ssh-authorized-keys:
        - <my ssh pub key>
  """
  ```



  To develop **testcloud**, you need to perform a more complicated process
  to install all its dependencies, download the source code and perform a
  set-up.

  To install **testcloud** for development purposes:



  1. Install the dependencies for **testcloud**.

         ```
         $ sudo dnf install libvirt python3-libvirt libguestfs libguestfs-tools python3-requests python3-jinja2
         ```

  2. Start **libvirtd**.

         ```
         $ sudo systemctl start libvirtd
         ```

  3. Add the `testcloud` group to the system.

         ```
         $ sudo groupadd testcloud
         ```

  4. Add a user into the `testcloud` group.

         ```
         $ sudo usermod -a -G testcloud $USER
         ```

  5. Log out of the system and log in again to update the group
     information on your user or use a login shell on a different
     terminal.

         ```
         $ su - $USER
         ```



  1. Clone the **testcloud** repository.

         ```
         $ git clone https://pagure.io/testcloud.git
         ```

  2. Create the application directories.

         ```
         $ sudo mkdir -p -m 775 /var/lib/testcloud
         ```

         ```
         $ sudo mkdir -p -m 775 /var/lib/testcloud/instances
         ```

         ```
         $ sudo mkdir -p -m 775 /var/lib/testcloud/backingstores
         ```

  3. Change ownership on these directories to enable their use with
     **testcloud**.

         ```
         $ sudo chown qemu:testcloud /var/lib/testcloud
         ```

         ```
         $ sudo chown qemu:testcloud /var/lib/testcloud/instances
         ```

         ```
         $ sudo chown qemu:testcloud /var/lib/testcloud/backingstores
         ```

  4. Copy the `.rules` file to the **polkit** rules.

         ```
         $ sudo cp conf/99-testcloud-nonroot-libvirt-access.rules /etc/polkit-1/rules.d/
         ```



  1. Navigate to your **testcloud** git repository.

         ```
         $ cd testcloud
         ```

  2. Execute the `run_testcloud.py` script to run the **testcloud**. You
     can use any options as with the regular installation, for example:

         ```
             $ ./run_testcloud.py instance create ...
         ```

  3. Alternatively, you can use **pip** to install **testcloud** onto the
     system and then use it like it has been installed normally.

         ```
         $ pip3 install -e . --user
         ```



  There is a small testsuite you can run with:

  ```
  tox
  ```

  This is a good place to contribute if you\'re looking to help out.



  Our project tracker is on the Fedora QA-devel
  [Pagure](https://pagure.io/testcloud//) instance.



  Thanks to [Oddshocks](https://github.com/oddshocks) for the koji
  downloader code :)



  This code is licensed GPLv2+. See the LICENSE file for details.


pkgId: cbf7dd8df649ca70fd44e1ed35a091063f80b0da3ef72faf6f49f69fff2ad263
name: python-testcloud
arch: src
version: 0.9.2
epoch: 0
release: 1
summary: A tool to download and boot cloud images locally, with an easy to use API.
url: https://pagure.io/testcloud
rpm_license: GPLv2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-58718f31-5166-4de1-8623-74ea29e3295c
location_href: 00008607-python-testcloud/python-testcloud-0.9.2-1.src.rpm
checksum_type: sha256
description:
  **testcloud** is a small helper script to download and boot cloud/coreos images
  locally. Testcloud supports wide range of distributions, namely Fedora, Fedora CoreOS,
  CentOS, CentOS Stream, Red Hat Enterprise Linux, Debian and Ubuntu.

  **testcloud** can run either in system mode or in constrained user session mode,
  which is usefull for running it eg. in unprivileged containers.



  The following procedure should only be used to install **testcloud** on
  a production system. For developing purposes, you need a different kind
  of installation which is described in the **Testcloud Development**
  section below.

  To use **testcloud** on a production system:

  1. Install the **testcloud**.

         ```
         $ sudo dnf install testcloud
         ```

  2. Add yourself to the `testcloud group`.

        ```
        $ sudo usermod -a -G testcloud $USER
        ```

  3. Restart your user session to update the group privileges, or use
     `su -` to get a login shell for that particular user where the group
     settings will be updated.

        ```
        $ su -i $USER
        ```

  4. Now, you are ready to use **testcloud**.





  To create a new instance, you will need to provide distribution and version you wish to use or the url of some cloud
  image in the *qcow2* format. If you do not have an image location of
  your own, you can use the image from the **Fedora Cloud** download pages
  (<https://alt.fedoraproject.org/cloud/>).

  To create a new instance with the cloud image, run:

  ```
  $ testcloud create <url for qcow2 image> or <distro:version>
  ```

  Some examples how to create an instance with distribution:version shortcut:

  ```

  $ testcloud create fedora
  ```

  ```

  $ testcloud create fedora:rawhide
  ```

  ```

  $ testcloud create centos-stream:8
  ```

  ```

  $ testcloud create ubuntu:hirsute
  ```

  ```

  $ testcloud create debian:11
  ```

  Supported distributions with shortcuts are: Fedora, CentOS, CentOS Stream, Ubuntu, Debian, Alma, Rocky, and Oracle.
  For other distributions, you can provide link to basically any qcow2 image which has the cloud-init package included.

  Testcloud supports also Vagrant .box files, in a limited manner and currently only for Fedora and CentOS.

  **testcloud** will download the *qcow2* image and save it in the
  `/var/lib/testcloud/backingstores/<qcow2-filename>`. It will use this
  image a backing store for the newly created instance in
  `/var/tmp/instances/<instance-name>`. When the image has been already
  downloaded, **testcloud** will use the previously download image to
  create the instance.

  To create a new instance with the coreos image, run:

  ```
  $ testcloud create fedora-coreos:<stream> or <url for qcow2 image>

  ```

  You will be able to see the instance using the `list` command.

  ```
  $ testcloud list
  ```

  Alternatively, the instances can also be viewed and manipulated using
  the **virt-manager** tool.



  Instances can be created with a different architecture than the host architecture. You'll need to have a proper
  qemu binary installed for this to work (eg. qemu-system-aarch64-core for aarch64 on x86_64 on Fedora). Supported
  architectures in testcloud are: x86_64, aarch64, ppc64le, and s390x. Any combinations of these are supported.

  Some examples:

  ```

  $ testcloud create fedora --arch aarch64
  ```

  ```

  $ testcloud create centos-stream --arch x86_64
  ```

  ```

  $ testcloud create fedora:rawhide --arch ppc64le
  ```



  Instances can be started and stopped using the `instance` interface of
  the **testcloud**, too:

  1. List all instances to see the correct name of the instance:

         ```
         $ testcloud list
         ```

  2. Start the instance:

         ```
         $ testcloud start <instance-name>
         ```

  3. Stop the instance:

         ```
         $ testcloud stop <instance-name>
         ```

  4. Remove the instance:

         ```
         $ testcloud remove <instance-name>
         ```

  Removing the instance only succeeds when the appropriate instance has
  been **stopped** before. However, you can use the `-f` option to force
  removing the instance.



  1. Reboot the instance:

         ```
         $ testcloud reboot <instance-name>
         ```

  2. Remove non-existing libvirt VMs from testcloud:

         ```
         $ testcloud clean
         ```



  When the cloud/coreos instance is created, **testcloud** will return its IP address
  that you can use to access the running instance via `ssh`. The default *login
  name* is `cloud-user` and the *password* is `passw0rd`. Testcloud will output info how you can connect to any of the Supported Distributions.

  ```
  ssh cloud-user@<instance-IP>
  ```

  The IP address of an instance is also shown when you list the instance
  using the `testcloud list` command. You can also control the
  instance using the **virt-manager** , **GNOME Boxes** or any other tool to manage libvirt VMs.



  There are several options (all optional) that can be used to create a
  new instance using **testcloud**.

  -c, \--connection QEMU_URI

  : You can specify uri to qemu you wish to use. For limited environments, you might wish to use *qemu:///session*. Remote connections other than *qemu:///session* and *qemu:///system* (like qemu+ssh,...) are known to be problematic.

  \--arch ARCH

  : To request a speciffic architecture for the guest. The default
  |    is the architecture of the host system.

  \--ram RAM

  : To set the amount of RAM that will be available to the virtual
      machine (in MiB).

  \--vcpus VCPUS

  : To set the amount of VCPUS that will be available to the virtual
      machine.

  \--no-graphic

  : This turns off the graphical display of the virtual machine.

  \--vnc

  : To open a VNC connection at the `:1` display of the instance.

  -n, \--name NAME

  : To specify a custom name for you instance.

  \--timeout TIMEOUT

  : A time (in seconds) to wait for boot to complete. Setting to 0
      (default) will disable this functionality.

  \--disksize DISKSIZE

  : To set the disk size of the virtual machine (in GiB)

  \--disk_number

  : To provide disk number you want

  There are several additional options that can be used to create a
  new Coreos instance using **testcloud**.

  \--bu_file BU_FILE

  : To provide a bu_file you want to use

  \--ign_file IGN_FILE

  : To provide an ign_file you want to use

  \--ssh_path

  : To provide ssh pubkey path



  The default configuration should work for many people but those defaults
  can be overridden through the use of a `settings.py` file containing the
  values to use when overriding default settings. The example file in
  `conf/settings-example.py` shows the possible configuration values which
  can be changed.

  Note that in order for those new values to be picked up, the filename
  must be `settings.py` and that file must live in one of the following
  locations:

  * `conf/settings.py` in the git checkout
  * `~/.config/testcloud/settings.py`
  * `/etc/testcloud/settings.py`

  For example, if you wanted to set up an ssh accessible root account that
  uses an ssh key as the authentification method, you could provide the
  following to the `~/.config/testcloud/settings.py`:

  ```yaml
  USER_DATA = """#cloud-config
  users:
      - default
      - name: root
        password: %s
        chpasswd: { expire: False }
        ssh-authorized-keys:
        - <my ssh pub key>
  """
  ```



  To develop **testcloud**, you need to perform a more complicated process
  to install all its dependencies, download the source code and perform a
  set-up.

  To install **testcloud** for development purposes:



  1. Install the dependencies for **testcloud**.

         ```
         $ sudo dnf install libvirt python3-libvirt libguestfs libguestfs-tools python3-requests python3-jinja2
         ```

  2. Start **libvirtd**.

         ```
         $ sudo systemctl start libvirtd
         ```

  3. Add the `testcloud` group to the system.

         ```
         $ sudo groupadd testcloud
         ```

  4. Add a user into the `testcloud` group.

         ```
         $ sudo usermod -a -G testcloud $USER
         ```

  5. Log out of the system and log in again to update the group
     information on your user or use a login shell on a different
     terminal.

         ```
         $ su - $USER
         ```



  1. Clone the **testcloud** repository.

         ```
         $ git clone https://pagure.io/testcloud.git
         ```

  2. Create the application directories.

         ```
         $ sudo mkdir -p -m 775 /var/lib/testcloud
         ```

         ```
         $ sudo mkdir -p -m 775 /var/lib/testcloud/instances
         ```

         ```
         $ sudo mkdir -p -m 775 /var/lib/testcloud/backingstores
         ```

  3. Change ownership on these directories to enable their use with
     **testcloud**.

         ```
         $ sudo chown qemu:testcloud /var/lib/testcloud
         ```

         ```
         $ sudo chown qemu:testcloud /var/lib/testcloud/instances
         ```

         ```
         $ sudo chown qemu:testcloud /var/lib/testcloud/backingstores
         ```

  4. Copy the `.rules` file to the **polkit** rules.

         ```
         $ sudo cp conf/99-testcloud-nonroot-libvirt-access.rules /etc/polkit-1/rules.d/
         ```



  1. Navigate to your **testcloud** git repository.

         ```
         $ cd testcloud
         ```

  2. Execute the `run_testcloud.py` script to run the **testcloud**. You
     can use any options as with the regular installation, for example:

         ```
             $ ./run_testcloud.py instance create ...
         ```

  3. Alternatively, you can use **pip** to install **testcloud** onto the
     system and then use it like it has been installed normally.

         ```
         $ pip3 install -e . --user
         ```



  There is a small testsuite you can run with:

  ```
  tox
  ```

  This is a good place to contribute if you\'re looking to help out.



  Our project tracker is on the Fedora QA-devel
  [Pagure](https://pagure.io/testcloud//) instance.



  Thanks to [Oddshocks](https://github.com/oddshocks) for the koji
  downloader code :)



  This code is licensed GPLv2+. See the LICENSE file for details.


pkgId: 3d9da6ce62f8d0c6721ac56dc8962753df9723db3f2e1f5ea9a328fbfe983efe
name: python-testinfra
arch: src
version: 6.0.0
epoch: 0
release: 1
summary: Test infrastructures
url: https://github.com/philpep/testinfra
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-36a1193b-0f86-4e15-b3fc-18598b7ed490
location_href: 00005284-python-testinfra/python-testinfra-6.0.0-1.src.rpm
checksum_type: sha256
description:
  Testinfra test your infrastructure


  This package is just a transitional package for https://github.com/pytest-dev/philpep you should install pytest-testinfra instead.


pkgId: 24920fc33972fb41c42be1d9c07853182d7ec1bb8ee2130ecc26df576246575d
name: python-testing.postgresql
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: automatically setups a postgresql instance in a temporary directory, and destroys it after testing
url: https://github.com/tk0miya/testing.postgresql
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-606d5ffd-ce78-4f66-9e62-ffd85a18a029
location_href: 00010896-python-testing-postgresql/python-testing.postgresql-1.3.0-1.src.rpm
checksum_type: sha256
description:
  ``testing.postgresql`` automatically setups a postgresql instance in a temporary directory, and destroys it after testing.
  Documentation
    https://github.com/tk0miya/testing.postgresql
  Issues
    https://github.com/tk0miya/testing.postgresql/issues
  Download
    https://pypi.python.org/pypi/testing.postgresql


pkgId: db969bb0919da03fcd0826705d27e3fe6bd696086b9be0b26fad367e0760f85f
name: python-testpath
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Test utilities for code working with files and commands
url: https://pypi.org/project/testpath/
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4c8a13e0-7a54-48d3-85d6-d539579016bb
location_href: 00005286-python-testpath/python-testpath-0.6.0-1.src.rpm
checksum_type: sha256
description:
  Testpath is a collection of utilities for Python code working with files and commands.

  It contains functions to check things on the filesystem, and tools for mocking
  system commands and recording calls to those.

  `Documentation on ReadTheDocs <https://testpath.readthedocs.io/en/latest/>`_

  e.g.::

      import testpath
      testpath.assert_isfile(path)

      with testpath.assert_calls('git', ['add', path]):
          function_under_test()


pkgId: cf0614329fe6c6041eed3d1233b4ae2f8393bcd3354371e4855fb50fc53c9a61
name: python-testrepository
arch: src
version: 0.0.20
epoch: 0
release: 1
summary: A repository of test results.
url: https://launchpad.net/testrepository
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4da6f423-e465-427b-9777-af45e0241e08
location_href: 00005287-python-testrepository/python-testrepository-0.0.20-1.src.rpm
checksum_type: sha256
description:
  Test Repository
  +++++++++++++++

  Overview
  ~~~~~~~~

  This project provides a database of test results which can be used as part of
  developer workflow to ensure/check things like:

  * No commits without having had a test failure, test fixed cycle.
  * No commits without new tests being added.
  * What tests have failed since the last commit (to run just a subset).
  * What tests are currently failing and need work.

  Test results are inserted using subunit (and thus anything that can output
  subunit or be converted into a subunit stream can be accepted).

  A mailing list for discussion, usage and development is at
  https://launchpad.net/~testrepository-dev - all are welcome to join. Some folk
  hang out on #testrepository on irc.freenode.net.

  CI for the project is at http://build.robertcollins.net/job/testrepository-default/.

  Licensing
  ~~~~~~~~~

  Test Repository is under BSD / Apache 2.0 licences. See the file COPYING in the source for details.

  Quick Start
  ~~~~~~~~~~~

  Create a config file::
    $ touch .testr.conf

  Create a repository::
    $ testr init

  Load a test run into the repository::
    $ testr load < testrun

  Query the repository::
    $ testr stats
    $ testr last
    $ testr failing

  Delete a repository::
    $ rm -rf .testrepository

  Documentation
  ~~~~~~~~~~~~~

  More detailed documentation including design and implementation details, a
  user manual, and guidelines for development of Test Repository itself can be
  found at https://testrepository.readthedocs.org/en/latest, or in the source
  tree at doc/ (run make -C doc html).


pkgId: 200f9e6d4795a249eb96a59620f4dc93c2cf4c13c1ed9730943e0694b9ba51f4
name: python-testresources
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Testresources, a pyunit extension for managing expensive test resources
url: https://launchpad.net/testresources
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-32167ee6-030a-4203-832d-af3d6f88427c
location_href: 00005288-python-testresources/python-testresources-2.0.1-1.src.rpm
checksum_type: sha256
description:
  * Python 2.6+ (or 3.3+)
  * docutils
  * testtools (http://pypi.python.org/pypi/testtools/)
  * fixtures (http://pypi.python.org/pypi/fixtures)


pkgId: 26e03e6f201cec65375feafdc1fecb69457c99c80965f1b11aea22fbb8b41b3e
name: python-text-unidecode
arch: src
version: 1.3
epoch: 0
release: 1
summary: The most basic Text::Unidecode port
url: https://github.com/kmike/text-unidecode/
rpm_license: Artistic License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1681c7b2-76be-4678-b4cc-c5cb2f46af8c
location_href: 00005290-python-text-unidecode/python-text-unidecode-1.3-1.src.rpm
checksum_type: sha256
description:
  text-unidecode is the most basic port of the
  `Text::Unidecode <http://search.cpan.org/~sburke/Text-Unidecode-0.04/lib/Text/Unidecode.pm>`_
  Perl library.
  There are other Python ports of Text::Unidecode (unidecode_
  and isounidecode_). unidecode_ is GPL; isounidecode_ uses too much memory,
  and it didn't support Python 3 when this package was created.
  You can redistribute it and/or modify this port under the terms of either:
  * `Artistic License`_, or
  * GPL or GPLv2+
  If you're OK with GPL-only, use unidecode_ (it has better memory usage and
  better transliteration quality).
  ``text-unidecode`` supports Python 2.7 and 3.4+.


pkgId: 85bc4c0997ccdceb5c2388b10da583303abfc2439a969eed167431c1262d2247
name: python-textblob
arch: src
version: 0.17.1
epoch: 0
release: 1
url: https://github.com/sloria/TextBlob
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-79ccdb50-c856-46d5-a1bf-9a5f372e5945
location_href: 00009706-python-textblob/python-textblob-0.17.1-1.src.rpm
checksum_type: sha256
summary:
  Simple, Pythonic text processing. Sentiment analysis, part-of-speech tagging, noun phrase parsing, and more.

description:
  Homepage: `https://textblob.readthedocs.io/ <https://textblob.readthedocs.io/>`_
  `TextBlob` is a Python (2 and 3) library for processing textual data. It provides a simple API for diving into common natural language processing (NLP) tasks such as part-of-speech tagging, noun phrase extraction, sentiment analysis, classification, translation, and more.
      from textblob import TextBlob
      text = '''
      The titular threat of The Blob has always struck me as the ultimate movie
      monster: an insatiably hungry, amoeba-like mass able to penetrate
      virtually any safeguard, capable of--as a doomed doctor chillingly
      describes it--"assimilating flesh on contact.
      Snide comparisons to gelatin be damned, it's a concept with the most
      devastating of potential consequences, not unlike the grey goo scenario
      proposed by technological theorists fearful of
      artificial intelligence run rampant.
      '''
      blob = TextBlob(text)
      blob.tags           # [('The', 'DT'), ('titular', 'JJ'),
                          
      blob.noun_phrases   # WordList(['titular threat', 'blob',
                          
                          
      for sentence in blob.sentences:
          print(sentence.sentiment.polarity)
      
      
  TextBlob stands on the giant shoulders of `NLTK`_ and `pattern`_, and plays nicely with both.


pkgId: 12f1ec5a75bd7b0d8bfe92819ac1d5302db111116c9a56b87ad88450e8eaa185
name: python-textdistance
arch: src
version: 4.5.0
epoch: 0
release: 1
summary: Compute distance between the two texts.
url: https://github.com/orsinium/textdistance
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5a22cb96-cf50-4f11-9717-cf7dca2a51ee
location_href: 00010502-python-textdistance/python-textdistance-4.5.0-1.src.rpm
checksum_type: sha256
description:
  ![TextDistance logo](logo.png)

  [![Build Status](https://travis-ci.org/life4/textdistance.svg?branch=master)](https://travis-ci.org/life4/textdistance) [![PyPI version](https://img.shields.io/pypi/v/textdistance.svg)](https://pypi.python.org/pypi/textdistance) [![Status](https://img.shields.io/pypi/status/textdistance.svg)](https://pypi.python.org/pypi/textdistance) [![License](https://img.shields.io/pypi/l/textdistance.svg)](LICENSE)

  **TextDistance** -- python library for comparing distance between two or more sequences by many algorithms.

  Features:

  - 30+ algorithms
  - Pure python implementation
  - Simple usage
  - More than two sequences comparing
  - Some algorithms have more than one implementation in one class.
  - Optional numpy usage for maximum speed.





  | Algorithm                                                                                 | Class                | Functions              |
  |-------------------------------------------------------------------------------------------|----------------------|------------------------|
  | [Hamming](https://en.wikipedia.org/wiki/Hamming_distance)                                 | `Hamming`            | `hamming`              |
  | [MLIPNS](http://www.sial.iias.spb.su/files/386-386-1-PB.pdf)                              | `Mlipns`             | `mlipns`               |
  | [Levenshtein](https://en.wikipedia.org/wiki/Levenshtein_distance)                         | `Levenshtein`        | `levenshtein`          |
  | [Damerau-Levenshtein](https://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance) | `DamerauLevenshtein` | `damerau_levenshtein`  |
  | [Jaro-Winkler](https://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance)               | `JaroWinkler`        | `jaro_winkler`, `jaro` |
  | [Strcmp95](http://cpansearch.perl.org/src/SCW/Text-JaroWinkler-0.1/strcmp95.c)            | `StrCmp95`           | `strcmp95`             |
  | [Needleman-Wunsch](https://en.wikipedia.org/wiki/Needleman%E2%80%93Wunsch_algorithm)      | `NeedlemanWunsch`    | `needleman_wunsch`     |
  | [Gotoh](http://bioinfo.ict.ac.cn/~dbu/AlgorithmCourses/Lectures/LOA/Lec6-Sequence-Alignment-Affine-Gaps-Gotoh1982.pdf) | `Gotoh`              | `gotoh`                |
  | [Smith-Waterman](https://en.wikipedia.org/wiki/Smith%E2%80%93Waterman_algorithm)          | `SmithWaterman`      | `smith_waterman`       |



  | Algorithm                                                                                 | Class                | Functions     |
  |-------------------------------------------------------------------------------------------|----------------------|---------------|
  | [Jaccard index](https://en.wikipedia.org/wiki/Jaccard_index)                              | `Jaccard`            | `jaccard`     |
  | [Sørensen–Dice coefficient](https://en.wikipedia.org/wiki/S%C3%B8rensen%E2%80%93Dice_coefficient) | `Sorensen`   | `sorensen`, `sorensen_dice`, `dice` |
  | [Tversky index](https://en.wikipedia.org/wiki/Tversky_index)                              | `Tversky`            | `tversky`    |
  | [Overlap coefficient](https://en.wikipedia.org/wiki/Overlap_coefficient)                  | `Overlap`            | `overlap`    |
  | [Tanimoto distance](https://en.wikipedia.org/wiki/Jaccard_index#Tanimoto_similarity_and_distance) | `Tanimoto`   | `tanimoto`   |
  | [Cosine similarity](https://en.wikipedia.org/wiki/Cosine_similarity)                      | `Cosine`             | `cosine`     |
  | [Monge-Elkan](https://www.academia.edu/200314/Generalized_Monge-Elkan_Method_for_Approximate_Text_String_Comparison) | `MongeElkan` | `monge_elkan` |
  | [Bag distance](https://github.com/Yomguithereal/talisman/blob/master/src/metrics/bag.js) | `Bag`        | `bag`        |



  | Algorithm | Class | Functions |
  |-----------|-------|-----------|
  | [longest common subsequence similarity](https://en.wikipedia.org/wiki/Longest_common_subsequence_problem)          | `LCSSeq` | `lcsseq` |
  | [longest common substring similarity](https://docs.python.org/2/library/difflib.html#difflib.SequenceMatcher)      | `LCSStr` | `lcsstr` |
  | [Ratcliff-Obershelp similarity](https://en.wikipedia.org/wiki/Gestalt_Pattern_Matching) | `RatcliffObershelp` | `ratcliff_obershelp` |



  [Normalized compression distance](https://en.wikipedia.org/wiki/Normalized_compression_distance#Normalized_compression_distance) with different compression algorithms.

  Classic compression algorithms:

  | Algorithm                                                                  | Class       | Function     |
  |----------------------------------------------------------------------------|-------------|--------------|
  | [Arithmetic coding](https://en.wikipedia.org/wiki/Arithmetic_coding)       | `ArithNCD`  | `arith_ncd`  |
  | [RLE](https://en.wikipedia.org/wiki/Run-length_encoding)                   | `RLENCD`    | `rle_ncd`    |
  | [BWT RLE](https://en.wikipedia.org/wiki/Burrows%E2%80%93Wheeler_transform) | `BWTRLENCD` | `bwtrle_ncd` |

  Normal compression algorithms:

  | Algorithm                                                                  | Class        | Function      |
  |----------------------------------------------------------------------------|--------------|---------------|
  | Square Root                                                                | `SqrtNCD`    | `sqrt_ncd`    |
  | [Entropy](https://en.wikipedia.org/wiki/Entropy_(information_theory))      | `EntropyNCD` | `entropy_ncd` |

  Work in progress algorithms that compare two strings as array of bits:

  | Algorithm                                  | Class     | Function   |
  |--------------------------------------------|-----------|------------|
  | [BZ2](https://en.wikipedia.org/wiki/Bzip2) | `BZ2NCD`  | `bz2_ncd`  |
  | [LZMA](https://en.wikipedia.org/wiki/LZMA) | `LZMANCD` | `lzma_ncd` |
  | [ZLib](https://en.wikipedia.org/wiki/Zlib) | `ZLIBNCD` | `zlib_ncd` |

  See [blog post](https://articles.life4web.ru/other/ncd/) for more details about NCD.



  | Algorithm                                                                    | Class    | Functions |
  |------------------------------------------------------------------------------|----------|-----------|
  | [MRA](https://en.wikipedia.org/wiki/Match_rating_approach)                   | `MRA`    | `mra`     |
  | [Editex](https://anhaidgroup.github.io/py_stringmatching/v0.3.x/Editex.html) | `Editex` | `editex`  |



  | Algorithm           | Class      | Functions  |
  |---------------------|------------|------------|
  | Prefix similarity   | `Prefix`   | `prefix`   |
  | Postfix similarity  | `Postfix`  | `postfix`  |
  | Length distance     | `Length`   | `length`   |
  | Identity similarity | `Identity` | `identity` |
  | Matrix similarity   | `Matrix`   | `matrix`   |





  Only pure python implementation:

  ```bash
  pip install textdistance
  ```

  With extra libraries for maximum speed:

  ```bash
  pip install "textdistance[extras]"
  ```

  With all libraries (required for [benchmarking](#benchmarks) and [testing](#running-tests)):

  ```bash
  pip install "textdistance[benchmark]"
  ```

  With algorithm specific extras:

  ```bash
  pip install "textdistance[Hamming]"
  ```

  Algorithms with available extras: `DamerauLevenshtein`, `Hamming`, `Jaro`, `JaroWinkler`, `Levenshtein`.



  Via pip:

  ```bash
  pip install -e git+https://github.com/life4/textdistance.git#egg=textdistance
  ```

  Or clone repo and install with some extras:

  ```bash
  git clone https://github.com/life4/textdistance.git
  pip install -e ".[benchmark]"
  ```



  All algorithms have 2 interfaces:

  1. Class with algorithm-specific params for customizing.
  2. Class instance with default params for quick and simple usage.

  All algorithms have some common methods:

  1. `.distance(*sequences)` -- calculate distance between sequences.
  2. `.similarity(*sequences)` -- calculate similarity for sequences.
  3. `.maximum(*sequences)` -- maximum possible value for distance and similarity. For any sequence: `distance + similarity == maximum`.
  4. `.normalized_distance(*sequences)` -- normalized distance between sequences. The return value is a float between 0 and 1, where 0 means equal, and 1 totally different.
  5. `.normalized_similarity(*sequences)` -- normalized similarity for sequences. The return value is a float between 0 and 1, where 0 means totally different, and 1 equal.

  Most common init arguments:

  1. `qval` -- q-value for split sequences into q-grams. Possible values:
      - 1 (default) -- compare sequences by chars.
      - 2 or more -- transform sequences to q-grams.
      - None -- split sequences by words.
  2. `as_set` -- for token-based algorithms:
      - True -- `t` and `ttt` is equal.
      - False (default) -- `t` and `ttt` is different.



  For example, [Hamming distance](https://en.wikipedia.org/wiki/Hamming_distance):

  ```python
  import textdistance

  textdistance.hamming('test', 'text')


  textdistance.hamming.distance('test', 'text')


  textdistance.hamming.similarity('test', 'text')


  textdistance.hamming.normalized_distance('test', 'text')


  textdistance.hamming.normalized_similarity('test', 'text')


  textdistance.Hamming(qval=2).distance('test', 'text')


  ```

  Any other algorithms have same interface.



  A few articles with examples how to use textdistance in the real world:

  - [Guide to Fuzzy Matching with Python](http://theautomatic.net/2019/11/13/guide-to-fuzzy-matching-with-python/)
  - [String similarity — the basic know your algorithms guide!](https://itnext.io/string-similarity-the-basic-know-your-algorithms-guide-3de3d7346227)
  - [Normalized compression distance](https://articles.life4web.ru/other/ncd/)



  For main algorithms textdistance try to call known external libraries (fastest first) if available (installed in your system) and possible (this implementation can compare this type of sequences). [Install](#installation) textdistance with extras for this feature.

  You can disable this by passing `external=False` argument on init:

  ```python3
  import textdistance
  hamming = textdistance.Hamming(external=False)
  hamming('text', 'testit')

  ```

  Supported libraries:

  1. [abydos](https://github.com/chrislit/abydos)
  1. [Distance](https://github.com/doukremt/distance)
  1. [jellyfish](https://github.com/jamesturk/jellyfish)
  1. [py_stringmatching](https://github.com/anhaidgroup/py_stringmatching)
  1. [pylev](https://github.com/toastdriven/pylev)
  1. [python-Levenshtein](https://github.com/ztane/python-Levenshtein)
  1. [pyxDamerauLevenshtein](https://github.com/gfairchild/pyxDamerauLevenshtein)

  Algorithms:

  1. DamerauLevenshtein
  1. Hamming
  1. Jaro
  1. JaroWinkler
  1. Levenshtein



  Without extras installation:

  | algorithm          | library               |    time |
  |--------------------|-----------------------|---------|
  | DamerauLevenshtein | rapidfuzz             | 0.00312 |
  | DamerauLevenshtein | jellyfish             | 0.00591 |
  | DamerauLevenshtein | pyxdameraulevenshtein | 0.03335 |
  | DamerauLevenshtein | abydos                | 0.63278 |
  | DamerauLevenshtein | **textdistance**      | 0.83524 |
  | Hamming            | Levenshtein           | 0.00038 |
  | Hamming            | rapidfuzz             | 0.00044 |
  | Hamming            | jellyfish             | 0.00091 |
  | Hamming            | distance              | 0.00812 |
  | Hamming            | abydos                | 0.00902 |
  | Hamming            | **textdistance**      | 0.03531 |
  | Jaro               | rapidfuzz             | 0.00092 |
  | Jaro               | jellyfish             | 0.00191 |
  | Jaro               | **textdistance**      | 0.07365 |
  | JaroWinkler        | rapidfuzz             | 0.00094 |
  | JaroWinkler        | jellyfish             | 0.00195 |
  | JaroWinkler        | **textdistance**      | 0.07501 |
  | Levenshtein        | rapidfuzz             | 0.00099 |
  | Levenshtein        | Levenshtein           | 0.00122 |
  | Levenshtein        | jellyfish             | 0.00254 |
  | Levenshtein        | pylev                 | 0.15688 |
  | Levenshtein        | distance              | 0.28669 |
  | Levenshtein        | **textdistance**      | 0.53902 |
  | Levenshtein        | abydos                | 1.25783 |

  Total: 24 libs.

  Yeah, so slow. Use TextDistance on production only with extras.

  Textdistance use benchmark's results for algorithm's optimization and try to call fastest external lib first (if possible).

  You can run benchmark manually on your system:

  ```bash
  pip install textdistance[benchmark]
  python3 -m textdistance.benchmark
  ```

  TextDistance show benchmarks results table for your system and save libraries priorities into `libraries.json` file in TextDistance's folder. This file will be used by textdistance for calling fastest algorithm implementation. Default [libraries.json](textdistance/libraries.json) already included in package.



  All you need is [task](https://taskfile.dev/). See [Taskfile.yml](./Taskfile.yml) for the list of available commands. For example, to run tests including third-party libraries usage, execute `task pytest-external:run`.



  PRs are welcome!

  - Found a bug? Fix it!
  - Want to add more algorithms? Sure! Just make it with the same interface as other algorithms in the lib and add some tests.
  - Can make something faster? Great! Just avoid external dependencies and remember that everything should work not only with strings.
  - Something else that do you think is good? Do it! Just make sure that CI passes and everything from the README is still applicable (interface, features, and so on).
  - Have no time to code? Tell your friends and subscribers about `textdistance`. More users, more contributions, more amazing features.

  Thank you :heart:


pkgId: 67fb2da12949c3b63998735b86047a75d8f23fa352b5d5e569907ff35da3ce7d
name: python-textfsm
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: Python module for parsing semi-structured text into python tables.
url: https://github.com/google/textfsm
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ec050111-4687-4882-b88e-88537aafad64
location_href: 00005291-python-textfsm/python-textfsm-1.1.3-1.src.rpm
checksum_type: sha256
description:
  Python module which implements a template based state machine for parsing
  semi-formatted text. Originally developed to allow programmatic access to
  information returned from the command line interface (CLI) of networking
  devices.
  The engine takes two inputs - a template file, and text input (such as command
  responses from the CLI of a device) and returns a list of records that contains
  the data parsed from the text.
  A template file is needed for each uniquely structured text input. Some examples
  are provided with the code and users are encouraged to develop their own.
  By developing a pool of template files, scripts can call TextFSM to parse useful
  information from a variety of sources. It is also possible to use different
  templates on the same data in order to create different tables (or views).
  TextFSM was developed internally at Google and released under the Apache 2.0
  licence for the benefit of the wider community.
  [**See documentation for more details.**](https://github.com/google/textfsm/wiki/TextFSM)


pkgId: 2ce471312acb2088673f87c1ac7680ceead97be94995773f67c23e9f8cb5699d
name: python-textparser
arch: src
version: 0.24.0
epoch: 0
release: 1
summary: Text parser.
url: https://github.com/eerimoq/textparser
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-919c6315-c54e-4fb6-97ff-2f5264207db8
location_href: 00005293-python-textparser/python-textparser-0.24.0-1.src.rpm
checksum_type: sha256
description:
  A text parser written in the Python language.
  The project has one goal, speed! See the benchmark below more details.
  Project homepage: https://github.com/eerimoq/textparser
  Documentation: http://textparser.readthedocs.org/en/latest


pkgId: b1b1d67b9ee6e66537fe946fda99d6ab79fdf19668db981273c7c0948ff9bf30
name: python-textstat
arch: src
version: 0.7.3
epoch: 0
release: 1
summary: Calculate statistical features from text
url: https://github.com/shivam5992/textstat
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d7465641-bd22-44de-8349-697ec81d2ec6
location_href: 00012883-python-textstat/python-textstat-0.7.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/textstat.svg)](https://pypi.org/project/textstat/)
  [![Build Status](https://github.com/shivam5992/textstat/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/shivam5992/textstat/actions/workflows/test.yml)
  [![Downloads](https://img.shields.io/badge/dynamic/json.svg?url=https://pypistats.org/api/packages/textstat/recent?mirrors=false&label=downloads&query=$.data.last_month&suffix=/month)](https://pypistats.org/packages/textstat)

  **Textstat is an easy to use library to calculate statistics from text. It helps determine readability, complexity, and grade level.**

  <p align="center">
    <img width="100%" src="https://images.unsplash.com/photo-1457369804613-52c61a468e7d?ixlib=rb-1.2.1&auto=format&fit=crop&w=1350&h=400&q=80">
  </p>
  <p align="right">
    <sup>Photo by <a href="https://unsplash.com/@impatrickt">Patrick Tomasso</a>
    on <a href="https://unsplash.com/images/things/book">Unsplash</a></sup>
  </p>



  ```python
  >>> import textstat

  >>> test_data = (
      "Playing games has always been thought to be important to "
      "the development of well-balanced and creative children; "
      "however, what part, if any, they should play in the lives "
      "of adults has never been researched that deeply. I believe "
      "that playing games is every bit as important for adults "
      "as for children. Not only is taking time out to play games "
      "with our children and other adults valuable to building "
      "interpersonal relationships but is also a wonderful way "
      "to release built up tension."
  )

  >>> textstat.flesch_reading_ease(test_data)
  >>> textstat.flesch_kincaid_grade(test_data)
  >>> textstat.smog_index(test_data)
  >>> textstat.coleman_liau_index(test_data)
  >>> textstat.automated_readability_index(test_data)
  >>> textstat.dale_chall_readability_score(test_data)
  >>> textstat.difficult_words(test_data)
  >>> textstat.linsear_write_formula(test_data)
  >>> textstat.gunning_fog(test_data)
  >>> textstat.text_standard(test_data)
  >>> textstat.fernandez_huerta(test_data)
  >>> textstat.szigriszt_pazos(test_data)
  >>> textstat.gutierrez_polini(test_data)
  >>> textstat.crawford(test_data)
  >>> textstat.gulpease_index(test_data)
  >>> textstat.osman(test_data)
  ```

  The argument (text) for all the defined functions remains the same -
  i.e the text for which statistics need to be calculated.



  You can install textstat either via the Python Package Index (PyPI) or from source.



  ```shell
  pip install textstat
  ```



  ```shell
  easy_install textstat
  ```



  ```shell
  git clone https://github.com/shivam5992/textstat.git
  cd textstat
  pip install .
  ```



  Download the latest version of textstat from http://pypi.python.org/pypi/textstat/

  You can install it by doing the following:

  ```shell
  tar xfz textstat-*.tar.gz
  cd textstat-*/
  python setup.py build
  python setup.py install # as root
  ```


  By default functions implement algorithms for english language.
  To change language, use:

  ```python
  textstat.set_lang(lang)
  ```

  The language will be used for syllable calculation and to choose
  variant of the formula.


  All functions implement `en_US` language. Some of them has also variants
  for other languages listed below.

  |  Function                   | en | de | es | fr | it | nl | pl | ru |
  |-----------------------------|----|----|----|----|----|----|----|----|
  | flesch_reading_ease         | ✔  | ✔  | ✔  | ✔  | ✔  | ✔  |    | ✔  |
  | gunning_fog                 | ✔  |    |    |    |    |    | ✔  |    |


  The following functions are specifically designed for spanish language.
  They can be used on non-spanish texts, even though that use case is not recommended.

  ```python
  >>> textstat.fernandez_huerta(test_data)
  >>> textstat.szigriszt_pazos(test_data)
  >>> textstat.gutierrez_polini(test_data)
  >>> textstat.crawford(test_data)
  ```

  Additional information on the formula they implement can be found in their respective docstrings.







  ```python
  textstat.flesch_reading_ease(text)
  ```

  Returns the Flesch Reading Ease Score.

  The following table can be helpful to assess the ease of
  readability in a document.

  The table is an _example_ of values. While the
  maximum score is 121.22, there is no limit on how low
  the score can be. A negative score is valid.

  | Score |    Difficulty     |
  |-------|-------------------|
  |90-100 | Very Easy         |
  | 80-89 | Easy              |
  | 70-79 | Fairly Easy       |
  | 60-69 | Standard          |
  | 50-59 | Fairly Difficult  |
  | 30-49 | Difficult         |
  | 0-29  | Very Confusing    |

  > Further reading on
  [Wikipedia](https://en.wikipedia.org/wiki/Flesch%E2%80%93Kincaid_readability_tests#Flesch_reading_ease)



  ```python
  textstat.flesch_kincaid_grade(text)
  ```

  Returns the Flesch-Kincaid Grade of the given text. This is a grade
  formula in that a score of 9.3 means that a ninth grader would be able to
  read the document.

  > Further reading on
  [Wikipedia](https://en.wikipedia.org/wiki/Flesch%E2%80%93Kincaid_readability_tests#Flesch%E2%80%93Kincaid_grade_level)



  ```python
  textstat.gunning_fog(text)
  ```

  Returns the FOG index of the given text. This is a grade formula in that
  a score of 9.3 means that a ninth grader would be able to read the document.

  > Further reading on
  [Wikipedia](https://en.wikipedia.org/wiki/Gunning_fog_index)



  ```python
  textstat.smog_index(text)
  ```

  Returns the SMOG index of the given text. This is a grade formula in that
  a score of 9.3 means that a ninth grader would be able to read the document.

  Texts of fewer than 30 sentences are statistically invalid, because
  the SMOG formula was normed on 30-sentence samples. textstat requires at
  least 3 sentences for a result.

  > Further reading on
  [Wikipedia](https://en.wikipedia.org/wiki/SMOG)



  ```python
  textstat.automated_readability_index(text)
  ```

  Returns the ARI (Automated Readability Index) which outputs
  a number that approximates the grade level needed to
  comprehend the text.

  For example if the ARI is 6.5, then the grade level to comprehend
  the text is 6th to 7th grade.

  > Further reading on
  [Wikipedia](https://en.wikipedia.org/wiki/Automated_readability_index)



  ```python
  textstat.coleman_liau_index(text)
  ```

  Returns the grade level of the text using the Coleman-Liau Formula. This is
  a grade formula in that a score of 9.3 means that a ninth grader would be
  able to read the document.

  > Further reading on
  [Wikipedia](https://en.wikipedia.org/wiki/Coleman%E2%80%93Liau_index)



  ```python
  textstat.linsear_write_formula(text)
  ```

  Returns the grade level using the Linsear Write Formula. This is
  a grade formula in that a score of 9.3 means that a ninth grader would be
  able to read the document.

  > Further reading on
  [Wikipedia](https://en.wikipedia.org/wiki/Linsear_Write)



  ```python
  textstat.dale_chall_readability_score(text)
  ```

  Different from other tests, since it uses a lookup table
  of the most commonly used 3000 English words. Thus it returns
  the grade level using the New Dale-Chall Formula.

  | Score       |  Understood by                                |
  |-------------|-----------------------------------------------|
  |4.9 or lower | average 4th-grade student or lower            |
  |  5.0–5.9    | average 5th or 6th-grade student              |
  |  6.0–6.9    | average 7th or 8th-grade student              |
  |  7.0–7.9    | average 9th or 10th-grade student             |
  |  8.0–8.9    | average 11th or 12th-grade student            |
  |  9.0–9.9    | average 13th to 15th-grade (college) student  |

  > Further reading on
  [Wikipedia](https://en.wikipedia.org/wiki/Dale%E2%80%93Chall_readability_formula)



  ```python
  textstat.text_standard(text, float_output=False)
  ```

  Based upon all the above tests, returns the estimated school
  grade level required to understand the text.

  Optional `float_output` allows the score to be returned as a
  `float`. Defaults to `False`.



  ```python
  textstat.spache_readability(text)
  ```

  Returns grade level of english text.

  Intended for text written for children up to grade four.

  > Further reading on
  [Wikipedia](https://en.wikipedia.org/wiki/Spache_readability_formula)



  ```python
  textstat.mcalpine_eflaw(text)
  ```

  Returns a score for the readability of an english text for a foreign learner or
  English, focusing on the number of miniwords and length of sentences.

  It is recommended to aim for a score equal to or lower than 25.

  > Further reading on
  [This blog post](https://strainindex.wordpress.com/2009/04/30/mcalpine-eflaw-readability-score/)



  ```python
  textstat.reading_time(text, ms_per_char=14.69)
  ```

  Returns the reading time of the given text.

  Assumes 14.69ms per character.

  > Further reading in
  [This academic paper](https://homepages.inf.ed.ac.uk/keller/papers/cognition08a.pdf)




  ```python
  textstat.fernandez_huerta(text)
  ```

  Reformulation of the Flesch Reading Ease Formula specifically for spanish.
  The results can be interpreted similarly

  > Further reading on
  [This blog post](https://legible.es/blog/lecturabilidad-fernandez-huerta/)



  ```python
  textstat.szigriszt_pazos(text)
  ```
  Adaptation of Flesch Reading Ease formula for spanish-based texts.

  Attempts to quantify how understandable a text is.

  > Further reading on
  [This blog post](https://legible.es/blog/perspicuidad-szigriszt-pazos/)



  ```python
  textstat.gutierrez_polini(text)
  ```

  Returns the Guttiérrez de Polini understandability index.

  Specifically designed for the texts in spanish, not an adaptation.
  Conceived for grade-school level texts.

  Scores for more complex text are not reliable.

  > Further reading on
  [This blog post](https://legible.es/blog/comprensibilidad-gutierrez-de-polini/)



  ```python
  textstat.crawford(text)
  ```

  Returns the Crawford score for the text.

  Returns an estimate of the years of schooling required to understand the text.

  The text is only valid for elementary school level texts.

  > Further reading on
  [This blog post](https://legible.es/blog/formula-de-crawford/)



  ```python
  textstat.osman(text)
  ```

  Returns OSMAN score for text.

  Designed for Arabic, an adaption of Flesch and Fog Formula.
  Introduces a new factor called "Faseeh".

  > Further reading in
  [This academic paper](https://www.aclweb.org/anthology/L16-1038.pdf)



  ```python
  textstat.gulpease_index(text)
  ```

  Returns the Gulpease index of Italian text, which translates to
  level of education completed.

  Lower scores require higher level of education to read with ease.

  > Further reading on
  [Wikipedia](https://it.wikipedia.org/wiki/Indice_Gulpease)



  ```python
  textstat.wiener_sachtextformel(text, variant)
  ```

  Returns a grade level score for the given text.

  A value of 4 means very easy text, whereas 15 means very difficult text.

  > Further reading on
  [Wikipedia](https://de.wikipedia.org/wiki/Lesbarkeitsindex#Wiener_Sachtextformel)





  ```python
  textstat.syllable_count(text)
  ```

  Returns the number of syllables present in the given text.

  Uses the Python module [Pyphen](https://github.com/Kozea/Pyphen)
  for syllable calculation.



  ```python
  textstat.lexicon_count(text, removepunct=True)
  ```

  Calculates the number of words present in the text.
  Optional `removepunct` specifies whether we need to take
  punctuation symbols into account while counting lexicons.
  Default value is `True`, which removes the punctuation
  before counting lexicon items.



  ```python
  textstat.sentence_count(text)
  ```

  Returns the number of sentences present in the given text.



  ```python
  textstat.char_count(text, ignore_spaces=True)
  ```

  Returns the number of characters present in the given text.



  ```python
  textstat.letter_count(text, ignore_spaces=True)
  ```

  Returns the number of characters present in the given text without punctuation.



  ```python
  textstat.polysyllabcount(text)
  ```

  Returns the number of words with a syllable count greater than or equal to 3.



  ```python
  textstat.monosyllabcount(text)
  ```

  Returns the number of words with a syllable count equal to one.



  If you find any problems, you should open an
  [issue](https://github.com/shivam5992/textstat/issues).

  If you can fix an issue you've found, or another issue, you should open
  a [pull request](https://github.com/shivam5992/textstat/pulls).

  1. Fork this repository on GitHub to start making your changes to the master
  branch (or branch off of it).
  2. Write a test which shows that the bug was fixed or that the feature works as expected.
  3. Send a pull request!



  > It is recommended you use a [virtual environment](
  https://docs.python.org/3/tutorial/venv.html), or [Pipenv](
  https://docs.pipenv.org/) to keep your development work isolated from your
  systems Python installation.

  ```bash
  $ git clone https://github.com/<yourname>/textstat.git  # Clone the repo from your fork
  $ cd textstat
  $ pip install -r requirements.txt  # Install all dependencies

  $ # Make changes

  $ python -m pytest test.py  # Run tests
  ```


