# packages

pkgId: cb84653f3c52407c46651dec9febcf2519df3c6e8c041d2862c750cb08642754
name: python-colcon-defaults
arch: src
version: 0.2.8
epoch: 0
release: 1
summary: Extension for colcon to read defaults from a config file.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fbf9f5e0-94fd-42b7-8f5e-42abe8430cbe
location_href: 00003275-python-colcon-defaults/python-colcon-defaults-0.2.8-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to provide custom default values for the command line arguments from a configuration file.
  For more information about the format of the configuration file see `colcon.readthedocs.io <http://colcon.readthedocs.io/en/released/user/configuration.html#defaults-yaml>`_.


pkgId: d0c2ed3c7d24dd7ffabc54f4c5819ed050f1ca722a3aa696f0ab6734a624ce68
name: python-colcon-devtools
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: Extension for colcon to provide information about all extension points and extensions
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f1728024-49d9-42c3-89e9-090115879045
location_href: 00003276-python-colcon-devtools/python-colcon-devtools-0.2.3-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to provide information about the plugin system.


pkgId: 3d08c8a8f2171f21406e64428a46dfd4a7d0910fdce687c11da7651a5cc30a9c
name: python-colcon-ed
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Extension for colcon to edit file in directories.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-127df619-bba6-47bd-807d-04d3d9969cfb
location_href: 00003277-python-colcon-ed/python-colcon-ed-0.2.2-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to edit a file within a package.
  See the `documentation <https://colcon.readthedocs.io/en/released/reference/verb/edit.html>`_ on how to use it.


pkgId: 502dc8e47a2c7376016cf511d06bbaf235083e06982514c45b955e9917286f80
name: python-colcon-lcov-result
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Extension for colcon to gather test results.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d96c3224-4065-4c59-85b1-450f3f03b9aa
location_href: 00003278-python-colcon-lcov-result/python-colcon-lcov-result-0.5.0-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to provide aggregate
  coverage results using `LCOV <http://ltp.sourceforge.net/coverage/lcov.php>`_.
  LCOV is a graphical front-end for GCC's coverage testing tool
  `gcov <https://gcc.gnu.org/onlinedocs/gcc/Gcov.html>`_, producing the following
  coverage metrics:
  - Statement coverage
  - Function coverage
  - Branch coverage
  For more information, see `this paper
  <http://ltp.sourceforge.net/documentation/technical_papers/gcov-ols2003.pdf>`_
  and `this Wikipedia page <https://en.wikipedia.org/wiki/Code_coverage>`_.


pkgId: 67add8d544340d8b9f2bf22b0f1eb0c5bdda84cccabb685d7a805b0661139f7e
name: python-colcon-library-path
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Extension for colcon adding an environment variable to find libraries.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b53e4d5e-fcec-4ae6-ad19-d1b3e990dd80
location_href: 00003279-python-colcon-library-path/python-colcon-library-path-0.2.1-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to set an environment variable to find shared libraries at runtime.


pkgId: 0a3c45b7d4d5110080e524886b9c35576466e6cccee4a80e126439b705398a3e
name: python-colcon-metadata
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: Extension for colcon to read package metadata from files.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-de269988-d84d-4517-aa8a-6659d205b023
location_href: 00003280-python-colcon-metadata/python-colcon-metadata-0.2.5-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to fetch and manage package metadata from repositories.
  For an example repository containing metadata see `colcon-metadata-repository <https://github.com/colcon/colcon-metadata-repository>`_.


pkgId: 74bc98b41933bc10ed16898b24fdfab7c515b2933aee0123f99876779feee5b6
name: python-colcon-mixin
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: Extension for colcon to read CLI mixins from files.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3734c872-24ef-44f0-b5b8-d98db7c85868
location_href: 00003281-python-colcon-mixin/python-colcon-mixin-0.2.3-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to fetch and manage CLI mixins from repositories.
  For an example repository containing mixins see `colcon-mixin-repository <https://github.com/colcon/colcon-mixin-repository>`_.


pkgId: 4995a22202309b5e60fc92e17b059b86627b6700ea67722401210a865a889bc6
name: python-colcon-notification
arch: src
version: 0.2.15
epoch: 0
release: 1
summary: Extension for colcon to provide status notifications.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-28b9e99b-0f3d-45b8-a6cf-cfd14bcbd8e7
location_href: 00003282-python-colcon-notification/python-colcon-notification-0.2.15-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to provide status notifications.


pkgId: 7506470636cc71fea65c200f60730ec1ed601847f7f96a54be57c6930dfa45f5
name: python-colcon-output
arch: src
version: 0.2.13
epoch: 0
release: 1
summary: Extension for colcon to customize the output in various ways.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a7390fb8-3bfc-411a-b14c-1d7967985e26
location_href: 00003283-python-colcon-output/python-colcon-output-0.2.13-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to customize the output in various ways.


pkgId: a17c1bdc3442dabddf07d7183eb5833ab09986cf305ebed016f586fa50a4816d
name: python-colcon-package-information
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: Extension for colcon to output package information.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6d86e272-ce37-4cb8-83f7-5626fd1a12a5
location_href: 00003284-python-colcon-package-information/python-colcon-package-information-0.3.3-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to provide information about the packages.


pkgId: 137bc8c4029379732d32538c3ded17318675e5fb9ceda63cac3899449456b0d3
name: python-colcon-package-information-help
arch: noarch
version: 0.3.3
epoch: 0
release: 1
summary: Development documents and examples for colcon-package-information
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6d86e272-ce37-4cb8-83f7-5626fd1a12a5
rpm_sourcerpm: python-colcon-package-information-0.3.3-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to provide information about the packages.

location_href:
  00003284-python-colcon-package-information/python-colcon-package-information-help-0.3.3-1.noarch.rpm


pkgId: 108a0432f990b7bea08b224d5aa41faf61c1ec95ac17b2d2ff42b813264ac71f
name: python-colcon-package-information-help
arch: noarch
version: 0.3.3
epoch: 0
release: 1
summary: Development documents and examples for colcon-package-information
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-345da78e-b6fa-466b-9c22-b0f548ada4f6
rpm_sourcerpm: python-colcon-package-information-0.3.3-1.src.rpm
checksum_type: sha256
description:
[cell repeats an earlier one in this file: 114 characters]

location_href:
  00006648-python-colcon-package-information/python-colcon-package-information-help-0.3.3-1.noarch.rpm


pkgId: 2848034fdfc7f82513728f9b87b28e793177d834f1407fae027f0143841aea1d
name: python-colcon-package-selection
arch: src
version: 0.2.10
epoch: 0
release: 1
summary: Extension for colcon to select the packages to process.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-74631edf-bffa-48eb-81bd-33d828c38e3a
location_href: 00003285-python-colcon-package-selection/python-colcon-package-selection-0.2.10-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to select a subset of packages for processing.


pkgId: 8de6504f32a3c0752115260f7935995d21f43b95264fbde5beaf6c14e82a5559
name: python-colcon-parallel-executor
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: Extension for colcon to process packages in parallel.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6056885c-7bb6-40e2-986b-628654eccef9
location_href: 00003286-python-colcon-parallel-executor/python-colcon-parallel-executor-0.2.4-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to process packages in parallel.


pkgId: e69ccde837a17009117d6fa814892acd42b0c474f56185dd5d87835b4c4739f9
name: python-colcon-pkg-config
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Extension for colcon adding an environment variable to find pkg-config files.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3c22012b-8b5e-40b9-b28f-702bdb2b1c70
location_href: 00003287-python-colcon-pkg-config/python-colcon-pkg-config-0.1.0-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to set an environment variable to find pkg-config files.


pkgId: 2f560c36333ccacae06ffbe568226a289a7318fad4b1fe8860e29b6e196cc591
name: python-colcon-powershell
arch: src
version: 0.3.7
epoch: 0
release: 1
summary: Extension for colcon to provide PowerShell scripts.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-785b6504-34ab-48f1-97d2-48148ec7f9a2
location_href: 00003288-python-colcon-powershell/python-colcon-powershell-0.3.7-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to provide `PowerShell <https://github.com/PowerShell/PowerShell>`_ scripts.


pkgId: 1e7a1741a759d440bf3906137750662ee43daa6b9f75d17bc1dc0b8b9f4292ce
name: python-colcon-python-setup-py
arch: src
version: 0.2.8
epoch: 0
release: 1
summary: Extension for colcon to support Python packages with the metadata in the setup.py file.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f7b6a299-e6a7-4616-bdd6-30659ebc51e8
location_href: 00003289-python-colcon-python-setup-py/python-colcon-python-setup-py-0.2.8-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to identify packages with a ``setup.py`` file by introspecting the arguments to the ``setup()`` function call of  `setuptools <https://setuptools.readthedocs.io/en/latest/>`_.


pkgId: a5fbf985dc892406d88c4a9f60bab7326d9c8c0eab5ec61498cc96ae85420985
name: python-colcon-recursive-crawl
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Extension for colcon to recursively crawl for packages.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-18c025c4-af9a-409d-bb4d-3514d9a5b54c
location_href: 00003290-python-colcon-recursive-crawl/python-colcon-recursive-crawl-0.2.1-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to recursively crawl for packages.


pkgId: f611c4a02598c9c6b6b08dfd5eb1cc4e30f157fc245ef31608bd1e4f8f04d0f7
name: python-colcon-ros
arch: src
version: 0.3.23
epoch: 0
release: 1
summary: Extension for colcon to support ROS packages.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bf7346c7-0708-4f45-9fcc-af26bb06de50
location_href: 00003291-python-colcon-ros/python-colcon-ros-0.3.23-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to support `ROS packages <http://www.ros.org>`_.


pkgId: 0da2c5f2a85884296d205c40c98fda8d7d680e3a507f7f3b4e156e59d59e70b3
name: python-colcon-ros-bazel
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: Extension for colcon to support ROS2 Bazel packages.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-501c62e1-9a47-4d80-970c-06c3893a43ad
location_href: 00003292-python-colcon-ros-bazel/python-colcon-ros-bazel-0.0.1-1.src.rpm
checksum_type: sha256
description:
  [![Travis CI](https://travis-ci.org/colcon/colcon-ros-bazel.svg?branch=master)](https://travis-ci.org/colcon/colcon-ros-bazel)
  [![AppVeyor](https://ci.appveyor.com/api/projects/status/github/colcon/colcon-ros-bazel?svg=true&branch=master)](https://ci.appveyor.com/project/Theosakamg/colcon-ros-bazel)
  [![codecov](https://codecov.io/gh/colcon/colcon-ros-bazel/branch/master/graph/badge.svg)](https://codecov.io/gh/colcon/colcon-ros-bazel)
  [![PyPI version](https://img.shields.io/pypi/v/colcon_ros_bazel.svg)](https://pypi.python.org/pypi/colcon_ros_bazel/)
  An extension for [colcon-core](https://github.com/colcon/colcon-core) to support ROS2 Bazel projects.


pkgId: 5cfa1a43b932d3bdebffff9b29ab4a5e60bbf50102adff7c665fe3cc9256c48d
name: python-colcon-test-result
arch: src
version: 0.3.8
epoch: 0
release: 1
summary: Extension for colcon to provide information about the test results.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9e8cfb35-83a9-49f0-97e8-2f1e0d7ba04d
location_href: 00003295-python-colcon-test-result/python-colcon-test-result-0.3.8-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to provide information about the test results.


pkgId: 6c25ee52e08f7980652ece9d5c993ed7fc25f70a908cb5a0f73f0a83135e023f
name: python-colcon-zsh
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Extension for colcon to provide Z shell scripts.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f55c6b6f-1a11-40ca-b190-09fa95daeb01
location_href: 00003296-python-colcon-zsh/python-colcon-zsh-0.4.0-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to provide `Z shell <http://www.zsh.org>`_ scripts.


pkgId: 1b1e7f53e644e8077b4401bfb4e748ed66288dc1d3c6f9bbf842a02078e8c141
name: python-colin
arch: src
version: 0.5.3
epoch: 0
release: 1
summary: Tool to check generic rules/best-practices for containers/images/dockerfiles.
url: https://github.com/user-cont/colin
rpm_license: GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c12d3604-8595-4b75-b7c2-b62a614bcac5
location_href: 00003297-python-colin/python-colin-0.5.3-1.src.rpm
checksum_type: sha256
description:
  ![PyPI](https://img.shields.io/pypi/v/colin.svg)
  ![PyPI - License](https://img.shields.io/pypi/l/colin.svg)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/colin.svg)
  ![PyPI - Status](https://img.shields.io/pypi/status/colin.svg)
  [![Codacy Badge](https://api.codacy.com/project/badge/Grade/427eb0c5dfc040cea798b23575dba025)](https://www.codacy.com/app/user-cont/colin?utm_source=github.com&utm_medium=referral&utm_content=user-cont/colin&utm_campaign=Badge_Grade)
  [![Build Status](https://ci.centos.org/job/user-cont-colin-master/badge/icon)](https://ci.centos.org/job/user-cont-colin-master/)

  Tool to check generic rules and best-practices for container images and dockerfiles.

  For more information, please check our [documentation on colin.readthedocs.io](https://colin.readthedocs.io/en/latest/).

  ![example](./docs/example.gif)



  - Validate a selected artifact against a ruleset.
  - Artifacts can be container images and dockerfiles.
  - We provide a default ruleset we believe every container image should satisfy.
  - There is a ruleset to validate an artifact whether it complies to [Fedora Container Guidelines](https://fedoraproject.org/wiki/Container:Guidelines)
  - Colin can list available rulesets and list checks in a ruleset.
  - There is a python API available
  - Colin can be integrated into your workflow easily - it can provide results in json format.





  If you are on Fedora distribution, please install python3-pyxattr so you don't
  have to compile it yourself when getting it from PyPI.

  ```bash
  $ pip3 install --user colin
  ```

  `colin` is supported on python 3.6+ only.



  colin is packaged in official Fedora repositories:

  ```
  $ dnf install -y colin
  ```



  - For checking `image` target-type, you have to install [podman](https://github.com/containers/libpod/blob/master/docs/tutorials/podman_tutorial.md). If you need to check local docker images, you need to prefix your images with `docker-daemon` (e.g. `colin check docker-daemon:docker.io/openshift/origin-web-console:v3.11`).

  - If you want to use `oci` target, you need to install following tools:
    - [umoci](https://github.com/opencontainers/umoci#install)
    - [skopeo](https://github.com/containers/skopeo#skopeo-)



  ```
  $ colin --help
  Usage: colin [OPTIONS] COMMAND [ARGS]...

    COLIN -- Container Linter

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

  Commands:
    check          Check the image/dockerfile (default).
    info           Show info about colin and its dependencies.
    list-checks    Print the checks.
    list-rulesets  List available rulesets.
  ```

  ```
  $ colin check --help
  Usage: colin check [OPTIONS] TARGET

    Check the image/dockerfile (default).

  Options:
    -r, --ruleset TEXT           Select a predefined ruleset (e.g. fedora).
    -f, --ruleset-file FILENAME  Path to a file to use for validation (by
                                 default they are placed in
                                 /usr/share/colin/rulesets).
    --debug                      Enable debugging mode (debugging logs, full
                                 tracebacks).
    --json FILENAME              File to save the output as json to.
    --stat                       Print statistics instead of full results.
    -s, --skip TEXT              Name of the check to skip. (this option is
                                 repeatable)
    -t, --tag TEXT               Filter checks with the tag.
    -v, --verbose                Verbose mode.
    --checks-path DIRECTORY      Path to directory containing checks (default
                                 ['/home/flachman/.local/lib/python3.7/site-
                                 packages/colin/checks']).
    --pull                       Pull the image from registry.
    --target-type TEXT           Type of selected target (one of image,
                                 dockerfile, oci). For oci, please specify
                                 image name and path like this: oci:path:image
    --timeout INTEGER            Timeout for each check in seconds.
                                 (default=600)
    --insecure                   Pull from an insecure registry (HTTP or invalid
                                 TLS).
    -h, --help                   Show this message and exit.
  ```

  Let's give it a shot:

  ```
  $ colin -f ./rulesets/fedora.json registry.fedoraproject.org/f29/cockpit
  PASS:Label 'architecture' has to be specified.
  PASS:Label 'build-date' has to be specified.
  FAIL:Label 'description' has to be specified.
  PASS:Label 'distribution-scope' has to be specified.
  :
  :
  PASS:10 FAIL:8
  ```



  It's possible to use colin directly from git:

  ```
  $ git clone https://github.com/user-cont/colin.git
  $ cd colin
  ```

  We can now run the analysis:

  ```
  $ python3 -m colin.cli.colin -f ./rulesets/fedora.json registry.fedoraproject.org/f29/cockpit
  PASS:Label 'architecture' has to be specified.
  PASS:Label 'build-date' has to be specified.
  FAIL:Label 'description' has to be specified.
  PASS:Label 'distribution-scope' has to be specified.
  :
  :
  PASS:10 FAIL:8
  ```



  Colin can exit with several codes:

  - `0` --> OK
  - `1` --> error in the execution
  - `2` --> CLI error, wrong parameters
  - `3` --> at least one check failed


pkgId: 550e0deb6a838892319deb8e0e9f18e6118136b345f217431f5f49e482a6d464
name: python-collections-extended
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: Extra Python Collections - bags (multisets) and setlists (ordered sets)
url: https://github.com/mlenzen/collections-extended
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3ff39d12-1696-4ba5-80eb-5fdd63a974bd
location_href: 00009462-python-collections-extended/python-collections-extended-2.0.2-1.src.rpm
checksum_type: sha256
description:
  ``collections_extended`` is a pure Python module with no dependencies providing:
  - a ``bag`` class, AKA **multiset**,
  - a ``setlist`` class, which is a **unique list** or **ordered set**,
  - a ``bijection`` class, ``RangeMap`` which is a mapping from ranges to values and
  - a ``IndexedDict`` class, which is an ordered mapping whose elements can be accessed using index, in addition to key.
  There are also frozen (hashable) varieties of bags and setlists.
  Compatible with and tested against Python 3.6, 3.7, 3.8, 3.9, 3.10 & PyPy3.


pkgId: 1dbb9bffdb01a2a28a30966c6ce78e89c9b6e8be622d81ff6ac344b79f72a1c4
name: python-colored
arch: src
version: 1.4.4
epoch: 0
release: 1
summary: Simple library for color and formatting to terminal
url: https://gitlab.com/dslackw/colored
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-121f36db-0d69-4255-9b5e-ffe5799abdc8
location_href: 00010943-python-colored/python-colored-1.4.4-1.src.rpm
checksum_type: sha256
description:
  The following colors works with most terminals and terminals emulators.
  ANSI/VT100 escape sequences can be used in every programming languages.
  Attributes:
      +-----+------------------+
      |Code | Description      |
      +-----+------------------+
      |  1  | bold             |
      |  2  | dim              |
      |  4  | underlined       |
      |  5  | blink            |
      |  7  | reverse          |
      |  8  | hidden           |
      |  0  | reset            |
      |  21 | res_bold         |
      |  22 | res_dim          |
      |  24 | res_underlined   |
      |  25 | res_blink        |
      |  27 | res_reverse      |
      |  28 | res_hidden       |
      +------------------------+
  256 Foreground and Background Colors - Full Chart:
      +-----+---------------------+
      |Code | Description         |
      +-----+---------------------+
      | 0   | black               |
      | 1   | red                 |
      | 2   | green               |
      | 3   | yellow              |
      | 4   | blue                |
      | 5   | magenta             |
      | 6   | cyan                |
      | 7   | light_gray          |
      | 8   | dark_gray           |
      | 9   | light_red           |
      | 10  | light_green         |
      | 11  | light_yellow        |
      | 12  | light_blue          |
      | 13  | light_magenta       |
      | 14  | light_cyan          |
      | 15  | white               |
      | 16  | grey_0              |
      | 17  | navy_blue           |
      | 18  | dark_blue           |
      | 19  | blue_3a             |
      | 20  | blue_3b             |
      | 21  | blue_1              |
      | 22  | dark_green          |
      | 23  | deep_sky_blue_4a    |
      | 24  | deep_sky_blue_4b    |
      | 25  | deep_sky_blue_4c    |
      | 26  | dodger_blue_3       |
      | 27  | dodger_blue_2       |
      | 28  | green_4             |
      | 29  | spring_green_4      |
      | 30  | turquoise_4         |
      | 31  | deep_sky_blue_3a    |
      | 32  | deep_sky_blue_3b    |
      | 33  | dodger_blue_1       |
      | 34  | green_3a            |
      | 35  | spring_green_3a     |
      | 36  | dark_cyan           |
      | 37  | light_sea_green     |
      | 38  | deep_sky_blue_2     |
      | 39  | deep_sky_blue_1     |
      | 40  | green_3b            |
      | 41  | spring_green_3b     |
      | 42  | spring_green_2a     |
      | 43  | cyan_3              |
      | 44  | dark_turquoise      |
      | 45  | turquoise_2         |
      | 46  | green_1             |
      | 47  | spring_green_2b     |
      | 48  | spring_green_1      |
      | 49  | medium_spring_green |
      | 50  | cyan_2              |
      | 51  | cyan_1              |
      | 52  | dark_red_1          |
      | 53  | deep_pink_4a        |
      | 54  | purple_4a           |
      | 55  | purple_4b           |
      | 56  | purple_3            |
      | 57  | blue_violet         |
      | 58  | orange_4a           |
      | 59  | grey_37             |
      | 60  | medium_purple_4     |
      | 61  | slate_blue_3a       |
      | 62  | slate_blue_3b       |
      | 63  | royal_blue_1        |
      | 64  | chartreuse_4        |
      | 65  | dark_sea_green_4a   |
      | 66  | pale_turquoise_4    |
      | 67  | steel_blue          |
      | 68  | steel_blue_3        |
      | 69  | cornflower_blue     |
      | 70  | chartreuse_3a       |
      | 71  | dark_sea_green_4b   |
      | 72  | cadet_blue_2        |
      | 73  | cadet_blue_1        |
      | 74  | sky_blue_3          |
      | 75  | steel_blue_1a       |
      | 76  | chartreuse_3b       |
      | 77  | pale_green_3a       |
      | 78  | sea_green_3         |
      | 79  | aquamarine_3        |
      | 80  | medium_turquoise    |
      | 81  | steel_blue_1b       |
      | 82  | chartreuse_2a       |
      | 83  | sea_green_2         |
      | 84  | sea_green_1a        |
      | 85  | sea_green_1b        |
      | 86  | aquamarine_1a       |
      | 87  | dark_slate_gray_2   |
      | 88  | dark_red_2          |
      | 89  | deep_pink_4b        |
      | 90  | dark_magenta_1      |
      | 91  | dark_magenta_2      |
      | 92  | dark_violet_1a      |
      | 93  | purple_1a           |
      | 94  | orange_4b           |
      | 95  | light_pink_4        |
      | 96  | plum_4              |
      | 97  | medium_purple_3a    |
      | 98  | medium_purple_3b    |
      | 99  | slate_blue_1        |
      | 100 | yellow_4a           |
      | 101 | wheat_4             |
      | 102 | grey_53             |
      | 103 | light_slate_grey    |
      | 104 | medium_purple       |
      | 105 | light_slate_blue    |
      | 106 | yellow_4b           |
      | 107 | dark_olive_green_3a |
      | 108 | dark_green_sea      |
      | 109 | light_sky_blue_3a   |
      | 110 | light_sky_blue_3b   |
      | 111 | sky_blue_2          |
      | 112 | chartreuse_2b       |
      | 113 | dark_olive_green_3b |
      | 114 | pale_green_3b       |
      | 115 | dark_sea_green_3a   |
      | 116 | dark_slate_gray_3   |
      | 117 | sky_blue_1          |
      | 118 | chartreuse_1        |
      | 119 | light_green_2       |
      | 120 | light_green_3       |
      | 121 | pale_green_1a       |
      | 122 | aquamarine_1b       |
      | 123 | dark_slate_gray_1   |
      | 124 | red_3a              |
      | 125 | deep_pink_4c        |
      | 126 | medium_violet_red   |
      | 127 | magenta_3a          |
      | 128 | dark_violet_1b      |
      | 129 | purple_1b           |
      | 130 | dark_orange_3a      |
      | 131 | indian_red_1a       |
      | 132 | hot_pink_3a         |
      | 133 | medium_orchid_3     |
      | 134 | medium_orchid       |
      | 135 | medium_purple_2a    |
      | 136 | dark_goldenrod      |
      | 137 | light_salmon_3a     |
      | 138 | rosy_brown          |
      | 139 | grey_63             |
      | 140 | medium_purple_2b    |
      | 141 | medium_purple_1     |
      | 142 | gold_3a             |
      | 143 | dark_khaki          |
      | 144 | navajo_white_3      |
      | 145 | grey_69             |
      | 146 | light_steel_blue_3  |
      | 147 | light_steel_blue    |
      | 148 | yellow_3a           |
      | 149 | dark_olive_green_3  |
      | 150 | dark_sea_green_3b   |
      | 151 | dark_sea_green_2    |
      | 152 | light_cyan_3        |
      | 153 | light_sky_blue_1    |
      | 154 | green_yellow        |
      | 155 | dark_olive_green_2  |
      | 156 | pale_green_1b       |
      | 157 | dark_sea_green_5b   |
      | 158 | dark_sea_green_5a   |
      | 159 | pale_turquoise_1    |
      | 160 | red_3b              |
      | 161 | deep_pink_3a        |
      | 162 | deep_pink_3b        |
      | 163 | magenta_3b          |
      | 164 | magenta_3c          |
      | 165 | magenta_2a          |
      | 166 | dark_orange_3b      |
      | 167 | indian_red_1b       |
      | 168 | hot_pink_3b         |
      | 169 | hot_pink_2          |
      | 170 | orchid              |
      | 171 | medium_orchid_1a    |
      | 172 | orange_3            |
      | 173 | light_salmon_3b     |
      | 174 | light_pink_3        |
      | 175 | pink_3              |
      | 176 | plum_3              |
      | 177 | violet              |
      | 178 | gold_3b             |
      | 179 | light_goldenrod_3   |
      | 180 | tan                 |
      | 181 | misty_rose_3        |
      | 182 | thistle_3           |
      | 183 | plum_2              |
      | 184 | yellow_3b           |
      | 185 | khaki_3             |
      | 186 | light_goldenrod_2a  |
      | 187 | light_yellow_3      |
      | 188 | grey_84             |
      | 189 | light_steel_blue_1  |
      | 190 | yellow_2            |
      | 191 | dark_olive_green_1a |
      | 192 | dark_olive_green_1b |
      | 193 | dark_sea_green_1    |
      | 194 | honeydew_2          |
      | 195 | light_cyan_1        |
      | 196 | red_1               |
      | 197 | deep_pink_2         |
      | 198 | deep_pink_1a        |
      | 199 | deep_pink_1b        |
      | 200 | magenta_2b          |
      | 201 | magenta_1           |
      | 202 | orange_red_1        |
      | 203 | indian_red_1c       |
      | 204 | indian_red_1d       |
      | 205 | hot_pink_1a         |
      | 206 | hot_pink_1b         |
      | 207 | medium_orchid_1b    |
      | 208 | dark_orange         |
      | 209 | salmon_1            |
      | 210 | light_coral         |
      | 211 | pale_violet_red_1   |
      | 212 | orchid_2            |
      | 213 | orchid_1            |
      | 214 | orange_1            |
      | 215 | sandy_brown         |
      | 216 | light_salmon_1      |
      | 217 | light_pink_1        |
      | 218 | pink_1              |
      | 219 | plum_1              |
      | 220 | gold_1              |
      | 221 | light_goldenrod_2b  |
      | 222 | light_goldenrod_2c  |
      | 223 | navajo_white_1      |
      | 224 | misty_rose1         |
      | 225 | thistle_1           |
      | 226 | yellow_1            |
      | 227 | light_goldenrod_1   |
      | 228 | khaki_1             |
      | 229 | wheat_1             |
      | 230 | cornsilk_1          |
      | 231 | grey_100            |
      | 232 | grey_3              |
      | 233 | grey_7              |
      | 234 | grey_11             |
      | 235 | grey_15             |
      | 236 | grey_19             |
      | 237 | grey_23             |
      | 238 | grey_27             |
      | 239 | grey_30             |
      | 240 | grey_35             |
      | 241 | grey_39             |
      | 242 | grey_42             |
      | 243 | grey_46             |
      | 244 | grey_50             |
      | 245 | grey_54             |
      | 246 | grey_58             |
      | 247 | grey_62             |
      | 248 | grey_66             |
      | 249 | grey_70             |
      | 250 | grey_74             |
      | 251 | grey_78             |
      | 252 | grey_82             |
      | 253 | grey_85             |
      | 254 | grey_89             |
      | 255 | grey_93             |
      | 256 | default             |
      +-----+---------------------+
  256 Colors Foreground (text):
  256 Colors Background:


pkgId: 6572412821eec1ba450804eaacabf3acc0448e8dc75f3e764ea97f6905f60b7c
name: python-coloredlogs
arch: src
version: 15.0.1
epoch: 0
release: 1
summary: Colored terminal output for Python's logging module
url: https://coloredlogs.readthedocs.io
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d8f81523-0698-47a9-afbd-bb7fa0312864
location_href: 00003303-python-coloredlogs/python-coloredlogs-15.0.1-1.src.rpm
checksum_type: sha256
description:
  The `coloredlogs` package enables colored terminal output for Python's logging_
  module. The ColoredFormatter_ class inherits from `logging.Formatter`_ and uses
  `ANSI escape sequences`_ to render your logging messages in color. It uses only
  standard colors so it should work on any UNIX terminal. It's currently tested
  on Python 2.7, 3.5+ and PyPy (2 and 3). On Windows `coloredlogs` automatically
  tries to enable native ANSI support (on up-to-date Windows 10 installations)
  and falls back on using colorama_ (if installed). Here is a screen shot of the
  demo that is printed when the command ``coloredlogs --demo`` is executed:
  Note that the screenshot above includes custom logging levels defined by my
  verboselogs_ package: if you install both `coloredlogs` and `verboselogs` it
  will Just Work (`verboselogs` is of course not required to use
  `coloredlogs`).


pkgId: 946e327123758b1e4acd659d57afb8b3822bda3aea39a5c5bbeb88b6612cffc1
name: python-colorful
arch: src
version: 0.5.5
epoch: 0
release: 1
summary: Terminal string styling done right, in Python.
url: http://github.com/timofurrer/colorful
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5fec188d-1b3c-4774-9a9a-c567281dfa6c
location_href: 00003304-python-colorful/python-colorful-0.5.5-1.src.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/timofurrer/colorful/workflows/Continuous%20Integration/badge.svg)](https://github.com/timofurrer/colorful/actions)
  [![codecov.io](https://codecov.io/github/timofurrer/colorful/coverage.svg?branch=master)](https://codecov.io/github/timofurrer/colorful?branch=master)
  [![PyPI version](https://badge.fury.io/py/colorful.svg)](https://badge.fury.io/py/colorful)
  [![PyPI](https://img.shields.io/pypi/pyversions/colorful.svg)](https://pypi.python.org/pypi/colorful)
  [![PyPI](https://img.shields.io/pypi/wheel/colorful.svg)](https://pypi.python.org/pypi/colorful)

  Terminal string styling done right, in Python :tada:



  ![colorful example](examples/basic_example.png)

  ```python
  import colorful as cf


  print(cf.bold_white('Hello World'))

  print('{c.bold}{c.lightCoral_on_white}Hello World{c.reset}'.format(c=cf))


  print(cf.red('red {0} red'.format(cf.white('white'))))
  print(cf.red('red' + cf.white(' white ', nested=True) + 'red'))


  print(cf.bold & cf.red | 'Hello World')


  cf.use_true_colors()


  cf.update_palette({'mint': '#c5e8c8'})
  print(cf.mint_on_snow('Wow, this is actually mint'))


  cf.use_style('solarized')

  print(cf.yellow('yellow'), cf.orange('orange'),
      cf.red('red'), cf.magenta('magenta'),
      cf.violet('violet'), cf.blue('blue'),
      cf.cyan('cyan'), cf.green('green'))


  cf.print('{c.bold_blue}Hello World{c.reset}')


  with cf.with_8_ansi_colors() as c:
      print(c.bold_green('colorful is awesome!'))


  MY_COMPANY_PALETTE = {
      'companyOrange': '#f4b942',
      'companyBaige': '#e8dcc5'
  }
  with cf.with_palette(MY_COMPANY_PALETTE) as c:
      print(c.companyOrange_on_companyBaige('Thanks for choosing our product!'))


  print(f'{cf.bold}Hello World')


  print(cf.red('你好'))
  ```



  * expressive and consistent API ([docs](#style-a-string))
  * support for different color modes (8 ANSI, 256 ANSI, true colors) ([docs](#color-modes))
  * support for predefined awesome styles (solarized, ...) ([docs](#styles))
  * support for custom color palettes ([docs](#color-palette))
  * support nesting styles ([docs](#nesting-styles))
  * support for different platforms (using colorama on Windows)
  * context managers for clean color mode, color palette or style switch ([docs](#temporarily-change-colorful-settings))
  * support `len()` on colored strings ([docs](#correctly-support-the-len-protocol))
  * support color names from [X11 rgb.txt](https://en.wikipedia.org/wiki/X11_color_names) ([docs](#1-style-a-string-with-a-method-call-colorfulmodifiers_fgcolor_on_bgcolorstr-nestedfalse))
  * no dependencies



  **colorful** supports all major Python versions: *3.5*, *3.6* and *3.7*, *3.8*, *3.9*, *3.10*, *3.11*. <br>
  We recommend to use the latest version released on [PyPI](https://pypi.python.org/pypi/colorful):

  ```bash
  pip install colorful
  ```

  **colorful** does not require any special setup in order to be used:

  ```python
  import colorful as cf

  print(cf.italic_coral_on_beige('Hello World'))
  print(cf.italic & cf.coral_on_beige | 'Hello World')
  print('{c.italic_coral_on_beige}Hello World{c.reset}'.format(c=cf))
  ```

  Note: the entire documentation assumes `colorful` to be imported as `cf`.

  See the [Style a string](https://github.com/timofurrer/colorful#style-a-string) section for more information!



  These days terminals not only support the ancient 8 ANSI colors but often they support up to 16 Million colors with *[true color](https://en.wikipedia.org/wiki/Color_depth#True_color_.2824-bit.29)*. And if they don't support *true color* they might support the *[256 ANSI color palette](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors)* at least.

  **colorful** supports the following color modes:

  * no colors / disable (``cf.NO_COLORS``)
  * 8 colors -> 8 ANSI colors (``cf.ANSI_8_COLORS``)
  * 256 colors -> 256 ANSI color palette (8bit ``cf.ANSI_256_COLORS``)
  * 16'777'215 colors -> true color (24bit, ``cf.TRUE_COLORS``)

  By default *colorful* tries to auto detect the best supported color mode by your terminal. Consult [`cf.terminal`](https://github.com/timofurrer/colorful/blob/master/colorful/terminal.py) for more details.

  However, sometimes it makes sense to specify what color mode should be used.<br>
  **colorful** provides multiple ways to do so:



  ```python
  cf.disable()
  cf.use_8_ansi_colors()
  cf.use_256_ansi_colors()
  cf.use_true_colors()
  ```

  If you change the color mode during runtime it takes affect immediately and globally.



  ```bash
  COLORFUL_DISABLE=1 python eggs.py  # this process will not use ANY coloring
  COLORFUL_FORCE_8_COLORS=1 python eggs.py  # this process will use 8 ANSI colors by default
  COLORFUL_FORCE_256_COLORS=1 python eggs.py  # this process will use 256 ANSI colors by default
  COLORFUL_FORCE_TRUE_COLORS=1 python eggs.py  # this process will use true colors by default
  ```



  ```python
  with cf.with_8_ansi_colors() as c:
      print(c.italic_coral_on_beige('Hello world'))

  with cf.with_256_ansi_colors() as c:
      print(c.italic_coral_on_beige('Hello world'))

  with cf.with_true_colors() as c:
      print(c.italic_coral_on_beige('Hello world'))
  ```



  **colorful**'s Python API is based on *color names* like in `cf.bold_white_on_black('Hello')`. During runtime these *color names* are translated into proper [ANSI escape code](https://en.wikipedia.org/wiki/ANSI_escape_code) sequences supported by the *color mode* in use. However, all *color names* are registered in a **color palette** which is basically a mapping between the *color names* and it's corresponding RGB value. Very much like this:

  ```python
  color_palette_example = {
      'black': '#000000',
      'white': '#FFFFFF',
  }
  ```

  *Note: Depending on the color mode which is used the RGB value will be reduced to fit in the value domain of the color mode.*

  The default color palette is the [X11 rgb.txt](https://en.wikipedia.org/wiki/X11_color_names) palette - it's shipped with *colorful*, thus, you don't have to provide your own.
  *colorful* ships with a second built-in [color palette called *colornames*](https://codepen.io/meodai/full/VMpNdQ/).
  Those colors are from the curated list of the [color-names](https://github.com/meodai/color-names) repository.
  You can use those via the `cf.setup()` method, like this:


  ```python
  cf.setup(colorpalette=cf.COLORNAMES_COLORS)
  ```

  If you wish to have another color palette from a file as your default color palette you can set the `COLORFUL_DEFAULT_COLOR_PALETTE` environment variable to this file:

  ```bash
  COLORFUL_DEFAULT_COLOR_PALETTE=/usr/share/X11/rgb.txt python spam.py
  ```

  The file either has to be a txt file like the X11 rgb.txt or a JSON file:

  ```json
  [
      {"name": "18th Century Green", "hex":"#a59344"},
      {"name": "1975 Earth Red", "hex":"#7a463a"}
  ]
  ```


  **colorful** supports to update or replace the default color palette with custom colors. The colors have to be specified as RGB hex or channel values:

  ```python

  ci_colors = {
      'mint': '#c5e8c8',  # RGB hex value
      'darkRed': '#c11b55',  # RGB hex value
      'lightBlue': (15, 138, 191)  # RGB channel triplet
  }


  cf.use_palette(ci_colors)

  cf.update_palette(ci_colors)


  print(cf.italic_mint_on_darkRed('My company'))
  ```



  **colorful** supports some famous color palettes using what's called *styles* in colorful:

  ```python
  cf.use_style('solarized')


  print(cf.yellow('yellow'), cf.orange('orange'),
      cf.red('red'), cf.magenta('magenta'),
      cf.violet('violet'), cf.blue('blue'),
      cf.cyan('cyan'), cf.green('green'))
  ```

  The following styles are already supported:

  <details open>
   <summary>solarized - <a href="http://ethanschoonover.com/solarized">Website</a></summary>
   <br>
   <img src="https://github.com/timofurrer/colorful/blob/master/examples/solarized_base_colors.png" alt="solarized colors">
  </details>
  <details open>
   <summary>monokai</summary>
   <br>
   <img src="https://github.com/timofurrer/colorful/blob/master/examples/monokai_base_colors.png" alt="monokai colors">
  </details>
  <br>

  *Note: if you know some awesome color palettes which could be a new style in colorful, please contribute it!*



  **colorful** provides multiple ways to use style a string. Most useful and expressive is probably the *method syntax* where you specify the modifiers and colors in the method name itself and pass the string as argument to this method. However, you can use all the following methods to achive similars things:



  ```python
  print(cf.red('I am red'))
  print(cf.italic_yellow('I am italic and yellow'))
  print(cf.black_on_white('I am black on white'))
  ```

  The method syntax can be one of:

  * `cf.<modifier>`
  * `cf.<modifier1>_<modifier2>`
  * `cf.<fg_color>`
  * `cf.on_<bg_color>`
  * `cf.<modifiers>_<fg_color>`
  * `cf.<modifiers>_<bg_color>`
  * `cf.<fg_colors>_on_<bg_color>`
  * `cf.<modifiers>_<fg_color>_on_<bg_color>`

  *Note that multiple `<modifier>`s can be specified at once.*

  Available modifiers are:

  * reset (explicitely reset all styles before the passed argument)
  * bold
  * dimmed (not widely supported)
  * italic
  * underlined
  * blinkslow
  * blinkrapid
  * inversed (not widely supported)
  * concealed (not widely supported)
  * struckthrough

  The available colors depend on the [color palette](#color-palette) you are using. By default all [X11 rgb.txt colors](https://en.wikipedia.org/wiki/X11_color_names) are available.

  The type of the return value of such a *style method* is `colorful.ColorfulString`. It correctly supports all `str()` methods including [`len()`](#correctly-support-the-len-protocol).

  As you can see from the syntax in the section name, **colorful** supports nesting styles. See [Nesting styles](#nesting-styles).



  **colorful** implements the `__or__` and `__and__` protocol to combine styles and pipe strings into them:

  ```python
  print(cf.bold & cf.red | 'Hello World')
  print(cf.bold_red_on_black | 'Hello World')
  print(cf.bold | cf.red_on_black('Hello World')
  ```

  *Note: the piping `|` has the same effect as doing a method call to the style.<br>
  So you could do `(cf.bold & cf.red)('Hello World')`*



  ```python
  print(cf.format('{c.red}I am {what}{c.close_fg_color}', what='red'))

  print(cf.format('{c.red}I am red{c.reset}'))

  print(cf.format('{c.italic_yellow}I am italic and yellow{c.no_italic}{c.close_fg_color}'))
  print(cf.format('{c.black_on_white}I am black on white{c.close_fg_color}{c.close_bg_color}'))
  ```

  **colorful** will replace the `{c.<style>}` with the correspnding style. It's **not** necessary to pass a colorful object for `c` to `format()` - colorful will handle that. Every other format argument (`{<name>}`) has to be pass to the `cf.format()` call as *args* or *kwarg*.

  Note: The same syntax, modifiers and colors for the style in `{c.<style>}` can be used as for [(1) Style a string with a method call](#1-style-a-string-with-a-method-call).



  ```python
  cf.print('{c.italic_yellow}I am italic and yellow{c.no_italic}{c.close_fg_color}')
  cf.print('{c.red}I am red{c.reset}', end='', file=open('log.txt', 'a+'))
  ```

  The `cf.print()` method accepts the same arguments as the Python 3.X [built-in print()](https://docs.python.org/3/library/functions.html#print) function.



  ```python
  print('{c.red}I am red{c.close_fg_color}'.format(c=cf))

  print('{c.red}I am red{c.reset}'.format(c=cf))

  print('{c.italic_yellow}I am italic and yellow{c.no_italic}{c.close_fg_color}'.format(
      c=cf))
  print('{c.black_on_white}I am black on white{c.close_fg_color}{c.close_bg_color}'.format(
      c=cf))
  ```

  Note: The same syntax, modifiers and colors for the style in `{c.<style>}` can be used as for [(1) Style a string with a method call](#1-style-a-string-with-a-method-call).



  **colorful** supports to nest styles with it's [method call syntax](#1-style-a-string-with-a-method-call) when setting the parameter `nested` to `True`.
  If you are using `str.format()` like in the first example below you don't even need the `nested=True` flag!

  The following examples show the behavior:

  ```python
  print(cf.red('red {0} red'.format(cf.white('white'))))
  print(cf.red('red' + cf.white(' white ', nested=True) + 'red'))



  print(cf.red('red', nested=True) + ' default color')
  ```



  **colorful** correctly supports the `len()` protocol (`__len__`) on the styled strings. As mentioned above, when you style a string a `colorful.ColorfulString` object is returned. This object returns the length (when calling `len()`) as it would be for the *unstyled string* to integrate styled strings seemlessly into your application.

  ```python
  >>> s = 'Hello World'
  >>> len(s)
  11
  >>> len(cf.yellow(s))
  11
  >>> assert len(s) == len(cf.yellow(s))
  ```



  **colorful** provides a hand full of convenient context managers to change the colorful settings temporarily:



  Use 8 ANSI colors:

  ```python
  with cf.with_8_ansi_colors() as c:
      print(c.red('I am red'))
  ```

  Use 256 ANSI colors:

  ```python
  with cf.with_256_ansi_colors() as c:
      print(c.red('I am red'))
  ```

  Use true colors:

  ```python
  with cf.with_true_colors() as c:
      print(c.red('I am red'))
  ```



  ```python

  with cf.with_palette(my_palette) as c:
      print(c.customRed('I am custom red'))


  with cf.with_updated_palette(my_palette) as c:
      print(c.customRed('I am custom red'))
  ```



  ```python
  with cf.with_style('solarized') as c:
      print(c.red('I am solarized red'))
  ```

  ***

  *<p align="center">This project is published under [MIT](LICENSE).<br>A [Timo Furrer](https://tuxtimo.me) project.<br>- :tada: -</p>*


pkgId: be9278cf4155a37de777b176783e6bbf14d3a913eaa27e2dff70e5996d8ac934
name: python-colorlog
arch: src
version: 6.7.0
epoch: 0
release: 1
summary: Add colours to the output of Python's logging module.
url: https://github.com/borntyping/python-colorlog
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-605ad8e4-da4f-48a0-a3fc-1e06ab52658a
location_href: 00003305-python-colorlog/python-colorlog-6.7.0-1.src.rpm
checksum_type: sha256
description:
  [![](https://img.shields.io/pypi/v/colorlog.svg)](https://pypi.org/project/colorlog/)
  [![](https://img.shields.io/pypi/l/colorlog.svg)](https://pypi.org/project/colorlog/)
  [![](https://img.shields.io/travis/borntyping/python-colorlog/master.svg)](https://travis-ci.org/borntyping/python-colorlog)
  Add colours to the output of Python's `logging` module.
  * [Source on GitHub](https://github.com/borntyping/python-colorlog)
  * [Packages on PyPI](https://pypi.org/pypi/colorlog/)


pkgId: 13d5487400dbac138bc93def0936ca92295519291953b1bc5efc60080d4f830a
name: python-colormath
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Color math and conversion library.
url: https://github.com/gtaylor/python-colormath
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3935d3bb-d55e-4804-b6d0-4025ad2f585b
location_href: 00013877-python-colormath/python-colormath-3.0.0-1.src.rpm
checksum_type: sha256
description:
  This module implements a large number of different color operations such as
  color space conversions, Delta E, and density to spectral.


pkgId: b8df54cfe54fd3a3f5fa3547e0deb9e5461da010c61d5a3435043e96efdeca67
name: python-colorspacious
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: A powerful, accurate, and easy-to-use Python library for doing colorspace conversions
url: https://github.com/njsmith/colorspacious
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bac7bf7c-bada-4223-befb-ee316a5779fa
location_href: 00003306-python-colorspacious/python-colorspacious-1.1.2-1.src.rpm
checksum_type: sha256
description:
  Colorspacious is a powerful, accurate, and easy-to-use library for
  performing colorspace conversions.
  In addition to the most common standard colorspaces (sRGB, XYZ, xyY,
  CIELab, CIELCh), we also include: color vision deficiency ("color
  blindness") simulations using the approach of Machado et al (2009); a
  complete implementation of `CIECAM02
  <https://en.wikipedia.org/wiki/CIECAM02>`_; and the perceptually
  uniform CAM02-UCS / CAM02-LCD / CAM02-SCD spaces proposed by Luo et al
  (2006).
  To get started, simply write::
    from colorspacious import cspace_convert
    Jp, ap, bp = cspace_convert([64, 128, 255], "sRGB255", "CAM02-UCS")
  This converts an sRGB value (represented as integers between 0-255) to
  CAM02-UCS `J'a'b'` coordinates (assuming standard sRGB viewing
  conditions by default). This requires passing through 4 intermediate
  colorspaces; ``cspace_convert`` automatically finds the optimal route
  and applies all conversions in sequence:
  This function also of course accepts arbitrary NumPy arrays, so
  converting a whole image is just as easy as converting a single value.
  Documentation:
    http://colorspacious.readthedocs.org/
  Installation:
    ``pip install colorspacious``
  Downloads:
    https://pypi.python.org/pypi/colorspacious/
  Code and bug tracker:
    https://github.com/njsmith/colorspacious
  Contact:
    Nathaniel J. Smith <njs@pobox.com>
  Dependencies:
    * Python 2.6+, or 3.3+
    * NumPy
  Developer dependencies (only needed for hacking on source):
    * nose: needed to run tests
  License:
    MIT, see LICENSE.txt for details.
  References for algorithms we implement:
    * Luo, M. R., Cui, G., & Li, C. (2006). Uniform colour spaces based on
      CIECAM02 colour appearance model. Color Research & Application, 31(4),
      320–330. doi:10.1002/col.20227
    * Machado, G. M., Oliveira, M. M., & Fernandes, L. A. (2009). A
      physiologically-based model for simulation of color vision
      deficiency. Visualization and Computer Graphics, IEEE Transactions on,
      15(6), 1291–1298. http://www.inf.ufrgs.br/~oliveira/pubs_files/CVD_Simulation/CVD_Simulation.html
  Other Python packages with similar functionality that you might want
  to check out as well or instead:
  * ``colour``: http://colour-science.org/
  * ``colormath``: http://python-colormath.readthedocs.org/
  * ``ciecam02``: https://pypi.python.org/pypi/ciecam02/
  * ``ColorPy``: http://markkness.net/colorpy/ColorPy.html


pkgId: eb6c23e0a82580f7ed3113d3c3a5c51169d3e32723315fcf1ab4223178b80489
name: python-colorthief
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: A module for grabbing the color palette from an image.
url: https://github.com/fengsp/color-thief-py
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-80c9dfe4-b9d1-4728-991e-fba07022eb96
location_href: 00012935-python-colorthief/python-colorthief-0.2.1-1.src.rpm
checksum_type: sha256
description:
  A module for grabbing the color palette from an image.
  Links
  `````
  * `github <https://github.com/fengsp/color-thief-py>`_
  * `development version
    <http://github.com/fengsp/color-thief-py/zipball/master#egg=color-thief-py-dev>`_


pkgId: 0cc3ab7727ad2e840628bb5a913db78634d1eb70cca03ec3bce83c64e56b7a67
name: python-commandparse
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: CLI application commands parser
url: https://github.com/flgy/commandparse
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2cf5ecff-8f26-4c79-bbd1-c55cefb42f52
location_href: 00003311-python-commandparse/python-commandparse-1.1.1-1.src.rpm
checksum_type: sha256
description:
  Module to parse command based CLI application.

  Usage:

  * Subclass the Command class
  * Add a method with a name such as `prefix_commandname` with kwargs as required argument
  * Create an ArgumentParser instance
  * Call the `Subclass.add_suparsers` with the ArgumentParser instance and other settings
  * Use the `dispatch_command` function with the args returned by `parser.parse_args()`

  ```
  parser = ArgumentParser(...)
  [...]
  Subclass.add_subparsers(parser, prefixes=["get_", "do_", ...], title="commands", description="available commands")

  cmd = Subclass(...)
  cmd.dispatch_command(commands, args)
  ```

  See example.py for a more complete example. For a real world application using this lib, see: https://github.com/franc-pentest/ldeep


pkgId: 5e355156aa5f9de0404aab8fc3d9a993dbbae1d636d2b8439a7e7c4569128ba4
name: python-commonmark
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: Python parser for the CommonMark Markdown spec
url: https://github.com/rtfd/commonmark.py
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e9652090-c596-44ae-a262-b97a5f332427
location_href: 00002844-python-CommonMark/python-commonmark-0.9.1-1.src.rpm
checksum_type: sha256
description:
  commonmark.py is a pure Python port of `jgm <https://github.com/jgm>`__'s
  `commonmark.js <https://github.com/jgm/commonmark.js>`__, a
  Markdown parser and renderer for the
  `CommonMark <http://commonmark.org>`__ specification, using only native
  modules. Once both this project and the CommonMark specification are
  stable we will release the first ``1.0`` version and attempt to keep up
  to date with changes in ``commonmark.js``.
  commonmark.py is tested against the CommonMark spec with Python versions
  2.7, 3.4, 3.5, 3.6, and 3.7.
  **Current version:** 0.9.1
  |Pypi Link| |Build Status| |Doc Link|


pkgId: f875a49e432c3e06ed2e2cbc3263390cec98e2c72770f3ddbfb0f3eedd5d6450
name: python-compal
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: Compal CH7465LG/Ziggo Connect Box client
url: https://github.com/ties/compal_CH7465LG_py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fcdc312e-f165-4995-adef-5f162c76ecd5
location_href: 00003312-python-compal/python-compal-0.5.1-1.src.rpm
checksum_type: sha256
description:
  This repository contains a simple api to wrap the web interface of the Ziggo Connect Box (i.e. the
  Compal CH7465LG). It is implemented in **Python >= 3.7**.
  At the moment it *only* contains the functionality that I needed while I was investigating my
  device, but pull requests that improve the documentation or add features are welcome.


pkgId: a5dcb79afe1f0b99638bb88b2d6a871feb022971c1cdb41655df1ec328e30d92
name: python-compiler-identification
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: Identifying the properties of a C/C++ compiler, such as type and version
url: https://github.com/yugabyte/compiler-identification
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8e6c0496-1eff-4e53-bb51-a5163fa95c23
location_href: 00010642-python-compiler-identification/python-compiler-identification-1.0.3-1.src.rpm
checksum_type: sha256
description:
  https://pypi.org/project/compiler-identification/

  A useful tool in identifying the version of C/C++ compilers, mainly various versions of GCC and
  Clang present in various Linux districtions and versions of macOS.

  Usage (an ipython session shown):

  ```
  In [1]: from compiler_identification import identify_compiler

  In [2]: identification = identify_compiler('clang')

  In [3]: identification
  Out[3]: <compiler_identification.CompilerIdentification family='clang' version_str='12.0.5' full_version_output_str='Apple clang version 12.0.5 (clang-1205.0.22.9)\nTarget: x86_64-apple-darwin20.3.0\nThread model: posix\nInstalledDir: /Library/Developer/CommandLineTools/usr/bin' parsed_version=<Version('12.0.5')> compiler_path='/usr/bin/clang' at 0x7f904a95e970>

  In [4]: identification.parsed_version
  Out[4]: <Version('12.0.5')>
  ```

  The `parsed_version`, which is a `Version` instance from the [`packaging`](https://pypi.org/project/packaging/) module, allows to do proper version comparisons. See https://packaging.pypa.io/en/latest/version.html for more details.


pkgId: 957368268b1b018a61394bd01aa7865e431cb941b4e7aaec53d3a6c2aa03e8fc
name: python-compreffor
arch: src
version: 0.5.3
epoch: 0
release: 1
summary: A CFF subroutinizer for fontTools.
url: https://pypi.org/project/compreffor/
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fed35c1e-7e4d-417a-a76f-4ce72946f2a4
location_href: 00003314-python-compreffor/python-compreffor-0.5.3-1.src.rpm
checksum_type: sha256
description:
  |CI Build Status|

  A CFF table subroutinizer for FontTools.

  .. |CI Build Status| image:: https://github.com/googlefonts/compreffor/workflows/Build%20+%20Deploy/badge.svg
     :target: https://github.com/googlefonts/compreffor/actions?query=workflow%3A%22Build+%2B+Deploy%22


pkgId: 72df9c402b00877e428d5fab4492ae1dbd2f3c903ac3095a0fa8ff138a8e8d45
name: python-compreffor-debuginfo
arch: aarch64
version: 0.5.3
epoch: 0
release: 1
summary: Debug information for package python-compreffor
url: https://pypi.org/project/compreffor/
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-fed35c1e-7e4d-417a-a76f-4ce72946f2a4
rpm_sourcerpm: python-compreffor-0.5.3-1.src.rpm
location_href: 00003314-python-compreffor/python-compreffor-debuginfo-0.5.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-compreffor.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: d980c114f9defd806b73971d49b0c24e5483f12480a5a66c2f38235437e5f61a
name: python-compreffor-debugsource
arch: aarch64
version: 0.5.3
epoch: 0
release: 1
summary: Debug sources for package python-compreffor
url: https://pypi.org/project/compreffor/
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-fed35c1e-7e4d-417a-a76f-4ce72946f2a4
rpm_sourcerpm: python-compreffor-0.5.3-1.src.rpm
location_href: 00003314-python-compreffor/python-compreffor-debugsource-0.5.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-compreffor.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: c747fc3903f09bffe767414721c1a240f72c3d7d4a5354afb4b36238886f44ee
name: python-comtypes
arch: src
version: 1.1.14
epoch: 0
release: 1
summary: Pure Python COM package
url: https://github.com/enthought/comtypes
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d64e8de7-9d1f-44c1-9dd7-ebb7d4b1dffd
location_href: 00010054-python-comtypes/python-comtypes-1.1.14-1.src.rpm
checksum_type: sha256
description:
  **comtypes** is a lightweight Python COM package, based on the ctypes_
  FFI library, in less than 10000 lines of code (not counting the
  tests).
  **comtypes** allows to define, call, and implement custom and
  dispatch-based COM interfaces in pure Python.  It works on Windows and
  64-bit Windows. Windows CE support was dropped since comtypes==1.1.8.
  Documentation:
      https://pythonhosted.org/comtypes
      Contribute using the `source repository and issue tracker
      <https://github.com/enthought/comtypes/>`_ on GitHub.
  Mailing list:
      http://gmane.org/info.php?group=gmane.comp.python.comtypes.user
      https://lists.sourceforge.net/lists/listinfo/comtypes-users/
  Download:
      Releases can be downloaded in the PyPI page:
      https://pypi.python.org/pypi/comtypes


pkgId: 4ccfa895f1c4f50858321ae2e60885ad4f035f92ae474b6f78c94735f0f42c74
name: python-concurrent-log-handler
arch: src
version: 0.9.22
epoch: 0
release: 1
summary: RotatingFileHandler replacement with concurrency, gzip and Windows support
url: https://github.com/Preston-Landers/concurrent-log-handler
rpm_license: http://www.apache.org/licenses/LICENSE-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ddc18c7a-695c-46c4-9401-97433b297a9c
location_href: 00009531-python-concurrent-log-handler/python-concurrent-log-handler-0.9.22-1.src.rpm
checksum_type: sha256
description:
  This package provides an additional log handler for Python's standard logging
  package (PEP 282). This handler will write log events to a log file which is
  rotated when the log file reaches a certain size.  Multiple processes can
  safely write to the same log file concurrently. Rotated logs can be gzipped
  if desired. Both Windows and POSIX systems are supported.  An optional threaded
  queue logging handler is provided to perform logging in the background.

  This is a fork of Lowell Alleman's ConcurrentLogHandler 0.9.1 which fixes
  a hanging/deadlocking problem. See this:

  https://bugs.launchpad.net/python-concurrent-log-handler/+bug/1265150

  Summary of other changes:

  * Renamed package to `concurrent_log_handler` (abbreviated CLH in this file.)
  * Provide `use_gzip` option to compress rotated logs
  * Support for Windows
  * Uses file locking to ensure exclusive write access
    Note: file locking is advisory, not a hard lock against external processes
  * More secure generation of random numbers for temporary filenames
  * Change the name of the lockfile to have .__ in front of it.
  * Provide a QueueListener / QueueHandler implementation for
    handling log events in a background thread. Optional: requires Python 3.
  * Allow setting owner and mode permissions of rollover file on Unix
  * Depends on `portalocker` package, which (on Windows only) depends on `PyWin32`



  The main use case this is designed to support is when you have a Python application that runs in
  multiple processes, potentially on multiple hosts connected with a shared network drive, and you want
  to write all log events to a central log file.

  However, this is not the only way to achieve shared logging from multiple processes. You can also
  centralize logging by using cloud logging services like Azure Log Monitor, Logstash, etc. Or you can
  implement your own remote logging server as shown here:

  https://docs.python.org/3/howto/logging-cookbook.html#sending-and-receiving-logging-events-across-a-network

  Concurrent-Log-Handler includes a QueueHandler and QueueListener implementation that can be used to
  perform logging in the background asynchronously, so the thread or process making the log statement doesn't have
  to wait for its completion. See [this section](#simple-example). Using that example code, each process still
  locks and writes the file separately, so there is no centralized writer. You could also write code to use
  QueueHandler and QueueListener to queue up log events within each process to be sent to a central server,
  instead of CLH's model where each process locks and writes to the log file.

  Please note that CLH only does size-based rotation at this time. There is a request open for
  time-based rotation.

  https://github.com/Preston-Landers/concurrent-log-handler/issues/23



  * [concurrent-log-handler on Github](https://github.com/Preston-Landers/concurrent-log-handler)
  * [concurrent-log-handler on the Python Package Index (PyPI)](https://pypi.org/project/concurrent-log-handler/)





  You can download and install the package with `pip` using the following command:

      pip install concurrent-log-handler

  This will also install the portalocker module, which on Windows in turn depends on pywin32.

  If installing from source, use the following command:

      python setup.py install



  If you plan to modify the code, you should follow this procedure:

  - Clone the repository
  - Create a virtual environment (`venv`) and activate it.
  - Install the package in editable mode with the [dev] option:

      `pip install -e .[dev]`

  - Run the tests:

      `tox`

    Or manually run a single pass of the stress test with specific options:

  ```
    python tests/stresstest.py --help
    python tests/stresstest.py --gzip --num-processes 12 --log-calls=5000
  ```
  - To build a Python "wheel" for distribution, use the following:

  ```shell
    python setup.py clean --all build sdist bdist_wheel
    
    
    pip install twine
    twine upload dist/concurrent-log-handler-0.9.21.tar.gz dist/concurrent_log_handler-0.9.21-py2.py3-none-any.whl
  ```



  Concurrent Log Handler (CLH) is designed to allow multiple processes to write to the same
  logfile in a concurrent manner. It is important that each process involved MUST follow
  these requirements:

  * You can't serialize a handler instance and reuse it in another process. This means you cannot, for
    example, pass a CLH handler instance from parent process to child process using
    the `multiprocessing` package in spawn mode (or similar techniques that use serialized objects).
    Each child process must initialize its own CLH instance.

  * When using the `multiprocessing` module in "spawn" (non-fork) mode, each child process must create
    its OWN instance of the handler (`ConcurrentRotatingFileHandler`). The child target function
    should call code that initializes a new CLH instance.

     * This requirement does not apply to threads within a given process. Different threads within a
       process can use the same CLH instance. Thread locking is handled automatically.

     * This also does not apply to `fork()` based child processes such as gunicorn --preload.
       Child processes of a fork() call should be able to inherit the CLH object instance.

     * This limitation exists because the CLH object can't be serialized, passed over a network or
       pipe, and reconstituted at the other end.

  * It is important that every process or thread writing to a given logfile must all use the same
    settings, especially related to file rotation. Also do not attempt to mix different handler
    classes writing to the same file, e.g. do not also use a `RotatingFileHandler` on the same file.

  * Special attention may need to be paid when the log file being written to resides on a network
    shared drive or a cloud synced folder (Dropbox, Google Drive, etc.). Whether the multiprocess
    advisory lock technique (via portalocker) works in these folders may depend on the details of
    your configuration.

    Note that a `lock_file_directory` setting (kwarg) now exists (as of v0.9.21) which lets you
    place the lockfile at a different location from the main logfile. This might solve problems
    related to trying to lock files in network shares or cloud folders (Dropbox, Google Drive, etc.)
    However, if multiple hosts are writing to the same shared logfile, they must also have access
    to the same lock file.

    Alternatively, you may be able to set your cloud sync software to ignore all `.lock` files.

  * A separate handler instance is needed for each individual log file. For instance, if your app
    writes to two different log files you will need to set up two CLH instances per process.



  Here is a simple direct usage example:

  ```python
  from logging import getLogger, INFO
  from concurrent_log_handler import ConcurrentRotatingFileHandler
  import os

  log = getLogger(__name__)

  logfile = os.path.abspath("mylogfile.log")

  rotateHandler = ConcurrentRotatingFileHandler(logfile, "a", 512*1024, 5)
  log.addHandler(rotateHandler)
  log.setLevel(INFO)

  log.info("Here is a very exciting log message, just for you")
  ```

  See also the file [src/example.py](src/example.py) for a configuration and usage example.
  This shows both the standard non-threaded non-async usage, and the use of the `asyncio`
  background logging feature. Under that option, when your program makes a logging statement,
  it is added to a background queue and may not be written immediately and synchronously. This
  queue can span multiple processes using `multiprocessing` or `concurrent.futures`, and spanning
  multiple hosts works due to the use of file locking on the log file. Note that with this async
  logging feature, currently there is no way for the caller to know when the logging statement
  completed (no "Promise" or "Future" object is returned).

  https://docs.python.org/3/library/logging.handlers.html#queuehandler



  To use this module from a logging config file, use a handler entry like this:

  ```ini
  [handler_hand01]
  class=handlers.ConcurrentRotatingFileHandler
  level=NOTSET
  formatter=form01
  args=("rotating.log", "a")
  kwargs={'backupCount': 5, 'maxBytes': 1048576, 'use_gzip': True}
  ```

  That sets the files to be rotated at about 10 MB, and to keep the last 5 rotations.
  It also turns on gzip compression for rotated files.

  Please note that Python 3.7 and higher accepts keyword arguments (kwargs) in a logging
  config file, but earlier versions of Python only accept positional args.

  Note: you must have an `import concurrent_log_handler` before you call fileConfig(). For
  more information see http://docs.python.org/lib/logging-config-fileformat.html



  For best performance, avoid setting the `backupCount` (number of rollover files to keep) too
  high. What counts as "too high" is situational, but a good rule of thumb might be to keep
  around a maximum of 20 rollover files. If necessary, increase the `maxBytes` so that each
  file can hold more. Too many rollover files can slow down the rollover process due to the
  mass file renames, and the rollover occurs while the file lock is held for the main logfile.

  How big to allow each file to grow (`maxBytes`) is up to your needs, but generally a value of
  10 MB (1048576) to 100 MB (1048576) is reasonable.

  Gzip compression is turned off by default. If enabled it will reduce the storage needed for rotated
  files, at the cost of some minimal CPU overhead. Use of the background logging queue shown below
  can help offload the cost of logging to another thread.

  Sometimes you may need to place the lock file at a different location from the main log
  file. A `lock_file_directory` setting (kwarg) now exists (as of v0.9.21) which lets you
  place the lockfile at a different location. This can often solve problems related to trying
  to lock files in cloud folders (Dropbox, Google Drive, OneDrive, etc.) However, in
  order for this to work, each process writing to the log must have access to the same
  lock file location, even if they are running on different hosts.

  You can set the `namer` attribute of the handler to customize the naming of the rotated files,
  in line with the `BaseRotatingHandler` class. See the Python docs for more details:
  https://docs.python.org/3.11/library/logging.handlers.html#logging.handlers.BaseRotatingHandler.namer



  By default, the logfile will have line endings appropriate to the platform. On Windows
  the line endings will be CRLF ('\r\n') and on Unix/Mac they will be LF ('\n').

  It is possible to force another line ending format by using the newline and terminator
  arguments.

  The following would force Windows-style CRLF line endings on Unix:

      kwargs={'newline': '', 'terminator': '\r\n'}

  The following would force Unix-style LF line endings on Windows:

      kwargs={'newline': '', 'terminator': '\n'}



  To use the background logging queue, you must call this code at some point in your
  app after it sets up logging configuration. Please read the doc string in the
  file `concurrent_log_handler/queue.py` for more details. This requires Python 3.
  See also [src/example.py](src/example.py).

  ```python
  from concurrent_log_handler.queue import setup_logging_queues


  setup_logging_queues()
  ```

  This module is designed to function well in a multi-threaded or multi-processes
  concurrent environment. However, all writers to a given log file should be using
  the same class and the *same settings* at the same time, otherwise unexpected
  behavior may result during file rotation.

  This may mean that if you change the logging settings at any point you may need to
  restart your app service so that all processes are using the same settings at the same time.




  The `ConcurrentRotatingFileHandler` class is a drop-in replacement for
  Python's standard log handler `RotatingFileHandler`. This module uses file
  locking so that multiple processes can concurrently log to a single file without
  dropping or clobbering log events. This module provides a file rotation scheme
  like with `RotatingFileHandler`.  Extra care is taken to ensure that logs
  can be safely rotated before the rotation process is started. (This module works
  around the file rename issue with `RotatingFileHandler` on Windows, where a
  rotation failure means that all subsequent log events are dropped).

  This module attempts to preserve log records at all cost. This means that log
  files will grow larger than the specified maximum (rotation) size. So if disk
  space is tight, you may want to stick with `RotatingFileHandler`, which will
  strictly adhere to the maximum file size.

  Important:

  If you have multiple instances of a script (or multiple scripts) all running at
  the same time and writing to the same log file, then *all* of the scripts should
  be using `ConcurrentRotatingFileHandler`. You should not attempt to mix
  and match `RotatingFileHandler` and `ConcurrentRotatingFileHandler`.
  The file locking is advisory only - it is respected by other Concurrent Log Handler
  instances, but does not protect against outside processes (or different Python logging
  file handlers) from writing to a log file in use.



  See [CHANGELOG.md](CHANGELOG.md)



  The original version was written by Lowell Alleman.

  Other contributors are listed in [CONTRIBUTORS.md](CONTRIBUTORS.md).



  See the [LICENSE file](LICENSE)


pkgId: 028aeaff3313c092d81cb4e379439f574a1cfce31a74bde5af565cb58268cb70
name: python-conda
arch: src
version: 4.3.16
epoch: 0
release: 1
summary: OS-agnostic, system-level binary package manager.
url: https://github.com/conda/conda
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-02f2aaf7-3478-473c-9d31-dee5ad398fe5
location_href: 00003316-python-conda/python-conda-4.3.16-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://s3.amazonaws.com/conda-dev/conda_logo.svg
     :alt: Conda Logo

  Conda is a cross-platform, language-agnostic binary package manager. It is the
  package manager used by `Anaconda
  <http://docs.continuum.io/anaconda/index.html>`_ installations, but it may be
  used for other systems as well.  Conda makes environments first-class
  citizens, making it easy to create independent environments even for C
  libraries. Conda is written entirely in Python, and is BSD licensed open
  source.


  Installation


  **WARNING:** Using ``pip install conda`` or ``easy_install conda`` will not
  give you conda as a standalone application.  Currently supported install
  methods include the Anaconda installer and the miniconda installer.  You
  can download the miniconda installer from https://conda.io/miniconda.html.


pkgId: 7f903b4888754294db8f5d13742e0915eda573066b5f5e2e70fd983f45322a20
name: python-conda-pack
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Package conda environments for redistribution
url: https://conda.github.io/conda-pack/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f896f06b-78a7-4e41-b735-cc3e74ca2f12
location_href: 00011074-python-conda-pack/python-conda-pack-0.6.0-1.src.rpm
checksum_type: sha256
description:
  `conda-pack` is a command line tool for creating relocatable conda
  environments. This is useful for deploying code in a consistent environment,
  potentially in locations where python or conda isn't already installed.

  See the <a href="https://conda.github.io/conda-pack/">documentation</a>
  for more information.

  Conda-pack is offered under a New BSD license; see the
  <a href="https://github.com/conda/conda-pack/blob/master/LICENSE.txt">license file</a>.



  | [![Build status](https://github.com/conda/conda-pack/workflows/Build%20and%20test%20the%20package/badge.svg)](https://github.com/conda/conda-pack/actions) [![codecov](https://codecov.io/gh/conda/conda-pack/branch/master/graph/badge.svg)](https://codecov.io/gh/conda/conda-pack) | [![Anaconda-Server Badge](https://anaconda.org/ctools/conda-pack/badges/latest_release_date.svg)](https://anaconda.org/ctools/conda-pack) |
  | --- | :-: |
  | [`conda install ctools/label/dev::conda-pack`](https://anaconda.org/ctools/conda-pack) | [![Anaconda-Server Badge](https://anaconda.org/ctools/conda-pack/badges/version.svg)](https://anaconda.org/ctools/conda-pack) |
  | [`conda install defaults::conda-pack`](https://anaconda.org/anaconda/conda-pack) | [![Anaconda-Server Badge](https://anaconda.org/anaconda/conda-pack/badges/version.svg)](https://anaconda.org/anaconda/conda-pack) |
  | [`conda install conda-forge::conda-pack`](https://anaconda.org/conda-forge/conda-pack) | [![Anaconda-Server Badge](https://anaconda.org/conda-forge/conda-pack/badges/version.svg)](https://anaconda.org/conda-forge/conda-pack) |


pkgId: 3bea6fc00e147c30a4c770fcfed7ec17ed460b5d311c6af34e073d08144c3d94
name: python-condor
arch: src
version: 0.1.3.1
epoch: 0
release: 1
summary: Condor - Grunt-like automation system
url: http://bivanov.bitbucket.org/condor
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c3562c1f-4fda-4a3d-bddc-4584563b321c
location_href: 00003318-python-condor/python-condor-0.1.3.1-1.src.rpm
checksum_type: sha256
description:
  Condor is a Grunt-alike automation system. It allows user to perform chains of operations
  with simple scripts, watch files and directories with further reaction to changes and so on
  Please, refer to documentation - http://bivanov.bitbucket.com/condor. Please be noticed that
  while Condor in constant development phase docs may not cover all or latest functionality.


pkgId: b3a361f1b84b9a97611276702cdca4cff83a009d402dd49e4e621841301dd4c8
name: python-config
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: A hierarchical, easy-to-use, powerful configuration module for Python
url: http://docs.red-dove.com/cfg/python.html
rpm_license: Copyright (C) 2004-2020 by Vinay Sajip. All Rights Reserved. See LICENSE for license.
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9f20a818-1381-4cc6-99ef-5daabbf265da
location_href: 00010310-python-config/python-config-0.5.1-1.src.rpm
checksum_type: sha256
description:
  This module allows a hierarchical configuration scheme with support for mappings and sequences, cross-references between one part of the configuration and another, the ability to flexibly access real Python objects without full-blown eval(), an include facility, simple expression evaluation and the ability to change, save, cascade and merge configurations. Interfaces easily with environment variables and command-line options.


pkgId: 6cbca524412ae1f10c1b7d8b110beaf3c018631d5b69383cdb73c93ba7288132
name: python-configobj
arch: src
version: 5.0.8
epoch: 0
release: 1
summary: Config file reading, writing and validation.
url: https://github.com/DiffSK/configobj
rpm_license: BSD (2 clause)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3e0bcfc8-6d0c-427c-96e3-31cd224c72fe
location_href: 00009498-python-configobj/python-configobj-5.0.8-1.src.rpm
checksum_type: sha256
description:
  * Nested sections (subsections), to any level
  * List values
  * Multiple line values
  * Full Unicode support
  * String interpolation (substitution)
  * Integrated with a powerful validation system
      - including automatic type checking/conversion
      - and allowing default values
      - repeated sections
  * All comments in the file are preserved
  * The order of keys/sections is preserved
  * Powerful ``unrepr`` mode for storing/retrieving Python data-types


pkgId: 52e75d63f2fe44b95f332ec559950b2274d4ee14870cc9db97613daaf085c0ef
name: python-confusable_homoglyphs
arch: src
version: 3.2.0
epoch: 0
release: 1
summary: Detect confusable usage of unicode homoglyphs, prevent homograph attacks.
url: https://github.com/vhf/confusable_homoglyphs
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fe26ad3b-8454-425f-951c-04a2350b7e3e
location_href: 00013170-python-confusable-homoglyphs/python-confusable_homoglyphs-3.2.0-1.src.rpm
checksum_type: sha256
description:
  *a homoglyph is one of two or more graphemes, characters, or glyphs with
  shapes that appear identical or very similar*
  `wikipedia:Homoglyph <https://en.wikipedia.org/wiki/Homoglyph>`__
  Unicode homoglyphs can be a nuisance on the web. Your most popular
  client, AlaskaJazz, might be upset to be impersonated by a trickster who
  deliberately chose the username ΑlaskaJazz.
  -  ``AlaskaJazz`` is single script: only Latin characters.
  -  ``ΑlaskaJazz`` is mixed-script: the first character is a greek
     letter.
  You might also want to avoid people being tricked into entering their
  password on ``www.micros﻿оft.com`` or ``www.faϲebook.com`` instead of
  ``www.microsoft.com`` or ``www.facebook.com``. `Here is a
  utility <http://unicode.org/cldr/utility/confusables.jsp>`__ to play
  with these **confusable homoglyphs**.
  Not all mixed-script strings have to be ruled out though, you could only
  exclude mixed-script strings containing characters that might be
  confused with a character from some unicode blocks of your choosing.
  -  ``Allo`` and ``ρττ`` are fine: single script.
  -  ``AlloΓ`` is fine when our preferred script alias is 'latin': mixed script, but ``Γ`` is not confusable.
  -  ``Alloρ`` is dangerous: mixed script and ``ρ`` could be confused with
     ``p``.
  This library is compatible Python 2 and Python 3.


pkgId: 41d6e8e7c44290e91cfab509ee9a6dea6b43401830696ce2790f88b743932e31
name: python-confuse
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Painless YAML configuration.
url: https://github.com/beetbox/confuse
rpm_license: None
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cffb3180-4076-40e9-ae13-83a4358d7ffa
location_href: 00003321-python-confuse/python-confuse-2.0.0-1.src.rpm
checksum_type: sha256
description:
  **Confuse** is a configuration library for Python that uses `YAML`_. It takes
  care of defaults, overrides, type checking, command-line integration,
  environment variable support, human-readable errors, and standard OS-specific
  locations.


pkgId: ab2e7a8ce7f592095c86b20a65e87eb63b926c6de86ce0b5552ab963642b7d59
name: python-conllu
arch: src
version: 4.5.2
epoch: 0
release: 1
summary: CoNLL-U Parser parses a CoNLL-U formatted string into a nested python dictionary
url: https://github.com/EmilStenstrom/conllu/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6f78eecf-7da9-453f-9200-74a9dc3fa793
location_href: 00011587-python-conllu/python-conllu-4.5.2-1.src.rpm
checksum_type: sha256
description:
  **CoNLL-U Parser** parses a [CoNLL-U formatted](http://universaldependencies.org/format.html) string into a nested python dictionary. CoNLL-U is often the output of natural language processing tasks.



  - It's simple. ~300 lines of code.
  - It has no dependencies
  - Full typing support so your editor can do autocompletion
  - Nice set of tests with CI setup: [![Build](https://github.com/EmilStenstrom/conllu/workflows/Run%20tests%20for%20all%20supported%20python%20versions/badge.svg)](https://github.com/EmilStenstrom/conllu/actions?query=workflow%3A%22Run+tests+for+all+supported+python+versions%22)
  - It has 100% test branch coverage (and has undergone [mutation testing](https://github.com/boxed/mutmut/))
  - It has [![lots of downloads](http://pepy.tech/badge/conllu)](http://pepy.tech/project/conllu)



  Note: As of conllu 4.0, Python 3.6 is required to install conllu. See [Notes on updating from 3.0 to 4.0](#notes-on-updating-from-30-to-40)

  ```bash
  pip install conllu
  ```

  Or, if you are using [conda](https://conda.io/docs/):

  ```bash
  conda install -c conda-forge conllu
  ```



  Conllu version 4.0 drops support for Python 2 and all versions of earlier than Python 3.6. If you need support for older versions of python, you can always pin your install to an old version of conllu. You can install it with `pip install conllu==3.1.1`.



  The Universal dependencies 2.0 release changed two of the field names from xpostag -> xpos and upostag -> upos. Version 3.0 of conllu handles this by aliasing the previous names to the new names. This means you can use xpos/upos or xpostag/upostag, they will both return the same thing. This does change the public API slightly, so I've upped the major version to 3.0, but I've taken care to ensure you most likely DO NOT have to update your code when you update to 3.0.



  I don't like breaking backwards compatibility, but to be able to add new features I felt I had to. This means that updating from 0.1 to 1.0 *might* require code changes. Here's a guide on [how to upgrade to 1.0
  ](https://github.com/EmilStenstrom/conllu/wiki/Migrating-from-0.1-to-1.0).



  At the top level, conllu provides two methods, `parse` and `parse_tree`. The first one parses sentences and returns a flat list. The other returns a nested tree structure. Let's go through them one by one.



  ```python
  >>> from conllu import parse
  >>>
  >>> data = """
  ... # text = The quick brown fox jumps over the lazy dog.
  ... 1   The     the    DET    DT   Definite=Def|PronType=Art   4   det     _   _
  ... 2   quick   quick  ADJ    JJ   Degree=Pos                  4   amod    _   _
  ... 3   brown   brown  ADJ    JJ   Degree=Pos                  4   amod    _   _
  ... 4   fox     fox    NOUN   NN   Number=Sing                 5   nsubj   _   _
  ... 5   jumps   jump   VERB   VBZ  Mood=Ind|Number=Sing|Person=3|Tense=Pres|VerbForm=Fin   0   root    _   _
  ... 6   over    over   ADP    IN   _                           9   case    _   _
  ... 7   the     the    DET    DT   Definite=Def|PronType=Art   9   det     _   _
  ... 8   lazy    lazy   ADJ    JJ   Degree=Pos                  9   amod    _   _
  ... 9   dog     dog    NOUN   NN   Number=Sing                 5   nmod    _   SpaceAfter=No
  ... 10  .       .      PUNCT  .    _                           5   punct   _   _
  ...
  ... """
  ```

  Now you have the data in a variable called `data`. Let's parse it:

  ```python
  >>> sentences = parse(data)
  >>> sentences
  [TokenList<The, quick, brown, fox, jumps, over, the, lazy, dog, ., metadata={text: "The quick brown fox jumps over the lazy dog."}>]
  ```

  <blockquote>

  **Advanced usage**: If you have many sentences (say over a megabyte) to parse at once, you can avoid loading them into memory at once by using `parse_incr()` instead of `parse`. It takes an opened file, and returns a generator instead of the list directly, so you need to either iterate over it, or call list() to get the TokenLists out. Here's how you would use it:

  ```python
  from io import open
  from conllu import parse_incr

  data_file = open("huge_file.conllu", "r", encoding="utf-8")
  for tokenlist in parse_incr(data_file):
      print(tokenlist)
  ```

  For most files, `parse` works fine.
  </blockquote>

  Since one CoNLL-U file usually contains multiple sentences, `parse()` always returns a list of sentences. Each sentence is represented by a TokenList.

  ```python
  >>> sentence = sentences[0]
  >>> sentence
  TokenList<The, quick, brown, fox, jumps, over, the, lazy, dog, ., metadata={text: "The quick brown fox jumps over the lazy dog."}>
  ```

  The TokenList supports indexing, so you can get the first token, represented by an ordered dictionary, like this:

  ```python
  >>> token = sentence[0]
  >>> token
  {'id': 1,
       'form': 'The',
       'lemma': 'the',
       ...}
  >>> token["form"]
  'The'
  ```



  ```python
  >>> sentence = sentences[0]
  >>> sentence
  TokenList<The, quick, brown, fox, jumps, over, the, lazy, dog, ., metadata={text: "The quick brown fox jumps over the lazy dog."}>
  >>> sentence.filter(form="quick")
  TokenList<quick>
  ```

  By using `filter(field1__field2=value)` you can filter based on subelements further down in a parsed token.

  ```python
  >>> sentence.filter(feats__Degree="Pos")
  TokenList<quick, brown, lazy>
  ```

  Filters can also be chained (meaning you can do `sentence.filter(...).filter(...)`), and filtering on multiple properties at the same time (`sentence.filter(field1=value1, field2=value2)`) means that ALL properties must match.



  You can also filter using a lambda function as value. This is useful if you, for instance, would like to filter out only tokens with integer ID:s:

  ```python
  >>> from conllu.models import TokenList, Token
  >>> sentence2 = TokenList([
  ...    Token(id=(1, "-", 2), form="It's"),
  ...    Token(id=1, form="It"),
  ...    Token(id=2, form="is"),
  ... ])
  >>> sentence2
  TokenList<It's, It, is>
  >>> sentence2.filter(id=lambda x: type(x) is int)
  TokenList<It, is>
  ```



  If you want to change your CoNLL-U file, there are a couple of convenience methods to know about.

  You can add a new token by simply appending a dictionary with the fields you want to a TokenList:

  ```python
  >>> sentence3 = TokenList([
  ...    {"id": 1, "form": "Lazy"},
  ...    {"id": 2, "form": "fox"},
  ... ])
  >>> sentence3
  TokenList<Lazy, fox>
  >>> sentence3.append({"id": 3, "form": "box"})
  >>> sentence3
  TokenList<Lazy, fox, box>
  ```

  Changing a sentence just means indexing into it, and setting a value to what you want:

  ```python
  >>> sentence4 = TokenList([
  ...    {"id": 1, "form": "Lazy"},
  ...    {"id": 2, "form": "fox"},
  ... ])
  >>> sentence4[1]["form"] = "crocodile"
  >>> sentence4
  TokenList<Lazy, crocodile>
  >>> sentence4[1] = {"id": 2, "form": "elephant"}
  >>> sentence4
  TokenList<Lazy, elephant>
  ```

  If you omit a field when passing in a dict, conllu will fill in a "_" for those values.

  ```python
  >>> sentences = parse("1  The")
  >>> sentences[0].append({"id": 2})
  >>> sentences[0]
  TokenList<The, _>
  ```



  Each sentence can also have metadata in the form of comments before the sentence starts. This is available in a property on the TokenList called `metadata`.

  ```python
  >>> sentence.metadata
  {'text': 'The quick brown fox jumps over the lazy dog.'}
  ```



  If you ever want to get your CoNLL-U formated text back (maybe after changing something?), use the `serialize()` method:

  ```python
  >>> print(sentence.serialize())

  1   The     the     DET    DT   Definite=Def|PronType=Art   4   det    _   _
  2   quick   quick   ADJ    JJ   Degree=Pos                  4   amod   _   _
  3   brown   brown   ADJ    JJ   Degree=Pos                  4   amod   _   _
  4   fox     fox     NOUN   NN   Number=Sing                 5   nsubj  _   _
  5   jumps   jump    VERB   VBZ  Mood=Ind|Number=Sing|Person=3|Tense=Pres|VerbForm=Fin   0   root   _   _
  6   over    over    ADP    IN   _                           9   case   _   _
  7   the     the     DET    DT   Definite=Def|PronType=Art   9   det    _   _
  8   lazy    lazy    ADJ    JJ   Degree=Pos                  9   amod   _   _
  9   dog     dog     NOUN   NN   Number=Sing                 5   nmod   _   SpaceAfter=No
  10  .       .       PUNCT  .    _                           5   punct  _   _
  ```



  You can also convert a TokenList to a TokenTree by using `to_tree`:

  ```python
  >>> sentence.to_tree()
  TokenTree<token={id=5, form=jumps}, children=[...]>
  ```

  That's it!



  Sometimes you're interested in the tree structure that hides in the `head` column of a CoNLL-U file. When this is the case, use `parse_tree` to get a nested structure representing the sentence.

  ```python
  >>> from conllu import parse_tree
  >>> sentences = parse_tree(data)
  >>> sentences
  [TokenTree<...>]
  ```

  <blockquote>

  **Advanced usage**: If you have many sentences (say over a megabyte) to parse at once, you can avoid loading them into memory at once by using `parse_tree_incr()` instead of `parse_tree`. It takes an opened file, and returns a generator instead of the list directly, so you need to either iterate over it, or call list() to get the TokenTrees out. Here's how you would use it:

  ```python
  from io import open
  from conllu import parse_tree_incr

  data_file = open("huge_file.conllu", "r", encoding="utf-8")
  for tokentree in parse_tree_incr(data_file):
      print(tokentree)
  ```

  </blockquote>

  Since one CoNLL-U file usually contains multiple sentences, `parse_tree()` always returns a list of sentences. Each sentence is represented by a TokenTree.

  ```python
  >>> root = sentences[0]
  >>> root
  TokenTree<token={id=5, form=jumps}, children=[...]>
  ```

  To quickly visualize the tree structure you can call `print_tree` on a TokenTree.

  ```python
  >>> root.print_tree()
  (deprel:root) form:jumps lemma:jump upos:VERB [5]
      (deprel:nsubj) form:fox lemma:fox upos:NOUN [4]
          (deprel:det) form:The lemma:the upos:DET [1]
          (deprel:amod) form:quick lemma:quick upos:ADJ [2]
          (deprel:amod) form:brown lemma:brown upos:ADJ [3]
      (deprel:nmod) form:dog lemma:dog upos:NOUN [9]
          (deprel:case) form:over lemma:over upos:ADP [6]
          (deprel:det) form:the lemma:the upos:DET [7]
          (deprel:amod) form:lazy lemma:lazy upos:ADJ [8]
      (deprel:punct) form:. lemma:. upos:PUNCT [10]
  ```

  To access the token corresponding to the current node in the tree, use `token`:

  ```python
  >>> root.token
  {
      'id': 5,
      'form': 'jumps',
      'lemma': 'jump',
      ...
  }
  ```

  To start walking down the children of the current node, use the children attribute:

  ```python
  >>> children = root.children
  >>> children
  [
      TokenTree<token={id=4, form=fox}, children=[...]>,
      TokenTree<token={id=9, form=dog}, children=[...]>,
      TokenTree<token={id=10, form=.}, children=None>
  ]
  ```

  Just like with `parse()`, if a sentence has metadata it is available in a property on the TokenTree root called `metadata`.

  ```python
  >>> root.metadata
  {'text': 'The quick brown fox jumps over the lazy dog.'}
  ```

  If you ever want to get your CoNLL-U formated text back (maybe after changing something?), use the `serialize()` method:

  ```python
  >>> print(root.serialize())

  1   The     the    DET    DT   Definite=Def|PronType=Art   4   det     _   _
  2   quick   quick  ADJ    JJ   Degree=Pos                  4   amod    _   _
  ...
  ```

  If you want to write it back to a file, you can use something like this:

  ```python
  >>> from conllu import parse_tree
  >>> sentences = parse_tree(data)
  >>>
  >>> # Make some change to sentences here
  >>>
  >>> with open('file-to-write-to', 'w') as f:
  ...     f.writelines([sentence.serialize() + "\n" for sentence in sentences])
  ```



  Far from all CoNLL-U files found in the wild follow the CoNLL-U format specification. CoNLL-U tries to parse even files that are malformed according to the specification, but sometimes that doesn't work. For those situations you can change how conllu parses your files.

  A normal CoNLL-U file consists of a specific set of fields (id, form, lemma, and so on...). Let's walk through how to parse a custom format using the three options `fields`, `field_parsers`, `metadata_parsers`. Here's the custom format we'll use.

  ```python
  >>> data = """
  ... # tagset = TAG1|TAG2|TAG3|TAG4
  ... # sentence-123
  ... 1   My       TAG1|TAG2
  ... 2   custom   TAG3
  ... 3   format   TAG4
  ...
  ... """
  ```

  Now, let's parse this with the the default settings, and look specifically at the first token to see how it was parsed.

  ```python
  >>> sentences = parse(data)
  >>> sentences[0][0]
  {'id': 1, 'form': 'My', 'lemma': 'TAG1|TAG2'}
  ```

  The parser has assumed (incorrectly) that the third field must the the default ´lemma´ field and parsed it as such. Let's customize this so the parser gets the name right, by setting the `fields` parameter when calling parse.

  ```python
  >>> sentences = parse(data, fields=["id", "form", "tag"])
  >>> sentences[0][0]
  {'id': 1, 'form': 'My', 'tag': 'TAG1|TAG2'}
  ```

  The only difference is that you now get the correct field name back when parsing. Now let's say you want those two tags returned as a list instead of as a string. This can be done using the `field_parsers` argument.

  ```python
  >>> split_func = lambda line, i: line[i].split("|")
  >>> sentences = parse(data, fields=["id", "form", "tag"], field_parsers={"tag": split_func})
  >>> sentences[0][0]
  {'id': 1, 'form': 'My', 'tag': ['TAG1', 'TAG2']}
  ```

  That's much better! `field_parsers` specifies a mapping from a field name, to a function that can parse that field. In our case, we specify that the field with custom logic is `"tag"` and that the function to handle it is `split_func`. Each field_parser gets sent two parameters:

  * `line`: The whole list of values from this line, split on whitespace. The reason you get the full line is so you can merge several tokens into one using a field_parser if you want.
  * `i`: The current location in the line where you currently are. Most often, you'll use `line[i]` to get the current value.

  In our case, we return `line[i].split("|")`, which returns a list like we want.

  Let's look at the metadata in this example.

  ```text


  ```

  None of these values are valid in CoNLL-U, but since the first line follows the key-value format of other (valid) fields, conllu will parse it anyway:

  ```python
  >>> sentences = parse(data)
  >>> sentences[0].metadata
  {'tagset': 'TAG1|TAG2|TAG3|TAG4'}
  ```

  Let's return this as a list using the `metadata_parsers` parameter.

  ```python
  >>> sentences = parse(data, metadata_parsers={"tagset": lambda key, value: (key, value.split("|"))})
  >>> sentences[0].metadata
  {'tagset': ['TAG1', 'TAG2', 'TAG3', 'TAG4']}
  ```

  A metadata parser behaves similarily to a field parser, but since most comments you'll see will be of the form "key = value" these values will be parsed and cleaned first, and then sent to your custom metadata_parser. Here we just take the value, and split it on "|", and return a list back. And lo and behold, we get what we wanted!

  Now, let's deal with the "sentence-123" comment. Specifying another metadata_parser won't work, because this is an ID that will be different for each sentence. Instead, let's use a special metadata parser, called `__fallback__`.

  ```python
  >>> sentences = parse(data, metadata_parsers={
  ...    "tagset": lambda key, value: (key, value.split("|")),
  ...    "__fallback__": lambda key, value: ("sentence-id", key)
  ... })
  >>> sentences[0].metadata
  {
      'tagset': ['TAG1', 'TAG2', 'TAG3', 'TAG4'],
      'sentence-id': 'sentence-123'
  }
  ```

  Just what we wanted! `__fallback__` gets called any time none of the other metadata_parsers match, and just like the others, it gets sent the key and value of the current line. In our case, the line contains no "=" to split on, so key will be "sentence-123" and value will be empty. We can return whatever we want here, but let's just say we want to call this field "sentence-id" so we return that as the key, and "sentence-123" as our value.

  Finally, consider an even trickier case.

  ```python
  >>> data = """
  ... # id=1-document_id=36:1047-span=1
  ... 1   My       TAG1|TAG2
  ... 2   custom   TAG3
  ... 3   format   TAG4
  ...
  ... """
  ```

  This is actually three different comments, but somehow they are separated by "-" instead of on their own lines. To handle this, we get to use the ability of a metadata_parser to return multiple matches from a single line.

  ```python
  >>> sentences = parse(data, metadata_parsers={
  ...    "__fallback__": lambda key, value: [pair.split("=") for pair in (key + "=" + value).split("-")]
  ... })
  >>> sentences[0].metadata
  {
      'id': '1',
      'document_id': '36:1047',
      'span': '1'
  }
  ```

  Our fallback parser returns a **list** of matches, one per pair of metadata comments we find. The `key + "=" + value` trick is needed since by default conllu assumes that this is a valid comment, so `key` is "id" and `value` is everything after the first "=", `1-document_id=36:1047-span=1` (note the missing "id=" in the beginning). We need to add it back before splitting on "-".

  And that's it! Using these tricks you should be able to parse all the strange files you stumble into.



  1. Make a fork of the repository to your own GitHub account.

  2. Clone the repository locally on your computer:
      ```bash
      git clone git@github.com:YOURUSERNAME/conllu.git conllu
      cd conllu
      ```

  3. Install the library used for running the tests:
      ```bash
      pip install tox
      ```

  4. Now you can run the tests:
      ```bash
      tox
      ```
      This runs tox across all supported versions of Python, and also runs checks for code-coverage, syntax errors, and how imports are sorted.

  4. (Alternative) If you just have one version of python installed, and don't want to go through the hassle of installing multiple version of python (hint: Install pyenv and pyenv-tox), **it's fine to run tox with just one version of python**:

      ```bash
      tox -e py36
      ```

  5. Make a pull request. Here's a [good guide on PRs from GitHub](https://help.github.com/articles/creating-a-pull-request-from-a-fork/).

  Thanks for helping conllu become a better library!


pkgId: d9cb72b20cac4faa495ce27295e6721bf7336e05a39e4901823f1a3040d09790
name: python-connect-box
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Python client for interacting with Compal CH7465LG devices.
url: https://github.com/home-assistant-ecosystem/python-connect-box
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8e418d23-5d2e-4c4a-8ed9-82ebc5e212cb
location_href: 00003322-python-connect-box/python-connect-box-0.3.0-1.src.rpm
checksum_type: sha256
description:
  Python Client for interacting with the cable modem/router Compal CH7465LG which
  is provided under different names by various ISP in Europe.
  - UPC Connect Box (CH)
  - Irish Virgin Media Super Hub 3.0 (IE)
  - Ziggo Connectbox (NL)
  - Unitymedia Connect Box (DE)
  This module is not official, developed, supported or endorsed by UPC,
  Unitymedia or Compal.
  There is an interface with is providing details about various states like the
  DHCP lease table for Ethernet and Wifi.
      <?xml version="1.0" encoding="UTF-8"?>
      <LanUserTable>
         <Ethernet>
            <clientinfo>
               <interface>Ethernet 2</interface>
               <IPv4Addr>192.168.0.160/24</IPv4Addr>
               <index>0</index>
               <interfaceid>2</interfaceid>
               <hostname>GW-B072BF27A983</hostname>
               <MACAddr>B0:72:BF:27:A9:83</MACAddr>
               <method>1</method>
               <leaseTime>00:00:34:53</leaseTime>
  ``connect_box`` is handling the retrieval of the data and the parsing. The
  primary use case is the `Home Assistant <https://home-assistant.io>`_
  ``upc_connect`` device tracker but one could use it in other projects as well.


pkgId: e3da0573b4a12725345a1792ad197ecfcdfa17804343aa0cab3c5104440f687e
name: python-constantly
arch: src
version: 15.1.0
epoch: 0
release: 1
summary: Symbolic constants in Python
url: https://github.com/twisted/constantly
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3db57537-f9ff-413c-8728-afaf198a0287
location_href: 00009488-python-constantly/python-constantly-15.1.0-1.src.rpm
checksum_type: sha256
description:
  A library that provides symbolic constant support.
  It includes collections and constants with text, numeric, and bit flag values.
  Originally ``twisted.python.constants`` from the `Twisted <https://twistedmatrix.com/>`_ project.


pkgId: 7012ca42d7f3ca04c112ff0922c7e12652e1c658065e613a91a3f3e27c4ebedf
name: python-construct
arch: src
version: 2.10.68
epoch: 0
release: 1
summary: A powerful declarative symmetric parser/builder for binary data
url: http://construct.readthedocs.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f6d960cd-ffba-4708-984a-be0061cd85e7
location_href: 00010334-python-construct/python-construct-2.10.68-1.src.rpm
checksum_type: sha256
description:
  Construct is a powerful **declarative** and **symmetrical** parser and builder for binary data.
  Instead of writing *imperative code* to parse a piece of data, you declaratively define a *data structure* that describes your data. As this data structure is not code, you can use it in one direction to *parse* data into Pythonic objects, and in the other direction, to *build* objects into binary data.
  The library provides both simple, atomic constructs (such as integers of various sizes), as well as composite ones which allow you form hierarchical and sequential structures of increasing complexity. Construct features **bit and byte granularity**, easy debugging and testing, an **easy-to-extend subclass system**, and lots of primitive constructs to make your work easier:
  * Fields: raw bytes or numerical types
  * Structs and Sequences: combine simpler constructs into more complex ones
  * Bitwise: splitting bytes into bit-grained fields
  * Adapters: change how data is represented
  * Arrays/Ranges: duplicate constructs
  * Meta-constructs: use the context (history) to compute the size of data
  * If/Switch: branch the computational path based on the context
  * On-demand (lazy) parsing: read and parse only what you require
  * Pointers: jump from here to there in the data stream
  * Tunneling: prefix data with a byte count or compress it


pkgId: 05b6fc57527dbbb9bb90de4f1bc541f36ee01b43ecc49bb6a4d26d788e63712d
name: python-contextily
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Context geo-tiles in Python
url: https://github.com/geopandas/contextily
rpm_license: 3-Clause BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0b6f7e2f-0988-4c28-a577-cb0ddee92992
location_href: 00003323-python-contextily/python-contextily-1.3.0-1.src.rpm
checksum_type: sha256
description:
  `contextily` is a small Python 3 (3.8 and above) package to retrieve tile maps from the
  internet. It can add those tiles as basemap to matplotlib figures or write tile
  maps to disk into geospatial raster files. Bounding boxes can be passed in both
  WGS84 (`EPSG:4326`) and Spheric Mercator (`EPSG:3857`). See the notebook
  `contextily_guide.ipynb` for usage.

  [![Tests](https://github.com/geopandas/contextily/actions/workflows/tests.yaml/badge.svg)](https://github.com/geopandas/contextily/actions/workflows/tests.yaml)
  [![codecov](https://codecov.io/gh/geopandas/contextily/branch/main/graph/badge.svg?token=5Eu3L1peBb)](https://codecov.io/gh/geopandas/contextily)
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/geopandas/contextily/main?urlpath=lab/tree/notebooks/intro_guide.ipynb)

  ![Tiles](tiles.png)

  The current tile providers that are available in contextily are the providers
  defined in the [`xyzservices`](https://xyzservices.readthedocs.io)
  package. This includes some popular tile maps, such as:

  * The standard [OpenStreetMap](http://openstreetmap.org) map tiles
  * Toner, Terrain and Watercolor map tiles by [Stamen Design](http://stamen.com)



  * `mercantile`
  * `numpy`
  * `matplotlib`
  * `pillow`
  * `rasterio`
  * `requests`
  * `geopy`
  * `joblib`
  * `xyzservices`



  **Python 3 only** (3.8 and above)

  [Latest released version](https://github.com/geopandas/contextily/releases/), using pip:

  ```sh
  pip3 install contextily
  ```

  or conda:

  ```sh
  conda install contextily
  ```



  `contextily` is developed by a community of enthusiastic volunteers. You can see a full list [here](https://github.com/geopandas/contextily/graphs/contributors).

  If you would like to contribute to the project, have a look at the list of [open issues](https://github.com/geopandas/contextily/issues), particularly those labeled as [good first contributions](https://github.com/geopandas/contextily/issues?q=is%3Aissue+is%3Aopen+label%3Agood-first-contribution).



  BSD compatible. See `LICENSE.txt`


pkgId: 85220fc34ec02916e4364bc5744c8337f3c01c4209b7e90f454b305c739c44a7
name: python-contextlib2
arch: src
version: 21.6.0
epoch: 0
release: 1
summary: Backports and enhancements for the contextlib module
url: http://contextlib2.readthedocs.org
rpm_license: PSF License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4ddde451-d79b-4aba-a873-f5f4817962eb
location_href: 00009071-python-contextlib2/python-contextlib2-21.6.0-1.src.rpm
checksum_type: sha256
description:
  As a backport of Python standard library software, the implementation, test
  suite and other supporting files for this project are distributed under the
  Python Software License used for the CPython reference implementation.
  The one exception is the included type hints file, which comes from the
  ``typeshed`` project, and is hence distributed under the Apache License 2.0.


pkgId: 3531d502cba8ba2824ffd25537e52488e2b669a79986dd479f4575b13621437e
name: python-contextvars
arch: src
version: 2.4
epoch: 0
release: 1
summary: PEP 567 Backport
url: http://github.com/MagicStack/contextvars
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a0f6b428-570f-4e90-a86d-ef391815bf07
location_href: 00009442-python-contextvars/python-contextvars-2.4-1.src.rpm
checksum_type: sha256
description:
  This package implements a backport of Python 3.7 ``contextvars``
  module (see PEP 567) for Python 3.6.
  **Important:** at this moment this package does not provide an
  asyncio event loop with PEP 567 support yet.  Stay tuned for updates.


pkgId: 2e7c10d1751a1800e09360f255d14e11e768aba1a5848d80eda34ce648046ee6
name: python-convertdate
arch: src
version: 2.4.0
epoch: 0
release: 1
summary: Converts between Gregorian dates and other calendar systems
url: https://github.com/fitnr/convertdate
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bfe8e358-945a-4d73-9caa-3b98ea8941a2
location_href: 00003326-python-convertdate/python-convertdate-2.4.0-1.src.rpm
checksum_type: sha256
description:
  The convertdate package was originally developed as "[Python Date
  Utils](http://sourceforge.net/projects/pythondateutil/)" by Phil
  Schwartz. It has been significantly updated and expanded.
  [Consult the complete docs for detailed usage info](https://convertdate.readthedocs.io/).
  Available calendars:
  -   Armenian
  -   Bahai
  -   Coptic (Alexandrian)
  -   French Republican
  -   Gregorian
  -   Hebrew
  -   Indian Civil
  -   Islamic
  -   Julian
  -   Mayan
  -   Persian
  -   Positivist
  -   Mayan
  -   ISO
  -   Ordinal (day of year)
  -   Dublin day count
  -   Julian day count
  The `holidays` module also provides some useful holiday-calculation,
  with a focus on North American and Jewish holidays.


pkgId: 76dc226f7b6705379e410ced0462a379ddf95a569803bbf9dfd0c9c5a9f1aa14
name: python-cookiecutter
arch: src
version: 2.1.1
epoch: 0
release: 1
url: https://github.com/cookiecutter/cookiecutter
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-149aa414-450c-46f4-b936-298d28862699
location_href: 00003327-python-cookiecutter/python-cookiecutter-2.1.1-1.src.rpm
checksum_type: sha256
summary:
  A command-line utility that creates projects from project templates, e.g. creating a Python package project from a Python package project template.

description:
  [![pypi](https://img.shields.io/pypi/v/cookiecutter.svg)](https://pypi.org/project/cookiecutter/)
  [![python](https://img.shields.io/pypi/pyversions/cookiecutter.svg)](https://pypi.org/project/cookiecutter/)
  [![Build Status](https://github.com/cookiecutter/cookiecutter/actions/workflows/main.yml/badge.svg?branch=master)](https://github.com/cookiecutter/cookiecutter/actions)
  [![codecov](https://codecov.io/gh/cookiecutter/cookiecutter/branch/master/graphs/badge.svg?branch=master)](https://codecov.io/github/cookiecutter/cookiecutter?branch=master)
  [![discord](https://img.shields.io/badge/Discord-cookiecutter-5865F2?style=flat&logo=discord&logoColor=white)](https://discord.gg/9BrxzPKuEW)
  [![docs](https://readthedocs.org/projects/cookiecutter/badge/?version=latest)](https://readthedocs.org/projects/cookiecutter/?badge=latest)
  [![Code Quality](https://img.shields.io/scrutinizer/g/cookiecutter/cookiecutter.svg)](https://scrutinizer-ci.com/g/cookiecutter/cookiecutter/?branch=master)

  A command-line utility that creates projects from **cookiecutters** (project templates), e.g. creating a Python package project from a Python package project template.

  - Documentation: [https://cookiecutter.readthedocs.io](https://cookiecutter.readthedocs.io)
  - GitHub: [https://github.com/cookiecutter/cookiecutter](https://github.com/cookiecutter/cookiecutter)
  - PyPI: [https://pypi.org/project/cookiecutter/](https://pypi.org/project/cookiecutter/)
  - Free and open source software: [BSD license](https://github.com/cookiecutter/cookiecutter/blob/master/LICENSE)

  ![Cookiecutter](https://raw.githubusercontent.com/cookiecutter/cookiecutter/3ac078356adf5a1a72042dfe72ebfa4a9cd5ef38/logo/cookiecutter_medium.png)



  - Cross-platform: Windows, Mac, and Linux are officially supported.
  - You don't have to know/write Python code to use Cookiecutter.
  - Works with Python 3.7, 3.8, 3.9., 3.10
  - Project templates can be in any programming language or markup format:
    Python, JavaScript, Ruby, CoffeeScript, RST, Markdown, CSS, HTML, you name it.
    You can use multiple languages in the same project template.



  - Simple command line usage:

    ```bash
    
    
    
    
    $ cookiecutter https://github.com/audreyfeldroy/cookiecutter-pypackage
    
    $ cookiecutter gh:audreyfeldroy/cookiecutter-pypackage
    ```

  - Use it at the command line with a local template:

    ```bash
    
    
    $ cookiecutter cookiecutter-pypackage/
    ```

  - Or use it from Python:

    ```py
    from cookiecutter.main import cookiecutter

    
    cookiecutter('cookiecutter-pypackage/')

    
    cookiecutter('https://github.com/audreyfeldroy/cookiecutter-pypackage.git')
    ```

  - Unless you suppress it with `--no-input`, you are prompted for input:
    - Prompts are the keys in `cookiecutter.json`.
    - Default responses are the values in `cookiecutter.json`.
    - Prompts are shown in order.
  - Cross-platform support for `~/.cookiecutterrc` files:

    ```yaml
    default_context:
      full_name: "Audrey Roy Greenfeld"
      email: "audreyr@gmail.com"
      github_username: "audreyfeldroy"
    cookiecutters_dir: "~/.cookiecutters/"
    ```

  - Cookiecutters (cloned Cookiecutter project templates) are put into `~/.cookiecutters/` by default, or cookiecutters_dir if specified.
  - If you have already cloned a cookiecutter into `~/.cookiecutters/`,  you can reference it by directory name:

    ```bash
    
    $ cookiecutter gh:audreyfeldroy/cookiecutter-pypackage
    
    $ cookiecutter cookiecutter-pypackage
    ```

  - You can use local cookiecutters, or remote cookiecutters directly from Git repos or from Mercurial repos on Bitbucket.
  - Default context: specify key/value pairs that you want used as defaults  whenever you generate a project.
  - Inject extra context with command-line arguments:

    ```bash
    cookiecutter --no-input gh:msabramo/cookiecutter-supervisor program_name=foobar startsecs=10
    ```

  - Direct access to the Cookiecutter API allows for injection of extra context.
  - Paths to local projects can be specified as absolute or relative.
  - Projects generated to your current directory or to target directory if specified with `-o` option.



  - Supports unlimited levels of directory nesting.
  - 100% of templating is done with Jinja2.
  - Both, directory names and filenames can be templated.
    For example:

    ```py
    {{cookiecutter.repo_name}}/{{cookiecutter.repo_name}}/{{cookiecutter.repo_name}}.py
    ```
  - Simply define your template variables in a `cookiecutter.json` file.
    For example:

    ```json
    {
      "full_name": "Audrey Roy Greenfeld",
      "email": "audreyr@gmail.com",
      "project_name": "Complexity",
      "repo_name": "complexity",
      "project_short_description": "Refreshingly simple static site generator.",
      "release_date": "2013-07-10",
      "year": "2013",
      "version": "0.1.1"
    }
    ```
  - Pre- and post-generate hooks: Python or shell scripts to run before or after generating a project.



  Making great cookies takes a lot of cookiecutters and contributors.
  We're so pleased that there are many Cookiecutter project templates to choose from.
  We hope you find a cookiecutter that is just right for your needs.



  The best place to start searching for specific and ready to use cookiecutter template is [Github search](https://github.com/search?q=cookiecutter&type=Repositories).
  Just type `cookiecutter` and you will discover over 4000 related repositories.

  We also recommend you to check related GitHub topics.
  For general search use [cookiecutter-template](https://github.com/topics/cookiecutter-template).
  For specific topics try to use `cookiecutter-yourtopic`, like `cookiecutter-python` or `cookiecutter-datascience`.
  This is a new GitHub feature, so not all active repositories use it at the moment.

  If you are template developer please add related [topics](https://help.github.com/en/github/administering-a-repository/classifying-your-repository-with-topics) with `cookiecutter` prefix to you repository.
  We believe it will make it more discoverable.
  You are almost not limited in topics amount, use it!



  These Cookiecutters are maintained by the cookiecutter team:

  - [cookiecutter-pypackage](https://github.com/audreyfeldroy/cookiecutter-pypackage):
    ultimate Python package project template by [@audreyfeldroy's](https://github.com/audreyfeldroy).
  - [cookiecutter-django](https://github.com/pydanny/cookiecutter-django):
    a framework for jumpstarting production-ready Django projects quickly.
    It is bleeding edge with Bootstrap 5, customizable users app, starter templates, working user registration, celery setup, and much more.
  - [cookiecutter-pytest-plugin](https://github.com/pytest-dev/cookiecutter-pytest-plugin):
    Minimal Cookiecutter template for authoring [pytest](https://docs.pytest.org/) plugins that help you to write better programs.



  The core committer team can be found in [authors section](AUTHORS.md).
  We are always welcome and invite you to participate.

  Stuck? Try one of the following:

  - See the [Troubleshooting](https://cookiecutter.readthedocs.io/en/latest/troubleshooting.html) page.
  - Ask for help on [Stack Overflow](https://stackoverflow.com/questions/tagged/cookiecutter).
  - You are strongly encouraged to [file an issue](https://github.com/cookiecutter/cookiecutter/issues?q=is%3Aopen) about the problem.
    Do it even if it's just "I can't get it to work on this cookiecutter" with a link to your cookiecutter.
    Don't worry about naming/pinpointing the issue properly.
  - Ask for help on [Discord](https://discord.gg/9BrxzPKuEW) if you must (but please try one of the other options first, so that others can benefit from the discussion).

  Development on Cookiecutter is community-driven:

  - Huge thanks to all the [contributors](AUTHORS.md) who have pitched in to help make Cookiecutter an even better tool.
  - Everyone is invited to contribute.
    Read the [contributing instructions](CONTRIBUTING.md), then get started.
  - Connect with other Cookiecutter contributors and users on [Discord](https://discord.gg/9BrxzPKuEW)
    (note: due to work and other commitments, a core committer might not always be available)

  Encouragement is unbelievably motivating.
  If you want more work done on Cookiecutter, show support:

  - Thank a core committer for their efforts.
  - Star [Cookiecutter on GitHub](https://github.com/cookiecutter/cookiecutter).
  - [Support this project](#support-this-project)

  Got criticism or complaints?

  - [File an issue](https://github.com/cookiecutter/cookiecutter/issues?q=is%3Aopen) so that Cookiecutter can be improved.
    Be friendly and constructive about what could be better.
    Make detailed suggestions.
  - **Keep us in the loop so that we can help.**
    For example, if you are discussing problems with Cookiecutter on a mailing list, [file an issue](https://github.com/cookiecutter/cookiecutter/issues?q=is%3Aopen) where you link to the discussion thread and/or cc at least 1 core committer on the email.
  - Be encouraging.
    A comment like "This function ought to be rewritten like this" is much more likely to result in action than a comment like "Eww, look how bad this function is."

  Waiting for a response to an issue/question?

  - Be patient and persistent. All issues are on the core committer team's radar and will be considered thoughtfully, but we have a lot of issues to work through.
    If urgent, it's fine to ping a core committer in the issue with a reminder.
  - Ask others to comment, discuss, review, etc.
  - Search the Cookiecutter repo for issues related to yours.
  - Need a fix/feature/release/help urgently, and can't wait?
    [@audreyfeldroy](https://github.com/audreyfeldroy) is available for hire for consultation or custom development.



  This project is run by volunteers.
  Shortly we will be providing means for organizations and individuals to support the project.



  Everyone interacting in the Cookiecutter project's codebases and documentation is expected to follow the [PyPA Code of Conduct](https://www.pypa.io/en/latest/code-of-conduct/).
  This includes, but is not limited to, issue trackers, chat rooms, mailing lists, and other virtual or in real life communication.



  This project was created and is led by [Audrey Roy Greenfeld](https://github.com/audreyfeldroy).

  She is supported by a team of maintainers.


pkgId: 8fd26d60ac8924ba06eba8c6bf58861fea3cd0b7d16df65beee47559de5789af
name: python-cookies
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: Friendlier RFC 6265-compliant cookie parser/renderer
url: https://github.com/sashahart/cookies
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d10252d6-f2f9-4269-9a4b-054d88ed70a0
location_href: 00010451-python-cookies/python-cookies-2.2.1-1.src.rpm
checksum_type: sha256
description:
  cookies.py is a Python module for working with HTTP cookies: parsing and
  rendering 'Cookie:' request headers and 'Set-Cookie:' response headers,
  and exposing a convenient API for creating and modifying cookies. It can be
  used as a replacement of Python's Cookie.py (aka http.cookies).


pkgId: 902b154a157c75173b1e5cedc0998f1d198ad27931121105bbb26623079fd020
name: python-copr-common
arch: src
version: 0.18
epoch: 0
release: 1
summary: Common python code used by Copr.
url: https://github.com/fedora-copr/copr
rpm_license: GPLv2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-847b720a-4834-4d09-9df7-1aa8f9ea5495
location_href: 00003329-python-copr-common/python-copr-common-0.18-1.src.rpm
checksum_type: sha256
description:
  COPR is lightweight build system. It allows you to create new project
  in WebUI, and submit new builds and COPR will create yum repository from latest builds.

  This package contains python code used by other Copr packages. Mostly
  useful for developers only.


pkgId: aa5114f15b63f45c0c30a59a59ecf35948b12a2d395610a4fb8a60d795ed8208
name: python-copr-messaging
arch: src
version: 0.8
epoch: 0
release: 1
summary: A schema and tooling for Copr fedora-messaging
url: https://github.com/fedora-copr/copr
rpm_license: GPLv2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a257ba6a-b780-432d-bc51-c4ac34a48628
location_href: 00003330-python-copr-messaging/python-copr-messaging-0.8-1.src.rpm
checksum_type: sha256
description:
  Schemas for messages sent by Copr project, as described on
  [fedora-messaging documentation page].
  This package also provides several convenience methods for working with copr
  messages, see docs.
  [fedora-messaging documentation page]: https://fedora-messaging.readthedocs.io/en/latest/messages.html#schema


pkgId: a669f99e4360eb7c14db2aedca237c3d70bab22e33b2cc8ec304f66c333c38ee
name: python-cornice_sphinx
arch: src
version: 0.3
epoch: 0
release: 1
summary: Generate Sphinx documentation from a Cornice application
url: https://github.com/Cornices/cornice.ext.sphinx
rpm_license: Apache License (2.0)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4483a56b-875b-4f58-9c9b-216615fd7fa0
location_href: 00003335-python-cornice-sphinx/python-cornice_sphinx-0.3-1.src.rpm
checksum_type: sha256
description:
  *Cornice extension to generate Sphinx doc*
  Maintaining documentation while the code is evolving is painful.
  Avoiding information duplication is also quite a challenge.
  Cornice tries to reduce a bit the pain by providing a Sphinx
  (http://sphinx.pocoo.org/) directive that scans the web
  services and build the documentation using:
  - the description provided when a Service instance is created
  - the docstrings of all functions involved in creating the response:
    the web services function itself and the validators.
  The assumption made is that maintaining those docstrings while
  working on the code is easier.


pkgId: fb7c520d8d026704505f13293f4579f807883efabc7b047803f18db591afbe2d
name: python-couchbase
arch: src
version: 4.1.2
epoch: 0
release: 1
summary: Python Client for Couchbase
url: https://github.com/couchbase/couchbase-python-client
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-23b9597d-0d27-4791-953c-d19a3e52dee1
location_href: 00003339-python-couchbase/python-couchbase-4.1.2-1.src.rpm
checksum_type: sha256
description:
  Python client for [Couchbase](https://couchbase.com)
  >**NOTE:** This is the documentation for the 4.x version of the client. This is mostly compatible with the older 3.x version. Please refer to the *3.2.7* tag for the older 3.x version.



  - [Prerequisites](#prerequisites)
  - [Installing](#installing)
  - [Building](#building)
  - [Using the SDK](#using-the-sdk)
  - [Building Documentation](#building-documentation)
  - [Testing](#testing)
  - [Contributing](#contributing)
  - [Support & Additional Resources](#support-additional-resources)
  - [License](#license)
  - [Appendix](#appendix)



  - [Couchbase Server](http://couchbase.com/download)
  - You may need a C++ compiler supporting C++ 17 and Python development files, unless a
    binary wheel is available for your platform. With the 4.0.2 release, wheels are available on Windows, MacOS and Linux (via manylinux) for Python 3.7 - 3.10.
  - CMake (version >= 3.18), unless a binary wheel is available for your platform.
  - Git, unless a binary wheel is available for your platform.
  - OpenSSL is now required for the 4.x Python SDK.
  - If using the Twisted Framework and the txcouchbase API, Twisted >= 21.7.0 is required.



  First-time setup:
  ```console
  $ sudo apt install git-all python3-dev python3-pip python3-setuptools cmake build-essential libssl-dev
  ```

  >**NOTE:** We have provided *Dockerfiles* to demonstrate steps to achieve a working setup for various linux platforms. See the [dockerfiles folder](https://github.com/couchbase/couchbase-python-client/tree/master/examples/dockerfiles) in the Python SDK examples folder for details.

  See [Debian and Ubuntu](#install-deb-ubuntu) install section to install SDK.



  First-time setup:
  ```console
  $ sudo yum install git-all gcc gcc-c++ python3-devel python3-pip python3-setuptools cmake openssl-devel
  ```

  >:exclamation:**IMPORTANT**:exclamation:<br>Some of the defaults for older operating systems like Centos/RHEL 7 and 8 have defaults to do not meet the 4.x Python SDK [minimum requirements](prerequisites). Be sure to update to the minimum requirements prior to installing the SDK.  Most notably be sure to check the following:
  >- The default Python version might be less than 3.7.  If so, the Python version _will_ need to be udpated.
  >- The default OpenSSL version might be less than 1.1.1.  If so, the OpenSSL version _will_ need to be updated.
  >- The gcc version must provide C++17 support.  If the installed gcc version does not support C++17, gcc _will_ need to be updated.
  >- The installed CMake version might be less than 3.17.  If so, the CMake version _will_ need to be updated.  Check out the steps [here](https://idroot.us/install-cmake-centos-8/) to update CMake.

  >**NOTE:** We have provided *Dockerfiles* to demonstrate steps to achieve a working setup for various linux platforms. See the [dockerfiles folder](https://github.com/couchbase/couchbase-python-client/tree/master/examples/dockerfiles) in the Python SDK examples folder for details.

  See [RHEL and Centos](#install-rhel-centos) install section to install SDK.



  It is not recommended to use the vendor-supplied Python that ships with OS X. Best practice is to use a Python virtual environment such as pyenv or venv (after another version of Python that is not vendor-supplied has been installed) to manage multiple versions of Python.

  >:exclamation:**IMPORTANT**:exclamation:<br>There can be a problem when using the Python (3.8.2) that ships with Xcode on Catalina.    It is advised to install Python with one of the following:
  >- [pyenv](#macos-pyenv)
  >- [Homebrew](#macos-homebrew)
  >- Install Python via [python.org](https://www.python.org/downloads)



  See detailed walk through in [Appendix](#appendix-pyenv).  Also, see pyenv install [docs](https://github.com/pyenv/pyenv#homebrew-on-macos) for further details.

  >**NOTE:** If using pyenv, make sure the python interpreter is the pyenv default, or a virtual environment has been activiated.  Otherwise cmake might not be able to find the correct version of Python3 to use when building.



  See Homebrew install [docs](https://brew.sh/) for further details.

  Get the latest packages:
  ```console
  $ brew update
  ```

  Install Python:
  ```console
  $ brew install python
  ```

  Update path:

  - **zsh:**
      ```console
      $ echo 'export PATH="/usr/local/bin:"$PATH' >> ~/.zshrc
      ```
  - **bash:**
      ```console
      $ echo 'export PATH="/usr/local/bin:"$PATH' >> ~/.bash_profile
      ```

  Install OpenSSL:
  ```console
  $ brew install openssl@1.1
  ```

  To get OpenSSL to be found by cmake on macos, find where openssl was
  installed via homebrew:

  ```
  brew info openssl@1.1
  ```

  This will show you how to get it seen by pkg-config. To check that it
  worked, do this:

  ```
  pkg-config --modversion openssl
  ```

  See [Mac OS](#install-macos) install section to install SDK.



  Wheels are available on Windows for Python 3.7, 3.8, 3.9 and 3.10.

  Best practice is to use a Python virtual environment such as venv or pyenv (checkout the [pyenv-win](https://github.com/pyenv-win/pyenv-win) project) to manage multiple versions of Python.

  If wanting to install from source, see the [Windows building](#building-windows) section for details.

  See [Windows install](#install-windows) section to install SDK.


  [Back to Contents](#contents)

  You can always get the latest supported release version from [pypi](https://pypi.org/project/couchbase/).

  >**NOTE:** If you have a recent version of *pip*, you may use the latest development version by issuing the following incantation:
  >```console
  >pip install git+https://github.com/couchbase/couchbase-python-client.git
  >```

  >**NOTE:** The Python Client installer relies on PEP517 which older versions of PIP do not support. If you experience issues installing it is advised to upgrade your PIP/setuptools installation as follows:<br>
  >```console
  >python3 -m pip install --upgrade pip setuptools wheel
  >```




  First, make sure the [prerequisites](#pre-deb-ubuntu) have been installed.

  Install the SDK:
  ```console
  $ python3 -m pip install couchbase
  ```



  First, make sure the [prerequisites](#pre-rhel-centos) have been installed.

  Install the SDK:
  ```console
  $ python3 -m pip install couchbase
  ```



  First, make sure the [prerequisites](#pre-macos) have been installed.

  Install the SDK:
  ```console
  $ python -m pip install couchbase
  ```




  First, make sure the [prerequisites](#pre-windows) have been installed.

  >**NOTE:** Commands assume user is working within a virtual environment.  For example, the following commands have been executed after downloading and installing Python from [python.org](https://www.python.org/downloads/):<br>
  >-```C:\Users\Administrator\AppData\Local\Programs\Python\Python39\python -m venv C:\python\python39```<br>
  >-```C:\python\python39\Scripts\activate```

  Install the SDK (if using Python 3.7, 3.8, 3.9 or 3.10):
  ```console
  python -m pip install couchbase
  ```



  In order to successfully install with the following methods, ensure a proper build system is in place (see the [Windows building](#building-windows) section for details).



  First, ensure all the [requirements](#building-windows) for a build system are met.

  Install the SDK:
  ```console
  python -m pip install couchbase --no-binary couchbase
  ```



  First, ensure all the [requirements](#building-windows) for a build system are met.

  Clone this Python SDK repository:
  ```console
  git clone --depth 1 --branch <tag_name> --recurse-submodules https://github.com/couchbase/couchbase-python-client.git
  ```

  >Where tag_name is equal to the latest release.<br>
  Example: ```git clone --depth 1 --branch 4.0.0 --recurse-submodules https://github.com/couchbase/couchbase-python-client.git```

  Move into the directory created after cloning the Python SDK repository:
  ```console
  cd couchbase-python-client
  ```

  >**NOTE:** If the ```--recurse-submodules``` option was not used when cloning the Python SDK repository, run (after moving into the cloned repository directory) ```git submodule update --init --recursive``` to recursively update and initialize the submodules.

  Install the SDK from source:
  ```console
  python -m pip install .
  ```



  To use the SDK within the Anaconda/Miniconda platform, make sure the prerequisites for the desired Operating System are met:
  - [Debian and Ubuntu](#pre-deb-ubuntu)
  - [RHEL and Centos](#pre-rhel-centos)
  - [Mac OS](#pre-macos)
  - [Windows](#pre-windows)

  In the *Anaconda Prompt*, create a new environment:
  ```console
  (base) C:\Users\user1>conda create -n test_env python=3.9
  ```

  Activate the environment
  ```console
  (base) C:\Users\user1>conda activate test_env
  ```

  Install the SDK:
  ```console
  (test_env) C:\Users\user1>python -m pip install couchbase
  ```

  >**NOTE:** If using Windows, and no wheel is available, see the [Alternative Install Methods Windows](#install-windows-alt) section.  The same process should work within the Anaconda/Miniconda platform.


  [Back to Contents](#contents)

  >**NOTE:** This section only applies to building from source.




  Make sure the prerequisites have been installed:
  - [Debian and Ubuntu](#pre-deb-ubuntu)
  - [RHEL and Centos](#pre-rhel-centos)


  First, make sure the [prerequisites](#pre-macos) have been installed.

  Install cmake:
  ```console
  $ brew install cmake
  ```

  Install command line developer tools:
  ```
  $ xcode-select --install
  ```

  >**NOTE:** It is possible that installing or updating to the the latest version of [Xcode](https://developer.apple.com/download) is needed.

  If setuptools is not installed:
  ```console
  $ python -m pip install setuptools
  ```



  - Download and install [Git](https://git-scm.com/downloads)
  - Download and install [Visual Studio 2019](https://visualstudio.microsoft.com/downloads/)
      + Check *Desktop development with C++* prior to installing
  - Download and install [CMake](https://cmake.org/download/) >= v 3.18
  - Download and install [Python](https://www.python.org/downloads/)



  If seeing issues when trying to build (steps in [](#)), some things to check/try:
  - Try running the build commands within the *Developer Command Prompt for VS2019*
  - Make sure *MSBuild* can find the correct *VCTargetsPath*
      + It is possible the *VCTargetsPath* environment variable needs to be set.  The below example is based on a typical path, but the actual setting should match that of your current environment setup.
          * ```set VCTargetsPath=C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\MSBuild\Microsoft\VC\v160```
  - Make sure *CMake* is picking up the correct generator
      + It is possible the *CMAKE_GENERATOR* environment variable needs to be set
          * ```set CMAKE_GENERATOR=Visual Studio 16 2019```


  Clone this Python SDK repository:
  ```console
  git clone https://github.com/couchbase/couchbase-python-client.git
  ```

  Move into the directory created after cloning the Python SDK repository:
  ```console
  cd couchbase-python-client
  ```

  The following will compile the module locally:
  ```console
  python setup.py build_ext --inplace
  ```

  You can also modify the environment ```CFLAGS``` and ```LDFLAGS``` variables.

  >:exclamation:**WARNING:** If you do not intend to install this module, ensure you set the ```PYTHONPATH``` environment variable to this directory before running any scripts depending on it. Failing to do so may result in your script running against an older version of this module (if installed), or throwing an exception stating that the ```couchbase``` module could not be found.


  ```console
  pip install .
  ```

  >:exclamation:**WARNING:** If you are on Linux/Mac OS you may need to remove the build directory: ```rm -rf ./build``` before installing with pip: ```pip3 install .```.


  [Back to Contents](#contents)



  See [official documentation](https://docs.couchbase.com/python-sdk/current/howtos/managing-connections.html) for further details on connecting.

  ```python

  from couchbase.cluster import Cluster
  from couchbase.auth import PasswordAuthenticator


  from couchbase.options import ClusterOptions, QueryOptions


  cluster = Cluster.connect('couchbase://localhost', ClusterOptions(
    PasswordAuthenticator('Administrator', 'password')))
  ```

  >**NOTE:** The authenticator is always required.



  See official documentation for further details on [Working with Data](https://docs.couchbase.com/python-sdk/current/howtos/kv-operations.html).

  Building upon the example code in the [Connecting](#sdk-connecting) section:

  ```python

  cb = cluster.bucket('travel-sample')


  cb_coll = cb.default_collection()


  result = cb_coll.get('airline_10')
  print(result.content_as[dict])


  call_sign = 'CBS'
  sql_query = 'SELECT VALUE name FROM `travel-sample` WHERE type = "airline" AND callsign = $1'
  query_res = cluster.query(sql_query, QueryOptions(positional_parameters=[call_sign]))
  for row in query_res:
      print(row)
  ```


  The Python Couchbase SDK supports asynchronous I/O through the use of the asyncio (Python standard library) or the Twisted async framework.



  To use asyncio, import ```acouchbase.cluster``` instead of ```couchbase.cluster```.  The ```acouchbase``` API offers an API similar to the ```couchbase``` API.

  ```python
  from acouchbase.cluster import Cluster, get_event_loop
  from couchbase.options import ClusterOptions
  from couchbase.auth import PasswordAuthenticator


  async def write_and_read(key, value):
      cluster = await Cluster.connect('couchbase://localhost',
                        ClusterOptions(PasswordAuthenticator('Administrator', 'password')))
      cb = cluster.bucket('default')
      await cb.on_connect()
      cb_coll = cb.default_collection()
      await cb_coll.upsert(key, value)
      result = await cb_coll.get(key)
      return result

  loop = get_event_loop()
  rv = loop.run_until_complete(write_and_read('foo', 'bar'))
  print(rv.content_as[str])
  ```


  To use with Twisted, import ```txcouchbase.cluster``` instead of ```couchbase.cluster```.  The ```txcouchbase``` API offers an API similar to the ```couchbase``` API.

  >**NOTE:** The minimum required Twisted version is 21.7.0.

  >:exclamation:**WARNING:** The 4.x SDK introduced a breaking change where the txcouchbase package must be imported _prior_ to importing the reactor (see example below).  This is so that the asyncio reactor can be installed.


  ```python

  import txcouchbase
  from twisted.internet import reactor, defer

  from txcouchbase.cluster import TxCluster
  from couchbase.options import ClusterOptions
  from couchbase.auth import PasswordAuthenticator


  def after_upsert(res, key, d):
      print('Set key.  Result CAS: ', res.cas)
      
      d.callback(key)

  def upsert_document(key, doc):
      d = defer.Deferred()
      res = cb.upsert(key, doc)
      res.addCallback(after_upsert, key, d)
      return d

  def on_get(res, _type=str):
      print('Got res: \n', res.content_as[_type])
      reactor.stop()

  def get_document(key):
      res = cb.get(key)
      res.addCallback(on_get)



  cluster = TxCluster('couchbase://localhost',
                      ClusterOptions(PasswordAuthenticator('Administrator', 'password')))


  bucket = cluster.bucket('default')

  cb = bucket.default_collection()

  d = upsert_document('testDoc_1', {'id': 1, 'type': 'testDoc', 'info': 'fake document'})
  d.addCallback(get_document)

  reactor.run()
  ```

  [Back to Contents](#contents)

  The documentation is using Sphinx and a number of extensions.  To build the documentation be sure to
  ``pip install`` the sphinx_requirements.txt.

  ```console
  python3 -m pip install -r sphinx_requirements.txt
  ```

  To build the documentation, go into the docs directory and run:
  ```console
  make html
  ```
  The HTML output can be found in docs/build/html/.

  Alternatively, you can also build the documentation from the top-level directory:
  ```console
  python setup.py build_sphinx
  ```

  Once built, the docs will be in in build/sphinx/html.  You can open the index.html file with the following command:
  ```console
  open docs/build/sphinx/html/index.html
  ```


  [Back to Contents](#contents)

  For running the tests, be sure to ``pip install`` the dev_requirements.txt.  The Couchbase Python SDK uses pytest for the test suite.

  ```console
  python3 -m pip install -r dev_requirements.txt
  ```

  The tests need a running Couchbase instance. For this, a test_config.ini file must be present, containing various connection parameters. The default test_config.ini file may be found in the tests directory. You may modify the values of the test_config.ini file as needed.

  To run the tests for the blocking API (i.e. couchbase API):
  ```console
  python -m pytest -m pycbc_couchbase -p no:asyncio -v -p no:warnings
  ```

  To run the tests for the asyncio API (i.e. acouchbase API):
  ```console
  python -m pytest -m pycbc_acouchbase --asyncio-mode=strict -v -p no:warnings
  ```


  [Back to Contents](#contents)

  We welcome contributions from the community!  Please see follow the steps outlined [here](https://github.com/couchbase/couchbase-python-client/blob/master/CONTRIBUTING.md) to get started.

  The Python SDK uses pre-commit in order to handle linting, formatting and verifying the code base.
  pre-commit can be installed either by install the dev-requirements:

  ```
  python3 -m pip install -r dev-requirements.txt
  ```

  Or by installing pre-commit separately
  ```
  python3 -m pip install pre-commit
  ```

  To run pre-commit, use the following:
  ```
  pre-commit run --all-files
  ```


  [Back to Contents](#contents)

  The Couchbase Python SDK is licensed under the Apache License 2.0.

  See [LICENSE](https://github.com/couchbase/couchbase-python-client/blob/master/LICENSE) for further details.


  [Back to Contents](#contents)

  If you found an issue, please file it in our [JIRA](https://issues.couchbase.com/projects/PYCBC/issues/).

  The Couchbase Discord server is a place where you can collaborate about all things Couchbase. Connect with others from the community, learn tips and tricks, and ask questions.  [Join Discord and contribute](https://discord.com/invite/sQ5qbPZuTh).

  You can ask questions in our [forums](https://forums.couchbase.com/).

  The [official documentation](https://docs.couchbase.com/python-sdk/current/hello-world/start-using-sdk.html) can be consulted as well for general Couchbase concepts and offers a more didactic approach to using the SDK.


  [Back to Contents](#contents)


  See pyenv install [docs](https://github.com/pyenv/pyenv#homebrew-on-macos) for further details.

  Get the latest packages:
  ```console
  $ brew update
  ```

  For TLS/SSL support:
  ```console
  $ brew install openssl@1.1
  ```

  Install pyenv:
  ```console
  $ brew install pyenv
  ```

  >**NOTE:** It is possible that Xcode might need to be reinstalled.  Try **one** of the following:<br>
  >- Use command ```xcode-select --install```
  >- Install the latest version of [Xcode](https://developer.apple.com/download)

  For *Zsh*, run the following commands to update *.zprofile* and *.zshrc*.  See pyenv install [docs](https://github.com/pyenv/pyenv#homebrew-on-macos) for further details on other shells.

  ```console
  $ echo 'eval "$(pyenv init --path)"' >> ~/.zprofile
  ```

  ```console
  $ echo 'eval "$(pyenv init -)"' >> ~/.zshrc
  ```

  >**NOTE:** You need to restart your login session for changes to take affect.  On MacOS, restarting terminal windows should suffice.

  Install Python version:
  ```console
  $ pyenv install 3.9.7
  ```

  Set local shell to installed Python version:
  ```console
  $  pyenv local 3.9.7
  ```

  To use virtualenvwrapper with pyenv, install pyenv-virtualenvwrapper:
  ```console
  $ brew install pyenv-virtualenvwrapper
  ```

  To setup a virtualenvwrapper in your pyenv shell, run either ```pyenv virtualenvwrapper``` or ```pyenv virtualenvwrapper_lazy```

  >**NOTE:** If issues with ```pyenv virtualenvwrapper```, using ```python -m pip install virtualenvwrapper``` should accomplish the same goal.

  Make a virtualenv:
  ```console
  $ mkvirtualenv python-3.9.7-test
  ```

  Install the SDK:
  ```console
  $ python -m pip install couchbase
  ```


  To run pre-commit hooks separately, use the following.


  ```
  pre-commit run autopep8 --all-files
  ```


  ```
  pre-commit run bandit --all-files
  ```


  ```
  pre-commit run clang-format --all-files
  ```


  ```
  pre-commit run flake8 --all-files
  ```


  ```
  pre-commit run isort --all-files
  ```


  ```
  pre-commit run trailing-whitespace --all-files
  ```


pkgId: eee8f0eea61a2a22932aca8eed9c97b6069a1111ab4439c7424e68e412f4bd84
name: python-coverage-badge
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Generate coverage badges for Coverage.py.
url: https://github.com/dbrgn/coverage-badge
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c73af81c-4cdb-4d6d-9e90-98ebb02d5ec2
location_href: 00011812-python-coverage-badge/python-coverage-badge-1.1.0-1.src.rpm
checksum_type: sha256
description:
  A small script to generate coverage badges using Coverage.py. Example of a generated badge:
  The badge template has been taken from shields.io_, therefore it should look
  mostly good. (The spec is a bit stricter on the margins, but I can't easily do
  text width calculations in Python so the margins might not always be 4px.)
  **:arrow_right: Note:** If you need a script with a few more features
  (e.g. test badges, flake8 reports, etc), check out genbadge_.


pkgId: 062c797d655d72fb094e312f445ff13803917ada5713bfd6ecde4e679e04a15a
name: python-coveralls
arch: src
version: 3.3.1
epoch: 0
release: 1
summary: Show coverage stats online via coveralls.io
url: http://github.com/TheKevJames/coveralls-python
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fd37184a-d5ab-4e7b-80fb-24257a5a3500
location_href: 00003342-python-coveralls/python-coveralls-3.3.1-1.src.rpm
checksum_type: sha256
description:
  `coveralls.io`_ is a service for publishing your coverage stats online. This
  package provides seamless integration with `coverage.py`_ (and thus ``pytest``,
  ``nosetests``, etc...) in your Python projects::
      pip install coveralls
      coverage run --source=mypkg -m pytest tests/
      coveralls
  For more information and usage instructions, see our `documentation`_.


pkgId: 4c28711e3cc12bb3c8acea64e9322ff39bd5ec68bbff57c488b7de9f3448438b
name: python-covid
arch: src
version: 2.5.2
epoch: 0
release: 1
url: https://nf1s.github.io/covid/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b606355e-2c38-4b85-adcb-4ed51c5777fe
location_href: 00009770-python-covid/python-covid-2.5.2-1.src.rpm
checksum_type: sha256
summary:
  Python package to get information regarding the novel corona virus provided by Johns Hopkins university and worldometers.info

description:
  [![CircleCI](https://circleci.com/gh/nf1s/covid.svg?style=shield)](https://circleci.com/gh/nf1s/covid) [![codecov](https://codecov.io/gh/nf1s/covid/branch/master/graph/badge.svg)](https://codecov.io/gh/nf1s/covid) ![GitHub Pipenv locked Python version](https://img.shields.io/github/pipenv/locked/python-version/nf1s/covid) [![Downloads](https://pepy.tech/badge/covid)](https://pepy.tech/project/covid) ![GitHub](https://img.shields.io/github/license/nf1s/covid)



  Python package to get information regarding the novel corona virus provided
  by Johns Hopkins university and worldometers.info

  Full Documentation can be found [here](https://nf1s.github.io/covid/)

  ![corona.jpeg](docs/img/corona.jpeg)



      python >= 3.6



      pip install covid



      pydantic
      requests





  ![john_hopkins](docs/img/john_hopkins.png)



  ```python
  from covid import Covid

  covid = Covid()
  covid.get_data()
  ```



  ```python
  [
      {
          'id': '53',
          'country': 'China',
          'confirmed': 81020,
          'active': 9960,
          'deaths': 3217,
          'recovered': 67843,
          'latitude': 30.5928,
          'longitude': 114.3055,
          'last_update': 1584097775000
      },
      {
          'id': '115',
          'country': 'Italy',
          'confirmed': 24747,
          'active': 20603,
          'deaths': 1809,
          'recovered': 2335,
          'latitude': 41.8719,
          'longitude': 12.5674,
          'last_update': 1584318130000
      },
      ...
  ]
  ```



  This comes in handy when you need to know the available names of countries
  when using `get_status_by_country_name`, eg. "The Republic of Moldova" or just "Moldova"
  So use this when you need to know the country exact name that you can use.

  ```python
  countries = covid.list_countries()
  ```



  ```python
  [
      {'id': '53', 'country': 'China'},
      {'id': '115', 'country': 'Italy'}
      ...
  ]
  ```



  ```python
  italy_cases = covid.get_status_by_country_id(115)
  ```



  ```python
  {
      'id': '115',
      'country': 'Italy',
      'confirmed': 24747,
      'active': 20603,
      'deaths': 1809,
      'recovered': 2335,
      'latitude': 41.8719,
      'longitude': 12.5674,
      'last_update': 1584318130000
  }
  ```



  ```python
  italy_cases = covid.get_status_by_country_name("italy")
  ```



  ```python
  {
      'id': '115',
      'country': 'Italy',
      'confirmed': 24747,
      'active': 20603,
      'deaths': 1809,
      'recovered': 2335,
      'latitude': 41.8719,
      'longitude': 12.5674,
      'last_update': 1584318130000
  }
  ```



  ```python
  confirmed = covid.get_total_confirmed_cases()
  ```



  ```python
  deaths = covid.get_total_deaths()
  ```



  ![worldometers](docs/img/worldometers.png)

  ```python
  covid = Covid(source="worldometers")
  ```



  ```python
  covid.get_data()
  ```



  ```python
  [
      {
          'country': 'USA',
          'confirmed': 311637,
          'new_cases': 280,
          'deaths': 8454,
          'recovered': 14828,
          'active': 288355,
          'critical': 8206,
          'new_deaths': 2,
          'total_tests': 1656897,
          'total_tests_per_million': Decimal('0'),
          'total_cases_per_million': Decimal('941'),
          'total_deaths_per_million': Decimal('26')
      },
      {
          'active': 1376,
          'confirmed': 81669,
          'country': 'China',
          'critical': 295,
          'deaths': 3329,
          'new_cases': 30,
          'new_deaths': 3,
          'recovered': 76964,
          'total_cases_per_million': Decimal('57'),
          'total_deaths_per_million': Decimal('2'),
          'total_tests': 0,
          'total_tests_per_million': Decimal('0')
      }
      ...
  ]

  ```



  ```python
  covid.get_status_by_country_name("italy")
  ```



  ```python
  {
      'active': 88274,
      'confirmed': 124632,
      'country': 'Italy',
      'critical': 3994,
      'deaths': 15362,
      'new_cases': 0,
      'new_deaths': 0,
      'recovered': 20996,
      'total_cases_per_million': Decimal('2061'),
      'total_deaths_per_million': Decimal('254'),
      'total_tests': 657224,
      'total_tests_per_million': Decimal('0')
   }
  ```



  ```python
  countries = covid.list_countries()
  ```



  ```python
  [
      'china',
      'italy',
      'usa',
      'spain',
      'germany',
  ...
  ]
  ```



  ```python
  active = covid.get_total_active_cases()
  ```



  ```python
  confirmed = covid.get_total_confirmed_cases()
  ```



  ```python
  recovered = covid.get_total_recovered()
  ```



  ```python
  deaths = covid.get_total_deaths()
  ```



  ```bash
  covid --help
  ```




  ```bash
  covid
  ```

  or

  ```bash
  covid -s john_hopkins
  ```



  ```bash
  covid -s worldometers
  ```



  This comes in handy when you need to know the available names of countries
  when using `covid -s 'source' -c 'country_name'`, eg. "The Republic of Moldova" or just "Moldova"
  So use this when you need to know the country exact name that you can use.

  ```bash
  covid -s worldometers --list-countries
  ```



  ```bash
  covid -s worldometers -c sweden
  ```



  ```bash
  covid -s worldometers -o active
  ```



  ```bash
  covid -s worldometers -o confirmed
  ```



  ```bash
  covid -s worldometers -o recovered
  ```



  ```bash
  covid -s worldometers -o deaths
  ```


pkgId: 31416ebd1a0a75303317ede4848fa362c48ba9e988cdff39fb5190bb19d03def
name: python-covidcast
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Access COVID-19 data through the Delphi COVIDcast API
url: https://cmu-delphi.github.io/covidcast/covidcast-py/html/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fc986da2-bf29-4275-9051-4091489af74b
location_href: 00011519-python-covidcast/python-covidcast-0.1.5-1.src.rpm
checksum_type: sha256
description:
  Provides Python access to the [COVIDcast
  API](https://cmu-delphi.github.io/delphi-epidata/api/covidcast.html) published
  by the [Delphi group](https://delphi.cmu.edu/) at [Carnegie Mellon
  University](https://www.cmu.edu). This API provides daily access to a range of
  COVID-related signals Delphi collects from a variety of sources, including
  cases, deaths, symptom surveys, healthcare data, and other information. This
  package also provides convenient tools for mapping and analyzing the API's data.

  For installation instructions, documentation, and examples, consult the [package
  documentation](https://cmu-delphi.github.io/covidcast/covidcast-py/html/).


pkgId: b142511b2b37233ff09269a984de0ceb4b8c321da48e9844f24daaa980777475
name: python-cowsay
arch: src
version: 5.0
epoch: 0
release: 1
summary: The famous cowsay for GNU/Linux is now available for python
url: https://github.com/VaasuDevanS/cowsay-python
rpm_license: GNU-GPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fd23707d-d924-4c07-ba10-0620d6a1a647
location_href: 00012528-python-cowsay/python-cowsay-5.0-1.src.rpm
checksum_type: sha256
description:
                  \
                   \
                     ^__^
                     (oo)\_______
                     (__)\       )\/\
                         ||----w |
                         ||     ||
  >>> print(cowsay.get_output_string('trex', 'Hello (extinct) World'))
    _____________________


pkgId: ed93943f34ef468a6491d99306ba094f8c041b5c455f38fb79291cf8b1f1fe29
name: python-cpplint
arch: src
version: 1.6.1
epoch: 0
release: 1
summary: Automated checker to ensure C++ files follow Google's style guide
url: https://github.com/cpplint/cpplint
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bbf0d462-611e-480b-a1e8-83b6e99e6422
location_href: 00011436-python-cpplint/python-cpplint-1.6.1-1.src.rpm
checksum_type: sha256
description:
  Cpplint is a command-line tool to check C/C++ files for style issues following `Google's C++ style guide <http://google.github.io/styleguide/cppguide.html>`_.
  Cpplint is developed and maintained by Google Inc. at `google/styleguide <https://github.com/google/styleguide>`_, also see the `wikipedia entry <http://en.wikipedia.org/wiki/Cpplint>`_
  While Google maintains cpplint, Google is not (very) responsive to issues and pull requests, this fork aims to be (somewhat) more open to add fixes to cpplint to enable fixes, when those fixes make cpplint usable in wider contexts.
  Also see discussion here https://github.com/google/styleguide/pull/528.


pkgId: ec535943e7689fc8a467c1b960549f2e8f7422575bec2ff4f77568ebc6d552e2
name: python-cppy
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/nucleic/cppy
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4393ff7f-76ff-4ce5-b6c1-155002df2ac1
location_href: 00011198-python-cppy/python-cppy-1.2.1-1.src.rpm
checksum_type: sha256
description:
  A small C++ header library which makes it easier to write Python extension
  modules. The primary feature is a PyObject smart pointer which automatically
  handles reference counting and provides convenience methods for performing
  common object operations.

rpm_license:
  Copyright (c) 2014, Nucleic All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: dda33a0adcb0bfa542ee39e0fc6bf956bbd3b8c9d8ec1f9bc887d1ff0bfd53d9
name: python-cqlsh
arch: src
version: 6.1.2
epoch: 0
release: 1
summary: cqlsh is a Python-based command-line client for running CQL commands on a cassandra cluster.
url: https://github.com/jeffwidman/cqlsh
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0393d76e-ae8a-428e-a8b2-c1f810287c12
location_href: 00014059-python-cqlsh/python-cqlsh-6.1.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/cqlsh.svg)](https://badge.fury.io/py/cqlsh)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cqlsh)
  [![Downloads](https://pepy.tech/badge/cqlsh)](https://pepy.tech/project/cqlsh)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)



  `cqlsh` is a Python-based command-line client for running `CQL` commands on a `cassandra` cluster.

  Normally it's packaged as part of the full Apache Cassandra™ installation. This repo repackages it into a standalone Python package for lighter-weight installs.



  Install and update using [`pip`](https://pip.pypa.io/en/stable/quickstart/):
  ```
  $ pip install -U cqlsh
  ```



  ```
  $ cqlsh --help
  ```



  Documentation is available as part of the official [Apache Cassandra™ documentation](https://cassandra.apache.org/doc/latest/tools/cqlsh.html).



  Because this is a repackaging of `cqlsh` from the official [Cassandra repo](https://gitbox.apache.org/repos/asf/cassandra.git), **only issues / PRs related to PyPI packaging should be opened against this repo**. If you would like to contribute to `cqlsh` itself, [find out more information here](https://github.com/apache/cassandra/blob/trunk/CONTRIBUTING.md).

  Steps to sanity check that the packaging works as expected:

  1. Install `cqlsh` locally (probably in a `virtualenv`):
  ```
  $ pip install -e .  # run from within the cqlsh directory
  ```
  2. Start a local copy of Cassandra:
  ```
  $ docker pull cassandra
  $ docker run -it --rm -p 9042:9042 cassandra
  ```
  3. Verify `cqlsh` successfully connects to the server:
  ```
  $ cqlsh

  Connected to Test Cluster at 127.0.0.1:9042
  [cqlsh 6.1.0 | Cassandra 4.1.0 | CQL spec 3.4.5 | Native protocol v5]
  Use HELP for help.
  cqlsh>
  ```

  This PyPI package is maintained by [Jeff Widman](https://github.com/jeffwidman) and [Brad Schoening](https://github.com/bschoening). Previous maintainers: [Spiro](https://github.com/spiside) and [Andrew Mussey](https://github.com/amussey).




  Unfortunately the Cassandra project does not always increment the `cqlsh` version number, so for every
  release we need to document not only the `cqlsh` version but also the `cassandra` version in which it
  shipped.



  This packages `cqlsh` `6.1.0` from [Cassandra 4.1.1](https://github.com/apache/cassandra/blob/cassandra-4.1.0/bin/cqlsh.py):
  * Now supports Python 3.11.
  * Although this is pulled from a Cassandra `4.x` release, it is protocol compatible with Cassandra `3.x` clusters, with the exception of DESCRIBE keywords which require a 4.x cluster.





  This packages `cqlsh` `6.1.0` from [Cassandra 4.1](https://github.com/apache/cassandra/blob/cassandra-4.1.0/bin/cqlsh.py):
  * Requires Python 3.6+.
  * Although this is pulled from a Cassandra `4.x` release, it is protocol compatible with Cassandra `3.x` clusters, with the exception of DESCRIBE keywords which require a 4.x cluster.



  The actual source code is identical to the `cqlsh` `6.0.0` release, except it's now packaged as
  a module. This allows it to be used as a library, not just an executable script. It also provides
  better Windows support. Details in https://github.com/jeffwidman/cqlsh/pull/7 by @bschoening.

  Note: This release was yanked from PyPI because it [broke Python 2 compatibility](https://github.com/jeffwidman/cqlsh/issues/11).



  This packages `cqlsh` `6.0.0` from [Cassandra 4.0](https://github.com/apache/cassandra/blob/cassandra-4.0.0/bin/cqlsh.py):
  * Requires Python 3.6+ or 2.7 (although support for Python 2 is deprecated).
  * Although this is pulled from a Cassandra `4.x` release, it should generally work against Cassandra `3.x` clusters without needing to set any flags.




  This packages `cqlsh` `5.0.1` from [Cassandra 4.0-beta4](https://github.com/apache/cassandra/blob/cassandra-4.0-beta4/bin/cqlsh.py):
  * Now supports Python 3.
  * Although this is pulled from a Cassandra `4.x` release, it should generally work against Cassandra `3.x` clusters without needing to set any flags.



  This packages `cqlsh` `5.0.1` from [Cassandra 3.11.10](https://github.com/apache/cassandra/blob/cassandra-3.11.10/bin/cqlsh.py).



  This packages `cqlsh` `5.0.1` from [Cassandra 3.4.0](https://github.com/apache/cassandra/blob/cassandra-3.4/bin/cqlsh.py).




  This packages `cqlsh` `5.0.1` from [Cassandra 2.2.0](https://github.com/apache/cassandra/blob/cassandra-2.2.0/bin/cqlsh.py).




  This packages `cqlsh` `4.1.1` from [Cassandra 2.0.5](https://github.com/apache/cassandra/blob/cassandra-2.0.5/bin/cqlsh).




  This packages `cqlsh` `4.1.0` from [Cassandra 2.0.3](https://github.com/apache/cassandra/blob/cassandra-2.0.3/bin/cqlsh).




  This packages `cqlsh` `4.0.1` from [Cassandra 2.0.1](https://github.com/apache/cassandra/blob/cassandra-2.0.1/bin/cqlsh).


pkgId: d9013c05929ba82c1ac370f0aa6b899991f49decbaae13805478b1f82b37bdd6
name: python-crashtest
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Manage Python errors with ease
url: https://github.com/sdispater/crashtest
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5f935d39-e498-4a42-a02c-0baf16e33642
location_href: 00003350-python-crashtest/python-crashtest-0.4.1-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/sdispater/crashtest/actions/workflows/main.yml/badge.svg)](https://github.com/sdispater/crashtest/actions/workflows/main.yml)
  [![PyPI version](https://img.shields.io/pypi/v/crashtest)](https://pypi.org/project/crashtest/)

  Crashtest is a Python library that makes exceptions handling and inspection easier.


pkgId: a800e3c0254c129b1f3d35f782be8d7d02e8d359cb070ef02ce9db4c8a74632a
name: python-crayons
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: TextUI colors for Python.
url: https://github.com/MasterOdin/crayons
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8d5468ac-02fc-424d-bea6-6fefdf2f2094
location_href: 00003351-python-crayons/python-crayons-0.4.0-1.src.rpm
checksum_type: sha256
description:
  This module is really simple, it gives you colored strings for terminal
  usage. Included colors are ``red``, ``green``, ``yellow``, ``blue``, ``black``, ``magenta``, ``cyan``, ``white``, and
  ``normal`` (as well as ``clean`` and ``disable``).
  **Crayons** is nice because it automatically wraps a given string in both the foreground color, as well as returning to the
  original state after the string is complete. Most terminal color libraries make you manage this yourself.
  Arguments include ``always=True`` and ``bold=True``.


pkgId: 997d82fd5f1968da0a4d3f05f1fd9d92d761440e9c377b1d1ec219670b643949
name: python-crc32c
arch: src
version: 2.3.post0
epoch: 0
release: 1
summary: A python package implementing the crc32c algorithm in hardware and software
url: https://github.com/ICRAR/crc32c
rpm_license: LGPLv2.1+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d3daf593-b19e-48ac-ad87-681d0e86818a
location_href: 00011560-python-crc32c/python-crc32c-2.3.post0-1.src.rpm
checksum_type: sha256
description:
  This package implements the crc32c checksum algorithm.
  It automatically chooses between a hardware-based implementation
  (using the CRC32C SSE 4.2 instruction of Intel CPUs,
  and the crc32* instructions on ARMv8 CPUs),
  or a software-based one when no hardware support can be found.
  Because ``crc32c`` is in PyPI, you can install it with::
   pip install crc32c
  Supported platforms are Linux and OSX using the gcc and clang compilers,
  and Windows using the Visual Studio compiler. Other compilers in
  Windows (MinGW for instance) might work.
  Binary wheels are also provided in PyPI for major platforms/architectures.


pkgId: aaeb6d67c3be8ef0a86a3cb592ac5ae7f8511fb04530bf397ed422571443a579
name: python-crc32c-debuginfo
arch: aarch64
version: 2.3.post0
epoch: 0
release: 1
summary: Debug information for package python-crc32c
url: https://github.com/ICRAR/crc32c
rpm_license: LGPLv2.1+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-d3daf593-b19e-48ac-ad87-681d0e86818a
rpm_sourcerpm: python-crc32c-2.3.post0-1.src.rpm
location_href: 00011560-python-crc32c/python-crc32c-debuginfo-2.3.post0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-crc32c.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 1eb1c7e62b113c2996a6e8101bcb35c2bca9d598ad07cfbd8af5721c3db68b15
name: python-crc32c-debugsource
arch: aarch64
version: 2.3.post0
epoch: 0
release: 1
summary: Debug sources for package python-crc32c
url: https://github.com/ICRAR/crc32c
rpm_license: LGPLv2.1+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-d3daf593-b19e-48ac-ad87-681d0e86818a
rpm_sourcerpm: python-crc32c-2.3.post0-1.src.rpm
location_href: 00011560-python-crc32c/python-crc32c-debugsource-2.3.post0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-crc32c.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: e93734a3ecba460a74e4b2ce15a1901bea1ef30f73d4064b22b6fcf8e2a22b2b
name: python-crcelk
arch: src
version: 1.3
epoch: 0
release: 1
url: https://github.com/zeroSteiner/crcelk
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-49356762-bd42-4dc6-acfa-73f64ad17f0c
location_href: 00003352-python-crcelk/python-crcelk-1.3-1.src.rpm
checksum_type: sha256
summary:
  CrcElk is an updated fork of the CrcMoose module for recent versions of Python. It provides a pure Python implementation of the CRC algorithm and allows for variants to easily be defined by providing their parameters such as width, starting polynomial, etc. Python versions 2.6+ and 3.1+ are supported.

description:
  |Github Issues| |PyPi Release|
  CrcElk is an updated fork of the `CrcMoose <http://www.nightmare.com/~ryb/>`__
  module for recent versions of Python. It provides a pure Python implementation
  of the CRC algorithm and allows for variants to easily be defined by providing
  their parameters such as width, starting polynomial, etc. Python versions 2.6+
  and 3.1+ are supported.


pkgId: 195def50ea306d334985d2eb5502a550a7f825181eafb70e2eb6c2e32159edf4
name: python-crhelper
arch: src
version: 2.0.11
epoch: 0
release: 1
summary: crhelper simplifies authoring CloudFormation Custom Resources
url: https://github.com/aws-cloudformation/custom-resource-helper
rpm_license: Apache2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2599b373-f1e7-42fc-94a0-c83de034eb6e
location_href: 00011613-python-crhelper/python-crhelper-2.0.11-1.src.rpm
checksum_type: sha256
description:
  Simplify best practice Custom Resource creation, sending responses to CloudFormation and providing exception, timeout
  trapping, and detailed configurable logging.

  [![PyPI Version](https://img.shields.io/pypi/v/crhelper.svg)](https://pypi.org/project/crhelper/)
  ![Python Versions](https://img.shields.io/pypi/pyversions/crhelper.svg)
  [![Build Status](https://travis-ci.com/aws-cloudformation/custom-resource-helper.svg?branch=main)](https://travis-ci.com/aws-cloudformation/custom-resource-helper)
  [![Test Coverage](https://codecov.io/gh/aws-cloudformation/custom-resource-helper/branch/main/graph/badge.svg)](https://codecov.io/gh/aws-cloudformation/custom-resource-helper)



  * Dead simple to use, reduces the complexity of writing a CloudFormation custom resource
  * Guarantees that CloudFormation will get a response even if an exception is raised
  * Returns meaningful errors to CloudFormation Stack events in the case of a failure
  * Polling enables run times longer than the lambda 15 minute limit
  * JSON logging that includes request id's, stack id's and request type to assist in tracing logs relevant to a
  particular CloudFormation event
  * Catches function timeouts and sends CloudFormation a failure response
  * Static typing (mypy) compatible



  Install into the root folder of your lambda function

  ```shell
  cd my-lambda-function/
  pip install crhelper -t .
  ```



  [This blog](https://aws.amazon.com/blogs/infrastructure-and-automation/aws-cloudformation-custom-resource-creation-with-python-aws-lambda-and-crhelper/) covers usage in more detail.

  ```python
  from __future__ import print_function
  from crhelper import CfnResource
  import logging

  logger = logging.getLogger(__name__)

  helper = CfnResource(json_logging=False, log_level='DEBUG', boto_level='CRITICAL', sleep_on_delete=120, ssl_verify=None)

  try:
      
      pass
  except Exception as e:
      helper.init_failure(e)


  @helper.create
  def create(event, context):
      logger.info("Got Create")
      
      
      
      
      
      
      helper.Data.update({"test": "testdata"})

      
      if not helper.Data.get("test"):
          raise ValueError("this error will show in the cloudformation events log and console.")

      return "MyResourceId"


  @helper.update
  def update(event, context):
      logger.info("Got Update")
      
      


  @helper.delete
  def delete(event, context):
      logger.info("Got Delete")
      
      


  @helper.poll_create
  def poll_create(event, context):
      logger.info("Got create poll")
      
      
      return True


  def handler(event, context):
      helper(event, context)
  ```



  If you need longer than the max runtime of 15 minutes, you can enable polling by adding additional decorators for
  `poll_create`, `poll_update` or `poll_delete`. When a poll function is defined for `create`/`update`/`delete` the
  function will not send a response to CloudFormation and instead a CloudWatch Events schedule will be created to
  re-invoke the lambda function every 2 minutes. When the function is invoked the matching `@helper.poll_` function will
  be called, logic to check for completion should go here, if the function returns `None` then the schedule will run again
  in 2 minutes. Once complete either return a PhysicalResourceID or `True` to have one generated. The schedule will be
  deleted and a response sent back to CloudFormation. If you use polling the following additional IAM policy must be
  attached to the function's IAM role:

  ```json
  {
    "Version": "2012-10-17",
    "Statement": [
      {
        "Effect": "Allow",
        "Action": [
          "lambda:AddPermission",
          "lambda:RemovePermission",
          "events:PutRule",
          "events:DeleteRule",
          "events:PutTargets",
          "events:RemoveTargets"
        ],
        "Resource": "*"
      }
    ]
  }
  ```

  To turn off certification verification, or to use a custom CA bundle path for the underlying boto3 clients used by this library, override the `ssl_verify` argument with the appropriate values.  These can be either:
  * `False` - do not validate SSL certificates. SSL will still be used, but SSL certificates will not be verified.
  * `path/to/cert/bundle.pem` - A filename of the CA cert bundle to uses. You can specify this argument if you want to use a different CA cert bundle than the one used by botocore.



  Decorator implementation inspired by https://github.com/ryansb/cfn-wrapper-python

  Log implementation inspired by https://gitlab.com/hadrien/aws_lambda_logging



  This library is licensed under the Apache 2.0 License.


pkgId: 3a644ab8c4582fd7930940480e6d8950ac46d8f0d0d289080288214417ed7747
name: python-crochet
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Use Twisted anywhere!
url: https://github.com/itamarst/crochet
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-50bb6cf5-9169-40e3-9e19-80f9cc96330e
location_href: 00003354-python-crochet/python-crochet-2.0.0-1.src.rpm
checksum_type: sha256
description:
  Crochet is an MIT-licensed library that makes it easier to use Twisted from
  regular blocking code. Some use cases include:
  * Easily use Twisted from a blocking framework like Django or Flask.
  * Write a library that provides a blocking API, but uses Twisted for its
    implementation.
  * Port blocking code to Twisted more easily, by keeping a backwards
    compatibility layer.
  * Allow normal Twisted programs that use threads to interact with Twisted more
    cleanly from their threaded parts. For example, this can be useful when using
    Twisted as a `WSGI container`_.
  Crochet is maintained by Itamar Turner-Trauring.
    **Note:** Crochet development is pretty slow these days because mostly it **Just Works**. PyPI shows about 30,000 downloads a month, so existing users seem happy: https://pypistats.org/packages/crochet
  You can install Crochet by running::
    $ pip install crochet
  Downloads are available on `PyPI`_.
  Documentation can be found on `Read The Docs`_.
  Bugs and feature requests should be filed at the project `Github page`_.


pkgId: 187a153da57f5d20e3244cdbee241d806fb33cd2761a22e91190e124eed65deb
name: python-cronex
arch: src
version: 0.1.3.1
epoch: 0
release: 1
summary: This module provides an easy to use interface for cron-like task scheduling.
url: https://github.com/ericpruitt/cronex
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-62025653-4323-4a4e-976e-44f2a4584223
location_href: 00011374-python-cronex/python-cronex-0.1.3.1-1.src.rpm
checksum_type: sha256
description:
  This module provides an easy to use interface for cron-like task
  scheduling. The cron expression evaluation implemented by this library
  is 100% Vixie Cron compatible and also supports `Java
  Quartz's <http://www.quartz-scheduler.org/documentation/quartz-1.x/tutorials/crontrigger>`__
  non-standard "L", "W" and "#" characters.
  One other useful feature this library provides is the ability to set
  triggers at arbitrary intervals such as every 9 hours, every 11 minutes,
  etc., without the issues caused by using asterisk-slash notation; using
  ``*/9`` in the hours field of most cron implementations would result in
  a trigger firing at 9:XX AM at 6:XX PM each day, but with
  CronExpresssions, the trigger would fire at 9:XX AM, 6:XX PM then, on
  the following day 3:XX AM, 12:XX PM, 9:XX PM and so.


pkgId: 4670a760560f78764717569a56e52eece34715b4858f31553cc00daa01e8f56c
name: python-croniter
arch: src
version: 1.3.8
epoch: 0
release: 1
summary: croniter provides iteration for datetime object with cron like format
url: http://github.com/kiorky/croniter
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a163ea9c-b063-4ffd-93cb-192e77e8f360
location_href: 00003355-python-croniter/python-croniter-1.3.8-1.src.rpm
checksum_type: sha256
description:
  croniter provides iteration for the datetime object with a cron like format.
                            _ _
        ___ _ __ ___  _ __ (_) |_ ___ _ __
       / __| '__/ _ \| '_ \| | __/ _ \ '__|
      | (__| | | (_) | | | | | ||  __/ |
       \___|_|  \___/|_| |_|_|\__\___|_|
  Website: https://github.com/kiorky/croniter


pkgId: 41dca5c7012afe8b87801e5631b7c1f2a33dc76e52beb49692057c08cd3ac70b
name: python-cronitor
arch: src
version: 4.6.0
epoch: 0
release: 1
summary: A lightweight Python client for Cronitor.
url: https://github.com/cronitorio/cronitor-python
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2f0e5f35-86cc-43f1-bfcd-4d937990d0c8
location_href: 00013783-python-cronitor/python-cronitor-4.6.0-1.src.rpm
checksum_type: sha256
description:
  ![Test](https://github.com/cronitorio/cronitor-python/workflows/Test/badge.svg)

  [Cronitor](https://cronitor.io/) provides end-to-end monitoring for background jobs, websites, APIs, and anything else that can send or receive an HTTP request. This library provides convenient access to the Cronitor API from applications written in Python. See our [API docs](https://cronitor.io/docs/api) for detailed references on configuring monitors and sending telemetry pings.

  In this guide:

  - [Installation](#Installation)
  - [Monitoring Background Jobs](#monitoring-background-jobs)
  - [Sending Telemetry Events](#sending-telemetry-events)
  - [Configuring Monitors](#configuring-monitors)
  - [Package Configuration & Env Vars](#package-configuration)
  - [Command Line Usage](#command-line-usage)



  ```
  pip install cronitor
  ```




  `cronitor-python` can automatically discover all of your declared Celery tasks, including your Celerybeat scheduled tasks,
  creating monitors for them and sending pings when tasks run, succeed, or fail. Your API keys can be found [here](https://cronitor.io/settings/api).

  Requires Celery 4.0 or higher. Celery auto-discover utilizes the Celery [message protocol version 2](https://docs.celeryproject.org/en/stable/internals/protocol.html#version-2).

  <details>
  <summary>Some important notes on support</summary>

  * Tasks on [solar schedules](https://docs.celeryproject.org/en/stable/userguide/periodic-tasks.html#solar-schedules) are not supported and will be ignored.
  * [`django-celery-beat`](https://docs.celeryproject.org/en/stable/userguide/periodic-tasks.html#using-custom-scheduler-classes) is not yet supported, but is in the works.
  * If you use the default `PersistentScheduler`, the celerybeat integration overrides the celerybeat local task run database (as referenced [here](https://docs.celeryproject.org/en/stable/userguide/periodic-tasks.html#starting-the-scheduler) in the docs), named `celerybeat-schedule` by default. If you currently specify a custom location for this database, this integration will override it. **Very** few people require setting custom locations for this database. If you fall into this group and want to use `cronitor-python`'s celerybeat integration, please reach out to Cronitor support.
  </details>

  ```python
  import cronitor.celery
  from celery import Celery

  app = Celery()
  app.conf.beat_schedule = {
      'run-me-every-minute': {
          'task': 'tasks.every_minute_celery_task',
          'schedule': 60
      }
  }


  cronitor.celery.initialize(app, api_key="apiKey123")

  @app.task
  def every_minute_celery_task():
      print("running a background job with celery...")

  @app.task
  def non_scheduled_celery_task():
      print("Even though I'm not on a schedule, I'll still be monitored!")
  ```

  If you want only to monitor Celerybeat periodic tasks, and not tasks triggered any other way, you can set `celereybeat_only=True` when initializing:
  ```python
  app = Celery()
  cronitor.celery.initialize(app, api_key="apiKey123", celerybeat_only=True)
  ```



  The `@cronitor.job` is a lightweight way to monitor any background task regardless of how it is executed. It will send telemetry events before calling your function and after it exits. If your function raises an exception a `fail` event will be sent (and the exception re-raised).

  ```python
  import cronitor


  cronitor.api_key = 'apiKey123'



  @cronitor.job('send-invoices')
  def send_invoices_task(*args, **kwargs):
      ...
  ```



  If you want to send a heartbeat events, or want finer control over when/how [telemetry events](https://cronitor.io/docs/telemetry-api) are sent for your jobs, you can create a monitor instance and call the `.ping` method.

  ```python
  import cronitor


  cronitor.api_key = 'apiKey123'

  monitor = cronitor.Monitor('heartbeat-monitor')
  monitor.ping() # send a heartbeat event



  monitor.ping(
      state='run|complete|fail|ok', # run|complete|fail used to measure lifecycle of a job, ok used for manual reset only.
      env='', # the environment this is running in (e.g. staging, production)
      message='', # message that will be displayed in alerts as well as monitor activity panel on your dashboard.
      metrics={
          'duration': 100, # how long the job ran (complete|fail only). cronitor will calculate this when not provided
          'count': 4500, # if your job is processing a number of items you can report a count
          'error_count': 10 # the number of errors that occurred while this job was running
      }
  )
  ```



  You can configure all of your monitors using a single YAML file. This can be version controlled and synced to Cronitor as part of
  a deployment or build process. For details on all of the attributes that can be set, see the [Monitor API](https://cronitor.io/docs/monitor-api) documentation.


  ```python
  import cronitor


  cronitor.api_key = 'apiKey123'

  cronitor.read_config('./cronitor.yaml') # parse the yaml file of monitors

  cronitor.validate_config() # send monitors to Cronitor for configuration validation

  cronitor.apply_config() # sync the monitors from the config file to Cronitor

  cronitor.generate_config() # generate a new config file from the Cronitor API
  ```


  The `cronitor.yaml` file includes three top level keys `jobs`, `checks`, `heartbeats`. You can configure monitors under each key by defining [monitors](https://cronitor.io/docs/monitor-api#attributes).

  ```yaml
  jobs:
      nightly-database-backup:
          schedule: 0 0 * * *
          notify:
              - devops-alert-pagerduty
          assertions:
              - metric.duration < 5 minutes

      send-welcome-email:
          schedule: every 10 minutes
          assertions:
              - metric.count > 0
              - metric.duration < 30 seconds

  checks:
      cronitor-homepage:
          request:
              url: https://cronitor.io
              regions:
                  - us-east-1
                  - eu-central-1
                  - ap-northeast-1
          assertions:
              - response.code = 200
              - response.time < 2s

      cronitor-ping-api:
          request:
              url: https://cronitor.link/ping
          assertions:
              - response.body contains ok
              - response.time < .25s

  heartbeats:
      production-deploy:
          notify:
              alerts: ['deploys-slack']
              events: true # send alert when the event occurs

  ```

  You can also create and update monitors by calling `Monitor.put`. For details on all of the attributes that can be set see the Monitor API [documentation)(https://cronitor.io/docs/monitor-api#attributes).

  ```python
  import cronitor

  monitors = cronitor.Monitor.put([
    {
      'type': 'job',
      'key': 'send-customer-invoices',
      'schedule': '0 0 * * *',
      'assertions': [
          'metric.duration < 5 min'
      ],
      'notify': ['devops-alerts-slack']
    },
    {
      'type': 'check',
      'key': 'Cronitor Homepage',
      'schedule': 'every 45 seconds',
      'request': {
          'url': 'https://cronitor.io'
      },
      'assertions': [
          'response.code = 200',
          'response.time < 600ms',
      ]
    }
  ])
  ```



  ```python
  import cronitor

  monitor = cronitor.Monitor('heartbeat-monitor');

  monitor.pause(24) # pause alerting for 24 hours
  monitor.unpause() # alias for .pause(0)
  monitor.ok() # manually reset to a passing state alias for monitor.ping({state: ok})
  monitor.delete() # destroy the monitor
  ```



  The package needs to be configured with your account's `API key`, which is available on the [account settings](https://cronitor.io/settings) page. You can also optionally specify an `api_version` and an `environment`. If not provided, your account default is used. These can also be supplied using the environment variables `CRONITOR_API_KEY`, `CRONITOR_API_VERSION`, `CRONITOR_ENVIRONMENT`.

  ```python
  import cronitor


  cronitor.api_key = 'apiKey123'
  cronitor.api_version = '2020-10-01'
  cronitor.environment = 'cluster_1_prod'
  ```



  ```bash
  >> python -m cronitor -h

  usage: cronitor [-h] [--apikey APIKEY] [--key KEY] [--msg MSG]
                  (--run | --complete | --fail | --ok | --pause PAUSE)

  Send status messages to Cronitor ping API.

  optional arguments:
    -h, --help            show this help message and exit
    --authkey AUTHKEY, -a AUTHKEY
                          Auth Key from Account page
    --key KEY, -k KEY     Unique key for the monitor to take ping
    --msg MSG, -m MSG     Optional message to send with ping/fail
    --tick, -t            Call ping on given monitor
    --run, -r             Call ping with state=run on given monitor
    --complete, -C        Call ping with state=complete on given monitor
    --fail, -f            Call ping with state=fail on given monitor
    --pause PAUSE, -P PAUSE
                          Call pause on given monitor
  ```




  Pull requests and features are happily considered! By participating in this project you agree to abide by the [Code of Conduct](http://contributor-covenant.org/version/2/0).



  Fork, then clone the repo:

      git clone git@github.com:your-username/cronitor-python.git

  Set up your machine:

      pip install -r requirements

  Make sure the tests pass:

      pytest

  Make your change. Add tests for your change. Make the tests pass:

      pytest


  Push to your fork and [submit a pull request]( https://github.com/cronitorio/cronitor-python/compare/)


pkgId: ec48173b174d9221467baa247716a6c050bcb1fcd1c1f65470b9dd8a69fbf1df
name: python-crontab
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Parse and use crontab schedules in Python
url: https://github.com/josiahcarlson/parse-crontab
rpm_license: GNU LGPL v2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2c9558dd-d4e9-4a70-bc23-5ad7917b78b1
location_href: 00009763-python-crontab/python-crontab-1.0.1-1.src.rpm
checksum_type: sha256
description:
  This package intends to offer a method of parsing crontab schedule entries and
  determining when an item should next be run. More specifically, it calculates
  a delay in seconds from when the .next() method is called to when the item
  should next be executed.
  Comparing the below chart to http://en.wikipedia.org/wiki/Cron#CRON_expression


pkgId: ceacb0972312b0aeac2007006881e4eb1c37218df61dd74d8c338f12b64e704a
name: python-crypto
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: Simple symmetric GPG file encryption and decryption
url: https://github.com/chrissimpkins/crypto
rpm_license: MIT license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-27ee5c24-c54c-43f1-a0d5-4c15da04d33e
location_href: 00009827-python-crypto/python-crypto-1.4.1-1.src.rpm
checksum_type: sha256
description:
  crypto provides a simple interface to symmetric Gnu Privacy Guard (gpg) encryption and decryption for one or more files on Unix and Linux platforms.  It runs on top of gpg and requires a gpg install on your system.  Encryption is performed with the AES256 cipher algorithm. `Benchmarks relative to default gpg settings are available for text and binary file mime types <https://chrissimpkins.github.io/crypto/benchmarks.html>`_.
  crypto provides a number of options including automated tar archives of multiple files prior to encryption, portable ASCII armored encryption formatting, and SHA256 hash digest generation for your encrypted files.  You can view all available options in the `usage documentation <http://chrissimpkins.github.io/crypto/usage.html>`_ or with the ``--help`` option.
  Tested in cPython 2.7.x, 3.4.x, and pypy 2.6.x (Python version 2.7.9)


pkgId: 80e9c764a62422626ce27995b48352f5d73bddf7dca630c06adea4bd115c6894
name: python-cryptocode
arch: src
version: 0.1
epoch: 0
release: 1
summary: Python library used to encrypt and decrypt strings in the simplest possible way.
url: https://github.com/gdavid7/cryptocode
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c4f16457-1a2b-4807-8e4d-a41334c4cde6
location_href: 00011326-python-cryptocode/python-cryptocode-0.1-1.src.rpm
checksum_type: sha256
description:
  Python library used to encrypt and decrypt strings in the simplest possible way, while also being incredibly secure.



  - **Python** 3 or later.



  Install some Python utilities along with some libraries and other stuff:

  ~~~
  pip install cryptocode
  ~~~


  Encrypting a message:

  ~~~
  >>> import cryptocode
  >>> myEncryptedMessage = cryptocode.encrypt("I like trains", "password123")
  >>> print(myEncryptedMessage)
  M+Wykmlub0z7FhEdmA==*PvAbXRNx0SiSDHHxLsKZ5w==*ihQM/fdkgrX3G+yOItyAUQ==*QFNDmuUP1ysgo01/P2MNpg==
  ~~~

  The first parameter is the string you want to encrypt. The second parameter is the password, which will be used for decrypting the string.

  Decrypting a message"
  ~~~
  >>> import cryptocode
  >>> myDecryptedMessage = cryptocode.decrypt("M+Wykmlub0z7FhEdmA==*PvAbXRNx0SiSDHHxLsKZ5w==*ihQM/fdkgrX3G+yOItyAUQ==*QFNDmuUP1ysgo01/P2MNpg==", "password123")
  >>> print(myDecryptedMessage)
  I like trains
  ~~~
  The first parameter is the encrypted string and the second parameter is the password. If the password is incorrect, decrypt function will return `False`.


  Here, we will be creating a simple "trial product key". This is useful if you have software that you would like people to use temporarily.
  In this example, we will be letting the user use the product for 2 hours. The password we will be using is ``cryptocode is amazing``.

  Code on the server side:
  ~~~
  import cryptocode
  import time
  hours = 2
  messageToEncrypt = str(time.time() + hours * 60 * 60)

  cryptocode.encrypt(messageToEncrypt, "cryptocode is amazing")
  ~~~

  Code on the client side:
  ~~~
  import cryptocode
  import time
  import sys

  def check_valid(key):
      message = cryptocode.decrypt(key, 'cryptocode is amazing')
      if message == False:
          
          return False
      if float(message) >= time.time():
          return True
      else:
          
          return False
  userKeyInput = input("Please enter your product key.")
  keyChecked = check_valid(userKeyInput)
  if keyChecked == True:
      print("You are good to go!")
  if keyChecked == False:
      print("You have either entered an invalid key or your time has expired. Sorry!")
      sys.exit()
  ~~~


pkgId: a4b561a961c9c4642ee95550902c954278dd6d54032e5ec31bad0e5f8e014f40
name: python-cson
arch: src
version: 0.8
epoch: 0
release: 1
summary: A parser for Coffeescript Object Notation (CSON)
url: https://github.com/avakar/pycson
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-430a38c7-8d0d-4c50-9553-2c60f7a953da
location_href: 00003358-python-cson/python-cson-0.8-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/avakar/pycson.svg?branch=master)](https://travis-ci.org/avakar/pycson)

  A python parser for the Coffeescript Object Notation (CSON).



  The parser is tested on Python 2.7 and 3.5.

      pip install cson

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

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



  There is not formal definition of CSON, only an informal note in [one project][1]'s readme.
  Informally, CSON is a JSON, but with a Coffeescript syntax. Sadly [Coffescript][2] has no
  format grammar either; it instead has a canonical implementation.

  This means that bugs in the implementation translate into bugs in the language itself.

  Worse, this particular implementation inserts a "rewriter" between the typical
  lexer/parser pair, purporting that it makes the grammar simpler. Unfortunately, it adds
  weird corner cases to the language..

  This parser does away with the corner cases,
  in exchange for changing the semantics of documents in a few unlikely circumstances.
  In other words, some documents may be parsed differently by the Coffescript parser and pycson.

  Here are some important highlights (see the [formal grammar][3] for details).

  * String interpolations (`"#{test}"`) are allowed, but are treated literally.
  * Whitespace is ignored in arrays and in objects enclosed in braces
    (Coffeescripts requires consistent indentation).
  * Unbraced objects greedily consume as many key/value pairs as they can.
  * All lines in an unbraced object must have the same indentation. This is the only place
    where whitespace is significant. There are no special provisions for partial dedents.
    For two lines to have the same indent, their maximal sequences of leading spaces and tabs
    must be the same (Coffescript only tracks the number of whitespace characters).
  * Unbraced objects that don't start on their own line will never span multiple lines.
  * Commas at the end of the line can always be removed without changing the output.

  I believe the above rules make the parse unambiguous.

  This example demonstrates the effect of indentation.

      
      [
        a: 1
        b: 2
        c: 3
      ]

      
      [
        a: 1
         b: 2
        c: 3
      ]

      
      [ a: 1
        b: 2
        c: 3 ]

  Note that pycson can parse all JSON documents correctly (Coffeescript can't because
  of whitespace and string interpolations).

    [1]: https://github.com/bevry/cson
    [2]: http://coffeescript.org/
    [3]: grammar.md


pkgId: 3b422b897cc5763ee95fa89c011742610f89038e2c057eeae6bab0ab31c5f921
name: python-css-parser
arch: src
version: 1.0.8
epoch: 0
release: 1
summary: A CSS Cascading Style Sheets library for Python
url: https://github.com/ebook-utils/css-parser
rpm_license: LGPL 3.0 or later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-54a0cf92-1a6b-4099-829a-ac091115bb98
location_href: 00003361-python-css-parser/python-css-parser-1.0.8-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/ebook-utils/css-parser/workflows/CI/badge.svg)](https://github.com/ebook-utils/css-parser/actions?query=workflow%3ACI)
  A fork of the cssutils project based on version 1.0.2.
  This fork includes general bug fixes and extensions
  specific to editing and working with ebooks.
  The main python source code has been modified so
  that it will run without further conversion on both
  Python >= 2.7 and Python 3.X without any further
  modules required.  All required modifications
  are handled local to each file
  For more information on usage, please see the
  [cssutils documentation](https://cssutils.readthedocs.io).


pkgId: baf1b017c584eeccba44ee2aa307af6cb62cecd53ef7344485925446686176db
name: python-cssselect2
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: CSS selectors for Python ElementTree
url: https://doc.courtbouillon.org/cssselect2/
rpm_license: None
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9b0282e3-39d4-4179-ab71-a8fa342533ea
location_href: 00003363-python-cssselect2/python-cssselect2-0.7.0-1.src.rpm
checksum_type: sha256
description:
  cssselect2 is a straightforward implementation of CSS4 Selectors for markup
  documents (HTML, XML, etc.) that can be read by ElementTree-like parsers
  (including cElementTree, lxml, html5lib, etc.)

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

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

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


pkgId: 313311e780c848a455ea4e09bef0727a081eab03792791587d59ec5c15f4f5b6
name: python-csvkit
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: A suite of command-line tools for working with CSV, the king of tabular file formats.
url: https://github.com/wireservice/csvkit
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f24bbb25-c368-4f9d-86b1-2e94fe6b6f06
location_href: 00003365-python-csvkit/python-csvkit-1.1.1-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://github.com/wireservice/csvkit/workflows/CI/badge.svg
      :target: https://github.com/wireservice/csvkit/actions
      :alt: Build status

  .. image:: https://coveralls.io/repos/wireservice/csvkit/badge.svg?branch=master
      :target: https://coveralls.io/r/wireservice/csvkit
      :alt: Coverage Status

  .. image:: https://img.shields.io/pypi/dm/csvkit.svg
      :target: https://pypi.python.org/pypi/csvkit
      :alt: PyPI downloads

  .. image:: https://img.shields.io/pypi/v/csvkit.svg
      :target: https://pypi.python.org/pypi/csvkit
      :alt: Version

  .. image:: https://img.shields.io/pypi/l/csvkit.svg
      :target: https://pypi.python.org/pypi/csvkit
      :alt: License

  .. image:: https://img.shields.io/pypi/pyversions/csvkit.svg
      :target: https://pypi.python.org/pypi/csvkit
      :alt: Support Python versions

  csvkit is a suite of command-line tools for converting to and working with CSV, the king of tabular file formats.

  It is inspired by pdftk, GDAL and the original csvcut tool by Joe Germuska and Aaron Bycoffe.

  Important links:

  * Documentation: https://csvkit.rtfd.org/
  * Repository:    https://github.com/wireservice/csvkit
  * Issues:        https://github.com/wireservice/csvkit/issues
  * Schemas:       https://github.com/wireservice/ffs


pkgId: d18b538d2e114f85fef8670cc890481e607c39bb17a4b5a1bfeedf48a46da1b3
name: python-cu2qu
arch: src
version: 1.6.7.post2
epoch: 0
release: 1
summary: Cubic-to-quadratic bezier curve conversion
url: https://github.com/googlefonts
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d2cf2b61-0efb-4b54-a634-04293e66352b
location_href: 00003366-python-cu2qu/python-cu2qu-1.6.7.post2-1.src.rpm
checksum_type: sha256
description:
  This library provides functions which take in UFO objects (Defcon Fonts
  or Robofab RFonts) and converts any cubic curves to quadratic. The most
  useful function is probably ``fonts_to_quadratic``.
  This library is now maintained as part of https://github.com/fonttools/fonttools


pkgId: d0a0d28953d402d619bfc65cfb6ccf13d5521b4f11cfa5ba31a090f4136cc421
name: python-cu2qu-debuginfo
arch: aarch64
version: 1.6.7.post2
epoch: 0
release: 1
summary: Debug information for package python-cu2qu
url: https://github.com/googlefonts
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-d2cf2b61-0efb-4b54-a634-04293e66352b
rpm_sourcerpm: python-cu2qu-1.6.7.post2-1.src.rpm
location_href: 00003366-python-cu2qu/python-cu2qu-debuginfo-1.6.7.post2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-cu2qu.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: fa0dfac513336b0e91f30e171dffec64128a50173225718b3748dedbf0aaac8e
name: python-cu2qu-debugsource
arch: aarch64
version: 1.6.7.post2
epoch: 0
release: 1
summary: Debug sources for package python-cu2qu
url: https://github.com/googlefonts
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-d2cf2b61-0efb-4b54-a634-04293e66352b
rpm_sourcerpm: python-cu2qu-1.6.7.post2-1.src.rpm
location_href: 00003366-python-cu2qu/python-cu2qu-debugsource-1.6.7.post2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-cu2qu.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 83d7e52385ec1cd7ccdc2dea626784a976ea2dfae02a113a6932eecbb2567f51
name: python-curio
arch: src
version: 1.6
epoch: 0
release: 1
summary: Curio
url: https://github.com/dabeaz/curio
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a37e0ee2-83dd-47e4-988d-308f9a149097
location_href: 00003367-python-curio/python-curio-1.6-1.src.rpm
checksum_type: sha256
description:
  Curio is a coroutine-based library for concurrent systems programming.  No longer
  maintained as a PyPi project.  Latest version is available on GitHub.


pkgId: 433ddd63c997ede7522f8f481cc3675d7590df0fa70378a621b83721b2c24ebf
name: python-cursor
arch: src
version: 1.3.5
epoch: 0
release: 1
summary: A small Python package to hide or show the terminal cursor
url: https://github.com/GijsTimmers/cursor
rpm_license: GNU General Public License v3 (GPLv3)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1c5f3d46-4a32-4fb7-a474-abc2c5a7c780
location_href: 00012450-python-cursor/python-cursor-1.3.5-1.src.rpm
checksum_type: sha256
description:
  [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)

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


  A small Python package to hide or show the terminal cursor.
  Works on Linux and Windows, on both Python 2 and Python 3.

  ![demonstration](http://i.imgur.com/2iXviMi.gif)


  The code is almost entirely a copy of
  [James Spencer's](http://stackoverflow.com/u/1375885/)
  [answer on StackOverflow](http://stackoverflow.com/a/10455937/1096437).



  The preferred way of installing `cursor` is via `pip`.
  You can install `pip` with your package manager:



      sudo apt-get install python-pip
      pip install --user cursor



      git clone https://aur.archlinux.org/python-cursor.git
      cd python-cursor
      makepkg -si



  ```python
  import cursor
  cursor.hide() ## Hides the cursor
  cursor.show() ## Shows the cursor
  ```


  Note that the cursor will stay hidden until you call `cursor.show()` —
  even after exiting your python script!

  Because of that, `pip` will install two scripts, which can be run
  from the command line: `cursor_hide` and `cursor_show`.

  An alternative is using the `HiddenCursor()` class in conjunction
  with Python's `with` statement. This will make sure that the cursor
  is shown again after running your code, even if exceptions are
  raised:

  ```python
  import cursor
  with cursor.HiddenCursor():     ## Cursor will stay hidden
      import time                 ## while code is being executed;
      for a in range(1,100):      ## afterwards it will show up again
          print(a)
          time.sleep(0.05)

  ```

  You could also use Python's `atexit` module:

  ```python
  import cursor
  import atexit
  import time

  atexit.register(cursor.show)    ## Make sure cursor.show() is called
                                  

  cursor.hide()                   ## Hides cursor
  for a in range(1,100):
      print(a)
      time.sleep(0.05)
  exit()                          ## Cursor will show again
  ```


  [Manraj Singh](https://github.com/ManrajGrover): allowed setting
  a customisable stream

  [Alexander Seiler](https://github.com/goggle): packaging for Arch

  Patrik Kopkan: packaging for Fedora



  [`halo`](https://github.com/ManrajGrover/halo): beautiful
  terminal spinners in Python

  [`pipenv`](https://github.com/pypa/pipenv): a tool that aims to bring the best of all packaging worlds to the Python world


pkgId: 75244cd090df40123a474f2fbc7141fcf11ab82c6e6449d842100bc8c9876c5f
name: python-curtsies
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Curses-like terminal wrapper, with colored strings!
url: https://github.com/bpython/curtsies
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b747593d-dbb2-483d-8cc2-c64db87c5dd1
location_href: 00003368-python-curtsies/python-curtsies-0.4.1-1.src.rpm
checksum_type: sha256
description:
  [FmtStr](http://curtsies.readthedocs.org/en/latest/FmtStr.html) objects are strings formatted with
  colors and styles displayable in a terminal with [ANSI escape sequences](http://en.wikipedia.org/wiki/ANSI_escape_code>`_).
  ![](https://i.imgur.com/bRLI134.png)
  [FSArray](http://curtsies.readthedocs.org/en/latest/FSArray.html) objects contain multiple such strings
  with each formatted string on its own row, and FSArray
  objects can be superimposed on each other
  to build complex grids of colored and styled characters through composition.
  (the import statement shown below is outdated)
  ![](http://i.imgur.com/rvTRPv1.png)
  Such grids of characters can be rendered to the terminal in alternate screen mode
  (no history, like `Vim`, `top` etc.) by [FullscreenWindow](http://curtsies.readthedocs.org/en/latest/window.html#curtsies.window.FullscreenWindow) objects
  or normal history-preserving screen by [CursorAwareWindow](http://curtsies.readthedocs.org/en/latest/window.html#curtsies.window.CursorAwareWindow) objects.
  User keyboard input events like pressing the up arrow key are detected by an
  [Input](http://curtsies.readthedocs.org/en/latest/input.html) object.


pkgId: 60365ef021b60a4879b53922ea5a61c270048b30b9ca2516f826215b997dc9c6
name: python-cvss
arch: src
version: 2.6
epoch: 0
release: 1
summary: CVSS2/3 library with interactive calculator for Python 2 and Python 3
url: https://github.com/RedHatProductSecurity/cvss
rpm_license: LGPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cfddeca3-ca25-4c0c-b6df-ca3c7cf09eb2
location_href: 00003369-python-cvss/python-cvss-2.6-1.src.rpm
checksum_type: sha256
description:
  This Python package contains CVSS v2 and v3 computation utilities and
  interactive calculator compatible with both Python 2 and Python 3.
  The library is tested on all currently-supported Python versions available
  via GitHub Actions (with the exception of Python 2.7, which is EOL but
  still tested against), but it is simple enough to run on even older versions.


pkgId: 8415043265af2d4277ae437281098b623975176b254a9a4e118d7f9b37848f17
name: python-cvxopt
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Convex optimization package
url: http://cvxopt.org
rpm_license: GNU GPL version 3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-89eed18c-1490-4aea-acbc-94558ed12517
location_href: 00003370-python-cvxopt/python-cvxopt-1.3.0-1.src.rpm
checksum_type: sha256
description:
  CVXOPT is a free software package for convex optimization based on the
  Python programming language. It can be used with the interactive Python
  interpreter, on the command line by executing Python scripts, or
  integrated in other software via Python extension modules. Its main
  purpose is to make the development of software for convex optimization
  applications straightforward by building on Python's extensive standard
  library and on the strengths of Python as a high-level programming
  language.


pkgId: 0bd4b2e801cf9b36e0e79c2067208f7671a1b410dc3e1e9ca4b7fb1d11f1c052
name: python-cvxpy
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: A domain-specific language for modeling convex optimization problems in Python.
url: https://github.com/cvxpy/cvxpy
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3fcc43ee-c625-4eaf-b386-f19d7b3fea7c
location_href: 00009950-python-cvxpy/python-cvxpy-1.3.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](http://github.com/cvxpy/cvxpy/workflows/build/badge.svg?event=push)](https://github.com/cvxpy/cvxpy/actions/workflows/build.yml)
  ![PyPI - downloads](https://img.shields.io/pypi/dm/cvxpy.svg?label=Pypi%20downloads)
  ![Conda - downloads](https://img.shields.io/conda/dn/conda-forge/cvxpy.svg?label=Conda%20downloads)
  [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=cvxpy_cvxpy&metric=coverage)](https://sonarcloud.io/summary/new_code?id=cvxpy_cvxpy)
  [![Benchmarks](http://img.shields.io/badge/benchmarked%20by-asv-blue.svg?style=flat)](https://cvxpy.github.io/benchmarks/)
  [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/cvxpy/cvxpy/badge)](https://api.securityscorecards.dev/projects/github.com/cvxpy/cvxpy)
  **The CVXPY documentation is at [cvxpy.org](http://www.cvxpy.org/).**
  *We are building a CVXPY community on [Discord](https://discord.gg/4urRQeGBCr). Join the conversation! For issues and long-form discussions, use [Github Issues](https://github.com/cvxpy/cvxpy/issues) and [Github Discussions](https://github.com/cvxpy/cvxpy/discussions).*
  **Contents**
  - [Installation](#installation)
  - [Getting started](#getting-started)
  - [Issues](#issues)
  - [Community](#community)
  - [Contributing](#contributing)
  - [Team](#team)
  - [Citing](#citing)
  CVXPY is a Python-embedded modeling language for convex optimization problems. It allows you to express your problem in a natural way that follows the math, rather than in the restrictive standard form required by solvers.
  For example, the following code solves a least-squares problem where the variable is constrained by lower and upper bounds:
  ```python3
  import cvxpy as cp
  import numpy

  m = 30
  n = 20
  numpy.random.seed(1)
  A = numpy.random.randn(m, n)
  b = numpy.random.randn(m)

  x = cp.Variable(n)
  objective = cp.Minimize(cp.sum_squares(A @ x - b))
  constraints = [0 <= x, x <= 1]
  prob = cp.Problem(objective, constraints)

  result = prob.solve()

  print(x.value)


  print(constraints[0].dual_value)
  ```
  With CVXPY, you can model
  * convex optimization problems,
  * mixed-integer convex optimization problems,
  * geometric programs, and
  * quasiconvex programs.
  CVXPY is not a solver. It relies upon the open source solvers
  [ECOS](http://github.com/ifa-ethz/ecos), [SCS](https://github.com/bodono/scs-python),
  and [OSQP](https://github.com/oxfordcontrol/osqp). Additional solvers are
  [available](https://www.cvxpy.org/tutorial/advanced/index.html#choosing-a-solver),
  but must be installed separately.
  CVXPY began as a Stanford University research project. It is now developed by
  many people, across many institutions and countries.

  CVXPY is available on PyPI, and can be installed with
  ```
  pip install cvxpy
  ```
  CVXPY can also be installed with conda, using
  ```
  conda install -c conda-forge cvxpy
  ```
  CVXPY has the following dependencies:
  - Python >= 3.7
  - OSQP >= 0.4.1
  - ECOS >= 2
  - SCS >= 1.1.6
  - NumPy >= 1.15
  - SciPy >= 1.1.0
  For detailed instructions, see the [installation
  guide](https://www.cvxpy.org/install/index.html).

  To get started with CVXPY, check out the following:
  * [official CVXPY tutorial](https://www.cvxpy.org/tutorial/index.html)
  * [example library](https://www.cvxpy.org/examples/index.html)
  * [API reference](https://www.cvxpy.org/api_reference/cvxpy.html)

  We encourage you to report issues using the [Github tracker](https://github.com/cvxpy/cvxpy/issues). We welcome all kinds of issues, especially those related to correctness, documentation, performance, and feature requests.
  For basic usage questions (e.g., "Why isn't my problem DCP?"), please use [StackOverflow](https://stackoverflow.com/questions/tagged/cvxpy) instead.

  The CVXPY community consists of researchers, data scientists, software engineers, and students from all over the world. We welcome you to join us!
  * To chat with the CVXPY community in real-time, join us on [Discord](https://discord.gg/4urRQeGBCr).
  * To have longer, in-depth discussions with the CVXPY community, use [Github Discussions](https://github.com/cvxpy/cvxpy/discussions).
  * To share feature requests and bug reports, use [Github Issues](https://github.com/cvxpy/cvxpy/issues).
  Please be respectful in your communications with the CVXPY community, and make sure to abide by our [code of conduct](https://github.com/cvxpy/cvxpy/blob/master/CODE_OF_CONDUCT.md).

  We appreciate all contributions. You don't need to be an expert in convex
  optimization to help out.
  You should first
  install [CVXPY from source](https://www.cvxpy.org/install/index.html#install-from-source).
  Here are some simple ways to start contributing immediately:
  * Read the CVXPY source code and improve the documentation, or address TODOs
  * Enhance the [website documentation](https://github.com/cvxpy/cvxpy/tree/master/doc)
  * Browse the [issue tracker](https://github.com/cvxpy/cvxpy/issues), and look for issues tagged as "help wanted"
  * Polish the [example library](https://github.com/cvxpy/cvxpy/tree/master/examples)
  * Add a [benchmark](https://github.com/cvxpy/cvxpy/tree/master/cvxpy/tests/test_benchmarks.py)
  If you'd like to add a new example to our library, or implement a new feature,
  please get in touch with us first to make sure that your priorities align with
  ours.
  Contributions should be submitted as [pull requests](https://github.com/cvxpy/cvxpy/pulls).
  A member of the CVXPY development team will review the pull request and guide
  you through the contributing process.
  Before starting work on your contribution, please read the [contributing guide](https://github.com/cvxpy/cvxpy/blob/master/CONTRIBUTING.md).

  CVXPY is a community project, built from the contributions of many
  researchers and engineers.
  CVXPY is developed and maintained by [Steven
  Diamond](https://stevendiamond.me/), [Akshay
  Agrawal](https://akshayagrawal.com), [Riley Murray](https://rileyjmurray.wordpress.com/),
  [Philipp Schiele](https://www.philippschiele.com/),
  and [Bartolomeo Stellato](https://stellato.io/), with many others contributing
  significantly. A non-exhaustive list of people who have shaped CVXPY over the
  years includes Stephen Boyd, Eric Chu, Robin Verschueren, Michael Sommerauer,
  Jaehyun Park, Enzo Busseti, AJ Friend, Judson Wilson, Chris
  Dembia, and Philipp Schiele.
  For more information about the team and our processes, see our [governance document](https://github.com/cvxpy/org/blob/main/governance.md).

  If you use CVXPY for academic work, we encourage you to [cite our papers](https://www.cvxpy.org/citing/index.html). If you use CVXPY in industry, we'd love to hear from you as well, on Discord or over email.


pkgId: cf5f9ad1dd21b2adb70a1104d90bcd545976ff6b5572a57bcad8ea84eaa5af2c
name: python-cvxpy-debuginfo
arch: aarch64
version: 1.3.1
epoch: 0
release: 1
summary: Debug information for package python-cvxpy
url: https://github.com/cvxpy/cvxpy
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-3fcc43ee-c625-4eaf-b386-f19d7b3fea7c
rpm_sourcerpm: python-cvxpy-1.3.1-1.src.rpm
location_href: 00009950-python-cvxpy/python-cvxpy-debuginfo-1.3.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-cvxpy.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 13df89500b729c03833fff721ca5db87bf0aad6a9b1ab982f6e331fa462259f6
name: python-cvxpy-debugsource
arch: aarch64
version: 1.3.1
epoch: 0
release: 1
summary: Debug sources for package python-cvxpy
url: https://github.com/cvxpy/cvxpy
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-3fcc43ee-c625-4eaf-b386-f19d7b3fea7c
rpm_sourcerpm: python-cvxpy-1.3.1-1.src.rpm
location_href: 00009950-python-cvxpy/python-cvxpy-debugsource-1.3.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-cvxpy.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 48fe883655fbf3d8515af13e4069df1d570be439b3ca4debc5d76497dd60e668
name: python-cwcwidth
arch: src
version: 0.1.8
epoch: 0
release: 1
summary: Python bindings for wc(s)width
url: https://github.com/sebastinas/cwcwidth
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-32aaf82c-521d-41da-8ec7-793062ae55d8
location_href: 00012386-python-cwcwidth/python-cwcwidth-0.1.8-1.src.rpm
checksum_type: sha256
description:
  `cwcwidth` provides Python bindings for `wcwidth` and `wcswidth` functions defined in POSIX.1-2001
  and POSIX.1-2008 based on [Cython](https://cython.org/). These functions compute the printable
  length of a unicode character/string on a terminal. The module provides the same functions as
  [wcwidth](https://pypi.org/project/wcwidth/) and its behavior is compatible.

  On systems not conforming to POSIX.1-2001 and POSIX.1-2008, Markus Kuhn's
  [implementation](https://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c) is used to provide the
  functionality.



  * `Cython >= 0.28` (optional, only for building). If Cython is not available, the C files are not
    regenerated from their source.



  `cwcwidth` can be installed via `pip`:
  ```sh
  pip install cwcwidth
  ```
  or by running:
  ```sh
  python3 setup.py install
  ```



  ```python3
  >>> import cwcwidth
  >>> cwcwidth.wcwidth("a")
  1
  >>> cwcwidth.wcswidth("コ")
  2
  >>> cwcwidth.wcswidth("コンニチハ, セカイ!")
  19
  >>> cwcwidth.wcswidth("コンニチハ, セカイ!", 5)
  10
  ```



  ```python3
  >>> import wcwidth, cwcwidth, timeit
  >>> timeit.timeit(lambda: wcwidth.wcswidth("コンニチハ, セカイ!"))
  19.14463168097427
  >>> timeit.timeit(lambda: cwcwidth.wcswidth("コンニチハ, セカイ!"))
  0.16294104099506512
  ```



  The code is licensed under the MIT license.


pkgId: 2a7d1acbed7ac58ba1424c40b71419abc0ea7452d9b5eed06d540ea0ec81ee55
name: python-cwcwidth-debuginfo
arch: aarch64
version: 0.1.8
epoch: 0
release: 1
summary: Debug information for package python-cwcwidth
url: https://github.com/sebastinas/cwcwidth
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-32aaf82c-521d-41da-8ec7-793062ae55d8
rpm_sourcerpm: python-cwcwidth-0.1.8-1.src.rpm
location_href: 00012386-python-cwcwidth/python-cwcwidth-debuginfo-0.1.8-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-cwcwidth.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: a3e0861a2ad87f78dfab99d716425843d473ab8761a5f5df2dfd2bd489e48646
name: python-cwcwidth-debugsource
arch: aarch64
version: 0.1.8
epoch: 0
release: 1
summary: Debug sources for package python-cwcwidth
url: https://github.com/sebastinas/cwcwidth
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-32aaf82c-521d-41da-8ec7-793062ae55d8
rpm_sourcerpm: python-cwcwidth-0.1.8-1.src.rpm
location_href: 00012386-python-cwcwidth/python-cwcwidth-debugsource-0.1.8-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-cwcwidth.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: e6d705920425899b98cd843c4bea733ff00999b636e04d61a6314f11dfff74f2
name: python-cx-Oracle
arch: src
version: 8.3.0
epoch: 0
release: 1
summary: Python interface to Oracle
url: https://oracle.github.io/python-cx_Oracle
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8130ca39-3f24-4ed4-bff7-29542cc8a53b
location_href: 00003371-python-cx-oracle/python-cx-Oracle-8.3.0-1.src.rpm
checksum_type: sha256
description:
  cx_Oracle is a Python extension module that enables access to Oracle
  Database.  It conforms to the [Python database API 2.0
  specification][1] with a considerable number of additions and a couple
  of exclusions.  See the
  [homepage](https://oracle.github.io/python-cx_Oracle/index.html) for a
  feature list.

  cx_Oracle 8.3 has been tested with Python versions 3.6 through 3.10. You can
  use cx_Oracle with Oracle 11.2, 12c, 18c, 19c and 21c client libraries.
  Oracle's standard client-server version interoperability allows connection to
  both older and newer databases. For example Oracle 19c client libraries can
  connect to Oracle Database 11.2.   Older versions of cx_Oracle may work with
  older versions of Python.



  See [cx_Oracle Installation][15].



  See the [cx_Oracle Documentation][2] and [Release Notes][14].



  See the [/samples][12] directory and the [tutorial][6].  You can also
  look at the scripts in [cx_OracleTools][7] and the modules in
  [cx_PyOracleLib][8].



  Issues and questions can be raised with the cx_Oracle community on
  [GitHub][9] or on the [mailing list][5].



  See [/test][11].



  See [CONTRIBUTING](https://github.com/oracle/python-cx_Oracle/blob/main/CONTRIBUTING.md)



  cx_Oracle is licensed under a BSD license which you can find [here][3].

  [1]: https://www.python.org/dev/peps/pep-0249
  [2]: http://cx-oracle.readthedocs.io
  [3]: https://github.com/oracle/python-cx_Oracle/blob/main/LICENSE.txt
  [5]: http://lists.sourceforge.net/lists/listinfo/cx-oracle-users
  [6]: https://github.com/oracle/python-cx_Oracle/tree/main/samples/tutorial
  [7]: http://cx-oracletools.sourceforge.net
  [8]: http://cx-pyoraclelib.sourceforge.net
  [9]: https://github.com/oracle/python-cx_Oracle/issues
  [11]: https://github.com/oracle/python-cx_Oracle/tree/main/test
  [12]: https://github.com/oracle/python-cx_Oracle/tree/main/samples
  [14]: https://cx-oracle.readthedocs.io/en/latest/release_notes.html
  [15]: https://cx-oracle.readthedocs.io/en/latest/user_guide/installation.html


pkgId: 7c3b35fe8990203aaea43216207fe39b0481a9f37e4660d4e82b53d244303e06
name: python-cymruwhois
arch: src
version: 1.6
epoch: 0
release: 1
summary: Client for the whois.cymru.com service
url: http://packages.python.org/cymruwhois/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4437e3b5-3895-4743-b356-49cb9a381f20
location_href: 00012354-python-cymruwhois/python-cymruwhois-1.6-1.src.rpm
checksum_type: sha256
description:
  Perform lookups by ip address and return ASN, Country Code, and Netblock Owner::

  >>> import socket
  >>> ip = socket.gethostbyname("www.google.com")
  >>> from cymruwhois import Client
  >>> c=Client()
  >>> r=c.lookup(ip)
  >>> print r.asn
  15169
  >>> print r.owner
  GOOGLE - Google Inc.


pkgId: bb3564d31e28dc2e1fc17c62892d7b766a0645e492c57f7b1a34f841f5de33d4
name: python-cytoolz
arch: src
version: 0.12.1
epoch: 0
release: 1
summary: Cython implementation of Toolz: High performance functional utilities
url: https://github.com/pytoolz/cytoolz
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9572472b-e530-4dce-b3ab-0e73ca5da6e9
location_href: 00003380-python-cytoolz/python-cytoolz-0.12.1-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Version Status|
  Cython implementation of the
  |literal toolz|_ `package, <https://pypi.python.org/pypi/toolz/>`__ which
  provides high performance utility functions for iterables, functions,
  and dictionaries.
  ``toolz`` is a pure Python package that borrows heavily from contemporary
  functional languanges.  It is designed to interoperate seamlessly with other
  libraries including ``itertools``, ``functools``, and third party libraries.
  High performance functional data analysis is possible with builtin types
  like ``list`` and ``dict``, and user-defined data structures; and low memory
  usage is achieved by using the iterator protocol and returning iterators
  whenever possible.
  ``cytoolz`` implements the same API as ``toolz``.  The main differences are
  that ``cytoolz`` is faster (typically 2-5x faster with a few spectacular
  exceptions) and ``cytoolz`` offers a C API that is accessible to other
  projects developed in Cython.  Since ``toolz`` is able to process very
  large (potentially infinite) data sets, the performance increase gained by
  using ``cytoolz`` can be significant.
  See the PyToolz documentation at https://toolz.readthedocs.io and the full
  `API Documentation <https://toolz.readthedocs.io/en/latest/api.html>`__
  for more details.


pkgId: e71dc291f3db06a373c6ab91a923eb98945b7bbc6c2977d2ac371ef1dab7d304
name: python-d2to1
arch: src
version: 0.2.12.post1
epoch: 0
release: 1
url: https://github.com/embray/d2to1
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fcbd00ae-ba56-4c22-928a-dcb8fefff401
location_href: 00003381-python-d2to1/python-d2to1-0.2.12.post1-1.src.rpm
checksum_type: sha256
summary:
  Allows using distutils2-like setup.cfg files for a package's metadata with a distribute/setuptools setup.py

description:
  d2to1 (the 'd' is for 'distutils') allows using distutils2-like setup.cfg files
  for a package's metadata with a distribute/setuptools setup.py script.  It
  works by providing a distutils2-formatted setup.cfg file containing all of a
  package's metadata, and a very minimal setup.py which will slurp its arguments
  from the setup.cfg.
  Note: distutils2 has been merged into the CPython standard library, where it is
  now known as 'packaging'.  This project was started before that change was
  finalized.  So all references to distutils2 should also be assumed to refer to
  packaging.


pkgId: 31996372aa2d136f7c75d677a19b6b663348bd36ee414fb4f204f9c7545e6119
name: python-dacite
arch: src
version: 1.8.0
epoch: 0
release: 1
summary: Simple creation of data classes from dictionaries.
url: https://github.com/konradhalas/dacite
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6ad3c76f-dd23-4344-b485-da921dcc109c
location_href: 00009571-python-dacite/python-dacite-1.8.0-1.src.rpm
checksum_type: sha256
description:
  ![](https://user-images.githubusercontent.com/1078369/212840759-174c0f2b-d446-4c3a-b97c-67a0b912e7f6.png)



  [![Build Status](https://travis-ci.org/konradhalas/dacite.svg?branch=master)](https://travis-ci.org/konradhalas/dacite)
  [![Coverage Status](https://coveralls.io/repos/github/konradhalas/dacite/badge.svg?branch=master)](https://coveralls.io/github/konradhalas/dacite?branch=master)
  [![License](https://img.shields.io/pypi/l/dacite.svg)](https://pypi.python.org/pypi/dacite/)
  [![Version](https://img.shields.io/pypi/v/dacite.svg)](https://pypi.python.org/pypi/dacite/)
  [![Python versions](https://img.shields.io/pypi/pyversions/dacite.svg)](https://pypi.python.org/pypi/dacite/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)

  This module simplifies creation of data classes ([PEP 557][pep-557])
  from dictionaries.



  To install dacite, simply use `pip`:

  ```
  $ pip install dacite
  ```



  Minimum Python version supported by `dacite` is 3.6.



  ```python
  from dataclasses import dataclass
  from dacite import from_dict


  @dataclass
  class User:
      name: str
      age: int
      is_active: bool


  data = {
      'name': 'John',
      'age': 30,
      'is_active': True,
  }

  user = from_dict(data_class=User, data=data)

  assert user == User(name='John', age=30, is_active=True)
  ```



  Dacite supports following features:

  - nested structures
  - (basic) types checking
  - optional fields (i.e. `typing.Optional`)
  - unions
  - forward references
  - collections
  - custom type hooks



  Passing plain dictionaries as a data container between your functions or
  methods isn't a good practice. Of course you can always create your
  custom class instead, but this solution is an overkill if you only want
  to merge a few fields within a single object.

  Fortunately Python has a good solution to this problem - data classes.
  Thanks to `@dataclass` decorator you can easily create a new custom
  type with a list of given fields in a declarative manner. Data classes
  support type hints by design.

  However, even if you are using data classes, you have to create their
  instances somehow. In many such cases, your input is a dictionary - it
  can be a payload from a HTTP request or a raw data from a database. If
  you want to convert those dictionaries into data classes, `dacite` is
  your best friend.

  This library was originally created to simplify creation of type hinted
  data transfer objects (DTO) which can cross the boundaries in the
  application architecture.

  It's important to mention that `dacite` is not a data validation library.
  There are dozens of awesome data validation projects and it doesn't make
  sense to duplicate this functionality within `dacite`. If you want to
  validate your data first, you should combine `dacite` with one of data
  validation library.

  Please check [Use Case](#use-case) section for a real-life example.



  Dacite is based on a single function - `dacite.from_dict`. This function
  takes 3 parameters:

  - `data_class` - data class type
  - `data` - dictionary of input data
  - `config` (optional) - configuration of the creation process, instance
  of `dacite.Config` class

  Configuration is a (data) class with following fields:

  - `type_hooks`
  - `cast`
  - `forward_references`
  - `check_types`
  - `strict`
  - `strict_unions_match`

  The examples below show all features of `from_dict` function and usage
  of all `Config` parameters.



  You can pass a data with nested dictionaries and it will create a proper
  result.

  ```python
  @dataclass
  class A:
      x: str
      y: int


  @dataclass
  class B:
      a: A


  data = {
      'a': {
          'x': 'test',
          'y': 1,
      }
  }

  result = from_dict(data_class=B, data=data)

  assert result == B(a=A(x='test', y=1))
  ```



  Whenever your data class has a `Optional` field and you will not provide
  input data for this field, it will take the `None` value.

  ```python
  from typing import Optional

  @dataclass
  class A:
      x: str
      y: Optional[int]


  data = {
      'x': 'test',
  }

  result = from_dict(data_class=A, data=data)

  assert result == A(x='test', y=None)
  ```



  If your field can accept multiple types, you should use `Union`. Dacite
  will try to match data with provided types one by one. If none will
  match, it will raise `UnionMatchError` exception.

  ```python
  from typing import Union

  @dataclass
  class A:
      x: str

  @dataclass
  class B:
      y: int

  @dataclass
  class C:
      u: Union[A, B]


  data = {
      'u': {
          'y': 1,
      },
  }

  result = from_dict(data_class=C, data=data)

  assert result == C(u=B(y=1))
  ```



  Dacite supports fields defined as collections. It works for both - basic
  types and data classes.

  ```python
  @dataclass
  class A:
      x: str
      y: int


  @dataclass
  class B:
      a_list: List[A]


  data = {
      'a_list': [
          {
              'x': 'test1',
              'y': 1,
          },
          {
              'x': 'test2',
              'y': 2,
          }
      ],
  }

  result = from_dict(data_class=B, data=data)

  assert result == B(a_list=[A(x='test1', y=1), A(x='test2', y=2)])
  ```



  You can use `Config.type_hooks` argument if you want to transform the input
  data of a data class field with given type into the new value. You have to
  pass a following mapping: `{Type: callable}`, where `callable` is a
  `Callable[[Any], Any]`.

  ```python
  @dataclass
  class A:
      x: str


  data = {
      'x': 'TEST',
  }

  result = from_dict(data_class=A, data=data, config=Config(type_hooks={str: str.lower}))

  assert result == A(x='test')
  ```

  If a data class field type is a `Optional[T]` you can pass both -
  `Optional[T]` or just `T` - as a key in `type_hooks`. The same with generic
  collections, e.g. when a field has type `List[T]` you can use `List[T]` to
  transform whole collection or `T` to transform each item.



  It's a very common case that you want to create an instance of a field type
  from the input data with just calling your type with the input value. Of
  course you can use `type_hooks={T: T}` to achieve this goal but `cast=[T]` is
  an easier and more expressive way. It also works with base classes - if `T`
  is a base class of type `S`, all fields of type `S` will be also "casted".

  ```python
  from enum import Enum

  class E(Enum):
      X = 'x'
      Y = 'y'
      Z = 'z'

  @dataclass
  class A:
      e: E


  data = {
      'e': 'x',
  }

  result = from_dict(data_class=A, data=data, config=Config(cast=[E]))



  result = from_dict(data_class=A, data=data, config=Config(cast=[Enum]))

  assert result == A(e=E.X)
  ```



  Definition of forward references can be passed as a `{'name': Type}` mapping to
  `Config.forward_references`. This dict is passed to `typing.get_type_hints()` as the
  `globalns` param when evaluating each field's type.

  ```python
  @dataclass
  class X:
      y: "Y"

  @dataclass
  class Y:
      s: str

  data = from_dict(X, {"y": {"s": "text"}}, Config(forward_references={"Y": Y}))
  assert data == X(Y("text"))
  ```



  There are rare cases when `dacite` built-in type checker can not validate
  your types (e.g. custom generic class) or you have such functionality
  covered by other library and you don't want to validate your types twice.
  In such case you can disable type checking with `Config(check_types=False)`.
  By default types checking is enabled.

  ```python
  T = TypeVar('T')


  class X(Generic[T]):
      pass


  @dataclass
  class A:
      x: X[str]


  x = X[str]()

  assert from_dict(A, {'x': x}, config=Config(check_types=False)) == A(x=x)
  ```



  By default `from_dict` ignores additional keys (not matching data class field)
  in the input data. If you want change this behaviour set `Config.strict` to
  `True`. In case of unexpected key `from_dict` will raise `UnexpectedDataError`
  exception.



  `Union` allows to define multiple possible types for a given field. By default
  `dacite` is trying to find the first matching type for a provided data and it
  returns instance of this type. It means that it's possible that there are other
  matching types further on the `Union` types list. With `strict_unions_match`
  only a single match is allowed, otherwise `dacite` raises `StrictUnionMatchError`.



  Whenever something goes wrong, `from_dict` will raise adequate
  exception. There are a few of them:

  - `WrongTypeError` - raised when a type of a input value does not match
  with a type of a data class field
  - `MissingValueError` - raised when you don't provide a value for a
  required field
  - `UnionMatchError` - raised when provided data does not match any type
  of `Union`
  - `ForwardReferenceError` - raised when undefined forward reference encountered in
  dataclass
  - `UnexpectedDataError` - raised when `strict` mode is enabled and the input
  data has not matching keys
  - `StrictUnionMatchError` - raised when `strict_unions_match` mode is enabled
  and the input data has ambiguous `Union` match



  First of all - if you want to submit your pull request, thank you very much!
  I really appreciate your support.

  Please remember that every new feature, bug fix or improvement should be tested.
  100% code coverage is a must-have.

  We are using a few static code analysis tools to increase the code quality
  (`black`, `mypy`, `pylint`). Please make sure that you are not generating any
  errors/warnings before you submit your PR. You can find current configuration
  in `.github/*` directory.

  Last but not least, if you want to introduce new feature, please discuss it
  first within an issue.



  Clone `dacite` repository:

  ```
  $ git clone git@github.com:konradhalas/dacite.git
  ```

  Create and activate virtualenv in the way you like:

  ```
  $ python3 -m venv dacite-env
  $ source dacite-env/bin/activate
  ```

  Install all `dacite` dependencies:

  ```
  $ pip install -e .[dev]
  ```

  And, optionally but recommended, install pre-commit hook for black:

  ```
  $ pre-commit install
  ```

  To run tests you just have to fire:

  ```
  $ pytest
  ```



  `dacite` is a small library, but its use is potentially very extensive. Thus, it is crucial
  to ensure good performance of the library.

  We achieve that with the help of `pytest-benchmark` library, and a suite of dedicated performance tests
  which can be found in the `tests/performance` directory. The CI process runs these tests automatically,
  but they can also be helpful locally, while developing the library.

  Whenever you run `pytest` command, a new benchmark report is saved to `/.benchmarks` directory.
  You can easily compare these reports by running: `pytest-benchmark compare`, which will load all the runs
  and display them in a table, where you can compare the performance of each run.

  You can even specify which particular runs you want to compare, e.g. `pytest-benchmark compare 0001 0003 0005`.



  There are many cases when we receive "raw" data (Python dicts) as a input to
  our system. HTTP request payload is a very common use case. In most web
  frameworks we receive request data as a simple dictionary. Instead of
  passing this dict down to your "business" code, it's a good idea to create
  something more "robust".

  Following example is a simple `flask` app - it has single `/products` endpoint.
  You can use this endpoint to "create" product in your system. Our core
  `create_product` function expects data class as a parameter. Thanks to `dacite`
  we can easily build such data class from `POST` request payload.


  ```python
  from dataclasses import dataclass
  from typing import List

  from flask import Flask, request, Response

  import dacite

  app = Flask(__name__)


  @dataclass
  class ProductVariantData:
      code: str
      description: str = ''
      stock: int = 0


  @dataclass
  class ProductData:
      name: str
      price: float
      variants: List[ProductVariantData]


  def create_product(product_data: ProductData) -> None:
      pass  # your business logic here


  @app.route("/products", methods=['POST'])
  def products():
      product_data = dacite.from_dict(
          data_class=ProductData,
          data=request.get_json(),
      )
      create_product(product_data=product_data)
      return Response(status=201)

  ```

  What if we want to validate our data (e.g. check if `code` has 6 characters)?
  Such features are out of scope of `dacite` but we can easily combine it with
  one of data validation library. Let's try with
  [marshmallow](https://marshmallow.readthedocs.io).

  First of all we have to define our data validation schemas:

  ```python
  from marshmallow import Schema, fields, ValidationError


  def validate_code(code):
      if len(code) != 6:
          raise ValidationError('Code must have 6 characters.')


  class ProductVariantDataSchema(Schema):
      code = fields.Str(required=True, validate=validate_code)
      description = fields.Str(required=False)
      stock = fields.Int(required=False)


  class ProductDataSchema(Schema):
      name = fields.Str(required=True)
      price = fields.Decimal(required=True)
      variants = fields.Nested(ProductVariantDataSchema(many=True))
  ```

  And use them within our endpoint:

  ```python
  @app.route("/products", methods=['POST'])
  def products():
      schema = ProductDataSchema()
      result, errors = schema.load(request.get_json())
      if errors:
          return Response(
              response=json.dumps(errors),
              status=400,
              mimetype='application/json',
          )
      product_data = dacite.from_dict(
          data_class=ProductData,
          data=result,
      )
      create_product(product_data=product_data)
      return Response(status=201)
  ```

  Still `dacite` helps us to create data class from "raw" dict with validated data.



  `dacite` uses some LRU caching to improve its performance where possible. To use the caching utility:

  ```python
  from dacite import set_cache_size, get_cache_size, clear_cache

  get_cache_size()  # outputs the current LRU max_size, default is 2048
  set_cache_size(4096)  # set LRU max_size to 4096
  set_cache_size(None)  # set LRU max_size to None
  clear_cache()  # Clear the cache
  ```

  The caching is completely transparent from the interface perspective.



  Follow `dacite` updates in [CHANGELOG][changelog].



  Created by [Konrad Hałas][halas-homepage].

  [pep-557]: https://www.python.org/dev/peps/pep-0557/
  [halas-homepage]: https://konradhalas.pl
  [changelog]: https://github.com/konradhalas/dacite/blob/master/CHANGELOG.md


pkgId: 438ad7357f5856f79760dd79d8fe864f14842d0168073a47a37a671f8b2f1d1f
name: python-dag-factory
arch: src
version: 0.17.3
epoch: 0
release: 1
summary: Dynamically build Airflow DAGs from YAML files
url: https://github.com/ajbosco/dag-factory
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4b186b93-66b2-4616-99ab-23447106faba
location_href: 00009973-python-dag-factory/python-dag-factory-0.17.3-1.src.rpm
checksum_type: sha256
description:
  [![Github Actions](https://github.com/ajbosco/dag-factory/workflows/build/badge.svg?branch=master&event=push)](https://github.com/ajbosco/dag-factory/actions?workflow=build)
  [![Coverage](https://codecov.io/github/ajbosco/dag-factory/coverage.svg?branch=master)](https://codecov.io/github/ajbosco/dag-factory?branch=master)
  [![PyPi](https://img.shields.io/pypi/v/dag-factory.svg)](https://pypi.org/project/dag-factory/)
  [![Code Style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
  [![Downloads](https://pepy.tech/badge/dag-factory)](https://pepy.tech/project/dag-factory)

  *dag-factory* is a library for dynamically generating [Apache Airflow](https://github.com/apache/incubator-airflow) DAGs from YAML configuration files.
  - [Installation](#installation)
  - [Usage](#usage)
  - [Benefits](#benefits)
  - [Contributing](#contributing)



  To install *dag-factory* run `pip install dag-factory`. It requires Python 3.6.0+ and Apache Airflow 2.0+.



  After installing *dag-factory* in your Airflow environment, there are two steps to creating DAGs. First, we need to create a YAML configuration file. For example:

  ```yaml
  example_dag1:
    default_args:
      owner: 'example_owner'
      start_date: 2018-01-01  # or '2 days'
      end_date: 2018-01-05
      retries: 1
      retry_delay_sec: 300
    schedule_interval: '0 3 * * *'
    concurrency: 1
    max_active_runs: 1
    dagrun_timeout_sec: 60
    default_view: 'tree'  # or 'graph', 'duration', 'gantt', 'landing_times'
    orientation: 'LR'  # or 'TB', 'RL', 'BT'
    description: 'this is an example dag!'
    on_success_callback_name: print_hello
    on_success_callback_file: /usr/local/airflow/dags/print_hello.py
    on_failure_callback_name: print_hello
    on_failure_callback_file: /usr/local/airflow/dags/print_hello.py
    tasks:
      task_1:
        operator: airflow.operators.bash_operator.BashOperator
        bash_command: 'echo 1'
      task_2:
        operator: airflow.operators.bash_operator.BashOperator
        bash_command: 'echo 2'
        dependencies: [task_1]
      task_3:
        operator: airflow.operators.bash_operator.BashOperator
        bash_command: 'echo 3'
        dependencies: [task_1]
  ```

  Then in the DAGs folder in your Airflow environment you need to create a python file like this:

  ```python
  from airflow import DAG
  import dagfactory

  dag_factory = dagfactory.DagFactory("/path/to/dags/config_file.yml")

  dag_factory.clean_dags(globals())
  dag_factory.generate_dags(globals())
  ```

  And this DAG will be generated and ready to run in Airflow!

  If you have several configuration files you can import them like this:

  ```python

  from dagfactory import load_yaml_dags

  load_yaml_dags(globals_dict=globals(), suffix=['dag.yaml'])
  ```

  ![screenshot](/img/example_dag.png)





  The package `airflow.sensors.http_sensor` works with all supported versions of Airflow. In Airflow 2.0+, the new package name can be used in the operator value: `airflow.providers.http.sensors.http`

  The following example shows `response_check` logic in a python file:

  ```yaml
  task_2:
        operator: airflow.sensors.http_sensor.HttpSensor
        http_conn_id: 'test-http'
        method: 'GET'
        response_check_name: check_sensor
        response_check_file: /path/to/example1/http_conn.py
        dependencies: [task_1]
  ```

  The `response_check` logic can also be provided as a lambda:

  ```yaml
  task_2:
        operator: airflow.sensors.http_sensor.HttpSensor
        http_conn_id: 'test-http'
        method: 'GET'
        response_check_lambda: 'lambda response: "ok" in reponse.text'
        dependencies: [task_1]
  ```



  * Construct DAGs without knowing Python
  * Construct DAGs without learning Airflow primitives
  * Avoid duplicative code
  * Everyone loves YAML! ;)



  Contributions are welcome! Just submit a Pull Request or Github Issue.


pkgId: 753566a8fb6881bff718121a4bdf8443320903b7edf899a88a1b49ed17c30f5a
name: python-dagster
arch: src
version: 1.2.6
epoch: 0
release: 1
summary: The data orchestration platform built for productivity.
url: https://dagster.io
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-25a38f6c-1478-47e6-bdb8-d52315b8aee5
location_href: 00010823-python-dagster/python-dagster-1.2.6-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <!-- Note: Do not try adding the dark mode version here with the `picture` element, it will break formatting in PyPI -->
    <a target="_blank" href="https://dagster.io" style="background:none">
      <img alt="dagster logo" src=".github/dagster-readme-header.svg" width="auto" height="100%">
    </a>
  <p style="text-align: center;">Remember to <a target="_blank" href="https://github.com/dagster-io/dagster">star the Dagster GitHub repo</a> for future reference.</p>
    <a target="_blank" href="https://github.com/dagster-io/dagster" style="background:none">
      <img src="https://img.shields.io/github/stars/dagster-io/dagster?labelColor=4F43DD&color=163B36&logo=github">
    </a>
    <a target="_blank" href="https://github.com/dagster-io/dagster/blob/master/LICENSE" style="background:none">
      <img src="https://img.shields.io/badge/License-Apache_2.0-blue.svg?label=license&labelColor=4F43DD&color=163B36">
    </a>
    <a target="_blank" href="https://pypi.org/project/dagster/" style="background:none">
      <img src="https://img.shields.io/pypi/v/dagster?labelColor=4F43DD&color=163B36">
    </a>
    <a target="_blank" href="https://pypi.org/project/dagster/" style="background:none">
      <img src="https://img.shields.io/pypi/pyversions/dagster?labelColor=4F43DD&color=163B36">
    </a>
    <a target="_blank" href="https://twitter.com/dagster" style="background:none">
      <img src="https://img.shields.io/badge/twitter-dagster-blue.svg?labelColor=4F43DD&color=163B36&logo=twitter" />
    </a>
    <a target="_blank" href="https://dagster.io/slack" style="background:none">
      <img src="https://img.shields.io/badge/slack-dagster-blue.svg?labelColor=4F43DD&color=163B36&logo=slack" />
    </a>
    <a target="_blank" href="https://linkedin.com/showcase/dagster" style="background:none">
      <img src="https://img.shields.io/badge/linkedin-dagster-blue.svg?labelColor=4F43DD&color=163B36&logo=linkedin" />
    </a>
  </div>

  __Dagster is a cloud-native data pipeline orchestrator for the whole development lifecycle, with integrated lineage and observability, a declarative programming model, and best-in-class testability.__

  It is designed for **developing and maintaining data assets**, such as tables, data sets, machine learning models, and reports.

  With Dagster, you declare—as Python functions—the data assets that you want to build. Dagster then helps you run your functions at the right time and keep your assets up-to-date.

  Here is an example of a graph of three assets defined in Python:

  ```python
  from dagster import asset
  from pandas import DataFrame, read_html, get_dummies
  from sklearn.linear_model import LinearRegression

  @asset
  def country_populations() -> DataFrame:
      df = read_html("https://tinyurl.com/mry64ebh")[0]
      df.columns = ["country", "continent", "rg", "pop2018", "pop2019", "change"]
      df["change"] = df["change"].str.rstrip("%").str.replace("−", "-").astype("float")
      return df

  @asset
  def continent_change_model(country_populations: DataFrame) -> LinearRegression:
      data = country_populations.dropna(subset=["change"])
      return LinearRegression().fit(get_dummies(data[["continent"]]), data["change"])

  @asset
  def continent_stats(country_populations: DataFrame, continent_change_model: LinearRegression) -> DataFrame:
      result = country_populations.groupby("continent").sum()
      result["pop_change_factor"] = continent_change_model.coef_
      return result
  ```
  The graph loaded into Dagster's web UI:

  <p align="center">
    <img width="400px" alt="An example asset graph as rendered in the Dagster UI" src="https://user-images.githubusercontent.com/654855/183537484-48dde394-91f2-4de0-9b17-a70b3e9a3823.png">
  </p>

  Dagster is built to be used at every stage of the data development lifecycle - local development, unit tests, integration tests, staging environments, all the way up to production.



  If you're new to Dagster, we recommend reading about its [core concepts](https://docs.dagster.io/concepts) or learning with the hands-on [tutorial](https://docs.dagster.io/tutorial).

  Dagster is available on PyPI and officially supports Python 3.7+.

  ```bash
  pip install dagster dagit
  ```

  This installs two modules:

  - **Dagster**: The core programming model.
  - **Dagit**: The web interface for developing and operating Dagster jobs and assets.

  Running on Using a Mac with an M1 or M2 chip? Check the [install details here](https://docs.dagster.io/getting-started/install#installing-dagster-into-an-existing-python-environment).



  You can find the full Dagster documentation [here](https://docs.dagster.io), including the ['getting started' guide](https://docs.dagster.io/getting-started).

  <hr/>



    <p align="center">
      <img width="100%" alt="image" src=".github/key-features-cards.svg">
    </p>


  Identify the key assets you need to create using a declarative approach, or you can focus on running basic tasks. Embrace CI/CD best practices from the get-go: build reusable components, spot data quality issues, and flag bugs early.


  Put your pipelines into production with a robust multi-tenant, multi-tool engine that scales technically and organizationally.


  Maintain control over your data as the complexity scales. Centralize your metadata in one tool with built-in observability, diagnostics, cataloging, and lineage. Spot any issues and identify performance improvement opportunities.

  <hr />



  Dagster provides a growing library of integrations for today’s most popular data tools. Integrate with the tools you already use, and deploy to your infrastructure.

  <br/>
  <p align="center">
      <a target="_blank" href="https://dagster.io/integrations" style="background:none">
          <img width="100%" alt="image" src=".github/integrations-bar-for-readme.png">
      </a>
  </p>



  Connect with thousands of other data practitioners building with Dagster. Share knowledge, get help,
  and contribute to the open-source project. To see featured material and upcoming events, check out
  our [Dagster Community](https://dagster.io/community) page.

  Join our community here:

  - 🌟 [Star us on Github](https://github.com/dagster-io/dagster)
  - 📥 [Subscribe to our Newsletter](https://dagster.io/newsletter-signup)
  - 🐦 [Follow us on Twitter](https://twitter.com/dagster)
  - 🕴️ [Follow us on LinkedIn](https://linkedin.com/showcase/dagster)
  - 📺 [Subscribe to our YouTube channel](https://www.youtube.com/channel/UCfLnv9X8jyHTe6gJ4hVBo9Q)
  - 📚 [Read our blog posts](https://dagster.io/blog)
  - 👋 [Join us on Slack](https://dagster.io/slack)
  - 🗃 [Browse Slack archives](https://discuss.dagster.io)
  - ✏️ [Start a Github Discussion](https://github.com/dagster-io/dagster/discussions)



  For details on contributing or running the project for development, check out our [contributing
  guide](https://docs.dagster.io/community/contributing/).



  Dagster is [Apache 2.0 licensed](https://github.com/dagster-io/dagster/blob/master/LICENSE).


pkgId: 0a942a34fce1231a0456e78afe5f7246a634193fbb7ff526fe491da6b9bf6782
name: python-dagster-pandas
arch: src
version: 0.18.6
epoch: 0
release: 1
url: https://github.com/dagster-io/dagster
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8513a975-9fce-4f46-b2f0-60a986749682
location_href: 00012393-python-dagster-pandas/python-dagster-pandas-0.18.6-1.src.rpm
checksum_type: sha256
summary:
  Utilities and examples for working with pandas and dagster, an opinionated framework for expressing data pipelines

description:
  The docs for `dagster-pandas` can be found
  [here](https://docs.dagster.io/_apidocs/libraries/dagster-pandas).


pkgId: c909df3a1e2a37731b714484c201a544edf6187d42fb68561ee25d58128d8501
name: python-daphne
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: Django ASGI (HTTP/WebSocket) server
url: https://github.com/django/daphne
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-19838aee-d284-492f-92ac-1358f384f946
location_href: 00003387-python-daphne/python-daphne-4.0.0-1.src.rpm
checksum_type: sha256
description:
  Daphne is a HTTP, HTTP2 and WebSocket protocol server for
  `ASGI <https://github.com/django/asgiref/blob/main/specs/asgi.rst>`_ and
  `ASGI-HTTP <https://github.com/django/asgiref/blob/main/specs/www.rst>`_,
  developed to power Django Channels.
  It supports automatic negotiation of protocols; there's no need for URL
  prefixing to determine WebSocket endpoints versus HTTP endpoints.


pkgId: 400bfd03ce4e3de62ec3faa963f61d9a4a617d8855b5655f5da8828c0021aa23
name: python-darglint
arch: src
version: 1.8.1
epoch: 0
release: 1
summary: A utility for ensuring Google-style docstrings stay up to date with the source code.
url: https://pypi.org/project/darglint/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-429638d3-6473-4eef-9ffb-7a34e7478f11
location_href: 00010545-python-darglint/python-darglint-1.8.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/terrencepreilly/darglint.svg?branch=develop)](https://travis-ci.com/terrencepreilly/darglint)



  A functional docstring linter which checks whether a docstring's
  description matches the actual function/method implementation.
  *Darglint* expects docstrings to be formatted using the
  [Google Python Style Guide](https://google.github.io/styleguide/pyguide.html),
  or [Sphinx Style Guide](https://pythonhosted.org/an_example_pypi_project/sphinx.html#function-definitions),
  or [Numpy Style Guide](https://numpydoc.readthedocs.io/en/latest/format.html).

  Feel free to submit an issue/pull request if you spot a problem or
  would like a feature in *darglint*.

  **Table of Contents**:

  - [Project Status](#project-status)
  - [Installation](#installation)
  - [Configuration](#configuration)
  - [Usage](#usage)
  - [Scope](#scope)
  - [Sphinx](#sphinx)
  - [Numpy](#numpy)
  - [Integrations](#integrations)
  - [Flake8](#flake8)
  - [Roadmap](#roadmap)
  - [Contribution](#development-and-contributions)




  I no longer work with Python regularly, and I'd like to spend some more
  time on other projects.  So while I'll continue to maintain darglint,
  I likely won't be adding significant new features.  That said, I will
  try to accept pull requests.  See the contribution section for more
  information.  Consider it in maintenance mode.




  To install *darglint*, use pip.

  ```bash
  pip install darglint
  ```

  Or, clone the repository, `cd` to the directory, and

  ```bash
  pip install .
  ```



  *darglint* can be configured using a configuration file.  The configuration
  file must be named either *.darglint*, *setup.cfg*, or *tox.ini*.  It must
  also have a section starting with the section header, `[darglint]`.
  Finally, the configuration file must be located either in the directory
  *darglint* is called from, or from a parent directory of that working
  directory.

  Currently, the configuration file allows us to ignore errors, to specify
  message templates, to specify the strictness of checks and to ignore common
  exceptions.



  If we would like to ignore `ExcessRaiseError`s (because we know that
  an underlying function will raise an exception), then we would add its
  error code to a file named *.darglint*:

  ```ini
  [darglint]
  ignore=DAR402
  ```

  We can ignore multiple errors by using a comma-separated list:

  ```ini
  [darglint]
  ignore=DAR402,DAR103
  ```

  Instead of specifying error codes to ignore in general one can also specify a
  regex to exclude certain function names from tests. For example, the following
  configuration would disable linting on all private methods.
  ```ini
  [darglint]
  ignore_regex=^_(.*)
  ```



  If we would like to specify a message template, we may do so as
  follows:

  ```ini
  [darglint]
  message_template={msg_id}@{path}:{line}
  ```

  Which will produce a message such as `DAR102@driver.py:72`.

  Finally, we can specify the docstring style type using `docstring_style`
  ("google" by default):

  ```ini
  [darglint]
  docstring_style=sphinx
  ```



  Strictness determines how lax darglint will be when checking docstrings.
  There are three levels of strictness available:

  - short: One-line descriptions are acceptable; anything
  more and the docstring will be fully checked.

  - long: One-line descriptions and descriptions without
  arguments/returns/yields/etc. sections will be allowed.  Anything more,
  and the docstring will be fully checked.

  - full: (Default) Docstrings will be fully checked.

  For example, if we have the following function:

  ```python
  def double(x):
      
      return x * 2
  ```

  Then the following table describes which errors will be raised for
  each of the docstrings (rows) when checked against each of the
  configurations (columns):

  ```
  ┌──────────────────────────────┬──────────────────┬────────────────┬──────────────────┐
  │ Docstring                    │  short           │  long          │  full            │
  ├──────────────────────────────┼──────────────────┼────────────────┼──────────────────┤
  │ """Doubles the argument."""  │ None             │ None           │ Missing argument │
  │                              │                  │                │ Missing return   │
  │                              │                  │                │                  │
  │                              │                  │                │                  │
  ├──────────────────────────────┼──────────────────┼────────────────┼──────────────────┤
  │ """Doubles the argument.     │ Missing argument │ None           │ Missing argument │
  │                              │ Missing return   │                │ Missing return   │
  │ Not very pythonic.           │                  │                │                  │
  │                              │                  │                │                  │
  │ """                          │                  │                │                  │
  │                              │                  │                │                  │
  ├──────────────────────────────┼──────────────────┼────────────────┼──────────────────┤
  │ """Doubles the argument.     │ Missing return   │ Missing return │ Missing return   │
  │                              │                  │                │                  │
  │ Args:                        │                  │                │                  │
  │     x: The number to double. │                  │                │                  │
  │                              │                  │                │                  │
  │ """                          │                  │                │                  │
  └──────────────────────────────┴──────────────────┴────────────────┴──────────────────┘
  ```

  In short, if you want to be able to have single-line docstrings, and check
  all other docstrings against their described parameters, you would specify

  ```ini
  [darglint]
  strictness=short
  ```

  In your configuration file.



  We can specify a list of exceptions that don't need to be documented in the
  raises section of a docstring. For example,

  ```ini
  [darglint]
  ignore_raise=ValueError,MyCustomError
  ```



  When *darglint* fails unexpectedly, you can try to gather more
  information when submitting a bug by running with logging.
  For example,

  ```bash
  darglint --log-level=INFO unexpected_failures.py
  ```

  *Darglint* accepts the levels, `DEBUG`, `INFO`, `WARNING`, `ERROR`, and
  `CRITICAL`.







  Given a python source file, `serializers.py`, you would check the docstrings
  as follows:

  ```bash
  darglint serializers.py
  ```

  You can give an optional verbosity setting to *darglint*.  For example,

  ```bash
  darglint -v 2 *.py
  ```

  Would give a description of the error along with information as to this
  specific instance.  The default verbosity is 1, which gives the filename,
  function name, line number, error code, and some general hints.

  To use an arbitrary error format, you can pass a message template, which
  is a python format string.  For example, if we pass the message
  template

  ```bash
  darglint -m "{path}:{line} -> {msg_id}" darglint/driver.py
  ```

  Then we would get back error messages like

  ```bash
  darglint/driver.py :61 -> DAR101
  ```

  The following attributes can be passed to the format string:
  - *line*: The line number,
  - *msg*: The error message,
  - *msg_id*: The error code,
  - *obj*: The function/method name,
  - *path*: The relative file path.

  The message template can also be specified in the configuration file
  as the value `message_template`.

  *darglint* is particularly useful when combined with the utility, `find`.
  This allows us to check all of the files in our project at once.  For example,
  when eating my own dogfood (as I tend to do), I invoke *darglint* as follows:

  ```bash
  find . -name "*.py" | xargs darglint
  ```

  Where I'm searching all files ending in ".py" recursively from the
  current directory, and calling *darglint* on each one in turn.



  You can ignore specific errors in a particular docstring.  The syntax
  is much like that of *pycodestyle*, etc.  It generally takes the from
  of:

  ```python

  ```

  Where `<error>` is the particular error to ignore (`DAR402`, or `DAR201`
  for example), and `<argument>` is what (if anything) the ignore
  statement refers to (if nothing, then it is not specified).

  Let us say that we want to ignore a missing return statement
  in the following docstring:

  ```python
  def we_dont_want_a_returns_section():
    """Return the value, 3.

    

    """
    return 3
  ```

  We put the `noqa` anywhere in the top level of the docstring.
  However, this won't work if we are missing something more specific,
  like a parameter.  We may not want to ignore all missing parameters,
  either, just one particular one.  For example, we may be writing a
  function that takes a class instance as self. (Say, in a bound *celery*
  task.) Then we would do something like:

  ```python
  def a_bound_function(self, arg1):
    """Do something interesting.

    Args:
      arg1: The first argument.

    

    """
    arg1.execute(self)
  ```

  So, the argument comes to the right of the error.

  We may also want to mark excess documentation as being okay.  For example,
  we may not want to explicitly catch and raise a `ZeroDivisionError`.  We
  could do the following:

  ```python
  def always_raises_exception(x):
      """Raise a zero division error or type error.o

      Args:
        x: The argument which could be a number or could not be.

      Raises:
        ZeroDivisionError: If x is a number.  # noqa: DAR402
        TypeError: If x is not a number.  # noqa: DAR402

      """
      x / 0
  ```

  So, in this case, the argument for `noqa` is really all the way to
  the left.  (Or whatever description we are parsing.)  We could also
  have put it on its own line, as `# noqa: DAR402 ZeroDivisionError`.



  Darglint parses type annotations in docstrings, and can, optionally,
  compare the documented type to the actual type annotation.  This can
  be useful when migrating a codebase to use type annotations.

  In order to make these comparisons, Darglint only accepts types
  accepted by Python (see [PEP 484](https://www.python.org/dev/peps/pep-0484/).)
  That is, it does not accept parentheses in type signatures. (If
  parentheses are used in the type signature, Darglint will mark that
  argument as missing.  See Issue #90.)




  - *DAR001*: The docstring was not parsed correctly due to a syntax error.
  - *DAR002*: An argument/exception lacks a description
  - *DAR003*: A line is under-indented or over-indented.
  - *DAR004*: The docstring contains an extra newline where it shouldn't.
  - *DAR005*: The item contains a type section (parentheses), but no type.
  - *DAR101*: The docstring is missing a parameter in the definition.
  - *DAR102*: The docstring contains a parameter not in function.
  - *DAR103*: The docstring parameter type doesn't match function.
  - *DAR104*: (disabled) The docstring parameter has no type specified
  - *DAR105*: The docstring parameter type is malformed.
  - *DAR201*: The docstring is missing a return from definition.
  - *DAR202*: The docstring has a return not in definition.
  - *DAR203*: The docstring parameter type doesn't match function.
  - *DAR301*: The docstring is missing a yield present in definition.
  - *DAR302*: The docstring has a yield not in definition.
  - *DAR401*: The docstring is missing an exception raised.
  - *DAR402*: The docstring describes an exception not explicitly raised.
  - *DAR501*: The docstring describes a variable which is not defined.

  The number in the hundreds narrows the error by location in the docstring:

  - 000: Syntax, formatting, and style
  - 100: Args section
  - 200: Returns section
  - 300: Yields section
  - 400: Raises section
  - 500: Variables section

  You can enable disabled-by-default exceptions in the configuration file
  using the `enable` option.  It accepts a comma-separated list of error
  codes.

  ```ini
  [darglint]
  enable=DAR104
  ```



  Darglint's primary focus is to identify incorrect and missing documentationd
  of a function's signature. Checking style is a stretch goal, and is supported
  on a best-effort basis.  Darglint does not check stylistic preferences expressed
  by tools in the Python Code Quality Authority (through tools such as `pydocstyle`).
  So when using Darglint, it may be a good idea to also use `pydocstyle`, if you
  want to enforce style.  (For example, `pydocstyle` requires the short summary
  to be separated from other sections by a line break.  Darglint makes no such check.)



  Darglint can handle sphinx-style docstrings, but imposes some restrictions
  on top of the Sphinx style. For example, all fields (such as `:returns:`)
  must be the last items in the docstring.  They must be together, and all
  indents should be four spaces.  These restrictions may be loosened at a
  later date.

  To analyze Sphinx-style docstrings, pass the style flag to the command:

  ```bash
  darglint -s sphinx example.py
  darglint --docstring-style sphinx example.py
  ```

  Alternatively, you can specify the style in the configuration file using
  the setting, "docstring\_style":

  ```ini
  [darglint]
  docstring_style=sphinx
  ```



  Darglint now has an initial implementation for Numpy-style docstrings.
  Similarly to Sphinx-style docstrings, you can pass a style flag to the
  command:

  ```bash
  darglint -s numpy example.py
  darglint --docstring-style numpy example.py
  ```

  Or set it in a configuration file:

  ```ini
  [darglint]
  docstring_style=numpy
  ```

  The numpy parser and error reporter are not yet fully stabilized.
  Add issues or suggestions to the tracking bug, Issue #69.





  Darglint can be used in conjunction with Flake8 as a plugin.  The only
  setup necessary is to install Flake8 and Darglint in the same environment.
  Darglint will pull its configuration from Flake8. So, if you would like to
  lint Sphinx-style comments, then you should have `docstring_style=sphinx` in a
  Flake8 configuration file in the project directory.  The settings would
  be entered under the flake8 configuration, not a separate configuration
  for Darglint.  E.g.:

  ```ini
  [flake8]
  strictness=short
  docstring_style=sphinx
  ```

  To see which options are exposed through Flake8, you can check the Flake8
  tool:

  ```bash
  flake8 --help | grep --before-context=2 Darglint
  ```



  A plugin for SublimeLinter can be found [here](https://github.com/raddessi/SublimeLinter-contrib-darglint)



  Download [pre-commit](https://pre-commit.com/) and
  [install](https://pre-commit.com/#install) it. Once it is installed, add this
  to `.pre-commit-config.yaml` in your repository:

  ```yaml
  repos:
  -   repo: https://github.com/terrencepreilly/darglint
      rev: master
      hooks:
      - id: darglint
  ```

  Then run `pre-commit install` and you're ready to go. Before commiting,
  `darglint` will be run on the staged files. If it finds any errors, the user
  is notified and the commit is aborted. Store necessary configuration (such as
  error formatting) in `.darglint`, `setup.cfg` or `tox.ini`.




  Below are some of the current features or efforts.  Where a milestone or
  issue is associated with the idea, it will be mentioned.  Some of these
  ideas are moonshots and may not get implemented.  They are ordered
  roughly according to current priority/feasibility.

  - [ ] Expose command-line options through sphinx.
  - [ ] Robust logging for errors caused/encountered by *darglint*.
  - [ ] Check class docstrings (See Issue #25).
  - [ ] Autoformatting docstrings.  (See Milestone #3).
  - [ ] Optional aggressive style checking through command line flag.
  - [ ] ALE support.
  - [ ] Syntastic support. (Syntastic is not accepting new checkers until
  their next API stabilizes, so this may take some time.)






  Install `darglint`. First, clone the repository:

  ```bash
  git clone https://github.com/terrencepreilly/darglint.git
  ```

  `cd` into the directory, create a virtual environment (optional), then setup:

  ```bash
  cd darglint/
  virtualenv -p python3.6 .env
  source .env/bin/activate
  pip install -e .
  ```

  You can install dependencies using

  ```bash
  pip install poetry
  poetry install
  ```

  You can run the tests using

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

  Or, install `pytest` manually, `cd` to the project's root directory,
  and run

  ```bash
  pytest
  ```

  This project tries to conform by the styles imposed by `pycodestyle`
  and `pydocstyle`, as well as by `darglint` itself.


  A dockerfile exists for testing with Python3.4.  Although it's not
  officially supported (only 3.6+), it's nice to try to make minor
  version numbers support it.  You would build the dockerfile and
  test using something like

  ```bash
  pushd docker-build
  docker build -t darglint-34 -f Dockerfile.test34 .
  popd
  docker run -it --rm -v $(pwd):/code darglint-34 pytest
  ```



  If you would like to tackle an issue or feature, email me or comment on the
  issue to make sure it isn't already being worked on.  Contributions will
  be accepted through pull requests.  New features should include unit tests,
  and, of course, properly formatted documentation.

  Also, check out the wiki prior to updating the grammar.  It includes a
  description of darglint's parsing pipline.


pkgId: b1acd27eeb17c38699904d2f81617d9d268ecf1cefe468412af13d497d6aa335
name: python-dartsclone
arch: src
version: 0.10.2
epoch: 0
release: 1
summary: Python binding of Darts Clone
url: https://github.com/rixwew/darts-clone-python
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c2c446ad-006e-4f00-87c6-7e8f6db84078
location_href: 00010822-python-dartsclone/python-dartsclone-0.10.2-1.src.rpm
checksum_type: sha256
description:
  [Darts-clone](https://github.com/s-yata/darts-clone) binding for Python 3.x.
  This repository provides Cython-based pip-installable package.



      pip install dartsclone




  darts-clone-python is almost compatible with darts-clone.

  ```python
  import dartsclone

  darts = dartsclone.DoubleArray()


  data = [b'apple', b'banana', b'orange']
  values = [1, 3, 2]
  darts.build(data, values=values)


  result = darts.exact_match_search('apple'.encode('utf-8'))
  print(result) # [1, 5]


  result = darts.common_prefix_search('apples'.encode('utf-8'), pair_type=False)
  print(result) # [1]


  darts.save('sample.dic')


  darts.clear()
  darts.open('sample.dic')


  array = darts.array()


  darts.clear()
  darts.set_array(array)

  ```


pkgId: a9f9e41d21c8ee7326fafef6e7b298f899d17e032590a149b0f36d34d80b4c4b
name: python-dartsclone-debuginfo
arch: aarch64
version: 0.10.2
epoch: 0
release: 1
summary: Debug information for package python-dartsclone
url: https://github.com/rixwew/darts-clone-python
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-c2c446ad-006e-4f00-87c6-7e8f6db84078
rpm_sourcerpm: python-dartsclone-0.10.2-1.src.rpm
location_href: 00010822-python-dartsclone/python-dartsclone-debuginfo-0.10.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-dartsclone.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 44fb172b5a780c8948119f95424b057aa34fe6693cbbfb4411716f18dde24fc7
name: python-dartsclone-debugsource
arch: aarch64
version: 0.10.2
epoch: 0
release: 1
summary: Debug sources for package python-dartsclone
url: https://github.com/rixwew/darts-clone-python
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-c2c446ad-006e-4f00-87c6-7e8f6db84078
rpm_sourcerpm: python-dartsclone-0.10.2-1.src.rpm
location_href: 00010822-python-dartsclone/python-dartsclone-debugsource-0.10.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-dartsclone.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 68e45012720212f66f290b365286922e992ef004031585b5760b8d27433a01e7
name: python-dash
arch: src
version: 2.9.2
epoch: 0
release: 1
summary: A Python framework for building reactive web-apps. Developed by Plotly.
url: https://plotly.com/dash
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eb2f317e-8dc3-4655-888d-4b2226825881
location_href: 00009672-python-dash/python-dash-2.9.2-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://img.shields.io/circleci/project/github/plotly/dash/master.svg)](https://circleci.com/gh/plotly/dash)
  [![GitHub](https://img.shields.io/github/license/plotly/dash.svg?color=dark-green)](https://github.com/plotly/dash/blob/master/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/dash.svg?color=dark-green)](https://pypi.org/project/dash/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/dash.svg?color=dark-green)](https://pypi.org/project/dash/)
  [![GitHub commit activity](https://img.shields.io/github/commit-activity/y/plotly/dash.svg?color=dark-green)](https://github.com/plotly/dash/graphs/contributors)
  [![LGTM Alerts](https://img.shields.io/lgtm/alerts/g/plotly/dash.svg)](https://lgtm.com/projects/g/plotly/dash/alerts)
  [![LGTM Grade](https://img.shields.io/lgtm/grade/python/g/plotly/dash.svg)](https://lgtm.com/projects/g/plotly/dash/context:python)



  Built on top of [Plotly.js](https://github.com/plotly/plotly.js), [React](https://reactjs.org/) and [Flask](https://palletsprojects.com/p/flask/), Dash ties modern UI elements like dropdowns, sliders, and graphs directly to your analytical Python code. Read [our tutorial](https://dash.plotly.com/getting-started) (proudly crafted ❤️ with Dash itself).

  - [Docs](https://dash.plotly.com/getting-started): Create your first Dash app in under 5 minutes

  - [dash.gallery](https://dash.gallery): Dash app gallery with Python & R code



  | Dash App | Description |
  |--- | :---: |
  |![Sample Dash App](https://user-images.githubusercontent.com/1280389/30086128-9bb4a28e-9267-11e7-8fe4-bbac7d53f2b0.gif) | Here’s a simple example of a Dash App that ties a Dropdown to a Plotly Graph. As the user selects a value in the Dropdown, the application code dynamically exports data from Google Finance into a Pandas DataFrame. This app was written in just **43** lines of code ([view the source](https://gist.github.com/chriddyp/3d2454905d8f01886d651f207e2419f0)). |
  |![Crossfiltering Dash App](https://user-images.githubusercontent.com/1280389/30086123-97c58bde-9267-11e7-98a0-7f626de5199a.gif)|Dash app code is declarative and reactive, which makes it easy to build complex apps that contain many interactive elements. Here’s an example with 5 inputs, 3 outputs, and cross filtering. This app was composed in just 160 lines of code, all of which were Python.|
  |![Dash App with Mapbox map showing walmart store openings](https://user-images.githubusercontent.com/1280389/30086299-768509d0-9268-11e7-8e6b-626ac9ca512c.gif)| Dash uses [Plotly.js](https://github.com/plotly/plotly.js) for charting. About 50 chart types are supported, including maps. |
  |![Financial report](https://user-images.githubusercontent.com/2678795/161153710-57952401-6e07-42d5-ba3e-bab6419998c7.gif)| Dash isn't just for dashboards. You have full control over the look and feel of your applications. Here's a Dash App that's styled to look like a PDF report. |

  To learn more about Dash, read the [extensive announcement letter](https://medium.com/@plotlygraphs/introducing-dash-5ecf7191b503) or [jump in with the user guide](https://plotly.com/dash).



  With Dash Open Source, Dash apps run on your local laptop or workstation, but cannot be easily accessed by others in your organization.

  Scale up with Dash Enterprise when your Dash app is ready for department or company-wide consumption. Or, launch your initiative with Dash Enterprise from the start to unlock developer productivity gains and hands-on acceleration from Plotly's team.

  ML Ops Features: A one-stop shop for ML Ops: Horizontally scalable hosting, deployment, and authentication for your Dash apps. No IT or DevOps required.
  - [**App manager**](https://plotly.com/dash/app-manager/) Deploy & manage Dash apps without needing IT or a DevOps team. App Manager gives you point & click control over all aspects of your Dash deployments.
  - [**Kubernetes scaling**](https://plotly.com/dash/kubernetes/) Ensure high availability of Dash apps and scale horizontally with Dash Enterprise’s Kubernetes architecture. No IT or Helm required.
  - [**No code auth**](https://plotly.com/dash/authentication/) Control Dash app access in a few clicks. Dash Enterprise supports LDAP, AD, PKI, Okta, SAML, OpenID Connect, OAuth, SSO, and simple email authentication.
  - [**Job Queue**](https://plotly.com/dash/job-queue/) The Job Queue is the key to building scalable Dash apps. Move heavy computation from synchronous Dash callbacks to the Job Queue for asynchronous background processing.

  Low-Code Features: Low-code Dash app capabilities that supercharge developer productivity.
  - [**Design Kit**](https://plotly.com/dash/design-kit/) Design like a pro without writing a line of CSS. Easily arrange, style, brand, and customize your Dash apps.
  - [**Snapshot Engine**](https://plotly.com/dash/snapshot-engine/) Save & share Dash app views as links or PDFs. Or, run a Python job through Dash and have Snapshot Engine email a report when the job is done.
  - [**Dashboard Toolkit**](https://plotly.com/dash/toolkit/) Drag & drop layouts, chart editing, and crossfilter for your Dash apps.
  - [**Embedding**](https://plotly.com/dash/embedding/) Natively embed Dash apps in an existing web application or website without the use of IFrames.

  Enterprise AI Features: Everything that your data science team needs to rapidly deliver AI/ML research and business initiatives.
  - [**AI App Marketplace**](https://plotly.com/dash/ai-and-ml-templates/) Dash Enterprise ships with dozens of Dash app templates for business problems where AI/ML is having the greatest impact.
  - [**Big Data for Pything**](https://plotly.com/dash/big-data-for-python/) Connect to Python's most popular big data back ends: Dask, Databricks, NVIDIA RAPIDS, Snowflake, Postgres, Vaex, and more.
  - [**GPU & Dask Acceleration**](https://plotly.com/dash/gpu-dask-acceleration/) Dash Enterprise puts Python’s most popular HPC stack for GPU and parallel CPU computing in the hands of business users.
  - [**Data Science Workspaces**](https://plotly.com/dash/workspaces/) Be productive from Day 1. Write and execute Python, R, & Julia code from Dash Enterprise's onboard code editor.

  See [https://plotly.com/contact-us/](https://plotly.com/contact-us/) to get in touch.

  ![Dash Enterprise](https://user-images.githubusercontent.com/2678795/161155614-21c54a22-f821-4dda-b910-ee27e27fb5f2.png)


pkgId: dd77ed6e1f61d6388db274821ce3024dba51fb4c67ce91bf061dd928d97784c2
name: python-dash-bootstrap-components
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: Bootstrap themed components for use in Plotly Dash
url: https://dash-bootstrap-components.opensource.faculty.ai/
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-36882351-b841-444a-956a-b81d6456a671
location_href: 00010555-python-dash-bootstrap-components/python-dash-bootstrap-components-1.4.1-1.src.rpm
checksum_type: sha256
description:
  <h1>Dash Bootstrap Components</h1>

  <p align="center">
    <a href="https://dash-bootstrap-components.opensource.faculty.ai/">
      <img src="https://cdn.opensource.faculty.ai/dbc/assets/logo.svg" alt="dash-bootstrap-components logo" width="200" height="200">
    </a>
  </p>

  <p align="center">
    Bootstrap components for Plotly Dash
    <br>
    <a href="https://dash-bootstrap-components.opensource.faculty.ai/">Explore the documentation </a>~
    <a href="https://github.com/facultyai/dash-bootstrap-components/issues/new?template=bug.md">Report a bug </a>~
    <a href="https://github.com/facultyai/dash-bootstrap-components/issues/new?template=feature.md">Request a feature</a>
    <br>
    <br>
    <img alt="GitHub Actions" src="https://github.com/facultyai/dash-bootstrap-components/workflows/Tests/badge.svg?branch=main">
    <img alt="GitHub" src="https://img.shields.io/github/license/facultyai/dash-bootstrap-components">
    <img alt="PyPI" src="https://img.shields.io/pypi/v/dash-bootstrap-components">
    <img alt="Conda (channel only)" src="https://img.shields.io/conda/vn/conda-forge/dash-bootstrap-components">
    <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/dash-bootstrap-components">
  </p>

  _dash-bootstrap-components_ is a library of [Bootstrap][bootstrap-homepage]
  components for use with [Plotly Dash][dash-homepage], that makes it easier to
  build consistently styled Dash apps with complex, responsive layouts.





  You can install _dash-bootstrap-components_ with `pip`:

  ```sh
  pip install dash-bootstrap-components
  ```



  You can also install _dash-bootstrap-components_ with `conda` through the
  conda-forge channel:

  ```sh
  conda install -c conda-forge dash-bootstrap-components
  ```



  To use _dash-bootstrap-components_ you must do two things:

  - Link a Bootstrap v5 compatible stylesheet
  - Incorporate _dash-bootstrap-components_ into your layout



  _dash-bootstrap-components_ doesn't come with CSS included. This is to give you
  the freedom to use any Bootstrap v5 stylesheet of your choice. This means
  however that in order for the components to be styled properly, you must link
  to a stylesheet yourself.

  For convenience, links to [BootstrapCDN][bootstrapcdn] for each theme are
  available through the `themes` module, which can be used as follows:

  ```python
  import dash
  import dash_bootstrap_components as dbc

  app = dash.Dash(external_stylesheets=[dbc.themes.BOOTSTRAP])
  ```

  For more information on how to link local or external CSS, check out the
  [Dash documentation][dash-docs-external].



  With CSS linked, you can start building your app's layout with our Bootstrap
  components. See our [_documentation_][docs-components] for a full list of
  available components.



  We welcome contributions to _dash-bootstrap-components_. If you find a bug or
  something is unclear please [submit a bug report][bug-report], if you have ideas
  for new features please feel free to make a [feature request][feature-request].
  If you would like to submit a pull request, please read our
  [contributing guide][contribution-guide].



  Code and documentation is copyright [Faculty Science Ltd.][faculty]
  2018-2022, and released under the [Apache 2.0 license](./LICENSE.txt)

  [dash-homepage]: https://dash.plot.ly/
  [dash-docs-external]: https:/dash.plot.ly/external-resources
  [bootstrap-homepage]: https://getbootstrap.com/
  [dbc-repo]: https://github.com/facultyai/dash-bootstrap-components
  [reactstrap-homepage]: https://reactstrap.github.io/
  [docs-homepage]: https://dash-bootstrap-components.opensource.faculty.ai
  [docs-components]: https://dash-bootstrap-components.opensource.faculty.ai/l/components
  [bootstrapcdn]: https://www.bootstrapcdn.com/
  [faculty]: https://faculty.ai
  [bug-report]: https://github.com/facultyai/dash-bootstrap-components/issues/new?template=bug.md
  [feature-request]: https://github.com/facultyai/dash-bootstrap-components/issues/new?template=feature.md
  [contribution-guide]: https://github.com/facultyai/dash-bootstrap-components/blob/main/.github/CONTRIBUTING.md


pkgId: a0014e4b8732b6ff06c7e9193418af8f55f3c967d5d5559e6faf434f4f2de88a
name: python-dask
arch: src
version: 2023.3.0
epoch: 0
release: 1
summary: Parallel PyData with Task Scheduling
url: https://github.com/dask/dask/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-968755af-6bed-46f7-b700-9c3ebaa96887
location_href: 00003388-python-dask/python-dask-2023.3.0-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Coverage| |Doc Status| |Discourse| |Version Status| |NumFOCUS|
  Dask is a flexible parallel computing library for analytics.  See
  documentation_ for more information.


pkgId: 2b3150f4e0fd038cfb8dcd89bc302951da9f021844eb9c8e974a312eb00927cf
name: python-dask-glm
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Generalized Linear Models with Dask
url: http://github.com/dask/dask-glm/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-50ed7293-fcc8-43df-84b2-2570d4ef5b3d
location_href: 00012602-python-dask-glm/python-dask-glm-0.2.0-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Documentation Status|
  *This library is not ready for use.*
  See the `documentation`_ for more information.


pkgId: e1b93e1960a1403c1b3fb81f643818c21f147a7e4d613262189a58e0a5aaf519
name: python-dask-jobqueue
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Deploy Dask on job queuing systems like PBS, Slurm, SGE or LSF
url: https://jobqueue.dask.org
rpm_license: BSD 3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-186af9b0-4e44-418f-a453-59c3573f7863
location_href: 00013919-python-dask-jobqueue/python-dask-jobqueue-0.8.1-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Doc Status| |Gitter| |Version Status|
  Easy deployment of Dask Distributed on job queuing systems such as PBS, Slurm,
  or SGE.  See documentation_ for more information.


pkgId: 878ecf1ba406dff40debf16b2da069909e6c260cb91aaafa99a9820c6e2e54ed
name: python-dask-ml
arch: src
version: 2023.3.24
epoch: 0
release: 1
summary: A library for distributed and parallel machine learning
url: https://github.com/dask/dask-ml
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1b56642c-c734-481f-9aa9-fa2cbcb5bf37
location_href: 00012237-python-dask-ml/python-dask-ml-2023.3.24-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Azure Pipelines| |Coverage| |Doc Status| |Discourse| |Version Status| |NumFOCUS|
  Dask-ML provides scalable machine learning in Python using `Dask <https://dask.org/>`__ alongside popular machine learning libraries like `Scikit-Learn <http://scikit-learn.org/>`__, `XGBoost <https://ml.dask.org/xgboost.html>`__, and others.
  You can try Dask-ML on a small cloud instance by clicking the following button:


pkgId: d93c47f074afeb6bbf7f8927498d5e4d134deac59b30cd2c21f2926c118ffa32
name: python-data
arch: src
version: 0.4
epoch: 0
release: 1
summary: Work with unicode/non-unicode data from files or strings uniformly.
url: http://github.com/mbr/data
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-654ec3b4-1229-4d4b-a09d-f1d4fd7688b7
location_href: 00013030-python-data/python-data-0.4-1.src.rpm
checksum_type: sha256
description:
  ``data`` is a small Python module that allows you to treat input in a singular
  way and leave it up to the caller to supply a byte-string, a unicode object, a
  file-like or a filename.
      >>> open('helloworld.txt', 'w').write('hello, world from a file')
      >>> from data import Data as I
      >>> a = I(u'hello, world')
      >>> b = I(file='helloworld.txt')
      >>> c = I(open('helloworld.txt'))
      >>> print unicode(a)
      hello, world
      >>> print unicode(b)
      hello, world from a file
      >>> print unicode(c)
      hello, world from a file
  This can be made even more convenient using the ``data`` decorator:
      >>> from data.decorators import data
      >>> @data('buf')
      >>> parse_buffer('hello')
      "buf passed in as Data(data='hello', encoding='utf8')"
      >>> rv = parse_buffer(open('helloworld.txt'))
      >>> assert 'file=' in rv


pkgId: 981745399db5d927046b9b572a1035b591f87eaea4739dc6dd6182d7628123ce
name: python-data-science-types
arch: src
version: 0.2.23
epoch: 0
release: 1
summary: Type stubs for Python machine learning libraries
url: https://github.com/predictive-analytics-lab/data-science-types
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9409f3e7-bb32-4063-8012-5a203c982732
location_href: 00012976-python-data-science-types/python-data-science-types-0.2.23-1.src.rpm
checksum_type: sha256
description:
  [![Join the chat at https://gitter.im/data-science-types/community](https://badges.gitter.im/data-science-types/community.svg)](https://gitter.im/data-science-types/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

  This is a [PEP-561][pep-561]-compliant stub-only package
  which provides type information for [matplotlib][matplotlib], [numpy][numpy] and [pandas][pandas].
  The [mypy][mypy] type checker (or pytype or PyCharm) can [recognize][mypy-docs] the types in these packages by installing this package.



  Many functions are already typed, but a *lot* is still missing (NumPy and pandas are *huge* libraries).
  Chances are, you will see a message from Mypy claiming that a function does not exist when it does exist.
  If you encounter missing functions, we would be delighted for you to send a PR.
  If you are unsure of how to type a function, we can discuss it.



  You can get this package from PyPI:

  ```bash
  pip install data-science-types
  ```

  To get the most up-to-date version, install it directly from GitHub:

  ```bash
  pip install git+https://github.com/predictive-analytics-lab/data-science-types
  ```

  Or clone the repository somewhere and do `pip install -e .`.



  These are the kinds of things that can be checked:



  ```python
  import numpy as np

  arr1: np.ndarray[np.int64] = np.array([3, 7, 39, -3])  # OK
  arr2: np.ndarray[np.int32] = np.array([3, 7, 39, -3])  # Type error
  arr3: np.ndarray[np.int32] = np.array([3, 7, 39, -3], dtype=np.int32)  # OK
  arr4: np.ndarray[float] = np.array([3, 7, 39, -3], dtype=float)  # Type error: the type of ndarray can not be just "float"
  arr5: np.ndarray[np.float64] = np.array([3, 7, 39, -3], dtype=float)  # OK
  ```



  ```python
  import numpy as np

  arr1: np.ndarray[np.int64] = np.array([3, 7, 39, -3])
  arr2: np.ndarray[np.int64] = np.array([4, 12, 9, -1])

  result1: np.ndarray[np.int64] = np.divide(arr1, arr2)  # Type error
  result2: np.ndarray[np.float64] = np.divide(arr1, arr2)  # OK

  compare: np.ndarray[np.bool_] = (arr1 == arr2)
  ```



  ```python
  import numpy as np

  arr: np.ndarray[np.float64] = np.array([[1.3, 0.7], [-43.0, 5.6]])

  sum1: int = np.sum(arr)  # Type error
  sum2: np.float64 = np.sum(arr)  # OK
  sum3: float = np.sum(arr)  # Also OK: np.float64 is a subclass of float
  sum4: np.ndarray[np.float64] = np.sum(arr, axis=0)  # OK


  ```



  The goal is not to recreate the APIs exactly.
  The main goal is to have *useful* checks on our code.
  Often the actual APIs in the libraries is more permissive than the type signatures in our stubs;
  but this is (usually) a feature and not a bug.



  We always welcome contributions.
  All pull requests are subject to CI checks.
  We check for compliance with Mypy and that the file formatting conforms to our Black specification.

  You can install these dev dependencies via

  ```bash
  pip install -e '.[dev]'
  ```

  This will also install NumPy, pandas, and Matplotlib to be able to run the tests.



  We include a script for running the CI checks that are triggered when a PR is opened.
  To test these out locally, you need to install the type stubs in your environment.
  Typically, you would do this with

  ```bash
  pip install -e .
  ```

  Then use the `check_all.sh` script to run all tests:

  ```bash
  ./check_all.sh
  ```

  Below we describe how to run the various checks individually,
  but `check_all.sh` should be easier to use.



  The settings for Mypy are specified in the `mypy.ini` file in the repository.
  Just running

  ```bash
  mypy tests
  ```

  from the base directory should take these settings into account.
  We enforce 0 Mypy errors.



  We use [Black][black] to format the stub files.
  First, install `black` and then run

  ```bash
  black .
  ```
  from the base directory.



  ```bash
  python -m pytest -vv tests/
  ```



  ```bash
  flake8 *-stubs
  ```



  [Apache 2.0](LICENSE)


  [pep-561]: https://www.python.org/dev/peps/pep-0561/
  [matplotlib]: https://matplotlib.org
  [numpy]: https://numpy.org
  [pandas]: https://pandas.pydata.org
  [mypy]: http://www.mypy-lang.org/
  [mypy-docs]: https://mypy.readthedocs.io/en/latest/installed_packages.html
  [black]: https://github.com/psf/black


pkgId: 034483c5ab78baf8f44d74be646e8870f9e5e074c0ca0daff6f0b35563b29dc6
name: python-databases
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Async database support for Python.
url: https://github.com/encode/databases
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d2da8acb-a765-4c75-adb7-4f129f058b2a
location_href: 00011174-python-databases/python-databases-0.7.0-1.src.rpm
checksum_type: sha256
description:
  ```shell
  $ pip install databases
  ```
  Database drivers supported are:
  * [asyncpg][asyncpg]
  * [aiopg][aiopg]
  * [aiomysql][aiomysql]
  * [asyncmy][asyncmy]
  * [aiosqlite][aiosqlite]
  You can install the required database drivers with:
  ```shell
  $ pip install databases[asyncpg]
  $ pip install databases[aiopg]
  $ pip install databases[aiomysql]
  $ pip install databases[asyncmy]
  $ pip install databases[aiosqlite]
  ```


pkgId: 75cd8193a3db6c361689696a2caa2c71ab1ac4da62fc09e73717783127dc5670
name: python-databay
arch: src
version: 0.3.0
epoch: 0
release: 1
url: https://github.com/Voyz/databay
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bad56b87-0cd9-4a73-9056-7d748ec72fdd
location_href: 00003393-python-databay/python-databay-0.3.0-1.src.rpm
checksum_type: sha256
summary:
  Databay is a Python interface for scheduled data transfer. It facilitates transfer of (any) data from A to B, on a scheduled interval.

description:
  While Databay comes with a handful of built-in inlets and outlets, its strength lies in extendability. To use Databay in your project, create concrete implementations of `Inlet` and `Outlet` classes that handle the data production and consumption functionality you require. Databay will then make sure data can repeatedly flow between the inlets and outlets you create. [Extending inlets][extending_inlets] and [extending outlets][extending_outlets] is easy and has a wide range of customization. Head over to [Extending Databay][extending] section for a detailed explanation or to [Examples][examples] for real use cases.

  | Python Version 	| <3.6 	| 3.6 	| 3.7 	| 3.8 	| 3.9 	|
  |----------------	|------	|-----	|-----	|-----	|-----	|
  | Supported      	| ❌    	| ✅   	| ✅   	| ✅   	| ✅   	|

  We aim to support the ecosystem of Databay users by collating and promoting inlets and outlets that implement popular functionalities. We encourage you to share the inlets and outlets you write with the community - start by reading the [guidelines][community_docs] on contributing to the Databay community.
  Did you write a cool inlet or outlet that you'd like to share with others? Put it on a public repo, send us an [email][voy1982_email] and we'll list it here!
  [voy1982@yahoo.co.uk][voy1982_email]

  * [FileInlet](https://databay.readthedocs.io/en/latest/api/databay/inlets/file_inlet/index.html) - File input inlet (built-in).
  * [HttpInlet](https://databay.readthedocs.io/en/latest/api/databay/inlets/http_inlet/index.html) - Asynchronous http request inlet using aiohttp (built-in).

  * [FileOutlet](https://databay.readthedocs.io/en/latest/api/databay/outlets/file_outlet/index.html) - Generic file outlet (built-in).
  * [CsvOutlet](https://databay.readthedocs.io/en/latest/api/databay/outlets/csv_outlet/index.html) - CSV file outlet (built-in).
  * [MongoOutlet](https://databay.readthedocs.io/en/latest/api/databay/outlets/mongo_outlet/index.html) - MongoDB outlet (built-in).

  The following are inlets and outlets that others would like to see implemented. Feel free to build an item from this list and share your implementation! Let us know if you'd like to add an item to this list.
  * PostgreSqlOutlet - [PostgreSQL](https://www.postgresql.org/) Outlet

  See full [Databay Roadmap][databay_roadmap]. Bare in mind this a live document that is shared to give you an idea of what can be expected in the future releases, rather than a locked schedule. Priorities and order of implementation may change without warning.

  1. Beta test the pre-release.
  1. ~~Complete 100% test coverage.~~
  1. ~~Add more advanced examples.~~
  1. Release v1.0.
  1. Buy a carrot cake and celebrate.

  1. Filters and translators - callbacks for processing data between inlets and outlets.
  1. Advanced scheduling - conditional, non uniform intervals.

  See [LICENSE](https://github.com/Voyz/databay/blob/master/LICENSE)
    [docs]: https://databay.readthedocs.io/
    [overview]: https://databay.readthedocs.io/en/latest/introduction.html#overview
    [examples]: https://databay.readthedocs.io/en/latest/examples.html
    [api]: https://databay.readthedocs.io/en/latest/api/databay/index.html
    [aps]: http://apscheduler.readthedocs.io/
    [schedule]: https://schedule.readthedocs.io/
    [simple_example]: https://databay.readthedocs.io/en/latest/examples.html#simple-usage
    [extending]: https://databay.readthedocs.io/en/latest/extending.html
    [extending_inlets]: https://databay.readthedocs.io/en/latest/extending/extending_inlets.html
    [extending_outlets]: https://databay.readthedocs.io/en/latest/extending/extending_outlets.html
    [asyncio]: https://docs.python.org/3/library/asyncio.html
    [records]: https://databay.readthedocs.io/en/latest/introduction.html#records
    [scheduling]: https://databay.readthedocs.io/en/latest/introduction.html#scheduling
    [exceptions]: https://databay.readthedocs.io/en/latest/introduction.html#exception-handling
    [logging]: https://databay.readthedocs.io/en/latest/introduction.html#logging
    [extending_base_planner]: https://databay.readthedocs.io/en/latest/extending/extending_base_planner.html
    [startup_and_shutdown]: https://databay.readthedocs.io/en/latest/introduction.html#start-and-shutdown
    [async_inlet]: https://databay.readthedocs.io/en/latest/extending/extending_inlets.html#asynchronous-inlet
    [async_outlet]: https://databay.readthedocs.io/en/latest/extending/extending_outlets.html#asynchronous-outlet
    [voy1982_email]: mailto:voy1982@yahoo.co.uk
    [issues]: https://github.com/Voyz/databay/issues
    [community_docs]: https://databay.readthedocs.io/en/latest/extending/community_contributions.html
    [databay_roadmap]: http://bit.ly/databay-roadmap


pkgId: 87fd1b46e2909033f47d621f27de3e8a09b609762b70a472cda5825bc66ce331
name: python-databricks-cli
arch: src
version: 0.17.6
epoch: 0
release: 1
summary: A command line interface for Databricks
url: https://github.com/databricks/databricks-cli
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3fa824a8-0cdd-448a-adbe-349d4dc3172a
location_href: 00009007-python-databricks-cli/python-databricks-cli-0.17.6-1.src.rpm
checksum_type: sha256
description:
  The Databricks Command Line Interface (CLI) is an open source tool which provides an easy to use interface to
  the Databricks platform. The CLI is built on top of the Databricks REST APIs.
  **Note**: This CLI is under active development and is released as an experimental client. This means that interfaces are still subject to change.
  If you're interested in contributing to the project please reach out.
  In addition, please leave bug reports as issues on our `GitHub project <https://github.com/databricks/databricks-cli>`_.


pkgId: d90c5ba6ce0afc58854990ae7eaaa0c62d3989201fae59ac2afb9b6d8294494d
name: python-databricksapi
arch: src
version: 1.1.8
epoch: 0
release: 1
summary: Python Databricks API wrapper using requests module
url: https://github.com/angel-hernandez91/databricks_api
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0d289e1a-49a1-43b6-990b-85ea22bc99ff
location_href: 00013379-python-databricksapi/python-databricksapi-1.1.8-1.src.rpm
checksum_type: sha256
description:
  *This package is a Python Implementation of the [Databricks API](https://docs.databricks.com/api/latest/index.html) for structured and programmatic use. This Python implementation requires that your Databricks API Token be saved as an environment variable in your system:* `export DATABRICKS_TOKEN=MY_DATABRICKS_TOKEN` in OSX / Linux. Or in Windows by searching for System Environment Variables in the Start Menu and adding it in the editor. For details see this [guide](https://superuser.com/questions/949560/how-do-i-set-system-environment-variables-in-windows-10).


  *Tokens can now be passed when a particular class is instantiated. E.g.:*

  ```python
  from databricksapi import Workspace
  url = 'https://my-databricks-instance.com'
  token = 'dapiXXXXXXXXXXXXX'
  ws = Workspace(url, token)

  ```


  You can either use `pip install databricksapi` to install it globally, or you can clone the repository. Please note that only compatability with Python 3.7+ is guaranteed.


  * Token
  * Secrets
  * Clusters
  * SCIM (Experimental)
  * Jobs
  * DBFS
  * Groups
  * Instance Profiles
  * Libraries
  * Workspace


  The modules above can be imported as follows
  ```python
  from databricksapi import Token, Jobs, DBFS
  url = 'https://url.for.databricks.net'

  token_instance = Token(url)
  jobs_instance = Jobs(url)
  ```


  The Token API allows any user to create, list, and revoke tokens that can be used to authenticate and access Databricks REST APIs. Initial authentication to this API is the same as for all of the Databricks API endpoints.


  1. createToken(*lifetime_seconds*, *comment*)
  2. listTokens()
  3. revokeToken(*token_id*)


  Create and return a token.
  ```python
  url = 'https://url.for.databricks.net'
  db_api = Token(url)

  db_api.createToken(600, 'Test token')
  ```


  List all Token IDs in your Databricks Environment.
  ```python
  url = 'https://url.for.databricks.net'
  db_api = Token(url)

  db_api.listTokens()
  ```


  Revoke an active Databricks token.
  ```python
  url = 'https://url.for.databricks.net'
  db_api = Token(url)


  db_api.revokeToken('5715498424f15ee0213be729257b53fc35a47d5953e3bdfd8ed22a0b93b339f4')
  ```


  The Secrets API allows you to manage secrets, secret scopes, and access permissions.


  1. createSecretScope(*scope*, *initial_manage_principal*)
  2. deleteSecretScope(*scope*)
  3. listSecretScopes()
  4. putSeceret(*value*, *value_type*, *scope*, *key*)
  5. deleteSecret(*scope*, *key*)
  6. listSecrets(*scope*)
  7. putSecretACL(*scope*, *principal*, *permission*)
  8. deleteSecretACL(*scope*, *principal*)
  9. getSecretACL(*scope, *principal*)
  10. listSecretACL(*scope*, *principal*)


  Creates a new secret scope.

  The scope name must consist of alphanumeric characters, dashes, underscores, and periods, and may not exceed 128 characters. The maximum number of scopes in a workspace is 100.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Secrets(url)

  scope = 'SomeSecretScope'
  initial_manage_princial = 'users'
  db_api.createSecretScope(scope, initial_manage_princial)
  ```



  Delete a secret scope.
  ```python
  url = 'https://url.for.databricks.net'
  db_api = Secrets(url)

  scope = 'SomeSecretScope'
  db_api.deleteSecretScope(scope)
  ```


  List all secret scopes in the workspace

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Secrets(url)

  db_api.listSecretScopes()
  ```


  Inserts a secret under the provided scope with the given name. If a secret already exists with the same name, this command overwrites the existing secret’s value. The server encrypts the secret using the secret scope’s encryption settings before storing it. You must have WRITE or MANAGE permission on the secret scope.

  The `value_type` parameter can either be set to `string` or `bytes` depending on the type fo value the user passes in.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Secrets(url)


  value = 'BeepBoop'
  value_type = 'string'
  scope = 'SomeSecretScope'
  key = 'uniqueScopekey'

  db_api.putSecret(value, value_type, scope, key)
  ```


  Deletes the secret stored in this secret scope. You must have WRITE or MANAGE permission on the secret scope.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Secrets(url)

  scope = 'SomeSecretScope'
  key = 'uniqueScopekey'

  db_api.deleteSecret(scope, key)
  ```


  Lists the secret keys that are stored at this scope. This is a metadata-only operation; secret data cannot be retrieved using this API. Users need READ permission to make this call.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Secrets(url)

  scope = 'SomeSecretScope'

  db_api.listSecrets(scope)
  ```


  Creates or overwrites the ACL associated with the given principal (user or group) on the specified scope point. In general, a user or group will use the most powerful permission available to them

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Secrets(url)

  scope = 'SomeSecretScope'
  prinicpal = 'users'
  permission = 'READ'

  db_api.putSecretACL(scope, principal, permission)
  ```


  Deletes the given ACL on the given scope.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Secrets(url)

  scope = 'SomeSecretScope'
  prinicpal = 'users'

  db_api.deleteSecretACL(scope, principal)
  ```


  Describes the details about the given ACL, such as the group and permission.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Secrets(url)

  scope = 'SomeSecretScope'
  prinicpal = 'users'

  db_api.getSecretACL(scope, principal)
  ```


  Lists the ACLs set on the given scope.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Secrets(url)

  scope = 'SomeSecretScope'
  prinicpal = 'users'

  db_api.listSecretACL(scope, principal)
  ```


  The Clusters API allows you to create, start, edit, list, terminate, and delete clusters via the API. The maximum allowed size of a request to the Clusters API is 10MB.


  1. createCluster(*worker*, *worker_type*, *cluster_name*, *spark_version*, *cluster_log_conf*, *node_type_id*, *driver_node_type_id=None*, *spark_conf=None*, *aws_attributes=None*, *ssh_public_keys=None*, *custom_tags=None*, *init_scripts=None*, *spark_env_vars=None*, *autotermination_minutes=None*, *enable_elastic_disk=None*)
  2. editCluster(*worker*, *worker_type*, *cluster_name*, *spark_version*, *cluster_log_conf*, *node_type_id*, *driver_node_type_id=None*, *spark_conf=None*, *aws_attributes=None*, *ssh_public_keys=None*, *custom_tags=None*, *init_scripts=None*, *spark_env_vars=None*, *autotermination_minutes=None*, *enable_elastic_disk=None*)
  3. startCluster(*cluster_id*)
  4. restartCluster(*cluster_id*)
  5. resizeCluster(*cluster_id*, *worker*, *worker_type*)
  6. terminateCluster(*cluster_id*)
  7. deleteCluster(*cluster_id*)
  8. getCluster(*cluster_id*)
  9. pinCluster(*cluster_id*)
  10. unpinCluster(*cluster_id*)
  11. listClusters()
  12. listNodeTypes()
  13. listZones()
  14. getSparkVersions()
  15. getClusterEvents(*cluster_id*, *order='DESC'*, *start_time=None*, *end_time=None*, *event_types=None*, *offset=None*, *limit=None*)



  Creates a new Spark cluster. This method acquires new instances from the cloud provider if necessary. This method is asynchronous; the returned cluster_id can be used to poll the cluster state. When this method returns, the cluster is in a PENDING state. The cluster is usable once it enters a RUNNING state.

  The `worker_type` can be either `workers` or `autoscale`. If a `autoscale` is set, then the `min_workers` and `max_workers` must be specified.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  worker = 25
  worker_type = 'workers'
  cluster_name = 'TestCluster'
  spark_version = '4.0.x-scala2.11'
  cluster_log_conf = '/dbfs/log/path'
  node_type_id = 'i3.xlarge'

  db_api.createCluster(worker=worker, worker_type=worker_type, cluster_name=cluster_name, spark_version=spark_version, cluster_log_conf=cluster_log_conf, node_type_id=node_type_id)
  ```



  Edit an existings clusters configuration.

  The `worker_type` can be either `workers` or `autoscale`. If a `autoscale` is set, then the `min_workers` and `max_workers` must be specified.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  worker = 35
  worker_type = 'workers'
  cluster_name = 'TestCluster'
  spark_version = '4.0.x-scala2.11'
  cluster_log_conf = '/dbfs/new/log/path'
  node_type_id = 'i5.xlarge'

  db_api.editCluster(worker=worker, worker_type=worker_type, cluster_name=cluster_name, spark_version=spark_version, cluster_log_conf=cluster_log_conf, node_type_id=node_type_id)
  ```


  Starts a terminated Spark cluster given its ID.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  cluster_id = '1202-211320-brick1'
  db_api.startCluster(cluster_id)
  ```


  Restarts a Spark cluster given its id. If the cluster is not in a RUNNING state, nothing will happen.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  cluster_id = '1202-211320-brick1'
  db_api.restartCluster(cluster_id)
  ```


  Resizes a cluster to have a desired number of workers. This will fail unless the cluster is in a RUNNING state.

  The parameter `worker_type` can be one of `workers` or `autoscale`.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  cluster_id = '1202-211320-brick1'
  workers = 30

  db_api.resizeCluster(cluster_id, workers, worker_type='workers')
  ```


  Terminates a Spark cluster given its id. The cluster is removed asynchronously. Once the termination has completed, the cluster will be in a TERMINATED state. If the cluster is already in a TERMINATING or TERMINATED state, nothing will happen.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  cluster_id = '1202-211320-brick1'

  db_api.terminateCluster(cluster_id)
  ```


  Permanently deletes a Spark cluster. If the cluster is running, it is terminated and its resources are asynchronously removed. If the cluster is terminated, then it is immediately removed.

  You cannot perform any action on a permanently deleted cluster and a permanently deleted cluster is no longer returned in the cluster list.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  cluster_id = '1202-211320-brick1'

  db_api.deleteCluster(cluster_id)
  ```


  Returns information about all pinned clusters, currently active clusters, up to 70 of the most recently terminated interactive clusters in the past 30 days, and up to 30 of the most recently terminated job clusters in the past 30 days.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  cluster_id = '1202-211320-brick1'

  db_api.getCluster(cluster_id)
  ```



  Pinning a cluster ensures that the cluster is always returned by the List API. Pinning a cluster that is already pinned has no effect.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  cluster_id = '1202-211320-brick1'

  db_api.pinCluster(cluster_id)
  ```


  Unpinning a cluster will allow the cluster to eventually be removed from the list returned by the List API. Unpinning a cluster that is not pinned has no effect.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  cluster_id = '1202-211320-brick1'

  db_api.unpinCluster(cluster_id)
  ```


  Retrieves the information for a cluster given its identifier. Clusters can be described while they are running, or up to 30 days after they are terminated.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  db_api.listClusters()
  ```


  Returns a list of supported Spark node types. These node types can be used to launch a cluster.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  db_api.listNodeTypes()
  ```


  Returns a list of availability zones where clusters can be created in (ex: us-west-2a). These zones can be used to launch a cluster.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  db_api.listZones()
  ```


  Returns the list of available Spark versions. These versions can be used to launch a cluster.

  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  db_api.getSparkVersions()
  ```


  Retrieves a list of events about the activity of a cluster. This API is paginated. If there are more events to read, the response includes all the parameters necessary to request the next page of events.



  ```python
  url = 'https://url.for.databricks.net'
  db_api = Clusters(url)

  cluster_id = '1202-211320-brick1'

  db_api.getClusterEvents(cluster_id)
  ```


  The Jobs API allows you to create, edit, and delete jobs via the API. The maximum allowed size of a request to the Jobs API is 10MB.


  1. createJob(*cluster*, *cluster_type*, *task*, *task_type*, *name*, *libraries=None*, *email_notications=None*, *timeout_seconds=None*, *max_retries=None*, *min_retry_interval_millis=None*, *retry_on_timeout=None*,*schedule=None*, *max_concurrent_runs=None*)
  2. listJobs()
  3. deleteJob(*job_id*)
  4. batchDelete(*\*args*)
  5. getJob(*job_id*)
  6. resetJob(*job_id*, *new_settings*)
  7. runJob(*job_id*, *job_type*, *params*)
  8. runsSubmit(*run_name*, *cluster*, *task*, *cluster_type*, *task_type*, *libraries=None*, *timeout_seconds=None*)
  9. runsList(*run*, *run_type*, *job_id*, *offset*, *limit*)
  10. runsGet(*run_id*)
  11. runsExport(*run_id*, *views_to_export*)
  12. runsCancel(*run_id*)
  13. runsGetOutput(*run_id*)
  14. runsDelete(*run_id*) 


  The `cluster_type` parameter can be one of `existing` or `new`.
  The `task_type` parameter must be one of `notebook`, `jar`, `submit`, or `python`.

  All other parameters are documented in the Databricks Rest API.


  Takes in a comma separated list of Job IDs to be deleted. This method is a wrapper around the `deleteJob` method.


  The `job_type` parameter must be one of `notebook`, `jar`, `submit` or `python`.


  The `cluster_type` parameter can be one of `existing` or `new`.


  The `run_type` parameter must be one of `completed` or `active`.


  The DBFS API is a Databricks API that makes it simple to interact with various data sources without having to include your credentials every time you read a file.


  1. addBlock(*data*, *handle*)
  2. closeStream(*handle*)
  3. createFile(*path*, *overwrite*)
  4. deleteFile(*path*, *recursive*)
  5. getStatus(*path*)
  6. listFiles(*path*)
  7. makeDirs(*path*)
  8. moveFiles(*source_path*, *target_path*)
  9. putFiles(*path*, *overwrite*, *files*, *contents=None*)
  10. readFiles(*path*, *offset*, *length*)


  The Groups API allows you to manage groups of users via the API. You must be a Databricks administrator to invoke this API.


  1. addMember(*parent_name*, *name*, *name_type*)
  2. createGroup(*group_name*)
  3. listGroupMembers(*group_name*, *return_type='json'*)
  4. listGroups()
  5. listParents(*name*, *name_type*)
  6. removeMember(*name*, *parent_name*, *name_type*)
  7. deleteGroup(*group_name*)


  The default `return_type` can be one of `json` or `list`, by default the paramter is set to `json`. This is provide to simplify pulling usernames from the default return time which can be cumbersome.


  The `name_type` parameter must be one of `user` or `group`.


  The `name_type` parameter must be one of `user` or `group`.


  The Instance Profiles API allows admins to add, list, and remove instance profiles that users can launch clusters with. Regular users can list the instance profiles available to them.


  1. addProfile(*profile_arn*, *skip_validation=None*)
  2. listProfiles()
  3. removeProfile()


  The Libraries API allows you to install and uninstall libraries and get the status of libraries on a cluster via the API.


  1. allClusterStatuses(*status*)
  2. clusterStatus(*cluster_id*)
  3. installLibrary(*cluster_id*, *libraries*)
  4. uninstallLibrary(*cluster_id*, *libraries*)


  1. deleteWorkspace(*path*, *recursive*)
  2. exportWorkspace(*path*, *export_format*, *direct_download*)
  3. getWorkspaceStatus(*path*)
  4. importWorkspace(*path*, *export_format*, *language*, *content*, *overwrite*)
  5. listWorkspace(*path*)
  6. mkdirsWorkspace(*path*)


pkgId: 801cf50aae62e466464be304a6ec064bd7157b8203281983685b6225c35654e4
name: python-databrickstools
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: A simple commandline application to manage databricks resources.
url: https://github.com/rhdzmota/databrickstools-cli
rpm_license: LICENSE.md
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eaf58a52-b1e3-43eb-85a6-7cd166a239ae
location_href: 00012653-python-databrickstools/python-databrickstools-0.3.2-1.src.rpm
checksum_type: sha256
description:
  A simple commandline application to keep in sync between databricks and your local filesystem. This project uses the databricks [workspace api](https://docs.databricks.com/dev-tools/api/latest/workspace.html).

  Key features:
  * List and MkDir commands.
  * Download databricks notebooks as HTML, Jupyter, or Source format.
  * Upload file from your filesystem (source format) to create/overwrite databricks notebooks.
  * Automatically transform markdown files to source!
      * Using markdown syntax instead of source is more convenient.
      * Use codeblocks to change between languages (e.g. `python`, `scala`, `sql`, `sh`).
      * Integrate local development and execution with databricks notebooks.

  ```commandline
  $ databrickstools ls --path /Shared
  ```

  ```commandline
  $ databrickstools upload markdown \
      --from-path exploration.md \
      --to-path /Shared/merchants/exploration
  ```



  Install via `pip`:

  ```commandline
  $ pip install databrickstools
  ```

  Or clone the repository and install the commandline application!

  1. Clone: `git clone https://github.com/rhdzmota/databrickstools-cli`
  1. Install: `pip install -e databrickstools-cli`

  **Note**: you'll need python 3.6 or greater.

  Create the `.env` file containing your environment variables.

  1. Create `.env` following the example `.env.example`:
      * `cp .env.example .env`
  1. Load the variables into the environment:
      *  `export $(cat .env | xargs)`

  **Note**: the `.env` file can be on any place of your machine. The commandline application just needs those variables to be present on the environment.

  Test with a simple command:

  ```commandline
  $ databrickstools ls --path /Shared
  ```



  Assume you have a file named `exploration.md` with the following markdown content:

  ````text


  This is a file containing the initial EDA work.



  ```python
  import pandas as pd
  from sqlalchemy import create_engine

  connection_string = "..."
  engine = create_engine(connection_string)
  ```



  Consider the following invalid merchant data:

  ```python
  SQL_INVALID_MERCHANTS = "SELECT * FROM merchants WHERE invalid = 1"

  df = pd.read_sql(query, engine)
  df.head()
  ```

  Location distribution:

  ```python
  df.groupby("state").size().to_frame()
  ```
  ...

  ````

  You could use [rmarkdown + reticulate](https://rstudio.github.io/reticulate/articles/r_markdown.html) for local development and execution of that report. And then use `databrickstools` to deploy and transform this markdown file into a databricks notebook!

  ```commandline
  $ databrickstools upload markdown \
      --from-path exploration.md \
      --to-path /Shared/merchants/exploration \
      --base-language python \
      --overwrite
  ```



  The CLI contains `groups` or `commands`. A `command` is a method call that received zero or more arguments. A `group` contains one or more `commands` with common functionality.

  Available groups:

  * `download`
  * `upload`





  List the databricks resources for a give path.

  ````commandline
  $ databrickstools ls --path <value>
  ````

  Where:

  `--path` (string)
  > Path to folder inside databricks.

  Example:

  ```text
  $ databrickstools ls --path /Shared
  ```



  Create a directory on databricks.

  ````commandline
  $ databrickstools mkdir --path <value>
  ````

  Where:

  `--path` (string)
  > Path to folder inside databricks.

  Example:

  ```text
  $ databrickstools mkdir --path /Shared/temp
  ```





  Download a given file from databricks!

  ````commandline
  $ databrickstools download file \
      --from-path <value> \
      --to-path <value> \
      --file-format <value>
  ````

  Where:

  `--from-path` (string)
  > Path to file inside databricks.

  `--to-path` (string)
  > Path in local machine.

  `--file-format` (string)
  > Format used to download file.
  > Default: DATABRICKSTOOLS_DEFAULT_FORMAT

  Example:

  ```text
  databrickstools download file \
      --from-path /Shared/example \
      --to-path example \
      --file-format SOURCE
  ```



  Download a notebook as an HTML file.

  ````commandline
  $ databrickstools download html \
      --from-path <value> \
      --to-path <value>
  ````

  Where:

  `--from-path` (string)
  > Path to file inside databricks.

  `--to-path` (string)
  > Path in local machine.

  Example:

  ```text
  $ databrickstools download html \
      --from-path /Shared/example \
      --to-path example.html
  ```



  Download a notebook as a Jupyter file. Only works for python-based notebooks.

  ````commandline
  $ databrickstools download ipynb \
      --from-path <value> \
      --to-path <value>
  ````

  Where:

  `--from-path` (string)
  > Path to file inside databricks.

  `--to-path` (string)
  > Path in local machine.

  Example:

  ```text
  $ databrickstools download ipynb \
      --from-path /Shared/example \
      --to-path example.ipynb
  ```



  Download a notebook as a source file. This can be either a `.py` file for Python or a `.sc` file for Scala.

  ````commandline
  $ databrickstools download source \
      --from-path <value> \
      --to-path <value>
  ````

  Where:

  `--from-path` (string)
  > Path to file inside databricks.

  `--to-path` (string)
  > Path in local machine.


  Example:

  ```text
  $ databrickstools download source \
      --from-path /Shared/example \
      --to-path example.py
  ```





  Upload a markdown file to databricks as a notebook.

  ````commandline
  $ databrickstools upload markdown \
      --from-path <value> \
      --to-path <value> \
      --base-language <value> \
      --overwrite
  ````

  Where:

  `--from-path` (string)
  > Path to `file.md` in your local machine.

  `--to-path` (string)
  > Path to notebook on databricks.

  `--base-language` (string)
  > The markdown might contain multiple languages, but we'll need to define (or know) the base language of the notebook. If not present, the CLI will try to infer the base language by looking into the file-ending or fallback to: `DATABRICKSTOOLS_DEFAULT_LANGUAGE`.

  `--overwrite` (flag)
  > If present, the new file will overwrite the current one on databricks.

  Example:

  ```text
  $ databrickstools markdown \
      --from-path markdown-file.md \
      --to-path /Shared/test \
      --overwrite
  ```



  Same as `markdown` but with the `SOURCE` format.



  To get the most out of markdown please consider taking a look into:
  * [Tut](https://tpolecat.github.io/tut/)
  * [Pandoc](https://pandoc.org/)
  * [RMarkdown](https://rmarkdown.rstudio.com/lesson-1.html)
  * [Reticulate](https://rstudio.github.io/reticulate/articles/r_markdown.html)


pkgId: 4680040eb1770f30ba7d4b69c9cb1e8d063c1bb6a9459a5142b4f4f9391cd819
name: python-dataclasses-json
arch: src
version: 0.5.7
epoch: 0
release: 1
summary: Easily serialize dataclasses to and from JSON
url: https://github.com/lidatong/dataclasses-json
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dcb75c92-65c8-42ca-8294-d8d54180eac0
location_href: 00009312-python-dataclasses-json/python-dataclasses-json-0.5.7-1.src.rpm
checksum_type: sha256
description:
  ![](https://github.com/lidatong/dataclasses-json/workflows/dataclasses-json/badge.svg)

  This library provides a simple API for encoding and decoding [dataclasses](https://docs.python.org/3/library/dataclasses.html) to and from JSON.

  It's very easy to get started.

  [README / Documentation website](https://lidatong.github.io/dataclasses-json). Features a navigation bar and search functionality, and should mirror this README exactly -- take a look!



  `pip install dataclasses-json`

  ```python
  from dataclasses import dataclass
  from dataclasses_json import dataclass_json


  @dataclass_json
  @dataclass
  class Person:
      name: str


  person = Person(name='lidatong')
  person.to_json()  # '{"name": "lidatong"}' <- this is a string
  person.to_dict()  # {'name': 'lidatong'} <- this is a dict
  Person.from_json('{"name": "lidatong"}')  # Person(1)
  Person.from_dict({'name': 'lidatong'})  # Person(1)




  Person.from_json('{"name": 42}')  # This is ok. 42 is not a `str`, but
                                    
  Person.schema().loads('{"name": 42}')  # Error! Raises `ValidationError`
  ```

  **What if you want to work with camelCase JSON?**

  ```python

  from dataclasses import dataclass
  from dataclasses_json import dataclass_json, LetterCase

  @dataclass_json(letter_case=LetterCase.CAMEL)  # now all fields are encoded/decoded from camelCase
  @dataclass
  class ConfiguredSimpleExample:
      int_field: int

  ConfiguredSimpleExample(1).to_json()  # {"intField": 1}
  ConfiguredSimpleExample.from_json('{"intField": 1}')  # ConfiguredSimpleExample(1)
  ```



  It's recursive (see caveats below), so you can easily work with nested dataclasses.
  In addition to the supported types in the
  [py to JSON table](https://docs.python.org/3/library/json.html#py-to-json-table), this library supports the following:

  - any arbitrary [Collection](https://docs.python.org/3/library/collections.abc.html#collections.abc.Collection) type is supported.
  [Mapping](https://docs.python.org/3/library/collections.abc.html#collections.abc.Mapping) types are encoded as JSON objects and `str` types as JSON strings.
  Any other Collection types are encoded into JSON arrays, but decoded into the original collection types.

  - [datetime](https://docs.python.org/3/library/datetime.html#available-types)
  objects. `datetime` objects are encoded to `float` (JSON number) using
  [timestamp](https://docs.python.org/3/library/datetime.html#datetime.datetime.timestamp).
  As specified in the `datetime` docs, if your `datetime` object is naive, it will
  assume your system local timezone when calling `.timestamp()`. JSON numbers
  corresponding to a `datetime` field in your dataclass are decoded
  into a datetime-aware object, with `tzinfo` set to your system local timezone.
  Thus, if you encode a datetime-naive object, you will decode into a
  datetime-aware object. This is important, because encoding and decoding won't
  strictly be inverses. See [this section](#Overriding) if you want to override this default
  behavior (for example, if you want to use ISO).

  - [UUID](https://docs.python.org/3/library/uuid.html#uuid.UUID) objects. They
  are encoded as `str` (JSON string).

  - [Decimal](https://docs.python.org/3/library/decimal.html) objects. They are
  also encoded as `str`.

  **The [latest release](https://github.com/lidatong/dataclasses-json/releases/latest) is compatible with both Python 3.7 and Python 3.6 (with the dataclasses backport).**





  ```python
  from dataclasses import dataclass
  from dataclasses_json import dataclass_json

  @dataclass_json
  @dataclass
  class Person:
      name: str

  lidatong = Person('lidatong')


  lidatong.to_json()  # '{"name": "lidatong"}'


  Person.from_json('{"name": "lidatong"}')  # Person(name='lidatong')
  ```

  Note that the `@dataclass_json` decorator must be stacked above the `@dataclass`
  decorator (order matters!)



  ```python
  from dataclasses import dataclass
  from dataclasses_json import DataClassJsonMixin

  @dataclass
  class Person(DataClassJsonMixin):
      name: str

  lidatong = Person('lidatong')


  assert Person.from_json(lidatong.to_json()) == lidatong
  ```

  Pick whichever approach suits your taste. Note that there is better support for
   the mixin approach when using _static analysis_ tools (e.g. linting, typing),
   but the differences in implementation will be invisible in _runtime_ usage.







  ```python
  from dataclasses import dataclass
  from dataclasses_json import dataclass_json

  @dataclass_json
  @dataclass
  class Person:
      name: str
  ```

  **Encode into a JSON array containing instances of my Data Class**

  ```python
  people_json = [Person('lidatong')]
  Person.schema().dumps(people_json, many=True)  # '[{"name": "lidatong"}]'
  ```

  **Decode a JSON array containing instances of my Data Class**

  ```python
  people_json = '[{"name": "lidatong"}]'
  Person.schema().loads(people_json, many=True)  # [Person(name='lidatong')]
  ```

  **Encode as part of a larger JSON object containing my Data Class (e.g. an HTTP
  request/response)**

  ```python
  import json

  response_dict = {
      'response': {
          'person': Person('lidatong').to_dict()
      }
  }

  response_json = json.dumps(response_dict)
  ```

  In this case, we do two steps. First, we encode the dataclass into a
  **python dictionary** rather than a JSON string, using `.to_dict`.

  Second, we leverage the built-in `json.dumps` to serialize our `dataclass` into
  a JSON string.

  **Decode as part of a larger JSON object containing my Data Class (e.g. an HTTP
  response)**

  ```python
  import json

  response_dict = json.loads('{"response": {"person": {"name": "lidatong"}}}')

  person_dict = response_dict['response']

  person = Person.from_dict(person_dict)
  ```

  In a similar vein to encoding above, we leverage the built-in `json` module.

  First, call `json.loads` to read the entire JSON object into a
  dictionary. We then access the key of the value containing the encoded dict of
  our `Person` that we want to decode (`response_dict['response']`).

  Second, we load in the dictionary using `Person.from_dict`.




  This can be by calling `.schema()` and then using the corresponding
  encoder/decoder methods, ie. `.load(...)`/`.dump(...)`.

  **Encode into a single Python dictionary**

  ```python
  person = Person('lidatong')
  person.to_dict()  # {'name': 'lidatong'}
  ```

  **Encode into a list of Python dictionaries**

  ```python
  people = [Person('lidatong')]
  Person.schema().dump(people, many=True)  # [{'name': 'lidatong'}]
  ```

  **Decode a dictionary into a single dataclass instance**

  ```python
  person_dict = {'name': 'lidatong'}
  Person.from_dict(person_dict)  # Person(name='lidatong')
  ```

  **Decode a list of dictionaries into a list of dataclass instances**

  ```python
  people_dicts = [{"name": "lidatong"}]
  Person.schema().load(people_dicts, many=True)  # [Person(name='lidatong')]
  ```



  JSON letter case by convention is camelCase, in Python members are by convention snake_case.

  You can configure it to encode/decode from other casing schemes at both the class level and the field level.

  ```python
  from dataclasses import dataclass, field

  from dataclasses_json import LetterCase, config, dataclass_json



  @dataclass_json(letter_case=LetterCase.CAMEL)
  @dataclass
  class Person:
      given_name: str
      family_name: str

  Person('Alice', 'Liddell').to_json()  # '{"givenName": "Alice"}'
  Person.from_json('{"givenName": "Alice", "familyName": "Liddell"}')  # Person('Alice', 'Liddell')


  @dataclass_json
  @dataclass
  class Person:
      given_name: str = field(metadata=config(letter_case=LetterCase.CAMEL))
      family_name: str

  Person('Alice', 'Liddell').to_json()  # '{"givenName": "Alice"}'

  Person.from_json('{"givenName": "Alice", "family_name": "Liddell"}')  # Person('Alice', 'Liddell')
  ```

  **This library assumes your field follows the Python convention of snake_case naming.**
  If your field is not `snake_case` to begin with and you attempt to parameterize `LetterCase`,
  the behavior of encoding/decoding is undefined (most likely it will result in subtle bugs).



  ```python
  from dataclasses import dataclass, field

  from dataclasses_json import config, dataclass_json

  @dataclass_json
  @dataclass
  class Person:
      given_name: str = field(metadata=config(field_name="overriddenGivenName"))

  Person(given_name="Alice")  # Person('Alice')
  Person.from_json('{"overriddenGivenName": "Alice"}')  # Person('Alice')
  Person('Alice').to_json()  # {"overriddenGivenName": "Alice"}
  ```



  By default, any fields in your dataclass that use `default` or
  `default_factory` will have the values filled with the provided default, if the
  corresponding field is missing from the JSON you're decoding.

  **Decode JSON with missing field**

  ```python
  @dataclass_json
  @dataclass
  class Student:
      id: int
      name: str = 'student'

  Student.from_json('{"id": 1}')  # Student(id=1, name='student')
  ```

  Notice `from_json` filled the field `name` with the specified default 'student'
  when it was missing from the JSON.

  Sometimes you have fields that are typed as `Optional`, but you don't
  necessarily want to assign a default. In that case, you can use the
  `infer_missing` kwarg to make `from_json` infer the missing field value as `None`.

  **Decode optional field without default**

  ```python
  @dataclass_json
  @dataclass
  class Tutor:
      id: int
      student: Optional[Student] = None

  Tutor.from_json('{"id": 1}')  # Tutor(id=1, student=None)
  ```

  Personally I recommend you leverage dataclass defaults rather than using
  `infer_missing`, but if for some reason you need to decouple the behavior of
  JSON decoding from the field's default value, this will allow you to do so.




  By default, it is up to the implementation what happens when a `json_dataclass` receives input parameters that are not defined.
  (the `from_dict` method ignores them, when loading using `schema()` a ValidationError is raised.)
  There are three ways to customize this behavior.

  Assume you want to instantiate a dataclass with the following dictionary:
  ```python
  dump_dict = {"endpoint": "some_api_endpoint", "data": {"foo": 1, "bar": "2"}, "undefined_field_name": [1, 2, 3]}
  ```

  1. You can enforce to always raise an error by setting the `undefined` keyword to `Undefined.RAISE`
   (`'RAISE'` as a case-insensitive string works as well). Of course it works normally if you don't pass any undefined parameters.

  ```python
  from dataclasses_json import Undefined

  @dataclass_json(undefined=Undefined.RAISE)
  @dataclass()
  class ExactAPIDump:
      endpoint: str
      data: Dict[str, Any]

  dump = ExactAPIDump.from_dict(dump_dict)  # raises UndefinedParameterError
  ```

  2. You can simply ignore any undefined parameters by setting the `undefined` keyword to `Undefined.EXCLUDE`
   (`'EXCLUDE'` as a case-insensitive string works as well). Note that you will not be able to retrieve them using `to_dict`:

  ```python
  from dataclasses_json import Undefined

  @dataclass_json(undefined=Undefined.EXCLUDE)
  @dataclass()
  class DontCareAPIDump:
      endpoint: str
      data: Dict[str, Any]

  dump = DontCareAPIDump.from_dict(dump_dict)  # DontCareAPIDump(endpoint='some_api_endpoint', data={'foo': 1, 'bar': '2'})
  dump.to_dict()  # {"endpoint": "some_api_endpoint", "data": {"foo": 1, "bar": "2"}}
  ```

  3. You can save them in a catch-all field and do whatever needs to be done later. Simply set the `undefined`
  keyword to `Undefined.INCLUDE` (`'INCLUDE'` as a case-insensitive string works as well) and define a field
  of type `CatchAll` where all unknown values will end up.
   This simply represents a dictionary that can hold anything.
   If there are no undefined parameters, this will be an empty dictionary.

  ```python
  from dataclasses_json import Undefined, CatchAll

  @dataclass_json(undefined=Undefined.INCLUDE)
  @dataclass()
  class UnknownAPIDump:
      endpoint: str
      data: Dict[str, Any]
      unknown_things: CatchAll

  dump = UnknownAPIDump.from_dict(dump_dict)  # UnknownAPIDump(endpoint='some_api_endpoint', data={'foo': 1, 'bar': '2'}, unknown_things={'undefined_field_name': [1, 2, 3]})
  dump.to_dict()  # {'endpoint': 'some_api_endpoint', 'data': {'foo': 1, 'bar': '2'}, 'undefined_field_name': [1, 2, 3]}
  ```

  Notes:
  - When using `Undefined.INCLUDE`, an `UndefinedParameterError` will be raised if you don't specify
  exactly one field of type `CatchAll`.
  - Note that `LetterCase` does not affect values written into the `CatchAll` field, they will be as they are given.
  - When specifying a default (or a default factory) for the the `CatchAll`-field, e.g. `unknown_things: CatchAll = None`, the default value will be used instead of an empty dict if there are no undefined parameters.
  - Calling __init__ with non-keyword arguments resolves the arguments to the defined fields and writes everything else into the catch-all field.

  4. All 3 options work as well using `schema().loads` and `schema().dumps`, as long as you don't overwrite it by specifying `schema(unknown=<a marshmallow value>)`.
  marshmallow uses the same 3 keywords ['include', 'exclude', 'raise'](https://marshmallow.readthedocs.io/en/stable/quickstart.html#handling-unknown-fields).

  5. All 3 operations work as well using `__init__`, e.g. `UnknownAPIDump(**dump_dict)` will **not** raise a `TypeError`, but write all unknown values to the field tagged as `CatchAll`.
     Classes tagged with `EXCLUDE` will also simply ignore unknown parameters. Note that classes tagged as `RAISE` still raise a `TypeError`, and **not** a `UndefinedParameterError` if supplied with unknown keywords.




  See [Overriding](#Overriding)


  Object hierarchies where fields are of the type that they are declared within require a small
  type hinting trick to declare the forward reference.
  ```python
  from typing import Optional
  from dataclasses import dataclass
  from dataclasses_json import dataclass_json

  @dataclass_json
  @dataclass
  class Tree():
      value: str
      left: Optional['Tree']
      right: Optional['Tree']
  ```

  Avoid using
  ```python
  from __future__ import annotations
  ```
  as it will cause problems with the way dataclasses_json accesses the type annotations.




  Using the `dataclass_json` decorator or mixing in `DataClassJsonMixin` will
  provide you with an additional method `.schema()`.

  `.schema()` generates a schema exactly equivalent to manually creating a
  marshmallow schema for your dataclass. You can reference the [marshmallow API docs](https://marshmallow.readthedocs.io/en/3.0/api_reference.html#schema)
  to learn other ways you can use the schema returned by `.schema()`.

  You can pass in the exact same arguments to `.schema()` that you would when
  constructing a `PersonSchema` instance, e.g. `.schema(many=True)`, and they will
  get passed through to the marshmallow schema.


  ```python
  from dataclasses import dataclass
  from dataclasses_json import dataclass_json

  @dataclass_json
  @dataclass
  class Person:
      name: str


  from marshmallow import Schema, fields

  class PersonSchema(Schema):
      name = fields.Str()
  ```

  Briefly, on what's going on under the hood in the above examples: calling
  `.schema()` will have this library generate a
  [marshmallow schema]('https://marshmallow.readthedocs.io/en/3.0/api_reference.html#schema)
  for you. It also fills in the corresponding object hook, so that marshmallow
  will create an instance of your Data Class on `load` (e.g.
  `Person.schema().load` returns a `Person`) rather than a `dict`, which it does
  by default in marshmallow.

  **Performance note**

  `.schema()` is not cached (it generates the schema on every call), so if you
  have a nested Data Class you may want to save the result to a variable to
  avoid re-generation of the schema on every usage.

  ```python
  person_schema = Person.schema()
  person_schema.dump(people, many=True)



  person_schema.dump(person)
  ```





  For example, you might want to encode/decode `datetime` objects using ISO format
  rather than the default `timestamp`.

  ```python
  from dataclasses import dataclass, field
  from dataclasses_json import dataclass_json, config
  from datetime import datetime
  from marshmallow import fields

  @dataclass_json
  @dataclass
  class DataClassWithIsoDatetime:
      created_at: datetime = field(
          metadata=config(
              encoder=datetime.isoformat,
              decoder=datetime.fromisoformat,
              mm_field=fields.DateTime(format='iso')
          )
      )
  ```



  Similarly, you might want to extend `dataclasses_json` to encode `date` objects.

  ```python
  from dataclasses import dataclass, field
  from dataclasses_json import dataclass_json, config
  from datetime import date
  from marshmallow import fields

  @dataclass_json
  @dataclass
  class DataClassWithIsoDatetime:
      created_at: date = field(
          metadata=config(
              encoder= date.isoformat,
              decoder= date.fromisoformat,
              mm_field= fields.DateTime(format='iso')
          ))
  ```

  As you can see, you can **override** or **extend** the default codecs by providing a "hook" via a
  callable:
  - `encoder`: a callable, which will be invoked to convert the field value when encoding to JSON
  - `decoder`: a callable, which will be invoked to convert the JSON value when decoding from JSON
  - `mm_field`: a marshmallow field, which will affect the behavior of any operations involving `.schema()`

  Note that these hooks will be invoked regardless if you're using
  `.to_json`/`dump`/`dumps`
  and `.from_json`/`load`/`loads`. So apply overrides / extensions judiciously, making sure to
  carefully consider whether the interaction of the encode/decode/mm_field is consistent with what you expect!




  All the `dataclasses_json.config` does is return a mapping, namespaced under the key `'dataclasses_json'`.

  Say there's another module, `other_dataclass_package` that uses metadata. Here's how you solve your problem:

  ```python
  metadata = {'other_dataclass_package': 'some metadata...'}  # pre-existing metadata for another dataclass package
  dataclass_json_config = config(
              encoder=datetime.isoformat,
              decoder=datetime.fromisoformat,
              mm_field=fields.DateTime(format='iso')
          )
  metadata.update(dataclass_json_config)

  @dataclass_json
  @dataclass
  class DataClassWithIsoDatetime:
      created_at: datetime = field(metadata=metadata)
  ```

  You can also manually specify the dataclass_json configuration mapping.

  ```python
  @dataclass_json
  @dataclass
  class DataClassWithIsoDatetime:
      created_at: date = field(
          metadata={'dataclasses_json': {
              'encoder': date.isoformat,
              'decoder': date.fromisoformat,
              'mm_field': fields.DateTime(format='iso')
          }}
      )
  ```



  ```python
  from dataclasses import dataclass
  from dataclasses_json import dataclass_json

  from typing import List

  @dataclass_json
  @dataclass(frozen=True)
  class Minion:
      name: str


  @dataclass_json
  @dataclass(frozen=True)
  class Boss:
      minions: List[Minion]

  boss = Boss([Minion('evil minion'), Minion('very evil minion')])
  boss_json = """
  {
      "minions": [
          {
              "name": "evil minion"
          },
          {
              "name": "very evil minion"
          }
      ]
  }
  """.strip()

  assert boss.to_json(indent=4) == boss_json
  assert Boss.from_json(boss_json) == boss
  ```



  Take a look at [this issue](https://github.com/lidatong/dataclasses-json/issues/228)



  Note this library is still pre-1.0.0 (SEMVER).

  The current convention is:
  - **PATCH** version upgrades for bug fixes and minor feature additions.
  - **MINOR** version upgrades for big API features and breaking changes.

  Once this library is 1.0.0, it will follow standard SEMVER conventions.




  Currently the focus is on investigating and fixing bugs in this library, working
  on performance, and finishing [this issue](https://github.com/lidatong/dataclasses-json/issues/31).

  That said, if you think there's a feature missing / something new needed in the
  library, please see the contributing section below.




  First of all, thank you for being interested in contributing to this library.
  I really appreciate you taking the time to work on this project.

  - If you're just interested in getting into the code, a good place to start are
  issues tagged as bugs.
  - If introducing a new feature, especially one that modifies the public API,
  consider submitting an issue for discussion before a PR. Please also take a look
  at existing issues / PRs to see what you're proposing has  already been covered
  before / exists.
  - I like to follow the commit conventions documented [here](https://www.conventionalcommits.org/en/v1.0.0/#summary)


pkgId: f5c32108f7b8b39a981d5a6c2cd62c00a13c03e6ddfe4a09f1335ca4d58e1997
name: python-dataclasses-jsonschema
arch: src
version: 2.16.0
epoch: 0
release: 1
summary: JSON schema generation from dataclasses
url: https://github.com/s-knibbs/dataclasses-jsonschema
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6ae24b80-5fc9-49cf-b758-7b68691ef086
location_href: 00013839-python-dataclasses-jsonschema/python-dataclasses-jsonschema-2.16.0-1.src.rpm
checksum_type: sha256
description:
  **Please Note:** This project is in maintenance mode. I'm currently only making urgent bugfixes.
  A library to generate JSON Schema from python 3.7 dataclasses. Python 3.6 is supported through the `dataclasses backport <https://github.com/ericvsmith/dataclasses>`_. Aims to be a more lightweight alternative to similar projects such as `marshmallow <https://github.com/marshmallow-code/marshmallow>`_ & `pydantic <https://github.com/samuelcolvin/pydantic>`_.


pkgId: 7598a5420bdcb924e7b1bd437adc77c209f5141c509716411d885369066d545c
name: python-dataclassy
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: A fast and flexible reimplementation of data classes
url: https://github.com/biqqles/dataclassy
rpm_license: Mozilla Public License 2.0 (MPL 2.0)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-691cf1ad-1869-4355-b0d7-31d82804a907
location_href: 00014139-python-dataclassy/python-dataclassy-1.0.1-1.src.rpm
checksum_type: sha256
description:
  **dataclassy** is a reimplementation of data classes in Python - an alternative to the built-in [dataclasses module](https://docs.python.org/3/library/dataclasses.html) that avoids many of [its](https://stackoverflow.com/questions/54678337) [common](https://stackoverflow.com/q/51575931) [pitfalls](https://stackoverflow.com/q/50180735). dataclassy is designed to be more flexible, less verbose, and more powerful than dataclasses, while retaining a familiar interface.

  In short, dataclassy is a library for moving data around your Python programs that's optimised for speed, simplicity and developer happiness.

  ```python
  from dataclassy import dataclass
  from typing import Dict

  @dataclass
  class Pet:
      name: str
      species: str
      fluffy: bool
      foods: Dict[str, int] = {}
  ```



  This section describes various motivations for using **dataclassy** over **dataclasses**.


  dataclassy implements the decorator options of the latest version of dataclasses, plus its own, such that they are compatible back to Python 3.6. It is [tested against](.github/workflows/ci.yml) **CPython 3.6 through 3.11** and **PyPy 3.6 through 3.9**.


  - new decorator options
      - [`slots`](#slots) generates `__slots__` to reduce memory footprint and improve attribute lookup performance
      - [`kwargs`](#kwargs) appends `**kwargs` to `__init__`'s parameter list to consume unexpected arguments
      - [`iter`](#iter) allows class instances to be destructured, like named tuples
      - [`hide_internals`](#hide_internals) automatically hides private fields from `__repr__` and excludes them from comparison and iteration
  - `@dataclass` usage and options are inherited (subclasses do not have to reuse the decorator)
  - fields can be in any order - fields with defaults are [reordered](#parameter-reordering) - making inheritance feasible
  - mutable default values (`list`, `set`, `dict` and more) are [automatically copied](#default-values) upon initialisation
  - new functions: [`is_dataclass_instance`](#is_dataclass_instanceobj) and [`values`](#valuesdataclass-internalsfalse)


  - implements all the decorator options and functions of dataclasses
  - is tiny (~160 LOC; less than 25% the size of dataclasses)
  - has no external dependencies, and no stdlib imports other than `types`, `typing` and `reprlib`
  - is [fast](benchmarks.py), matching dataclasses' performance when `slots=False` and significantly exceeding it when `slots=True`
  - supports multiple inheritance and custom metaclasses
  - comes with [support for mypy](#mypy-support)


  dataclassy's API is strongly influenced by dataclasses', but with a focus on minimalism and elegance.

  - there's no `field` or `Field`. Use [`Hashed`](#hashed), [`Internal`](#internal) or [`factory`](#factorycreator) to replicate its functions
  - there's no `InitVar`. Simply add arguments to `__post_init__`
  - there's no need for `ClassVar`. Simply omit the field's type hint to ignore it



  - [`attrs`](https://github.com/python-attrs/attrs) if you need complex validation and type conversions
  - [`pydantic`](https://github.com/samuelcolvin/pydantic) if you need strict type checking




  Install the latest release from [PyPI](https://pypi.org/project/dataclassy/) with pip:

  ```console
  pip install dataclassy
  ```

  Or install the latest development version straight from this repository:

  ```console
  pip install https://github.com/biqqles/dataclassy/archive/master.zip -U
  ```



  dataclassy's API is broadly similar to dataclasses. If you simply use the decorator and other functions, it is possible to instantly migrate from dataclasses to dataclassy by simply changing

  ```Python
  from dataclasses import *
  ```

  to

  ```Python
  from dataclassy import *
  ```

  Otherwise, you will have to make a couple of easy refactorings (that should leave you with cleaner code!). Consult the table under [Differences](#differences) or skip ahead to [Examples](#examples) to see dataclassy in action.


  dataclassy's `dataclass` decorator takes all of the same arguments as dataclasses', plus its own, and should therefore be a drop-in replacement.

  dataclassy also implements all dataclasses' [functions](#functions): `is_dataclass`, `fields`, `replace`, `make_dataclass`, `asdict` and `astuple` (the last two are aliased from `as_dict` and `as_tuple` respectively), and they should work as you expect.


  Although dataclassy's API is similar to dataclasses', [compatibility with it is not a goal](https://straight-shoota.github.io/crystal-book/feature/tutorials-initial/) (this is similar to the relationship between Crystal and Ruby).

  dataclassy has several important differences from dataclasses, mainly reflective of its minimalistic style and implementation. These differences are enumerated below and fully expanded on in the next section.

  |                                 |dataclasses                                 |dataclassy                              |
  |---------------------------------|:-------------------------------------------|:---------------------------------------|
  |*init-only variables*            |fields with type `InitVar`                  |arguments to `__post_init__`            |
  |*class variables*                |fields with type `ClassVar`                 |fields without type annotation          |
  |*mutable defaults*               |`a: Dict = field(default_factory=dict)`     |`a: Dict = {}`                          |
  |*dynamic defaults*               |`b: MyClass = field(default_factory=MyClass)`|`b: MyClass = factory(MyClass)`        |
  |*field excluded from `repr`*     |`c: int = field(repr=False)`                |`Internal` type wrapper or `_name`      |
  |*"late init" field*              |`d: int = field(init=False)`                |`d: int = None`                         |
  |*abstract data class*            |`class Foo(ABC):`                           |`class Foo(metaclass=ABCMeta):`         |

  There are a couple of minor differences, too:

  - `fields` returns `Dict[str, Type]` instead of `Dict[Field, Type]` and has an additional parameter which filters internal fields
  - Attempting to modify a frozen instance raises `AttributeError` with an explanation rather than `FrozenInstanceError`

  Finally, there are some quality of life improvements that, while not being directly implicated in migration, will allow you to make your code cleaner:

  - `@dataclass` does not need to be applied to every subclass - its behaviour and options are inherited
  - Unlike dataclasses, fields with defaults do not need to follow those without them. This is particularly useful when working with subclasses, which is almost impossible with dataclasses
  - dataclassy adds a `DataClass` type annotation to represent variables that should be generic data class instances
  - dataclassy has the `is_dataclass_instance` suggested as a [recipe](https://docs.python.org/3/library/dataclasses.html#dataclasses.is_dataclass) for dataclasses built-in
  - The generated comparison methods (when `order=True`) are compatible with supertypes and subtypes of the class. This means that heterogeneous collections of instances with the same superclass can be sorted

  It is also worth noting that internally, dataclasses and dataclassy work in different ways. You can think of dataclassy as _turning your class into a different type of thing_ (indeed, it uses a metaclass) and dataclasses as merely _adding things to your class_ (it does not).




  To define a data class, simply apply the `@dataclass` decorator to a class definition ([see above](#dataclassy)).

  Without arguments to the decorator, the resulting class will behave very similarly to its equivalent from the built-in module. However, dataclassy's decorator has some additional options over dataclasses', and it is also inherited so that subclasses of data classes are automatically data classes too.

  The decorator generates various methods for the class. Which ones exactly depend on the options to the decorator. For example, `@dataclass(repr=False)` will prevent a `__repr__` method from being generated. `@dataclass` is equivalent to using the decorator with default parameters (i.e. `@dataclass` and `@dataclass()` are equivalent). Options to the decorator are detailed fully in the [next section](#decorator-options).


  You can exclude a class attribute from dataclassy's mechanisms entirely by simply defining it without a type annotation. This can be used for class variables and constants.


  dataclassy modifies the order of fields when converting them into parameters for the generated `__init__`. Specifically, fields with default values always follow those without them. This stems from Python's requirement that _parameters_ with default arguments follow those without them. Conceptually, you can think of the process to generate the parameter list like this:

  1. dataclassy takes the fields in definition order
  2. it splits them into two lists, the first being fields without default values and the second being fields with them
  3. it appends the second list to the first

  This simple design decision prevents the dreaded `TypeError: non-default argument '...' follows default argument` error that anyone who has tried to do serious inheritance using dataclasses will know well.

  You can verify the signature of the generated initialiser for any class using `signature` from the `inspect` module. For example, using the definition linked to above, `inspect.signature(Pet)` will return `(name: str, species: str, fluffy: bool, foods: Dict[str, int] = {}))`.

  If we then decided to subclass `Pet` to add a new field, `hungry`:

  ```python
  @dataclass
  class HungryPet(Pet):
      hungry: bool
  ```

  You will see that `inspect.signature(HungryPet)` returns `(name: str, species: str, fluffy: bool, hungry: bool, foods: Dict[str, int] = {})`.


  Unlike dataclasses, dataclassy's decorator only needs to be applied once, and all subclasses will become data classes with the same options as the parent class. The decorator can still be reapplied to subclasses in order to apply new parameters.

  To change the type, or to add or change the default value of a field in a subclass, simply redeclare it in the subclass.


  If an initialiser is requested (`init=True`), dataclassy automatically sets the attributes of the class upon initialisation. You can define code that should run after this happens - this is called _post-init processing_.

  The method that contains this logic should be called `__post_init__`. Like with dataclasses, if `init=False` or the class has no fields, `__post_init__` will not be called.

  ```Python
  @dataclass
  class CustomInit:
      a: int
      b: int

      def __post_init__(self):
          self.c = self.a / self.b
  ```

  In this example, when the class is instantiated with `CustomInit(1, 2)`, the field `c` is calculated as `0.5`.

  Like with any function, your `__post_init__` can also take parameters which exist only in the context of `__post_init__`. These can be used for arguments to the class that you do not want to store as fields. A parameter cannot have the name of a class field; this is to prevent ambiguity.


  Default values for fields work exactly as default arguments to functions (and in fact this is how they are implemented), with one difference: for copyable defaults, a copy is automatically created for each class instance. This means that a new copy of the `list` field `foods` in `Pet` above will be created each time it is instantiated, so that appending to that attribute in one instance will not affect other instances. A "copyable default" is defined as any object implementing a `copy` method, which includes all the built-in mutable collections (including `defaultdict`).

  If you want to create new instances of objects which do not have a `copy` method, use the [`factory`](#factorycreator) function. This function takes any zero-argument callable. When the class is instantiated, this callable is executed to produce a default value for the field:

  ```Python
  class MyClass:
      pass

  @dataclass
  class CustomDefault:
      m: MyClass = factory(MyClass)

  CustomDefault()  # CustomDefault(m=<__main__.MyClass object at 0x7f8b156feb50>)
  CustomDefault()  # CustomDefault(m=<__main__.MyClass object at 0x7f8b156fc7d0>)
  ```




  The decorator used to signify that a class definition should become a data class. The decorator returns a new data class with generated methods as detailed below. If the class already defines a particular method, it will not be replaced with a generated one.

  Without arguments, its behaviour is, superficially, almost identical to its equivalent in the built-in module. However, dataclassy's decorator only needs to be applied once, and all subclasses will become data classes with the same parameters. The decorator can still be reapplied to subclasses in order to change parameters.

  A data class' fields are defined using Python's type annotations syntax. To change the type or default value of a field in a subclass, simply redeclare it.

  This decorator takes advantage of two equally important features added in Python 3.6: [variable annotations](https://docs.python.org/3/glossary.html#term-variable-annotation) and [dictionaries being ordered](https://docs.python.org/3.7/tutorial/datastructures.html#dictionaries). (The latter is technically an [implementation detail](https://docs.python.org/3.6/whatsnew/3.6.html#whatsnew36-compactdict) of Python 3.6, only becoming standardised in Python 3.7, but is the case for all current implementations of Python 3.6, i.e. CPython and PyPy.)



  > The term "field", as used in this section, refers to a class-level variable with a type annotation. For more information, see the documentation for [`fields()`](#fieldsdataclass-internalsfalse) below.


  If true (the default), generate an [`__init__`](https://docs.python.org/3/reference/datamodel.html#object.__init__) method that has as parameters all fields up its inheritance chain. These are ordered in definition order, with all fields with default values placed towards the end, following all fields without them. The method initialises the class by applying these parameters to the class as attributes. If defined, it will also call `__post_init__` with any remaining arguments.

  This ordering is an important distinction from dataclasses, where all fields are simply ordered in definition order, and is what allows dataclassy's data classes to be far more flexible in terms of inheritance.

  A shallow copy will be created for mutable arguments (defined as those defining a `copy` method). This means that default field values that are mutable (e.g. a list) will not be mutated between instances.


  If true (the default), generate a [`__repr__`](https://docs.python.org/3/reference/datamodel.html#object.__repr__) method that displays all fields (or if [`hide_internals`](#hide_internals) is true, all fields excluding [internal](#internal) ones) of the data class instance and their values.


  If true (the default), generate an [`__eq__`](https://docs.python.org/3/reference/datamodel.html#object.__eq__) method that compares this data class to another of the same type as if they were tuples created by [`as_tuple`](#as_tupledataclass), excluding [internal fields](#internal) if [`hide_internals`](#hide_internals) is true.


  If true, a [`__lt__`](https://docs.python.org/3/reference/datamodel.html#object.__lt__) method is generated, making the class *orderable*. If `eq` is also true, all other comparison methods are also generated. These methods compare this data class to another of the same type (or a subclass) as if they were tuples created by [`as_tuple`](#as_tupledataclass), excluding [internal fields](#internal) if [`hide_internals`](#hide_internals) is true. The normal rules of [lexicographical comparison](https://docs.python.org/3/reference/expressions.html#value-comparisons) apply.


  If true, force the generation of a [`__hash__`](https://docs.python.org/3/reference/datamodel.html#object.__hash__) method that attempts to hash the class as if it were a tuple of its hashable fields. If `unsafe_hash` is false, `__hash__` will only be generated if `eq` and `frozen` are both true.


  If true (the default), generate a `__match_args__` attribute that enables structural pattern matching on Python 3.10+.


  If true, all parameters to the generated `__init__` are marked as [keyword-only](https://peps.python.org/pep-3102). This includes arguments passed through to `__post_init__`.


  If true, instances are nominally immutable: fields cannot be overwritten or deleted after initialisation in `__init__`. Attempting to do so will raise an `AttributeError`. **Warning: incurs a significant initialisation performance penalty.**


  If true (the default), [internal fields](#internal) are not included in the generated [`__repr__`](#repr), comparison functions ([`__eq__`](#eq), [ `__lt__`](#order), etc.), or [`__iter__`](#iter).


  If true, generate an [`__iter__`](https://docs.python.org/3/reference/datamodel.html#object.__iter__) method that returns the values of the class's fields, in order of definition, noting that [internal fields](#internal) are excluded when [`hide_internals`](#hide_internals) is true. This can be used to destructure a data class instance, as with a Scala `case class` or a Python `namedtuple`.


  If true, add [`**kwargs`](https://docs.python.org/3.3/glossary.html#term-parameter) to the end of the parameter list for `__init__`. This simplifies data class instantiation from dictionaries that may have keys in addition to the fields of the data class (i.e. `SomeDataClass(**some_dict)`).


  If true, generate a [`__slots__`](https://docs.python.org/3/reference/datamodel.html#slots) attribute for the class. This reduces the memory footprint of instances and attribute lookup overhead. However, `__slots__` come with a few [restrictions](https://docs.python.org/3/reference/datamodel.html#notes-on-using-slots) (for example, multiple inheritance becomes tricky) that you should be aware of.


  Set this parameter to use a metaclass other than dataclassy's own. This metaclass must subclass [`dataclassy.dataclass.DataClassMeta`](dataclassy/dataclass.py).

  `DataClassMeta` is best considered less stable than the parts of the library available in the root namespace. Only use a custom metaclass if absolutely necessary.




  Takes a zero-argument callable and creates a _factory_ that executes this callable to generate a default value for the field at class initialisation time.


  Returns True if `obj` is a data class as implemented in this module.


  Returns True if `obj` is an instance of a data class as implemented in this module.


  Return a dict of `dataclass`'s fields and their types. `internals` selects whether to include internal fields. `dataclass` can be either a data class or an instance of a data class.

  A field is defined as a class-level variable with a [type annotation](https://docs.python.org/3/glossary.html#term-variable-annotation). Variables defined in the class without type annotations are completely excluded from dataclassy's consideration. Class variables and constants can therefore be indicated by the absence of type annotations.


  Return a dict of `dataclass`'s fields and their values. `internals` selects whether to include internal fields. `dataclass` must be an instance of a data class.


  Recursively create a dict of a data class instance's fields and their values.

  This function is recursively called on data classes, named tuples and iterables.


  Recursively create a tuple of the values of a data class instance's fields, in definition order.

  This function is recursively called on data classes, named tuples and iterables.


  Dynamically create a data class with name `name`, fields `fields`, default field values `defaults` and inheriting from `bases`.


  Return a new copy of `dataclass` with field values replaced as specified in `changes`.



  The `Internal` type wrapper marks a field as being "internal" to the data class. Fields which begin with the ["internal use"](https://www.python.org/dev/peps/pep-0008/#descriptive-naming-styles) idiomatic indicator `_` or the [private field](https://docs.python.org/3/tutorial/classes.html#private-variables) interpreter indicator `__` are automatically treated as internal fields.  The `Internal` type wrapper therefore serves as an alternative method of indicating that a field is internal for situations where you are unable to name your fields in this way.


  Use `Hashed` to wrap the type annotations of fields that you want to be included in a data class' `__hash__`. The value hashed by `__hash__` consists of a tuple of the instance's type followed by any fields marked as `Hashed`.


  Use this type hint to indicate that a variable, parameter or field should be a generic data class instance. For example, dataclassy uses these in the signatures of `as_dict`, `as_tuple` and `values` to show that these functions should be called on data class instances.


  In order to use dataclassy in projects with mypy, you will need to use the mypy plugin. You can create a `mypy.ini` or `.mypy.ini` for such projects with the following content:

  ```ini
  [mypy]
  plugins = dataclassy.mypy
  ```


pkgId: aa4a1f64e2edff93812afaccbe12873462ac18745e43c93ea22fd3d01ed94f79
name: python-datadiff
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: DataDiff is a library to provide human-readable diffs of python data structures.
url: http://sourceforge.net/projects/datadiff/
rpm_license: Apache License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7a5c9901-c70c-4b86-a9cd-b6bba2e058c7
location_href: 00012190-python-datadiff/python-datadiff-2.1.0-1.src.rpm
checksum_type: sha256
description:
  DataDiff is a library to provide human-readable diffs of python data structures.
  It can handle sequence types (lists, tuples, etc), sets, and dictionaries.
  Dictionaries and sequences will be diffed recursively, when applicable.
  It has special-case handling for multi-line strings, showing them as a typical unified diff.
  Drop-in replacements for some nose assertions are available.  If the assertion fails,
  a nice data diff is shown, letting you easily pinpoint the root difference.
  ``datadiff`` works on Python 2.6 through Python 3.
  DataDiff project homepage: http://sourceforge.net/projects/datadiff/


pkgId: 5f65ddfe97dec9acf469f6f176e4901fc56313c71c7109e69ad1276fb84f6296
name: python-datadispatch
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Like functools.singledispatch but for values
url: https://github.com/pb-/datadispatch
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-27e6f963-62a9-45a2-b960-bb60d9ebcc01
location_href: 00011046-python-datadispatch/python-datadispatch-1.0.0-1.src.rpm
checksum_type: sha256
description:
  datadispatch provides a dispatch mechanism (a.k.a. polymorphism) like `functools.singledispatch`, but it operates on data instead of types. This is useful if you are creating simple data-centric applications where you want polymorphism à la carte without resorting to types or classes.

  datadispatch is available through pip: `pip install datadispatch`



  ```python
  from datadispatch import datadispatch

  @datadispatch(lambda args, _: args[0].get('type'))
  def handle(message):
    raise ValueError('cannot handle message: {}'.format(message))


  @handle.register('ping')
  def _(message):
    return 'you sent ping'


  @handle.register('pong')
  def _(message):
    return 'you sent pong'


  print(handle(
    {'type': 'ping', 'payload': 'hello'}
  ))
  ```


pkgId: 32b1eb196f43e5caa9cd852332a73bdaca2077b4ef872f0a50acaab9f28e46ae
name: python-datalab
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: Google Cloud Datalab
url: https://github.com/googledatalab/pydatalab
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-df7d39f1-c627-44c2-99d1-e141890533f8
location_href: 00009230-python-datalab/python-datalab-1.2.1-1.src.rpm
checksum_type: sha256
description:
  Datalab is deprecated. [Vertex AI Workbench](https://cloud.google.com/vertex-ai/docs/workbench)
  provides a notebook-based environment that offers capabilities beyond Datalab.
  We recommend that you use Vertex AI Workbench for new projects and
  [migrate your Datalab notebooks to Vertex AI Workbench](https://cloud.google.com/datalab/docs/resources/troubleshooting#migrate).
  For more information, see
  [Deprecation information](https://cloud.google.com/datalab/docs/resources/deprecation).
  To get help migrating Datalab projects to Vertex AI Workbench see
  [Get help](https://cloud.google.com/datalab/docs/resources/support#get-help).


pkgId: 5c2ec4bb63be1596c6ed9b8fabac8e0c9abbe517b088a8c2e42892259664e51d
name: python-datanommer.models
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: SQLAlchemy models for datanommer
url: https://github.com/fedora-infra/datanommer
rpm_license: GPL-3.0-or-later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a14c6725-4102-4627-83e4-1e233d07d3ad
location_href: 00003396-python-datanommer-models/python-datanommer.models-1.0.4-1.src.rpm
checksum_type: sha256
description:
  This package contains the SQLAlchemy data model for datanommer.
  Datanommer is a storage consumer for the Fedora Infrastructure Message Bus
  (fedmsg).  It is comprised of a `fedmsg <http://fedmsg.com>`_ consumer that
  stuffs every message into a sqlalchemy database.


pkgId: ac046963c4929d20e5097e496407d112863c9b2af4ecabd898194f4cea4e0ce5
name: python-datapackage
arch: src
version: 1.15.2
epoch: 0
release: 1
summary: Utilities to work with Data Packages as defined on specs.frictionlessdata.io
url: https://github.com/frictionlessdata/datapackage-py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-732f72bb-8ce7-4b8b-8acc-2e6c9cf864a4
location_href: 00012767-python-datapackage/python-datapackage-1.15.2-1.src.rpm
checksum_type: sha256
description:
  [![Travis](https://travis-ci.org/frictionlessdata/datapackage-py.svg?branch=master)](https://travis-ci.org/frictionlessdata/datapackage-py)
  [![Coveralls](https://coveralls.io/repos/github/frictionlessdata/datapackage-py/badge.svg?branch=master)](https://coveralls.io/github/frictionlessdata/datapackage-py?branch=master)
  [![PyPi](https://img.shields.io/pypi/v/datapackage.svg)](https://pypi.python.org/pypi/datapackage)
  [![Github](https://img.shields.io/badge/github-master-brightgreen)](https://github.com/frictionlessdata/datapackage-py)
  [![Gitter](https://img.shields.io/gitter/room/frictionlessdata/chat.svg)](https://gitter.im/frictionlessdata/chat)

  A library for working with [Data Packages](http://specs.frictionlessdata.io/data-package/).

  > **[Important Notice]** We have released [Frictionless Framework](https://github.com/frictionlessdata/frictionless-py). This framework provides improved `datapackage` 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 `datapackage` to Frictionless Framework.
  > - we continue to bug-fix `datapackage@1.x` in this [repository](https://github.com/frictionlessdata/datapackage-py) as well as it's available on [PyPi](https://pypi.org/project/datapackage/) 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



   - `Package` class for working with data packages
   - `Resource` class for working with data resources
   - `Profile` class for working with profiles
   - `validate` function for validating data package descriptors
   - `infer` function for inferring data package descriptors



  <!--TOC-->

    - [Getting Started](#getting-started)
      - [Installation](#installation)
    - [Documentation](#documentation)
      - [Introduction](#introduction)
      - [Working with Package](#working-with-package)
      - [Working with Resource](#working-with-resource)
      - [Working with Group](#working-with-group)
      - [Working with Profile](#working-with-profile)
      - [Working with Foreign Keys](#working-with-foreign-keys)
      - [Working with validate/infer](#working-with-validateinfer)
      - [Frequently Asked Questions](#frequently-asked-questions)
    - [API Reference](#api-reference)
      - [`cli`](#cli)
      - [`Package`](#package)
      - [`Resource`](#resource)
      - [`Group`](#group)
      - [`Profile`](#profile)
      - [`validate`](#validate)
      - [`infer`](#infer)
      - [`DataPackageException`](#datapackageexception)
      - [`TableSchemaException`](#tableschemaexception)
      - [`LoadError`](#loaderror)
      - [`CastError`](#casterror)
      - [`IntegrityError`](#integrityerror)
      - [`RelationError`](#relationerror)
      - [`StorageError`](#storageerror)
    - [Contributing](#contributing)
    - [Changelog](#changelog)

  <!--TOC-->





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

  ```bash
  $ pip install datapackage
  ```


  If you receive an error about the `cchardet` package when installing datapackage on Mac OSX 10.14 (Mojave) or higher, follow these steps:
  1. Make sure you have the latest x-code by running the following in terminal: `xcode-select --install`
  2. Then go to [https://developer.apple.com/download/more/](https://developer.apple.com/download/more/) and download the `command line tools`. Note, this requires an Apple ID.
  3. Then, in terminal, run `open /Library/Developer/CommandLineTools/Packages/macOS_SDK_headers_for_macOS_10.14.pkg`
  You can read more about these steps in this [post.](https://stackoverflow.com/questions/52509602/cant-compile-c-program-on-a-mac-after-upgrade-to-mojave)





  Let's start with a simple example:

  ```python
  from datapackage import Package

  package = Package('datapackage.json')
  package.get_resource('resource').read()
  ```



  A class for working with data packages. It provides various capabilities like loading local or remote data package, inferring a data package descriptor, saving a data package descriptor and many more.

  Consider we have some local csv files in a `data` directory. Let's create a data package based on this data using a `Package` class:

  > data/cities.csv

  ```csv
  city,location
  london,"51.50,-0.11"
  paris,"48.85,2.30"
  rome,"41.89,12.51"
  ```

  > data/population.csv

  ```csv
  city,year,population
  london,2017,8780000
  paris,2017,2240000
  rome,2017,2860000
  ```

  First we create a blank data package:

  ```python
  package = Package()
  ```

  Now we're ready to infer a data package descriptor based on data files we have. Because we have two csv files we use glob pattern `**/*.csv`:

  ```python
  package.infer('**/*.csv')
  package.descriptor
















  ```

  An `infer` method has found all our files and inspected it to extract useful metadata like profile, encoding, format, Table Schema etc. Let's tweak it a little bit:

  ```python
  package.descriptor['resources'][1]['schema']['fields'][1]['type'] = 'year'
  package.commit()
  package.valid # true
  ```

  Because our resources are tabular we could read it as a tabular data:

  ```python
  package.get_resource('population').read(keyed=True)



  ```

  Let's save our descriptor on the disk as a zip-file:

  ```python
  package.save('datapackage.zip')
  ```

  To continue the work with the data package we just load it again but this time using local `datapackage.zip`:

  ```python
  package = Package('datapackage.zip')

  ```

  It was onle basic introduction to the `Package` class. To learn more let's take a look on `Package` class API reference.



  A class for working with data resources. You can read or iterate tabular resources using the `iter/read` methods and all resource as bytes using `row_iter/row_read` methods.

  Consider we have some local csv file. It could be inline data or remote link - all supported by `Resource` 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 resource. Because resource is tabular we could use `resource.read` method with a `keyed` option to get an array of keyed rows:

  ```python
  resource = Resource({path: 'data.csv'})
  resource.tabular # true
  resource.read(keyed=True)





  resource.headers


  ```

  As we could see our locations are just a strings. But it should be geopoints. Also Rome's location is not available but it's also just a `N/A` string instead of Python `None`. First we have to infer resource metadata:

  ```python
  resource.infer()
  resource.descriptor







  resource.read(keyed=True)

  ```

  Let's fix not available location. There is a `missingValues` property in Table Schema specification. As a first try we set `missingValues` to `N/A` in `resource.descriptor.schema`. Resource descriptor could be changed in-place but all changes should be commited by `resource.commit()`:

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

  ```

  As a good citiziens we've decided to check out recource descriptor validity. And it's not valid! We should use an array for `missingValues` property. Also don't forget to have an empty string as a missing value:

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

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

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





  ```

  Now we see that:
  - locations are arrays with numeric lattide and longitude
  - Rome's location is a native JavaScript `null`

  And because there are no errors on data reading we could be sure that our data is valid againt our schema. Let's save our resource descriptor:

  ```python
  resource.save('dataresource.json')
  ```

  Let's check newly-crated `dataresource.json`. It contains path to our data file, inferred metadata and our `missingValues` tweak:

  ```json
  {
      "path": "data.csv",
      "profile": "tabular-data-resource",
      "encoding": "utf-8",
      "name": "data",
      "format": "csv",
      "mediatype": "text/csv",
      "schema": {
          "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 `dataresource.json` file and then open it again using local file name:

  ```python
  resource = Resource('dataresource.json')

  ```

  It was onle basic introduction to the `Resource` class. To learn more let's take a look on `Resource` class API reference.



  A class representing a group of tabular resources. Groups can be used to read multiple resource as one or to export them, for example, to a database as one table. To define a group add the `group: <name>` field to corresponding resources. The group's metadata will be created from the "leading" resource's metadata (the first resource with the group name).

  Consider we have a data package with two tables partitioned by a year and a shared schema stored separately:

  >  cars-2017.csv

  ```csv
  name,value
  bmw,2017
  tesla,2017
  nissan,2017
  ```

  >  cars-2018.csv

  ```csv
  name,value
  bmw,2018
  tesla,2018
  nissan,2018
  ```

  > cars.schema.json

  ```json
  {
      "fields": [
          {
              "name": "name",
              "type": "string"
          },
          {
              "name": "value",
              "type": "integer"
          }
      ]
  }
  ```

  > datapackage.json

  ```json
  {
      "name": "datapackage",
      "resources": [
          {
              "group": "cars",
              "name": "cars-2017",
              "path": "cars-2017.csv",
              "profile": "tabular-data-resource",
              "schema": "cars.schema.json"
          },
          {
              "group": "cars",
              "name": "cars-2018",
              "path": "cars-2018.csv",
              "profile": "tabular-data-resource",
              "schema": "cars.schema.json"
          }
      ]
  }
  ```

  Let's read the resources separately:

  ```python
  package = Package('datapackage.json')
  package.get_resource('cars-2017').read(keyed=True) == [
      {'name': 'bmw', 'value': 2017},
      {'name': 'tesla', 'value': 2017},
      {'name': 'nissan', 'value': 2017},
  ]
  package.get_resource('cars-2018').read(keyed=True) == [
      {'name': 'bmw', 'value': 2018},
      {'name': 'tesla', 'value': 2018},
      {'name': 'nissan', 'value': 2018},
  ]
  ```

  On the other hand, these resources defined with a `group: cars` field. It means we can treat them as a group:

  ```python
  package = Package('datapackage.json')
  package.get_group('cars').read(keyed=True) == [
      {'name': 'bmw', 'value': 2017},
      {'name': 'tesla', 'value': 2017},
      {'name': 'nissan', 'value': 2017},
      {'name': 'bmw', 'value': 2018},
      {'name': 'tesla', 'value': 2018},
      {'name': 'nissan', 'value': 2018},
  ]
  ```

  We can use this approach when we need to save the data package to a storage, for example, to a SQL database. There is the `merge_groups` flag to enable groupping behaviour:

  ```python
  package = Package('datapackage.json')
  package.save(storage='sql', engine=engine)



  package.save(storage='sql', engine=engine, merge_groups=True)


  ```



  A component to represent JSON Schema profile from [Profiles Registry]( https://specs.frictionlessdata.io/schemas/registry.json):

  ```python
  profile = Profile('data-package')

  profile.name # data-package
  profile.jsonschema # JSON Schema contents

  try:
     valid = profile.validate(descriptor)
  except exceptions.ValidationError as exception:
     for error in exception.errors:
         
  ```



  The library supports foreign keys described in the [Table Schema](http://specs.frictionlessdata.io/table-schema/#foreign-keys) specification. It means if your data package descriptor use `resources[].schema.foreignKeys` property for some resources a data integrity will be checked on reading operations.

  Consider we have a data package:

  ```python
  DESCRIPTOR = {
    'resources': [
      {
        'name': 'teams',
        'data': [
          ['id', 'name', 'city'],
          ['1', 'Arsenal', 'London'],
          ['2', 'Real', 'Madrid'],
          ['3', 'Bayern', 'Munich'],
        ],
        'schema': {
          'fields': [
            {'name': 'id', 'type': 'integer'},
            {'name': 'name', 'type': 'string'},
            {'name': 'city', 'type': 'string'},
          ],
          'foreignKeys': [
            {
              'fields': 'city',
              'reference': {'resource': 'cities', 'fields': 'name'},
            },
          ],
        },
      }, {
        'name': 'cities',
        'data': [
          ['name', 'country'],
          ['London', 'England'],
          ['Madrid', 'Spain'],
        ],
      },
    ],
  }
  ```

  Let's check relations for a `teams` resource:

  ```python
  from datapackage import Package

  package = Package(DESCRIPTOR)
  teams = package.get_resource('teams')
  teams.check_relations()

  ```

  As we could see there is a foreign key violation. That's because our lookup table `cities` doesn't have a city of `Munich` but we have a team from there. We need to fix it in `cities` resource:

  ```python
  package.descriptor['resources'][1]['data'].append(['Munich', 'Germany'])
  package.commit()
  teams = package.get_resource('teams')
  teams.check_relations()

  ```

  Fixed! But not only a check operation is available. We could use `relations` argument for `resource.iter/read` methods to dereference a resource relations:

  ```python
  teams.read(keyed=True, relations=True)



  ```

  Instead of plain city name we've got a dictionary containing a city data. These `resource.iter/read` methods will fail with the same as `resource.check_relations` error if there is an integrity issue. But only if `relations=True` flag is passed.



  A standalone function to validate a data package descriptor:

  ```python
  from datapackage import validate, exceptions

  try:
      valid = validate(descriptor)
  except exceptions.ValidationError as exception:
     for error in exception.errors:
         
  ```

  A standalone function to infer a data package descriptor.

  ```python
  descriptor = infer('**/*.csv')
















  ```





  Before the `package = Package("https://xxx.json")` call set these environment variables:

  ```python
  import os

  os.environ["HTTP_PROXY"] = 'xxx'
  os.environ["HTTPS_PROXY"] = 'xxx'
  ```




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

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

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

  Commands:
    infer
    validate
  ```



  ```python
  Package(self,
          descriptor=None,
          base_path=None,
          strict=False,
          unsafe=False,
          storage=None,
          schema=None,
          default_base_path=None,
          **options)
  ```
  Package representation

  __Arguments__
  - __descriptor (str/dict)__: data package descriptor as local path, url or object
  - __base_path (str)__: base path for all relative paths
  - __strict (bool)__: strict flag to alter validation behavior.
          Setting it to `True` leads to throwing errors
          on any operation with invalid descriptor
  - __unsafe (bool)__:
          if `True` unsafe paths will be allowed. For more inforamtion
          https://specs.frictionlessdata.io/data-resource/#data-location.
          Default to `False`
  - __storage (str/tableschema.Storage)__: storage name like `sql` or storage instance
  - __options (dict)__: storage options to use for storage creation

  __Raises__
  - `DataPackageException`: raises error if something goes wrong




  Package's base path

  __Returns__

  `str/None`: returns the data package base path




  Package's descriptor

  __Returns__

  `dict`: descriptor




  Validation errors

  Always empty in strict mode.

  __Returns__

  `Exception[]`: validation errors




  Package's profile

  __Returns__

  `Profile`: an instance of `Profile` class




  Package's resource names

  __Returns__

  `str[]`: returns an array of resource names




  Package's resources

  __Returns__

  `Resource[]`: returns an array of `Resource` instances




  Validation status

  Always true in strict mode.

  __Returns__

  `bool`: validation status




  ```python
  package.get_resource(name)
  ```
  Get data package resource by name.

  __Arguments__
  - __name (str)__: data resource name

  __Returns__

  `Resource/None`: returns `Resource` instances or null if not found




  ```python
  package.add_resource(descriptor)
  ```
  Add new resource to data package.

  The data package descriptor will be validated with newly added resource descriptor.

  __Arguments__
  - __descriptor (dict)__: data resource descriptor

  __Raises__
  - `DataPackageException`: raises error if something goes wrong

  __Returns__

  `Resource/None`: returns added `Resource` instance or null if not added




  ```python
  package.remove_resource(name)
  ```
  Remove data package resource by name.

  The data package descriptor will be validated after resource descriptor removal.

  __Arguments__
  - __name (str)__: data resource name

  __Raises__
  - `DataPackageException`: raises error if something goes wrong

  __Returns__

  `Resource/None`: returns removed `Resource` instances or null if not found




  ```python
  package.get_group(name)
  ```
  Returns a group of tabular resources by name.

  For more information about groups see [Group](#group).

  __Arguments__
  - __name (str)__: name of a group of resources

  __Raises__
  - `DataPackageException`: raises error if something goes wrong

  __Returns__

  `Group/None`: returns a `Group` instance or null if not found




  ```python
  package.infer(pattern=False)
  ```
  Infer a data package metadata.

  > Argument `pattern` works only for local files

  If `pattern` is not provided only existent resources will be inferred
  (added metadata like encoding, profile etc). If `pattern` is provided
  new resoures with file names mathing the pattern will be added and inferred.
  It commits changes to data package instance.

  __Arguments__
  - __pattern (str)__: glob pattern for new resources

  __Returns__

  `dict`: returns data package descriptor




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

  __Example__


  ```python
  package = Package({
      'name': 'package',
      'resources': [{'name': 'resource', 'data': ['data']}]
  })

  package.name # package
  package.descriptor['name'] = 'renamed-package'
  package.name # package
  package.commit()
  package.name # renamed-package
  ```

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

  __Raises__
  - `DataPackageException`: raises error if something goes wrong

  __Returns__

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




  ```python
  package.save(target=None,
               storage=None,
               merge_groups=False,
               to_base_path=False,
               **options)
  ```
  Saves this data package

  It saves it to storage if `storage` argument is passed or
  saves this data package's descriptor to json file if `target` arguments
  ends with `.json` or saves this data package to zip file otherwise.

  __Example__


  It creates a zip file into ``file_or_path`` with the contents
  of this Data Package and its resources. Every resource which content
  lives in the local filesystem will be copied to the zip file.
  Consider the following Data Package descriptor:

  ```json
  {
      "name": "gdp",
      "resources": [
          {"name": "local", "format": "CSV", "path": "data.csv"},
          {"name": "inline", "data": [4, 8, 15, 16, 23, 42]},
          {"name": "remote", "url": "http://someplace.com/data.csv"}
      ]
  }
  ```

  The final structure of the zip file will be:

  ```
  ./datapackage.json
  ./data/local.csv
  ```

  With the contents of `datapackage.json` being the same as
  returned `datapackage.descriptor`. The resources' file names are generated
  based on their `name` and `format` fields if they exist.
  If the resource has no `name`, it'll be used `resource-X`,
  where `X` is the index of the resource in the `resources` list (starting at zero).
  If the resource has `format`, it'll be lowercased and appended to the `name`,
  becoming "`name.format`".

  __Arguments__
  - __target (string/filelike)__:
          the file path or a file-like object where
          the contents of this Data Package will be saved into.
  - __storage (str/tableschema.Storage)__:
          storage name like `sql` or storage instance
  - __merge_groups (bool)__:
          save all the group's tabular resoruces into one bucket
          if a storage is provided (for example into one SQL table).
          Read more about [Group](#group).
  - __to_base_path (bool)__:
          save the package to the package's base path
          using the "<base_path>/<target>" route
  - __options (dict)__:
          storage options to use for storage creation

  __Raises__
  - `DataPackageException`: raises if there was some error writing the package

  __Returns__

  `bool/Storage`: on success return true or a `Storage` instance


  ```python
  Resource(self,
           descriptor={},
           base_path=None,
           strict=False,
           unsafe=False,
           storage=None,
           package=None,
           **options)
  ```
  Resource represenation

  __Arguments__
  - __descriptor (str/dict)__: data resource descriptor as local path, url or object
  - __base_path (str)__: base path for all relative paths
  - __strict (bool)__:
          strict flag to alter validation behavior.  Setting it to `true`
          leads to throwing errors on any operation with invalid descriptor
  - __unsafe (bool)__:
          if `True` unsafe paths will be allowed. For more inforamtion
          https://specs.frictionlessdata.io/data-resource/#data-location.
          Default to `False`
  - __storage (str/tableschema.Storage)__: storage name like `sql` or storage instance
  - __options (dict)__: storage options to use for storage creation

  __Raises__
  - `DataPackageException`: raises error if something goes wrong




  Return resource data



  Package's descriptor

  __Returns__

  `dict`: descriptor




  Validation errors

  Always empty in strict mode.

  __Returns__

  `Exception[]`: validation errors




  Group name

  __Returns__

  `str`: group name




  Resource's headers

  > Only for tabular resources (reading has to be started first or it's `None`)

  __Returns__

  `str[]/None`: returns data source headers




  Whether resource inline

  __Returns__

  `bool`: returns true if resource is inline




  Whether resource local

  __Returns__

  `bool`: returns true if resource is local




  Whether resource multipart

  __Returns__

  `bool`: returns true if resource is multipart




  Resource name

  __Returns__

  `str`: name




  Package instance if the resource belongs to some package

  __Returns__

  `Package/None`: a package instance if available




  Resource's profile

  __Returns__

  `Profile`: an instance of `Profile` class




  Whether resource remote

  __Returns__

  `bool`: returns true if resource is remote




  Resource's schema

  > Only for tabular resources

  For tabular resources it returns `Schema` instance to interact with data schema.
  Read API documentation - [tableschema.Schema](https://github.com/frictionlessdata/tableschema-py#schema).

  __Returns__

  `tableschema.Schema`: schema




  Resource's source

  Combination of `resource.source` and `resource.inline/local/remote/multipart`
  provides predictable interface to work with resource data.

  __Returns__

  `list/str`: returns `data` or `path` property




  Return resource table



  Whether resource tabular

  __Returns__

  `bool`: returns true if resource is tabular




  Validation status

  Always true in strict mode.

  __Returns__

  `bool`: validation status




  ```python
  resource.iter(integrity=False, relations=False, **options)
  ```
  Iterates through the resource data and emits rows cast based on table schema.

  > Only for tabular resources

  __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 (bool):
          if true actual size in BYTES and SHA256 hash of the file
          will be checked against `descriptor.bytes` and `descriptor.hash`
          (other hashing algorithms are not supported and will be skipped silently)

      relations (bool):
          if true foreign key fields will be checked and resolved to its references

      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__
  - `DataPackageException`: 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
  resource.read(integrity=False,
                relations=False,
                foreign_keys_values=False,
                **options)
  ```
  Read the whole resource and return as array of rows

  > Only for tabular resources
  > It has the same API as `resource.iter` except for

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

  __Returns__

  `list[]`: returns rows




  ```python
  resource.check_integrity()
  ```
  Checks resource integrity

  > Only for tabular resources

  It checks size in BYTES and SHA256 hash of the file
  against `descriptor.bytes` and `descriptor.hash`
  (other hashing algorithms are not supported and will be skipped silently).

  __Raises__
  - `exceptions.IntegrityError`: raises if there are integrity issues

  __Returns__

  `bool`: returns True if no issues




  ```python
  resource.check_relations(foreign_keys_values=False)
  ```
  Check relations

  > Only for tabular resources

  It checks foreign keys and raises an exception if there are integrity issues.

  __Raises__
  - `exceptions.RelationError`: raises if there are relation issues

  __Returns__

  `bool`: returns True if no issues




  ```python
  resource.drop_relations()
  ```
  Drop relations

  > Only for tabular resources

  Remove relations data from memory

  __Returns__

  `bool`: returns True




  ```python
  resource.raw_iter(stream=False)
  ```
  Iterate over data chunks as bytes.

  If `stream` is true File-like object will be returned.

  __Arguments__
  - __stream (bool)__: File-like object will be returned

  __Returns__

  `bytes[]/filelike`: returns bytes[]/filelike




  ```python
  resource.raw_read()
  ```
  Returns resource data as bytes.

  __Returns__

  `bytes`: returns resource data in bytes




  ```python
  resource.infer(**options)
  ```
  Infer resource metadata

  Like name, format, mediatype, encoding, schema and profile.
  It commits this changes into resource instance.

  __Arguments__
  - __options__:
          options will be passed to `tableschema.infer` call,
          for more control on results (e.g. for setting `limit`, `confidence` etc.).

  __Returns__

  `dict`: returns resource descriptor




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

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

  __Raises__
  - `DataPackageException`: raises error if something goes wrong

  __Returns__

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




  ```python
  resource.save(target, storage=None, to_base_path=False, **options)
  ```
  Saves this resource

  Into storage if `storage` argument is passed or
  saves this resource's descriptor to json file otherwise.

  __Arguments__
  - __target (str)__:
          path where to save a resource
  - __storage (str/tableschema.Storage)__:
          storage name like `sql` or storage instance
  - __to_base_path (bool)__:
          save the resource to the resource's base path
          using the "<base_path>/<target>" route
  - __options (dict)__:
          storage options to use for storage creation

  __Raises__
  - `DataPackageException`: raises error if something goes wrong

  __Returns__

  `bool`: returns true on success
  Building index...
  Started generating documentation...


  ```python
  Group(self, resources)
  ```
  Group representation

  __Arguments__
  - __Resource[]__: list of TABULAR resources




  Group's headers

  __Returns__

  `str[]/None`: returns headers




  Group name

  __Returns__

  `str`: name




  Resource's schema

  __Returns__

  `tableschema.Schema`: schema




  ```python
  group.iter(**options)
  ```
  Iterates through the group data and emits rows cast based on table schema.

  > It concatenates all the resources and has the same API as `resource.iter`




  ```python
  group.read(limit=None, **options)
  ```
  Read the whole group and return as array of rows

  > It concatenates all the resources and has the same API as `resource.read`




  ```python
  group.check_relations()
  ```
  Check group's relations

  The same as `resource.check_relations` but without the optional
  argument *foreign_keys_values*.  This method will test foreignKeys of the
  whole group at once otpimizing the process by creating the foreign_key_values
  hashmap only once before testing the set of resources.



  ```python
  Profile(self, profile)
  ```
  Profile representation

  __Arguments__
  - __profile (str)__: profile name in registry or URL to JSON Schema

  __Raises__
  - `DataPackageException`: raises error if something goes wrong




  JSONSchema content

  __Returns__

  `dict`: returns profile's JSON Schema contents




  Profile name

  __Returns__

  `str/None`: name if available




  ```python
  profile.validate(descriptor)
  ```
  Validate a data package `descriptor` against the profile.

  __Arguments__
  - __descriptor (dict)__: retrieved and dereferenced data package descriptor

  __Raises__
  - `ValidationError`: raises if not valid
  __Returns__

  `bool`: returns True if valid



  ```python
  validate(descriptor)
  ```
  Validate a data package descriptor.

  __Arguments__
  - __descriptor (str/dict)__: package descriptor (one of):
        - local path
        - remote url
        - object

  __Raises__
  - `ValidationError`: raises on invalid

  __Returns__

  `bool`: returns true on valid



  ```python
  infer(pattern, base_path=None)
  ```
  Infer a data package descriptor.

  > Argument `pattern` works only for local files

  __Arguments__
  - __pattern (str)__: glob file pattern

  __Returns__

  `dict`: returns data package descriptor



  ```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
  CastError(self, message, errors=[])
  ```
  All value cast errors.



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



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



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




  > 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 could be found in nicely formatted [commit history](https://github.com/frictionlessdata/datapackage-py/commits/master).



  > WARNING: it can be breaking for some setups, please read the discussions below

  - Fixed header management according to the specs:
      - https://github.com/frictionlessdata/datapackage-py/pull/257
      - https://github.com/frictionlessdata/datapackage-py/issues/256
      - https://github.com/frictionlessdata/forum/issues/1



  - Add experimental options for pick/skiping fileds/rows



  - Add `unsafe` option to Package and Resource (#262)



  - Use `chardet` for encoding deteciton by default. For `cchardet`: `pip install datapackage[cchardet]`



  - `resource/package.save` now accept a `to_base_path` argument (#254)
  - `package.save` now returns a `Storage` instance if available



  - Added an ability to check tabular resource's integrity



  - Added `resource.package` property



  - Added support for [groups of resources](#group)



  - Added support for [compression of resources](https://frictionlessdata.io/specs/patterns/#compression-of-resources)



  - Added support for custom request session



  Updated behaviour:
  - Added support for Python 3.7



  New API added:
  - added `skip_rows` support to the resource descriptor



  New API added:
  - property `package.base_path` is now publicly available



  Updated behaviour:
  - CLI command `$ datapackage infer` now outputs only a JSON-formatted data package descriptor.



  New API added:
  - Added an integration between `Package/Resource` and the `tableschema.Storage` - https://github.com/frictionlessdata/tableschema-py#storage. It allows to load and save data package from/to different storages like SQL/BigQuery/etc.


