# packages

pkgId: 521f0b5c5d4300ee1bfeaf7415e2d388bf8dc3e9a427c37a320f62ec922e1cf2
name: python-ipgetter2
arch: src
version: 1.1.10
epoch: 0
release: 1
summary: Utility to fetch your external IP address
url: https://github.com/starofrainnight/ipgetter2
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b41fe962-8e99-4154-ad62-659cc9e0907a
location_href: 00003924-python-ipgetter2/python-ipgetter2-1.1.10-1.src.rpm
checksum_type: sha256
description:
  Utility to fetch your external IP address.
  This module is designed to fetch your external IP address from the internet.
  It is used mostly when behind a NAT.
  It picks your IP randomly from a server list to minimize request overhead on a single server
  NOTICE: This library is try to act as a replacement of the **ipgetter** library, because that library has disappeared on pypi.org and github.
  * License: Apache-2.0
  * Documentation: https://ipgetter2.readthedocs.io.


pkgId: 555a9d6cfd98458c487df947af391540b6a85567b7923d8466d1c4582824d92c
name: python-ipmi
arch: src
version: 1.1
epoch: 0
release: 1
summary: A ipmi python client used in NetXMS migrated from perl
url: https://github.com/zhao-ji/check_ipmi_sensor_v3
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d2877796-78d5-450e-9484-ebfa981294aa
location_href: 00003925-python-ipmi/python-ipmi-1.1-1.src.rpm
checksum_type: sha256
description:
  mainly use the /usr/sbin/ipmi-sensors command

  Release Log:
  1.1: add parameter --filter-by-headers filter the ipmi result by headers
  1.0: add --ignore-unrecognized-event parameter to ipmi-sensor
  0.9: add event field to output
  0.8: add show header switch param


pkgId: e7d9df8af59508cd98faa3253cb859b365b3de14f4eee0188f5e1a59fc333ae4
name: python-iptools
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Python utilites for manipulating IPv4 and IPv6 addresses
url: https://github.com/bd808/python-iptools
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-deafb4a7-8c55-492d-8925-8f25a28cbf25
location_href: 00003927-python-iptools/python-iptools-0.7.0-1.src.rpm
checksum_type: sha256
description:
  Utilities for manipulating IPv4 and IPv6 addresses including a
  class that can be used to include CIDR network blocks in Django's
  INTERNAL_IPS setting.

  Full documentation at http://python-iptools.readthedocs.org/


pkgId: 00887b21178342697a1f570a28d179af214e7b585434ee8656448912b16f9a96
name: python-ipydeps
arch: src
version: 2020.240.0
epoch: 0
release: 1
summary: A pip interface wrapper for installing packages from within Jupyter notebooks.
url: https://github.com/nbgallery/ipydeps
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ae4595ee-ef05-4f35-b6eb-7690a3543543
location_href: 00013183-python-ipydeps/python-ipydeps-2020.240.0-1.src.rpm
checksum_type: sha256
description:
  A friendly way to specify your Jupyter notebook's dependencies right at the top of the notebook.
  This helps ensure that other users have the Python packages they need to successfully run your notebook.

  Unlike `!pip install`, ipydeps makes sure that the packages get installed into the same Python environment that's executing your notebook's code cells.
  No more `!pip`, `!pip3`, `!pip -V` frustrations for you and your users.

  It also includes features for installation accelerators via centrally-managed overrides, and PKI integration.



  You can install individual packages like so.

  ```python
  import ipydeps
  ipydeps.pip('numpy')
  import numpy as np
  ```

  You can also install multiple packages by passing a list.

  ```python
  import ipydeps
  ipydeps.pip(['pymc', 'beautifulsoup4'])
  from pymc import DiscreteUniform
  from bs4 import BeautifulSoup
  ```

  If you want more verbose output from pip, just set the ```verbose``` parameter to ```True```.

  ```python
  import ipydeps
  ipydeps.pip('sklearn', verbose=True)
  from sklearn.cluster import KMeans
  ```




  pip options for your particular environment can be placed in ~/.config/ipydeps/ipydeps.conf.  For example, the following ipydeps.conf could be used to specify that you want ipydeps to trust a host, timeout after 30 seconds, and install all packages into user space:

  ```text
  --trusted-host=my.pip.server.com
  --user
  --timeout=30
  ```

  Some pip options have to be specified per-package.  ipydeps will take care of specifying the option for each package for you.  However, make sure you're working in a fully trusted environment before using these options.  Putting these two lines in your ipydeps.conf will basically turn off any of pip's built-in verification.

  ```text
  --allow-external
  --allow-unverified
  ```

  If you were installing packages called "foo" and "bar" that you didn't want verified, then normally you'd have to pass ```--allow-external=foo --allow-external=bar --allow-unverified=foo --allow-unverified=bar```, but ipydeps will just fill these in for each package automatically if you simply put ```--allow-external``` and ```--allow-unverified``` in your ipydeps.conf.



  Sometimes there's a better way to install certain packages, such as a pre-built rpm or apk.  ~/.config/ipydeps/dependencies.link contains a URL for a file that overrides ipydeps.pip() calls for certain packages.

  For example, maybe you want to install numpy, so you call ipydeps.pip('numpy').  However, numpy can take a while to install from scratch.  If there's a pre-built version of numpy available, it can install in seconds instead of minutes.

  dependencies.link contains a URL pointing to a dependencies.json file which maps the original package names to their overrides.

  Only place a trusted link in your dependencies.link file, since dependencies.json could contain malicious commands that get executed as you.

  If you are managing multiple Jupyter environment deployments, you can have different dependencies.link files pointing at different dependencies.json files for each environment.
  For example, Fedora deployments can have a dependencies.link that points to https://trusted.host/dependencies-fedora.json, while FreeBSD deployments can have a dependencies.link that points to https://trusted.host/dependencies-freebsd.json.
  This allows multiple environment deployments to be centrally managed by changing their corresponding dependencies.json files.



  dependencies.link contains a URL pointing to a dependencies.json file which maps the original package names to their overrides.
  The dependencies.json file should look something like this contrived example:

  ```json
  {
    "python-3": {
      "numpy": [
        [ "yum", "install", "python3-numpy" ]
      ],
      "labsetup": [
        [ "yum", "install", "python3-numpy" ],
        [ "yum", "install", "python3-scikitlearn" ],
        [ "yum", "install", "python3-pandas" ],
        [ "yum", "install", "python3-pymc3" ]
      ]
    },
    "python-3.5": {
      "numpy": [
        [ "yum", "install", "special-prerequisite-for-python-3.5" ],
        [ "yum", "install", "python3-numpy" ]
      ]
    },
    "python-2.7": {
      "foo": [
        [ "echo", "Why", "are", "you", "still", "using", "python", "2.7?" ]
      ]
    }
  }
  ```

  Note that ipydeps will use the most specific override it can find.
  In the example above, a Python 3.5 environment will use the python-3.5 override for numpy.  The python-3 override for numpy will be ignored.

  Also note that all package names are handled in a case-insensitive manner (just like pip), so ipydeps will output a warning if it finds duplicate packages listed in your dependencies.json file.



  ipydeps now supports Windows as well as Linux.  It will look for your home directory using `os.path.expanduser('~')`.  In most cases, this just points to C:\Users\yourname.  You should put your .config/ipydeps/ipydeps.conf file in that directory.



  In some environments, having a PKI-enabled pip server is advantageous.  To that end, pypki2 integration is supported.  Simply add the following to ipydeps.conf:

  ```text
  --use-pypki2
  ```


pkgId: 0f7f53ad46b25a8a296018c3774ab9330fccb4ed7abf01dfb31cae61b17cc670
name: python-ipython
arch: src
version: 8.11.0
epoch: 0
release: 1
summary: IPython: Productive Interactive Computing
url: https://ipython.org
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b7c7206b-75d7-4cf5-94fb-ed4cb27ed304
location_href: 00003931-python-ipython/python-ipython-8.11.0-1.src.rpm
checksum_type: sha256
description:
  IPython provides a rich toolkit to help you make the most out of using Python
  interactively.  Its main components are:

   * A powerful interactive Python shell
   * A `Jupyter <https://jupyter.org/>`_ kernel to work with Python code in Jupyter
     notebooks and other interactive frontends.

  The enhanced interactive Python shells have the following main features:

   * Comprehensive object introspection.

   * Input history, persistent across sessions.

   * Caching of output results during a session with automatically generated
     references.

   * Extensible tab completion, with support by default for completion of python
     variables and keywords, filenames and function keywords.

   * Extensible system of 'magic' commands for controlling the environment and
     performing many tasks related either to IPython or the operating system.

   * A rich configuration system with easy switching between different setups
     (simpler than changing $PYTHONSTARTUP environment variables every time).

   * Session logging and reloading.

   * Extensible syntax processing for special purpose situations.

   * Access to the system shell with user-extensible alias system.

   * Easily embeddable in other Python programs and GUIs.

   * Integrated access to the pdb debugger and the Python profiler.

  The latest development version is always available from IPython's `GitHub
  site <http://github.com/ipython>`_.


pkgId: d77c169b6268cf60b12c03520b9bb6f1c3a7423a8b1cc1c0d0e15df94e93c366
name: python-ipywidgets
arch: src
version: 8.0.4
epoch: 0
release: 1
summary: Jupyter interactive widgets
url: http://jupyter.org
rpm_license: BSD 3-Clause License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f3cc2ff9-b718-4ebb-a7eb-8d84e1943ba9
location_href: 00003936-python-ipywidgets/python-ipywidgets-8.0.4-1.src.rpm
checksum_type: sha256
description:
  **ipywidgets**, also known as jupyter-widgets or simply widgets, are
  [interactive HTML widgets](https://github.com/jupyter-widgets/ipywidgets/blob/master/docs/source/examples/Index.ipynb)
  for Jupyter notebooks and the IPython kernel.

  This package contains the python implementation of the core interactive widgets bundled in ipywidgets.



  The fundamental widgets provided by this library are called core interactive
  widgets. A [demonstration notebook](https://github.com/jupyter-widgets/ipywidgets/blob/master/docs/source/examples/Index.ipynb)
  provides an overview of the core interactive widgets, including:

  - sliders
  - progress bars
  - text boxes
  - toggle buttons and checkboxes
  - display areas
  - and more


  For more information, see the main [documentation](https://github.com/jupyter-widgets/ipywidgets#readme).


pkgId: 51dfdac19304e6ae251f3571e0a4f9d27358d96891dec06044dab8ad1871356b
name: python-iso4217
arch: src
version: 1.11.20220401
epoch: 0
release: 1
summary: ISO 4217 currency data package for Python
url: https://github.com/dahlia/iso4217
rpm_license: Public Domain
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b23b8ac5-35c6-4c61-8dd5-464e1012b5de
location_href: 00012905-python-iso4217/python-iso4217-1.11.20220401-1.src.rpm
checksum_type: sha256
description:
  This Python package contains `ISO 4217`_ currency data, represented as
  enum_ module which was introduced in 3.4.  Note that this works on Python 2.7
  as well as 3.10, the latest version of Python, through enum34_ package.
  >>> from iso4217 import Currency
  >>> Currency.usd
  <Currency.usd: 'USD'>
  >>> Currency.usd.code
  'USD'
  >>> Currency.usd.currency_name
  'US Dollar'
  >>> Currency.usd.exponent  # USD has cents
  2
  >>> Currency.jpy
  <Currency.jpy: 'JPY'>
  >>> Currency.jpy.currency_name
  'Yen'
  >>> Currency.jpy.exponent  # JPY has no minor units
  0
  >>> Currency('KRW')  # Get by the code string
  <Currency.krw: 'KRW'>
  >>> Currency.krw is Currency('KRW')
  True
  Written by `Hong Minhee`_.  Distributed under Public Domain.


pkgId: 748e2cc8db6f38598a3fa3c30b7ede93ca5d7bb1ccefc40a9be087f22dfe3425
name: python-iso639
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: ISO639-2 support for Python.
url: https://github.com/janpipek/iso639-python
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-071dd95e-c39c-441e-95d3-2bf9145322f1
location_href: 00003941-python-iso639/python-iso639-0.1.4-1.src.rpm
checksum_type: sha256
description:
  A simple (really simple) library for working with ISO639-2 language codes.
  Tested for Python 2.7 & 3.4.
  Includes data from Congress library: http://www.loc.gov/standards/iso639-2/php/code_list.php (+ updates)


pkgId: 3603004ce06b30b183aca96a3590e5f6de8c0f6fbf502cd2ae78e619a607f758
name: python-iso8601
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Simple module to parse ISO 8601 dates
url: https://github.com/micktwomey/pyiso8601
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e5fcb58d-ac81-46ad-85c7-f601b1a868d1
location_href: 00009253-python-iso8601/python-iso8601-1.1.0-1.src.rpm
checksum_type: sha256
description:
  You can parse full date + times, or just the date. In both cases a datetime instance is returned but with missing times defaulting to 0, and missing days / months defaulting to 1.


pkgId: 708278e0bdefc7590da58e6f1cdab8aeb29c2c10827adb23e627b40a3c113223
name: python-isodate
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: An ISO 8601 date/time/duration parser and formatter
url: https://github.com/gweis/isodate/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-794abd9b-b213-4a0c-9385-b3c502876623
location_href: 00008929-python-isodate/python-isodate-0.6.1-1.src.rpm
checksum_type: sha256
description:
  This module implements ISO 8601 date, time and duration parsing.
  The implementation follows ISO8601:2004 standard, and implements only
  date/time representations mentioned in the standard. If something is not
  mentioned there, then it is treated as non existent, and not as an allowed
  option.
  For instance, ISO8601:2004 never mentions 2 digit years. So, it is not
  intended by this module to support 2 digit years. (while it may still
  be valid as ISO date, because it is not explicitly forbidden.)
  Another example is, when no time zone information is given for a time,
  then it should be interpreted as local time, and not UTC.
  As this module maps ISO 8601 dates/times to standard Python data types, like
  *date*, *time*, *datetime* and *timedelta*, it is not possible to convert
  all possible ISO 8601 dates/times. For instance, dates before 0001-01-01 are
  not allowed by the Python *date* and *datetime* classes. Additionally
  fractional seconds are limited to microseconds. That means if the parser finds
  for instance nanoseconds it will round it to microseconds.


pkgId: 5270038eb6251d983bab98aee0e80c0ee2798ebdecc514c7c349becfe24db9d6
name: python-isoduration
arch: src
version: 20.11.0
epoch: 0
release: 1
summary: Operations with ISO 8601 durations
url: https://github.com/bolsote/isoduration
rpm_license: ISC License (ISCL)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2f481d1f-b13e-484c-9be6-a532198020cb
location_href: 00011966-python-isoduration/python-isoduration-20.11.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI Package](https://img.shields.io/pypi/v/isoduration?style=flat-square)](https://pypi.org/project/isoduration/)



  ISO 8601 is most commonly known as a way to exchange datetimes in textual format. A
  lesser known aspect of the standard is the representation of durations. They have a
  shape similar to this:

  ```
  P3Y6M4DT12H30M5S
  ```

  This string represents a duration of 3 years, 6 months, 4 days, 12 hours, 30 minutes,
  and 5 seconds.

  The state of the art of ISO 8601 duration handling in Python is more or less limited to
  what's offered by [`isodate`](https://pypi.org/project/isodate/). What we are trying to
  achieve here is to address the shortcomings of `isodate` (as described in their own
  [_Limitations_](https://github.com/gweis/isodate/#limitations) section), and a few of
  our own annoyances with their interface, such as the lack of uniformity in their
  handling of types, and the use of regular expressions for parsing.



  This package revolves around the [`Duration`](src/isoduration/types.py) type.

  Given a ISO duration string we can produce such a type by using the `parse_duration()`
  function:

  ```py
  >>> from isoduration import parse_duration
  >>> duration = parse_duration("P3Y6M4DT12H30M5S")
  >>> duration.date
  DateDuration(years=Decimal('3'), months=Decimal('6'), days=Decimal('4'), weeks=Decimal('0'))
  >>> duration.time
  TimeDuration(hours=Decimal('12'), minutes=Decimal('30'), seconds=Decimal('5'))
  ```

  The `date` and `time` portions of the parsed duration are just regular
  [dataclasses](https://docs.python.org/3/library/dataclasses.html), so their members can
  be accessed in a non-surprising way.

  Besides just parsing them, a number of additional operations are available:

  - Durations can be compared and negated:
    ```py
    >>> parse_duration("P3Y4D") == parse_duration("P3Y4DT0H")
    True
    >>> -parse_duration("P3Y4D")
    Duration(DateDuration(years=Decimal('-3'), months=Decimal('0'), days=Decimal('-4'), weeks=Decimal('0')), TimeDuration(hours=Decimal('0'), minutes=Decimal('0'), seconds=Decimal('0')))
    ```
  - Durations can be added to, or subtracted from, Python datetimes:
    ```py
    >>> from datetime import datetime
    >>> datetime(2020, 3, 15) + parse_duration("P2Y")
    datetime.datetime(2022, 3, 15, 0, 0)
    >>> datetime(2020, 3, 15) - parse_duration("P33Y1M4D")
    datetime.datetime(1987, 2, 11, 0, 0)
    ```
  - Durations are hashable, so they can be used as dictionary keys or as part of sets.
  - Durations can be formatted back to a ISO 8601-compliant duration string:
    ```py
    >>> from isoduration import parse_duration, format_duration
    >>> format_duration(parse_duration("P11YT2H"))
    'P11YT2H'
    >>> str(parse_duration("P11YT2H"))
    'P11YT2H'
    ```



  These steps, in this order, should land you in a development environment:

  ```sh
  git clone git@github.com:bolsote/isoduration.git
  cd isoduration/
  python -m venv ve
  . ve/bin/activate
  pip install -U pip
  pip install -e .
  pip install -r requirements/dev.txt
  ```

  Adapt to your own likings and/or needs.

  Testing is driven by [tox](https://tox.readthedocs.io). The output of `tox -l` and a
  careful read of [tox.ini](tox.ini) should get you there.




  Some years have 366 days. If it's not always the same, then it's not the same.


  `timedelta` cannot represent certain durations, such as those involving years or months.
  Since it cannot represent all possible durations without dangerous arithmetic, then it
  must not be the right type.


  [Regular expressions should only be used to parse regular languages.](https://stackoverflow.com/a/1732454)


  Because this wonderful representation is not unique.


  Probably because the standard made me to.


  Probably because the standard doesn't allow me to.


  I'm confused.


  You shouldn't do what people on the Internet tell you to do.


  Yes.



  - [XML Schema Part 2: Datatypes, Appendix D](https://www.w3.org/TR/xmlschema-2/#isoformats):
    This excitingly named document contains more details about ISO 8601 than any human
    should be allowed to understand.
  - [`isodate`](https://pypi.org/project/isodate/): The original implementation of ISO
    durations in Python. Worth a look. But ours is cooler.


pkgId: 7abc5f37f36a08992d99800e33ad7fc4af868e225b873f4b823da631401b3dc0
name: python-isort
arch: src
version: 5.12.0
epoch: 0
release: 1
summary: A Python utility / library to sort Python imports.
url: https://pycqa.github.io/isort/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bc2e084b-c85d-4495-b3d5-5a7a6014f6fa
location_href: 00009011-python-isort/python-isort-5.12.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/isort.svg)](https://badge.fury.io/py/isort)
  [![Test Status](https://github.com/pycqa/isort/workflows/Test/badge.svg?branch=develop)](https://github.com/pycqa/isort/actions?query=workflow%3ATest)
  [![Lint Status](https://github.com/pycqa/isort/workflows/Lint/badge.svg?branch=develop)](https://github.com/pycqa/isort/actions?query=workflow%3ALint)
  [![Code coverage Status](https://codecov.io/gh/pycqa/isort/branch/main/graph/badge.svg)](https://codecov.io/gh/pycqa/isort)
  [![License](https://img.shields.io/github/license/mashape/apistatus.svg)](https://pypi.org/project/isort/)
  [![Join the chat at https://gitter.im/timothycrosley/isort](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/timothycrosley/isort?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
  [![Downloads](https://pepy.tech/badge/isort)](https://pepy.tech/project/isort)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
  [![DeepSource](https://static.deepsource.io/deepsource-badge-light-mini.svg)](https://deepsource.io/gh/pycqa/isort/?ref=repository-badge)
  _________________
  [Read Latest Documentation](https://pycqa.github.io/isort/) - [Browse GitHub Code Repository](https://github.com/pycqa/isort/)
  _________________
  isort your imports, so you don't have to.
  isort is a Python utility / library to sort imports alphabetically, and
  automatically separated into sections and by type. It provides a command line
  utility, Python library and [plugins for various
  editors](https://github.com/pycqa/isort/wiki/isort-Plugins) to
  quickly sort all your imports. It requires Python 3.8+ to run but
  supports formatting Python 2 code too.
  - [Try isort now from your browser!](https://pycqa.github.io/isort/docs/quick_start/0.-try.html)
  - [Using black? See the isort and black compatibility guide.](https://pycqa.github.io/isort/docs/configuration/black_compatibility.html)
  - [isort has official support for pre-commit!](https://pycqa.github.io/isort/docs/configuration/pre-commit.html)
  ![Example Usage](https://raw.github.com/pycqa/isort/main/example.gif)
  Before isort:
  ```python
  from my_lib import Object
  import os
  from my_lib import Object3
  from my_lib import Object2
  import sys
  from third_party import lib15, lib1, lib2, lib3, lib4, lib5, lib6, lib7, lib8, lib9, lib10, lib11, lib12, lib13, lib14
  import sys
  from __future__ import absolute_import
  from third_party import lib3
  print("Hey")
  print("yo")
  ```
  After isort:
  ```python
  from __future__ import absolute_import
  import os
  import sys
  from third_party import (lib1, lib2, lib3, lib4, lib5, lib6, lib7, lib8,
                           lib9, lib10, lib11, lib12, lib13, lib14, lib15)
  from my_lib import Object, Object2, Object3
  print("Hey")
  print("yo")
  ```

  Installing isort is as simple as:
  ```bash
  pip install isort
  ```
  Install isort with requirements.txt support:
  ```bash
  pip install isort[requirements_deprecated_finder]
  ```
  Install isort with Pipfile support:
  ```bash
  pip install isort[pipfile_deprecated_finder]
  ```
  Install isort with both formats support:
  ```bash
  pip install isort[requirements_deprecated_finder,pipfile_deprecated_finder]
  ```

  **From the command line**:
  To run on specific files:
  ```bash
  isort mypythonfile.py mypythonfile2.py
  ```
  To apply recursively:
  ```bash
  isort .
  ```
  If [globstar](https://www.gnu.org/software/bash/manual/html_node/The-Shopt-Builtin.html)
  is enabled, `isort .` is equivalent to:
  ```bash
  isort **/*.py
  ```
  To view proposed changes without applying them:
  ```bash
  isort mypythonfile.py --diff
  ```
  Finally, to atomically run isort against a project, only applying
  changes if they don't introduce syntax errors:
  ```bash
  isort --atomic .
  ```
  (Note: this is disabled by default, as it prevents isort from
  running against code written using a different version of Python.)
  **From within Python**:
  ```python
  import isort
  isort.file("pythonfile.py")
  ```
  or:
  ```python
  import isort
  sorted_code = isort.code("import b\nimport a\n")
  ```

  Several plugins have been written that enable to use isort from within a
  variety of text-editors. You can find a full list of them [on the isort
  wiki](https://github.com/pycqa/isort/wiki/isort-Plugins).
  Additionally, I will enthusiastically accept pull requests that include
  plugins for other text editors and add documentation for them as I am
  notified.

  You will notice above the \"multi\_line\_output\" setting. This setting
  defines how from imports wrap when they extend past the line\_length
  limit and has [12 possible settings](https://pycqa.github.io/isort/docs/configuration/multi_line_output_modes.html).

  To change the how constant indents appear - simply change the
  indent property with the following accepted formats:
  -   Number of spaces you would like. For example: 4 would cause standard
      4 space indentation.
  -   Tab
  -   A verbatim string with quotes around it.
  For example:
  ```python
  "    "
  ```
  is equivalent to 4.
  For the import styles that use parentheses, you can control whether or
  not to include a trailing comma after the last import with the
  `include_trailing_comma` option (defaults to `False`).

  As of isort 3.1.0 support for balanced multi-line imports has been
  added. With this enabled isort will dynamically change the import length
  to the one that produces the most balanced grid, while staying below the
  maximum import length defined.
  Example:
  ```python
  from __future__ import (absolute_import, division,
                          print_function, unicode_literals)
  ```
  Will be produced instead of:
  ```python
  from __future__ import (absolute_import, division, print_function,
                          unicode_literals)
  ```
  To enable this set `balanced_wrapping` to `True` in your config or pass
  the `-e` option into the command line utility.

  isort provides configuration options to change almost every aspect of how
  imports are organized, ordered, or grouped together in sections.
  [Click here](https://pycqa.github.io/isort/docs/configuration/custom_sections_and_ordering.html) for an overview of all these options.

  To make isort ignore a single import simply add a comment at the end of
  the import line containing the text `isort:skip`:
  ```python
  import module  # isort:skip
  ```
  or:
  ```python
  from xyz import (abc,  # isort:skip
                   yo,
                   hey)
  ```
  To make isort skip an entire file simply add `isort:skip_file` to the
  module's doc string:
  ```python
  """ my_module.py
      Best module ever
     isort:skip_file
  """
  import b
  import a
  ```

  isort can be ran or configured to add / remove imports automatically.
  [See a complete guide here.](https://pycqa.github.io/isort/docs/configuration/add_or_remove_imports.html)


pkgId: cb8adcf4e709c83c0ee5fb2767c80249cce617cffcfe05417693315207e9ea45
name: python-isoweek
arch: src
version: 1.3.3
epoch: 0
release: 1
summary: Objects representing a week
url: http://github.com/gisle/isoweek
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c1cc1c8b-0995-4c14-81e5-158411940bdb
location_href: 00010199-python-isoweek/python-isoweek-1.3.3-1.src.rpm
checksum_type: sha256
description:
  The isoweek module provide the class *Week*.  Instances represent specific weeks
  spanning Monday to Sunday.  There are 52 or 53 numbered weeks in a year.  Week
  1 is defined to be the first week with 4 or more days in January.
  It's called isoweek because this is the week definition of ISO 8601.  This
  standard also define a notation for identifying weeks; yyyyWww (where the "W"
  is a literal).  An example is "2011W08" which denotes the 8th week of year
  2011.  *Week* instances stringify to this form.
  See also http://en.wikipedia.org/wiki/ISO_week_date
  The *Week* instances are light weight and immutable with an interface similar
  to the datetime.date objects.  Example code::
      from isoweek import Week
      w = Week(2011, 20)
      print "Week %s starts on %s" % (w, w.monday())
      print "Current week number is", Week.thisweek().week
      print "Next week is", Week.thisweek() + 1


pkgId: efe1adb8a8766386ebc0bb214ff49b24bd82571ae2255ef5dab989f53e8bb2da
name: python-itemadapter
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Common interface for data container classes
url: https://github.com/scrapy/itemadapter
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-08bdefd6-be46-441d-adc5-0f9fb230d329
location_href: 00009988-python-itemadapter/python-itemadapter-0.8.0-1.src.rpm
checksum_type: sha256
description:
  * Python 3.7+
  * [`scrapy`](https://scrapy.org/): optional, needed to interact with `scrapy` items
  * [`attrs`](https://pypi.org/project/attrs/): optional, needed to interact with `attrs`-based items


pkgId: 5e4ed28cfe07a6fa0384e52baa6fecfa9d91bd4c79da57804c939f932172f957
name: python-itsdangerous
arch: src
version: 2.1.2
epoch: 0
release: 1
summary: Safely pass data to untrusted environments and back.
url: https://palletsprojects.com/p/itsdangerous/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e2d9216f-5eb9-4447-8f56-416e1dcfad73
location_href: 00008920-python-itsdangerous/python-itsdangerous-2.1.2-1.src.rpm
checksum_type: sha256
description:
  Various helpers to pass data to untrusted environments and to get it
  back safe and sound. Data is cryptographically signed to ensure that a
  token has not been tampered with.
  It's possible to customize how data is serialized. Data is compressed as
  needed. A timestamp can be added and verified automatically while
  loading a token.


pkgId: 8fddbdb047af9634e89e5baaac8c373496c8945a6e3e41f28047ce7d9fbae0fa
name: python-itypes
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Simple immutable types for python.
url: http://github.com/PavanTatikonda/itypes
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9d88b37c-5248-4547-9cc4-6d654b6a68b3
location_href: 00003943-python-itypes/python-itypes-1.2.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/PavanTatikonda/itypes.svg?branch=master)](https://travis-ci.org/PavanTatikonda/itypes)

  Basic immutable container types for Python.

  A simple implementation that's designed for simplicity over performance.

  Use these in circumstances where it may result in more comprehensible code,
  or when you want to create custom types with restricted, immutable interfaces.

  For an alternative implementation designed for performance,
  please see [pyrsistent](https://github.com/tobgu/pyrsistent).



  Install using `pip`:

      pip install itypes



      >>> import itypes
      >>> d = itypes.Dict({'a': 1, 'b': 2, 'c': 3})
      >>> l = itypes.List(['a', 'b', 'c'])



      >>> d = itypes.Dict({'a': 123, 'b': ['a', 'b', 'c']})
      >>> d['b']
      List(['a', 'b', 'c'])



  Methods: `set(key, value)`, `delete(key)`

      >>> d2 = d.set('c', 456)
      >>> d2
      Dict({'a': 123, 'b': ['a', 'b', 'c'], 'c': 456})
      >>> d3 = d2.delete('a')
      >>> d3
      Dict({'b': ['a', 'b', 'c'], 'c': 456})



      >>> d['z'] = 123
      TypeError: 'Dict' object doesn't support item assignment
      >>> del(d['c'])
      TypeError: 'Dict' object doesn't support item deletion



  Method: `get_in(keys, default=None)`

      >>> d['b'][-1]
      'c'
      >>> d['b'][5]
      IndexError: list index out of range
      >>> d.get_in(['b', -1])
      'c'
      >>> d.get_in(['b', 5])
      None



  Methods: `set_in(keys, value)`, `delete_in(keys)`

      >>> d2 = d.set_in(['b', 1], 'xxx')
      >>> d2
      Dict({'a': 123, 'b': ['a', 'xxx', 'c']})
      >>> d3 = d2.delete_in(['b', 0])
      >>> d3
      Dict({'a': 123, 'b': ['xxx', 'c']})



      >>> d = itypes.Dict({'a': 1, 'b': 2, 'c': 3})
      >>> d == {'a': 1, 'b': 2, 'c': 3}
      True



      >>> hash(d)
      277752239



  Functions: `to_mutable(instance)`, `to_immutable(value)`

      >>> value = itypes.to_mutable(d)
      >>> value
      {'a': 123, 'b': ['a', 'b', 'c']}
      >>> itypes.to_immutable(value)
      Dict({'a': 123, 'b': ['a', 'b', 'c']})



  Only private attribute names may be set on instances. Use `@property` for attribute access.

  Define a `.clone(self, data)` method if objects have additional state.

  Example:

      class Configuration(itypes.Dict):
          def __init__(self, title, *args, **kwargs):
              self._title = title
              super(Configuration, self).__init__(*args, **kwargs)

          @property
          def title(self):
              return self._title

          def clone(self, data):
              return Configuration(self._title, data)

  Using the custom class:

      >>> config = Configuration('worker-process', {'hostname': 'example.com', 'dynos': 4})
      >>> config.title
      'worker-process'
      >>> new = config.set('dynos', 2)
      >>> new
      Configuration({'dynos': 2, 'hostname': 'example.com'})
      >>> new.title
      'worker-process'



  Subclass `itypes.Object` for an object that prevents setting public attributes.

      >>> class Custom(itypes.Object):
      ...     pass

  Only private attribute names may be set on instances. Use `@property` for attribute access.

      >>> class Document(itypes.Object):
      ... def __init__(self, title, content):
      ...     self._title = title
      ...     self._content = title
      ... @property
      ... def title(self):
      ...     return self._title
      ... @property
      ... def content(self):
      ...     return self._content

  Using immutable objects:

      >>> doc = Document(title='Immutability', content='For simplicity')
      >>> doc.title
      'Immutability'
      >>> doc.title = 'Changed'
      TypeError: 'Document' object doesn't support property assignment.


pkgId: 4c3a82155daa85d09c2ea3614ff51b9f124f96a9e024e8d10f8c1993a61c2ca2
name: python-j2cli
arch: src
version: 0.3.10
epoch: 0
release: 1
summary: Command-line interface to Jinja2 for templating in shell scripts.
url: https://github.com/kolypto/j2cli
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e003b186-8407-4a8d-899a-7cd79f854310
location_href: 00009985-python-j2cli/python-j2cli-0.3.10-1.src.rpm
checksum_type: sha256
description:
  `j2cli` is a command-line tool for templating in shell-scripts,
  leveraging the [Jinja2](http://jinja.pocoo.org/docs/) library.
  Features:
  * Jinja2 templating
  * INI, YAML, JSON data sources supported
  * Allows the use of environment variables in templates! Hello [Docker](http://www.docker.com/) :)
  Inspired by [mattrobenolt/jinja2-cli](https://github.com/mattrobenolt/jinja2-cli)


pkgId: 757fd3c96a7f466abaab748fee57e0b74b86845f703cbd6016340f232dd1bca0
name: python-japanize-matplotlib
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: matplotlibのフォント設定を自動で日本語化する
url: https://github.com/uehara1414/japanize-matplotlib
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d04c1679-a05d-4a7d-9886-a193b36c5132
location_href: 00012006-python-japanize-matplotlib/python-japanize-matplotlib-1.1.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/japanize-matplotlib.svg)](https://badge.fury.io/py/japanize-matplotlib)

  matplotlib を日本語表示に対応させます


  matplotlibをimportした後、japanize_matplotlibをimportします。

  ```python
  import matplotlib.pyplot as plt
  import japanize_matplotlib

  plt.plot([1, 2, 3, 4])
  plt.xlabel('簡単なグラフ')
  plt.show()
  ```


  ![demo](https://raw.githubusercontent.com/uehara1414/japanize-matplotlib/master/demo.png?token=AOnChuZIQchUxiL0U8qlW633FM-RMSuvks5bxW8zwA%3D%3D "demo")


  ```sh

  pipenv install japanize-matplotlib


  pip install japanize-matplotlib
  ```


  IPAフォントのIPAexゴシック(Ver.003.01)を利用しています。
  利用にあたっては[IPAフォントライセンスv1.0](https://github.com/uehara1414/japanize-matplotlib/blob/master/japanize_matplotlib/fonts/IPA_Font_License_Agreement_v1.0.txt)に同意してください。



  import japanize_matplotlib してから matplotlib でグラフを描画するまでにフォントの設定が変わる処理が入っていると、日本語表示がなされない可能性があります。

  例えば、seaborn を利用している場合であれば sns.set() などで描画フォントが seaborn のデフォルトに上書きされ、日本語表示がされなくなります。

  sns.set(font="IPAexGothic") のように利用フォントに IPAexGothic を設定するか、フォント上書き後に japanize_matplotlib.japanize() を利用するなどで日本語表示できるはずです。


  リンターなどの警告が気になる・コードを消される方向けに japanize_matplotlib.japanize() メソッドの実行でも import 時と同じくフォントを設定できるようになっています。
  無意味な実行になりますが、時と場合に応じて実行してください。

  もしくはリンターごとに無視させる設定をすることで対応できるはずです。# noqa などで設定してください。


  チェインケースが読みやすく好きだからです。import時にはチェインケースは利用できないのでスネークケースになっています。


pkgId: 78c67f834b3fc1ba27812ae1b4c5f4bbf383ec55285605f00e8e6453195ead14
name: python-javabridge
arch: src
version: 1.0.19
epoch: 0
release: 1
summary: Python wrapper for the Java Native Interface
url: http://github.com/CellProfiler/python-javabridge/
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-10859fe8-ddda-4f82-979f-944cf85ae050
location_href: 00003949-python-javabridge/python-javabridge-1.0.19-1.src.rpm
checksum_type: sha256
description:
  The python-javabridge package makes it easy to start a Java virtual
  machine (JVM) from Python and interact with it. Python code can
  interact with the JVM using a low-level API or a more convenient
  high-level API. Python-javabridge was developed for and is used by the
  cell image analysis software CellProfiler (cellprofiler.org).


pkgId: 0d8eebc9cb710f6c2400bbef78b41d0e0af5f560e389a191fca4aff3b2a8008b
name: python-javaobj
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Module for serializing and de-serializing Java objects.
url: http://code.google.com/p/python-javaobj
rpm_license: APL2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f3265e17-4bcc-49ae-84c6-03d632312520
location_href: 00003951-python-javaobj/python-javaobj-0.1.0-1.src.rpm
checksum_type: sha256
description:
  Provides functions for reading and writing (writing is WIP currently) Java objects serialized or will be deserialized by ObjectOutputStream. This form of object representation is a standard data interchange format in Java world. javaobj module exposes an API familiar to users of the standard library marshal, pickle and json modules.


pkgId: 6c230a405cddd5aaa7f32f1293f4b6ca3da60f3e29476c290c009d9a6da9690d
name: python-javaobj-py3
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: Module for serializing and de-serializing Java objects.
url: https://github.com/tcalmant/python-javaobj
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-285bde20-15f3-43a1-b98f-98e582f48c46
location_href: 00010876-python-javaobj-py3/python-javaobj-py3-0.4.3-1.src.rpm
checksum_type: sha256
description:
  <p>
      <a href="https://pypi.python.org/pypi/javaobj-py3/">
          <img src="https://img.shields.io/pypi/v/javaobj-py3.svg" alt="Latest Version" />
          <img src="https://img.shields.io/pypi/l/javaobj-py3.svg" alt="License" />
      </a>
      <a href="https://travis-ci.org/tcalmant/python-javaobj">
      <img src="https://travis-ci.org/tcalmant/python-javaobj.svg?branch=master"
          alt="Travis-CI status" />
      </a>
      <a href="https://coveralls.io/r/tcalmant/python-javaobj?branch=master">
          <img src="https://coveralls.io/repos/tcalmant/python-javaobj/badge.svg?branch=master"
              alt="Coveralls status" />
      </a>
  </p>

  *python-javaobj* is a python library that provides functions for reading and
  writing (writing is WIP currently) Java objects serialized or will be
  deserialized by `ObjectOutputStream`. This form of object representation is a
  standard data interchange format in Java world.

  The `javaobj` module exposes an API familiar to users of the standard library
  `marshal`, `pickle` and `json` modules.



  This project is a fork of *python-javaobj* by Volodymyr Buell, originally from
  [Google Code](http://code.google.com/p/python-javaobj/) and now hosted on
  [GitHub](https://github.com/vbuell/python-javaobj).

  This fork intends to work both on Python 2.7 and Python 3.4+.





  | Implementations | Version  |
  |-----------------|----------|
  | `v1`, `v2`      | `0.4.0+` |

  Since version 0.4.0, two implementations of the parser are available:

  * `v1`: the *classic* implementation of `javaobj`, with a work in progress
    implementation of a writer.
  * `v2`: the *new* implementation, which is a port of the Java project
    [`jdeserialize`](https://github.com/frohoff/jdeserialize/),
    with support of the object transformer (with a new API) and of the `numpy`
    arrays loading.

  You can use the `v1` parser to ensure that the behaviour of your scripts
  doesn't change and to keep the ability to write down files.

  You can use the `v2` parser for new developments
  *which won't require marshalling* and as a *fallback* if the `v1`
  fails to parse a file.



  | Implementations | Version  |
  |-----------------|----------|
  | `v1`            | `0.2.0+` |

  As of version 0.2.0, the notion of *object transformer* from the original
  project as been replaced by an *object creator*.

  The *object creator* is called before the deserialization.
  This allows to store the reference of the converted object before deserializing
  it, and avoids a mismatch between the referenced object and the transformed one.



  | Implementations | Version  |
  |-----------------|----------|
  | `v2`            | `0.4.0+` |

  The `v2` implementation provides a new API for the object transformers.
  Please look at the *Usage (V2)* section in this file.



  | Implementations | Version  |
  |-----------------|----------|
  | `v1`            | `0.2.3+` |

  As of version 0.2.3, bytes arrays are loaded as a `bytes` object instead of
  an array of integers.



  | Implementations | Version  |
  |-----------------|----------|
  | `v2`            | `0.4.2+` |

  A new transformer API has been proposed to handle objects written with a custom
  Java writer.
  You can find a sample usage in the *Custom Transformer* section in this file.



  * Java object instance un-marshalling
  * Java classes un-marshalling
  * Primitive values un-marshalling
  * Automatic conversion of Java Collections to python ones
    (`HashMap` => `dict`, `ArrayList` => `list`, etc.)
  * Basic marshalling of simple Java objects (`v1` implementation only)
  * Automatically uncompresses GZipped files



  * Python >= 2.7 or Python >= 3.4
  * `enum34` and `typing` when using Python <= 3.4 (installable with `pip`)
  * Maven 2+ (for building test data of serialized objects.
    You can skip it if you do not plan to run `tests.py`)



  Un-marshalling of Java serialised object:

  ```python
  import javaobj

  with open("obj5.ser", "rb") as fd:
      jobj = fd.read()

  pobj = javaobj.loads(jobj)
  print(pobj)
  ```

  Or, you can use `JavaObjectUnmarshaller` object directly:

  ```python
  import javaobj

  with open("objCollections.ser", "rb") as fd:
      marshaller = javaobj.JavaObjectUnmarshaller(fd)
      pobj = marshaller.readObject()

      print(pobj.value, "should be", 17)
      print(pobj.next, "should be", True)

      pobj = marshaller.readObject()
  ```

  **Note:** The objects and methods provided by `javaobj` module are shortcuts
  to the `javaobj.v1` package, for Compatibility purpose.
  It is **recommended** to explicitly import methods and classes from the `v1`
  (or `v2`) package when writing new code, in order to be sure that your code
  won't need import updates in the future.




  The following methods are provided by the `javaobj.v2` package:

  * `load(fd, *transformers, use_numpy_arrays=False)`:
    Parses the content of the given file descriptor, opened in binary mode (`rb`).
    The method accepts a list of custom object transformers. The default object
    transformer is always added to the list.

    The `use_numpy_arrays` flag indicates that the arrays of primitive type
    elements must be loaded using `numpy` (if available) instead of using the
    standard parsing technic.

  * `loads(bytes, *transformers, use_numpy_arrays=False)`:
    This the a shortcut to the `load()` method, providing it the binary data
    using a `BytesIO` object.

  **Note:** The V2 parser doesn't have the marshalling capability.

  Sample usage:

  ```python
  import javaobj.v2 as javaobj

  with open("obj5.ser", "rb") as fd:
      pobj = javaobj.load(fd)

  print(pobj.dump())
  ```



  An object transformer can be called during the parsing of a Java object
  instance or while loading an array.

  The Java object instance parsing works in two main steps:

  1. The transformer is called to create an instance of a bean that inherits
     `JavaInstance`.
  1. The latter bean is then called:

     * When the object is written with a custom block data
     * After the fields and annotations have been parsed, to update the content
     of the Python bean.

  Here is an example for a Java `HashMap` object. You can look at the code of
  the `javaobj.v2.transformer` module to see the whole implementation.

  ```python
  class JavaMap(dict, javaobj.v2.beans.JavaInstance):
      """
      Inherits from dict for Python usage, JavaInstance for parsing purpose
      """
      def __init__(self):
          
          dict.__init__(self)
          JavaInstance.__init__(self)

      def load_from_blockdata(self, parser, reader, indent=0):
      """
      Reads content stored in a block data.

      This method is called only if the class description has both the
      `SC_EXTERNALIZABLE` and `SC_BLOCK_DATA` flags set.

      The stream parsing will stop and fail if this method returns False.

      :param parser: The JavaStreamParser in use
      :param reader: The underlying data stream reader
      :param indent: Indentation to use in logs
      :return: True on success, False on error
      """
      
      return False

      def load_from_instance(self, indent=0):
          
          """
          Load content from the parsed instance object.

          This method is called after the block data (if any), the fields and
          the annotations have been loaded.

          :param indent: Indentation to use while logging
          :return: True on success (currently ignored)
          """
          
          for cd, annotations in self.annotations.items():
              
              if cd.name == "java.util.HashMap":
                  
                  
                  
                  args = [iter(annotations[1:])] * 2
                  for key, value in zip(*args):
                      self[key] = value

                  
                  return True

          
          return False

  class MapObjectTransformer(javaobj.v2.api.ObjectTransformer):
      """
      Creates a JavaInstance object with custom loading methods for the
      classes it can handle
      """
      def create_instance(self, classdesc):
          
          """
          Transforms a parsed Java object into a Python object

          :param classdesc: The description of a Java class
          :return: The Python form of the object, or the original JavaObject
          """
          if classdesc.name == "java.util.HashMap":
              
              return JavaMap()
          else:
              
              return None
  ```



  The custom transformer is called when the class is not handled by the default
  object transformer.
  A custom object transformer still inherits from the `ObjectTransformer` class,
  but it also implements the `load_custom_writeObject` method.

  The sample given here is used in the unit tests.



  On the Java side, we create various classes and write them as we wish:

  ```java
  class CustomClass implements Serializable {

      private static final long serialVersionUID = 1;

      public void start(ObjectOutputStream out) throws Exception {
          this.writeObject(out);
      }

      private void writeObject(ObjectOutputStream out) throws IOException {
          CustomWriter custom = new CustomWriter(42);
          out.writeObject(custom);
          out.flush();
      }
  }

  class RandomChild extends Random {

      private static final long serialVersionUID = 1;
      private int num = 1;
      private double doub = 4.5;

      RandomChild(int seed) {
          super(seed);
      }
  }

  class CustomWriter implements Serializable {
      protected RandomChild custom_obj;

      CustomWriter(int seed) {
          custom_obj = new RandomChild(seed);
      }

      private static final long serialVersionUID = 1;
      private static final int CURRENT_SERIAL_VERSION = 0;

      private void writeObject(ObjectOutputStream out) throws IOException {
          out.writeInt(CURRENT_SERIAL_VERSION);
          out.writeObject(custom_obj);
      }
  }
  ```

  An here is a sample writing of that kind of object:

  ```java
  ObjectOutputStream oos = new ObjectOutputStream(
      new FileOutputStream("custom_objects.ser"));
  CustomClass writer = new CustomClass();
  writer.start(oos);
  oos.flush();
  oos.close();
  ```



  On the Python side, the first step is to define the custom transformers.
  They are children of the `javaobj.v2.transformers.ObjectTransformer` class.

  ```python
  class BaseTransformer(javaobj.v2.transformers.ObjectTransformer):
      """
      Creates a JavaInstance object with custom loading methods for the
      classes it can handle
      """

      def __init__(self, handled_classes=None):
          self.instance = None
          self.handled_classes = handled_classes or {}

      def create_instance(self, classdesc):
          """
          Transforms a parsed Java object into a Python object

          :param classdesc: The description of a Java class
          :return: The Python form of the object, or the original JavaObject
          """
          if classdesc.name in self.handled_classes:
              self.instance = self.handled_classes[classdesc.name]()
              return self.instance

          return None

  class RandomChildTransformer(BaseTransformer):
      def __init__(self):
          super(RandomChildTransformer, self).__init__(
              {"RandomChild": RandomChildInstance}
          )

  class CustomWriterTransformer(BaseTransformer):
      def __init__(self):
          super(CustomWriterTransformer, self).__init__(
              {"CustomWriter": CustomWriterInstance}
          )

  class JavaRandomTransformer(BaseTransformer):
      def __init__(self):
          super(JavaRandomTransformer, self).__init__()
          self.name = "java.util.Random"
          self.field_names = ["haveNextNextGaussian", "nextNextGaussian", "seed"]
          self.field_types = [
              javaobj.v2.beans.FieldType.BOOLEAN,
              javaobj.v2.beans.FieldType.DOUBLE,
              javaobj.v2.beans.FieldType.LONG,
          ]

      def load_custom_writeObject(self, parser, reader, name):
          if name != self.name:
              return None

          fields = []
          values = []
          for f_name, f_type in zip(self.field_names, self.field_types):
              values.append(parser._read_field_value(f_type))
              fields.append(javaobj.beans.JavaField(f_type, f_name))

          class_desc = javaobj.beans.JavaClassDesc(
              javaobj.beans.ClassDescType.NORMALCLASS
          )
          class_desc.name = self.name
          class_desc.desc_flags = javaobj.beans.ClassDataType.EXTERNAL_CONTENTS
          class_desc.fields = fields
          class_desc.field_data = values
          return class_desc
  ```

  Second step is defining the representation of the instances, where the real
  object loading occurs. Those classes inherit from
  `javaobj.v2.beans.JavaInstance`.

  ```python
  class CustomWriterInstance(javaobj.v2.beans.JavaInstance):
      def __init__(self):
          javaobj.v2.beans.JavaInstance.__init__(self)

      def load_from_instance(self):
          """
          Updates the content of this instance
          from its parsed fields and annotations
          :return: True on success, False on error
          """
          if self.classdesc and self.classdesc in self.annotations:
              
              
              fields = ["int_not_in_fields"] + self.classdesc.fields_names
              raw_data = self.annotations[self.classdesc]
              int_not_in_fields = struct.unpack(
                  ">i", BytesIO(raw_data[0].data).read(4)
              )[0]
              custom_obj = raw_data[1]
              values = [int_not_in_fields, custom_obj]
              self.field_data = dict(zip(fields, values))
              return True

          return False


  class RandomChildInstance(javaobj.v2.beans.JavaInstance):
      def load_from_instance(self):
          """
          Updates the content of this instance
          from its parsed fields and annotations
          :return: True on success, False on error
          """
          if self.classdesc and self.classdesc in self.field_data:
              fields = self.classdesc.fields_names
              values = [
                  self.field_data[self.classdesc][self.classdesc.fields[i]]
                  for i in range(len(fields))
              ]
              self.field_data = dict(zip(fields, values))
              if (
                  self.classdesc.super_class
                  and self.classdesc.super_class in self.annotations
              ):
                  super_class = self.annotations[self.classdesc.super_class][0]
                  self.annotations = dict(
                      zip(super_class.fields_names, super_class.field_data)
                  )
              return True

          return False
  ```

  Finally we can use the transformers in the loading process.
  Note that even if it is not explicitly given, the `DefaultObjectTransformer`
  will be also be used, as it is added automatically by `javaobj` if it is
  missing from the given list.

  ```python

  transformers = [
      CustomWriterTransformer(),
      RandomChildTransformer(),
      JavaRandomTransformer()
  ]
  pobj = javaobj.loads("custom_objects.ser", *transformers)




  print(pobj.field_data["int_not_in_fields"])
  ```


pkgId: 7413bb68a633e61b88e25606b5efb27c9a50bb77003e2b0bf2d7f2ddb1e45065
name: python-javascriptpy
arch: src
version: 1.1.6
epoch: 0
release: 1
summary: This package lets you use Javascript like objects in python.
url: https://github.com/CodeWithSwastik/javascript-py
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-994190df-aa47-43a3-9e5f-ba454ab39890
location_href: 00013524-python-javascriptpy/python-javascriptpy-1.1.6-1.src.rpm
checksum_type: sha256
description:
  This package lets you use javascript like objects in python.



  Stable version:

  ```
  pip install javascriptpy
  ```

  Working version:

  ```
  pip install git+https://github.com/CodeWithSwastik/javascript-py
  ```



  ```python
  from javascript import *

  array = Array('apple', 'orange', 'cherry')
  index = Math.floor(Math.random() * array.length)

  console.info('Random element:', array[index])
  console.table(array)
  ```



  ```py
  from javascript import console, Array

  console.clear()
  console.error("Syntax Error!")
  console.warn("Forgot an import!")
  console.table(Array(['earth', 'venus']))
  ```

  ![image](https://user-images.githubusercontent.com/61446939/126521684-669e4dd5-4263-4c5e-9cce-9c0e097759e3.png)



  - Added RegExp, Date, JSON


pkgId: 1512a74a48684bf0b919cb75578e1c770946b3ad1f1e0213156f7de58009dada
name: python-jax
arch: src
version: 0.4.8
epoch: 0
release: 1
summary: Differentiate, compile, and transform Numpy code.
url: https://github.com/google/jax
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0c85bcc2-ca79-4d9a-b356-3a85e3b66573
location_href: 00009145-python-jax/python-jax-0.4.8-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
  <img src="https://raw.githubusercontent.com/google/jax/main/images/jax_logo_250px.png" alt="logo"></img>
  </div>



  ![Continuous integration](https://github.com/google/jax/actions/workflows/ci-build.yaml/badge.svg)
  ![PyPI version](https://img.shields.io/pypi/v/jax)

  [**Quickstart**](#quickstart-colab-in-the-cloud)
  | [**Transformations**](#transformations)
  | [**Install guide**](#installation)
  | [**Neural net libraries**](#neural-network-libraries)
  | [**Change logs**](https://jax.readthedocs.io/en/latest/changelog.html)
  | [**Reference docs**](https://jax.readthedocs.io/en/latest/)




  JAX is [Autograd](https://github.com/hips/autograd) and [XLA](https://www.tensorflow.org/xla),
  brought together for high-performance machine learning research.

  With its updated version of [Autograd](https://github.com/hips/autograd),
  JAX can automatically differentiate native
  Python and NumPy functions. It can differentiate through loops, branches,
  recursion, and closures, and it can take derivatives of derivatives of
  derivatives. It supports reverse-mode differentiation (a.k.a. backpropagation)
  via [`grad`](#automatic-differentiation-with-grad) as well as forward-mode differentiation,
  and the two can be composed arbitrarily to any order.

  What’s new is that JAX uses [XLA](https://www.tensorflow.org/xla)
  to compile and run your NumPy programs on GPUs and TPUs. Compilation happens
  under the hood by default, with library calls getting just-in-time compiled and
  executed. But JAX also lets you just-in-time compile your own Python functions
  into XLA-optimized kernels using a one-function API,
  [`jit`](#compilation-with-jit). Compilation and automatic differentiation can be
  composed arbitrarily, so you can express sophisticated algorithms and get
  maximal performance without leaving Python. You can even program multiple GPUs
  or TPU cores at once using [`pmap`](#spmd-programming-with-pmap), and
  differentiate through the whole thing.

  Dig a little deeper, and you'll see that JAX is really an extensible system for
  [composable function transformations](#transformations). Both
  [`grad`](#automatic-differentiation-with-grad) and [`jit`](#compilation-with-jit)
  are instances of such transformations. Others are
  [`vmap`](#auto-vectorization-with-vmap) for automatic vectorization and
  [`pmap`](#spmd-programming-with-pmap) for single-program multiple-data (SPMD)
  parallel programming of multiple accelerators, with more to come.

  This is a research project, not an official Google product. Expect bugs and
  [sharp edges](https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html).
  Please help by trying it out, [reporting
  bugs](https://github.com/google/jax/issues), and letting us know what you
  think!

  ```python
  import jax.numpy as jnp
  from jax import grad, jit, vmap

  def predict(params, inputs):
    for W, b in params:
      outputs = jnp.dot(inputs, W) + b
      inputs = jnp.tanh(outputs)  # inputs to the next layer
    return outputs                # no activation on last layer

  def loss(params, inputs, targets):
    preds = predict(params, inputs)
    return jnp.sum((preds - targets)**2)

  grad_loss = jit(grad(loss))  # compiled gradient evaluation function
  perex_grads = jit(vmap(grad_loss, in_axes=(None, 0, 0)))  # fast per-example grads
  ```


  * [Quickstart: Colab in the Cloud](#quickstart-colab-in-the-cloud)
  * [Transformations](#transformations)
  * [Current gotchas](#current-gotchas)
  * [Installation](#installation)
  * [Neural net libraries](#neural-network-libraries)
  * [Citing JAX](#citing-jax)
  * [Reference documentation](#reference-documentation)


  Jump right in using a notebook in your browser, connected to a Google Cloud GPU.
  Here are some starter notebooks:
  - [The basics: NumPy on accelerators, `grad` for differentiation, `jit` for compilation, and `vmap` for vectorization](https://jax.readthedocs.io/en/latest/notebooks/quickstart.html)
  - [Training a Simple Neural Network, with TensorFlow Dataset Data Loading](https://colab.research.google.com/github/google/jax/blob/main/docs/notebooks/neural_network_with_tfds_data.ipynb)

  **JAX now runs on Cloud TPUs.** To try out the preview, see the [Cloud TPU
  Colabs](https://github.com/google/jax/tree/main/cloud_tpu_colabs).

  For a deeper dive into JAX:
  - [The Autodiff Cookbook, Part 1: easy and powerful automatic differentiation in JAX](https://jax.readthedocs.io/en/latest/notebooks/autodiff_cookbook.html)
  - [Common gotchas and sharp edges](https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html)
  - See the [full list of
  notebooks](https://github.com/google/jax/tree/main/docs/notebooks).

  You can also take a look at [the mini-libraries in
  `jax.example_libraries`](https://github.com/google/jax/tree/main/jax/example_libraries/README.md),
  like [`stax` for building neural
  networks](https://github.com/google/jax/tree/main/jax/example_libraries/README.md#neural-net-building-with-stax)
  and [`optimizers` for first-order stochastic
  optimization](https://github.com/google/jax/tree/main/jax/example_libraries/README.md#first-order-optimization),
  or the [examples](https://github.com/google/jax/tree/main/examples).



  At its core, JAX is an extensible system for transforming numerical functions.
  Here are four transformations of primary interest: `grad`, `jit`, `vmap`, and
  `pmap`.



  JAX has roughly the same API as [Autograd](https://github.com/hips/autograd).
  The most popular function is
  [`grad`](https://jax.readthedocs.io/en/latest/jax.html#jax.grad)
  for reverse-mode gradients:

  ```python
  from jax import grad
  import jax.numpy as jnp

  def tanh(x):  # Define a function
    y = jnp.exp(-2.0 * x)
    return (1.0 - y) / (1.0 + y)

  grad_tanh = grad(tanh)  # Obtain its gradient function
  print(grad_tanh(1.0))   # Evaluate it at x = 1.0

  ```

  You can differentiate to any order with `grad`.

  ```python
  print(grad(grad(grad(tanh)))(1.0))

  ```

  For more advanced autodiff, you can use
  [`jax.vjp`](https://jax.readthedocs.io/en/latest/jax.html#jax.vjp) for
  reverse-mode vector-Jacobian products and
  [`jax.jvp`](https://jax.readthedocs.io/en/latest/jax.html#jax.jvp) for
  forward-mode Jacobian-vector products. The two can be composed arbitrarily with
  one another, and with other JAX transformations. Here's one way to compose those
  to make a function that efficiently computes [full Hessian
  matrices](https://jax.readthedocs.io/en/latest/_autosummary/jax.hessian.html#jax.hessian):

  ```python
  from jax import jit, jacfwd, jacrev

  def hessian(fun):
    return jit(jacfwd(jacrev(fun)))
  ```

  As with [Autograd](https://github.com/hips/autograd), you're free to use
  differentiation with Python control structures:

  ```python
  def abs_val(x):
    if x > 0:
      return x
    else:
      return -x

  abs_val_grad = grad(abs_val)
  print(abs_val_grad(1.0))   # prints 1.0
  print(abs_val_grad(-1.0))  # prints -1.0 (abs_val is re-evaluated)
  ```

  See the [reference docs on automatic
  differentiation](https://jax.readthedocs.io/en/latest/jax.html#automatic-differentiation)
  and the [JAX Autodiff
  Cookbook](https://jax.readthedocs.io/en/latest/notebooks/autodiff_cookbook.html)
  for more.



  You can use XLA to compile your functions end-to-end with
  [`jit`](https://jax.readthedocs.io/en/latest/jax.html#just-in-time-compilation-jit),
  used either as an `@jit` decorator or as a higher-order function.

  ```python
  import jax.numpy as jnp
  from jax import jit

  def slow_f(x):
    
    return x * x + x * 2.0

  x = jnp.ones((5000, 5000))
  fast_f = jit(slow_f)
  %timeit -n10 -r3 fast_f(x)  # ~ 4.5 ms / loop on Titan X
  %timeit -n10 -r3 slow_f(x)  # ~ 14.5 ms / loop (also on GPU via JAX)
  ```

  You can mix `jit` and `grad` and any other JAX transformation however you like.

  Using `jit` puts constraints on the kind of Python control flow
  the function can use; see
  the [Gotchas
  Notebook](https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#python-control-flow-+-JIT)
  for more.



  [`vmap`](https://jax.readthedocs.io/en/latest/jax.html#vectorization-vmap) is
  the vectorizing map.
  It has the familiar semantics of mapping a function along array axes, but
  instead of keeping the loop on the outside, it pushes the loop down into a
  function’s primitive operations for better performance.

  Using `vmap` can save you from having to carry around batch dimensions in your
  code. For example, consider this simple *unbatched* neural network prediction
  function:

  ```python
  def predict(params, input_vec):
    assert input_vec.ndim == 1
    activations = input_vec
    for W, b in params:
      outputs = jnp.dot(W, activations) + b  # `activations` on the right-hand side!
      activations = jnp.tanh(outputs)        # inputs to the next layer
    return outputs                           # no activation on last layer
  ```

  We often instead write `jnp.dot(activations, W)` to allow for a batch dimension on the
  left side of `activations`, but we’ve written this particular prediction function to
  apply only to single input vectors. If we wanted to apply this function to a
  batch of inputs at once, semantically we could just write

  ```python
  from functools import partial
  predictions = jnp.stack(list(map(partial(predict, params), input_batch)))
  ```

  But pushing one example through the network at a time would be slow! It’s better
  to vectorize the computation, so that at every layer we’re doing matrix-matrix
  multiplication rather than matrix-vector multiplication.

  The `vmap` function does that transformation for us. That is, if we write

  ```python
  from jax import vmap
  predictions = vmap(partial(predict, params))(input_batch)

  predictions = vmap(predict, in_axes=(None, 0))(params, input_batch)
  ```

  then the `vmap` function will push the outer loop inside the function, and our
  machine will end up executing matrix-matrix multiplications exactly as if we’d
  done the batching by hand.

  It’s easy enough to manually batch a simple neural network without `vmap`, but
  in other cases manual vectorization can be impractical or impossible. Take the
  problem of efficiently computing per-example gradients: that is, for a fixed set
  of parameters, we want to compute the gradient of our loss function evaluated
  separately at each example in a batch. With `vmap`, it’s easy:

  ```python
  per_example_gradients = vmap(partial(grad(loss), params))(inputs, targets)
  ```

  Of course, `vmap` can be arbitrarily composed with `jit`, `grad`, and any other
  JAX transformation! We use `vmap` with both forward- and reverse-mode automatic
  differentiation for fast Jacobian and Hessian matrix calculations in
  `jax.jacfwd`, `jax.jacrev`, and `jax.hessian`.



  For parallel programming of multiple accelerators, like multiple GPUs, use
  [`pmap`](https://jax.readthedocs.io/en/latest/jax.html#parallelization-pmap).
  With `pmap` you write single-program multiple-data (SPMD) programs, including
  fast parallel collective communication operations. Applying `pmap` will mean
  that the function you write is compiled by XLA (similarly to `jit`), then
  replicated and executed in parallel across devices.

  Here's an example on an 8-GPU machine:

  ```python
  from jax import random, pmap
  import jax.numpy as jnp


  keys = random.split(random.PRNGKey(0), 8)
  mats = pmap(lambda key: random.normal(key, (5000, 6000)))(keys)


  result = pmap(lambda x: jnp.dot(x, x.T))(mats)  # result.shape is (8, 5000, 5000)


  print(pmap(jnp.mean)(result))

  ```

  In addition to expressing pure maps, you can use fast [collective communication
  operations](https://jax.readthedocs.io/en/latest/jax.lax.html#parallel-operators)
  between devices:

  ```python
  from functools import partial
  from jax import lax

  @partial(pmap, axis_name='i')
  def normalize(x):
    return x / lax.psum(x, 'i')

  print(normalize(jnp.arange(4.)))

  ```

  You can even [nest `pmap` functions](https://colab.research.google.com/github/google/jax/blob/main/cloud_tpu_colabs/Pmap_Cookbook.ipynb#scrollTo=MdRscR5MONuN) for more
  sophisticated communication patterns.

  It all composes, so you're free to differentiate through parallel computations:

  ```python
  from jax import grad

  @pmap
  def f(x):
    y = jnp.sin(x)
    @pmap
    def g(z):
      return jnp.cos(z) * jnp.tan(y.sum()) * jnp.tanh(x).sum()
    return grad(lambda w: jnp.sum(g(w)))(x)

  print(f(x))





  print(grad(lambda x: jnp.sum(f(x)))(x))




  ```

  When reverse-mode differentiating a `pmap` function (e.g. with `grad`), the
  backward pass of the computation is parallelized just like the forward pass.

  See the [SPMD
  Cookbook](https://colab.research.google.com/github/google/jax/blob/main/cloud_tpu_colabs/Pmap_Cookbook.ipynb)
  and the [SPMD MNIST classifier from scratch
  example](https://github.com/google/jax/blob/main/examples/spmd_mnist_classifier_fromscratch.py)
  for more.



  For a more thorough survey of current gotchas, with examples and explanations,
  we highly recommend reading the [Gotchas
  Notebook](https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html).
  Some standouts:

  1. JAX transformations only work on [pure functions](https://en.wikipedia.org/wiki/Pure_function), which don't have side-effects and respect [referential transparency](https://en.wikipedia.org/wiki/Referential_transparency) (i.e. object identity testing with `is` isn't preserved). If you use a JAX transformation on an impure Python function, you might see an error like `Exception: Can't lift Traced...`  or `Exception: Different traces at same level`.
  1. [In-place mutating updates of
     arrays](https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#in-place-updates), like `x[i] += y`, aren't supported, but [there are functional alternatives](https://jax.readthedocs.io/en/latest/jax.ops.html). Under a `jit`, those functional alternatives will reuse buffers in-place automatically.
  1. [Random numbers are
     different](https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#random-numbers), but for [good reasons](https://github.com/google/jax/blob/main/docs/jep/263-prng.md).
  1. If you're looking for [convolution
     operators](https://jax.readthedocs.io/en/latest/notebooks/convolutions.html),
     they're in the `jax.lax` package.
  1. JAX enforces single-precision (32-bit, e.g. `float32`) values by default, and
     [to enable
     double-precision](https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#double-64bit-precision)
     (64-bit, e.g. `float64`) one needs to set the `jax_enable_x64` variable at
     startup (or set the environment variable `JAX_ENABLE_X64=True`).
     On TPU, JAX uses 32-bit values by default for everything _except_ internal
     temporary variables in 'matmul-like' operations, such as `jax.numpy.dot` and `lax.conv`.
     Those ops have a `precision` parameter which can be used to simulate
     true 32-bit, with a cost of possibly slower runtime.
  1. Some of NumPy's dtype promotion semantics involving a mix of Python scalars
     and NumPy types aren't preserved, namely `np.add(1, np.array([2],
     np.float32)).dtype` is `float64` rather than `float32`.
  1. Some transformations, like `jit`, [constrain how you can use Python control
     flow](https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#control-flow).
     You'll always get loud errors if something goes wrong. You might have to use
     [`jit`'s `static_argnums`
     parameter](https://jax.readthedocs.io/en/latest/jax.html#just-in-time-compilation-jit),
     [structured control flow
     primitives](https://jax.readthedocs.io/en/latest/jax.lax.html#control-flow-operators)
     like
     [`lax.scan`](https://jax.readthedocs.io/en/latest/_autosummary/jax.lax.scan.html#jax.lax.scan),
     or just use `jit` on smaller subfunctions.



  JAX is written in pure Python, but it depends on XLA, which needs to be
  installed as the `jaxlib` package. Use the following instructions to install a
  binary package with `pip` or `conda`, or to [build JAX from
  source](https://jax.readthedocs.io/en/latest/developer.html#building-from-source).

  We support installing or building `jaxlib` on Linux (Ubuntu 16.04 or later) and
  macOS (10.12 or later) platforms.

  Windows users can use JAX on CPU and GPU via the [Windows Subsystem for
  Linux](https://docs.microsoft.com/en-us/windows/wsl/about). In addition, there
  is some initial community-driven native Windows support, but since it is still
  somewhat immature, there are no official binary releases and it must be [built
  from source for Windows](https://jax.readthedocs.io/en/latest/developer.html#additional-notes-for-building-jaxlib-from-source-on-windows).
  For an unofficial discussion of native Windows builds, see also the [Issue #5795
  thread](https://github.com/google/jax/issues/5795).



  To install a CPU-only version of JAX, which might be useful for doing local
  development on a laptop, you can run

  ```bash
  pip install --upgrade pip
  pip install --upgrade "jax[cpu]"
  ```

  On Linux, it is often necessary to first update `pip` to a version that supports
  `manylinux2014` wheels. Also note that for Linux, we currently release wheels for `x86_64` architectures only, other architectures require building from source. Trying to pip install with other Linux architectures may lead to `jaxlib` not being installed alongside `jax`, although `jax` may successfully install (but fail at runtime).
  **These `pip` installations do not work with Windows, and may fail silently; see
  [above](#installation).**



  There are two ways to install JAX with NVIDIA GPU support: using CUDA and CUDNN
  installed from pip wheels, and using a self-installed CUDA/CUDNN. We recommend
  installing CUDA and CUDNN using the pip wheels, since it is much easier!

  You must first install the NVIDIA driver. We
  recommend installing the newest driver available from NVIDIA, but the driver
  must be version >= 525.60.13 for CUDA 12 and >= 450.80.02 for CUDA 11 on Linux.

  ```bash
  pip install --upgrade pip



  pip install --upgrade "jax[cuda12_pip]" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html



  pip install --upgrade "jax[cuda11_pip]" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
  ```



  If you prefer to use a preinstalled copy of CUDA, you must first
  install [CUDA](https://developer.nvidia.com/cuda-downloads) and
  [CuDNN](https://developer.nvidia.com/CUDNN).

  JAX provides pre-built CUDA-compatible wheels for **Linux x86_64 only**. Other
  combinations of operating system and architecture are possible, but require
  [building from source](https://jax.readthedocs.io/en/latest/developer.html#building-from-source).

  You should use an NVIDIA driver version that is at least as new as your
  [CUDA toolkit's corresponding driver version](https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#cuda-major-component-versions__table-cuda-toolkit-driver-versions).
  If you need to use an newer CUDA toolkit with an older driver, for example
  on a cluster where you cannot update the NVIDIA driver easily, you may be
  able to use the
  [CUDA forward compatibility packages](https://docs.nvidia.com/deploy/cuda-compatibility/)
  that NVIDIA provides for this purpose.

  JAX currently ships three CUDA wheel variants:
  * CUDA 12.0 and CuDNN 8.8.
  * CUDA 11.8 and CuDNN 8.6.
  * CUDA 11.4 and CuDNN 8.2. This wheel is deprecated and will be discontinued
    with jax 0.4.8.

  You may use a JAX wheel provided the major version of your CUDA and CuDNN
  installation matches, and the minor version is at least as new as the version
  JAX expects. For example, you would be able to use the CUDA 12.0 wheel with
  CUDA 12.1 and CuDNN 8.9.

  Your CUDA installation must also be new enough to support your GPU. If you have
  an Ada Lovelace (e.g., RTX 4080) or Hopper (e.g., H100) GPU,
  you must use CUDA 11.8 or newer.


  To install, run

  ```bash
  pip install --upgrade pip



  pip install --upgrade "jax[cuda12_local]" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html



  pip install --upgrade "jax[cuda11_local]" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html


  pip install "jax[cuda11_cudnn82]" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
  ```

  **These `pip` installations do not work with Windows, and may fail silently; see
  [above](#installation).**

  You can find your CUDA version with the command:

  ```bash
  nvcc --version
  ```

  Some GPU functionality expects the CUDA installation to be at
  `/usr/local/cuda-X.X`, where X.X should be replaced with the CUDA version number
  (e.g. `cuda-11.8`). If CUDA is installed elsewhere on your system, you can either
  create a symlink:

  ```bash
  sudo ln -s /path/to/cuda /usr/local/cuda-X.X
  ```

  Please let us know on [the issue tracker](https://github.com/google/jax/issues)
  if you run into any errors or problems with the prebuilt wheels.


  JAX also provides pre-built wheels for
  [Google Cloud TPU](https://cloud.google.com/tpu/docs/users-guide-tpu-vm).
  To install JAX along with appropriate versions of `jaxlib` and `libtpu`, you can run
  the following in your cloud TPU VM:
  ```bash
  pip install jax[tpu] -f https://storage.googleapis.com/jax-releases/libtpu_releases.html
  ```


  Colab TPU runtimes use an older TPU architecture than Cloud TPU VMs, so the installation instructions differ.
  The Colab TPU runtime comes with JAX pre-installed, but before importing JAX you must run the following code to initialize the TPU:
  ```python
  import jax.tools.colab_tpu
  jax.tools.colab_tpu.setup_tpu()
  ```
  Note that Colab TPU runtimes are not compatible with JAX version 0.4.0 or newer.
  If you need to re-install JAX on a Colab TPU runtime, you can use the following command:
  ```
  !pip install jax<=0.3.25 jaxlib<=0.3.25
  ```



  There is a community-supported Conda build of `jax`. To install using `conda`,
  simply run

  ```bash
  conda install jax -c conda-forge
  ```

  To install on a machine with an NVIDIA GPU, run
  ```bash
  conda install jaxlib=*=*cuda* jax cuda-nvcc -c conda-forge -c nvidia
  ```

  Note the `cudatoolkit` distributed by `conda-forge` is missing `ptxas`, which
  JAX requires. You must therefore either install the `cuda-nvcc` package from
  the `nvidia` channel, or install CUDA on your machine separately so that `ptxas`
  is in your path. The channel order above is important (`conda-forge` before
  `nvidia`).

  If you would like to override which release of CUDA is used by JAX, or to
  install the CUDA build on a machine without GPUs, follow the instructions in the
  [Tips & tricks](https://conda-forge.org/docs/user/tipsandtricks.html#installing-cuda-enabled-packages-like-tensorflow-and-pytorch)
  section of the `conda-forge` website.

  See the `conda-forge`
  [jaxlib](https://github.com/conda-forge/jaxlib-feedstock#installing-jaxlib) and
  [jax](https://github.com/conda-forge/jax-feedstock#installing-jax) repositories
  for more details.


  See [Building JAX from
  source](https://jax.readthedocs.io/en/latest/developer.html#building-from-source).



  Multiple Google research groups develop and share libraries for training neural
  networks in JAX. If you want a fully featured library for neural network
  training with examples and how-to guides, try
  [Flax](https://github.com/google/flax).

  In addition, DeepMind has open-sourced an [ecosystem of libraries around
  JAX](https://deepmind.com/blog/article/using-jax-to-accelerate-our-research)
  including [Haiku](https://github.com/deepmind/dm-haiku) for neural network
  modules, [Optax](https://github.com/deepmind/optax) for gradient processing and
  optimization, [RLax](https://github.com/deepmind/rlax) for RL algorithms, and
  [chex](https://github.com/deepmind/chex) for reliable code and testing. (Watch
  the NeurIPS 2020 JAX Ecosystem at DeepMind talk
  [here](https://www.youtube.com/watch?v=iDxJxIyzSiM))



  To cite this repository:

  ```
  @software{jax2018github,
    author = {James Bradbury and Roy Frostig and Peter Hawkins and Matthew James Johnson and Chris Leary and Dougal Maclaurin and George Necula and Adam Paszke and Jake Vander{P}las and Skye Wanderman-{M}ilne and Qiao Zhang},
    title = {{JAX}: composable transformations of {P}ython+{N}um{P}y programs},
    url = {http://github.com/google/jax},
    version = {0.3.13},
    year = {2018},
  }
  ```

  In the above bibtex entry, names are in alphabetical order, the version number
  is intended to be that from [jax/version.py](../main/jax/version.py), and
  the year corresponds to the project's open-source release.

  A nascent version of JAX, supporting only automatic differentiation and
  compilation to XLA, was described in a [paper that appeared at SysML
  2018](https://mlsys.org/Conferences/2019/doc/2018/146.pdf). We're currently working on
  covering JAX's ideas and capabilities in a more comprehensive and up-to-date
  paper.



  For details about the JAX API, see the
  [reference documentation](https://jax.readthedocs.io/).

  For getting started as a JAX developer, see the
  [developer documentation](https://jax.readthedocs.io/en/latest/developer.html).


pkgId: 0332bbcc11174809864e8d69e83ad53ba7aadca94dbb4176d1c7c7698fb7e4f8
name: python-jcconv
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: jcconv "JapaneseCharacterCONVerter", interconvert hiragana, katakana, halfwidth kana
url: http://github.com/taichino/jcconv
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-22fa392d-c8dc-4eb7-aaef-25c10264ff90
location_href: 00003953-python-jcconv/python-jcconv-0.2.3-1.src.rpm
checksum_type: sha256
description:
  jcconv, Japanese Characters CONVerter, interconvert hiragana, katakana, half-width kana.
     This module also treat 'half/wide number', 'half/wide alphabet'.

     Since 0.2.0, check_hira, check_kata, check_half functions were added.
     you can check if string consists of characters you specified.

     IMPOTANT: In current version, this works only with utf-8 encoding.


     Simple example of usage is followings

         >>> from jcconv import *
         >>> print hira2kata('あいうえお')   # hiragana to katakana
         アイウエオ
         >>> print kata2hira('カタカナ')     # katakana to hiragana
         かたかな
         >>> print half2hira('ﾊﾝｶｸｶﾀｶﾅ')      # half-width kana to hiragana
         はんかくかたかな
         >>> print half2wide('hello jcconv') # half-width alphabet to wide-width
         ｈｅｌｌｏ ｊｃｃｏｎｖ
         >>> print wide2half('ＷＩＤＥ')     # wide-width alphabet to half-width
         wide


pkgId: 2d2451fa1c1406e5e68b60cce30d9db71f58a8bd529ca22e04d588c9a864c102
name: python-jdcal
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: Julian dates from proleptic Gregorian and Julian calendars.
url: https://github.com/phn/jdcal
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-afb7d109-fd6f-431b-b785-4fe41748fb7c
location_href: 00003954-python-jdcal/python-jdcal-1.4.1-1.src.rpm
checksum_type: sha256
description:
  This module contains functions for converting between Julian dates and
  calendar dates.
  A function for converting Gregorian calendar dates to Julian dates, and
  another function for converting Julian calendar dates to Julian dates
  are defined. Two functions for the reverse calculations are also
  defined.
  Different regions of the world switched to Gregorian calendar from
  Julian calendar on different dates. Having separate functions for Julian
  and Gregorian calendars allow maximum flexibility in choosing the
  relevant calendar.
  Julian dates are stored in two floating point numbers (double).  Julian
  dates, and Modified Julian dates, are large numbers. If only one number
  is used, then the precision of the time stored is limited. Using two
  numbers, time can be split in a manner that will allow maximum
  precision. For example, the first number could be the Julian date for
  the beginning of a day and the second number could be the fractional
  day. Calculations that need the latter part can now work with maximum
  precision.
  All the above functions are "proleptic". This means that they work for
  dates on which the concerned calendar is not valid. For example,
  Gregorian calendar was not used prior to around October 1582.
  A function to test if a given Gregorian calendar year is a leap year is
  also defined.
  Zero point of Modified Julian Date (MJD) and the MJD of 2000/1/1
  12:00:00 are also given as module level constants.


pkgId: 539d96c6b71f81757084253f24e890612aeec661a4bf048cc6b0587b92a04134
name: python-jedi
arch: src
version: 0.18.2
epoch: 0
release: 1
summary: An autocompletion tool for Python that can be used for text editors.
url: https://github.com/davidhalter/jedi
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c10852db-b9bc-45ea-906e-f39e692c6af3
location_href: 00003955-python-jedi/python-jedi-0.18.2-1.src.rpm
checksum_type: sha256
description:
  You can file issues and questions in the `issue tracker
  <https://github.com/davidhalter/jedi/>`. Alternatively you can also ask on
  `Stack Overflow <https://stackoverflow.com/questions/tagged/python-jedi>`_ with
  the label ``python-jedi``.


pkgId: 9b67b8466e0a25ce3e5d6049c2862666ea4b531c01d17e32d5fb20fc6331e299
name: python-jellyfish
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: a library for doing approximate and phonetic matching of strings.
url: http://github.com/jamesturk/jellyfish
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-559cd875-53f3-4b44-bd18-6426186e9a0c
location_href: 00003957-python-jellyfish/python-jellyfish-0.9.0-1.src.rpm
checksum_type: sha256
description:
  **jellyfish** is a library for approximate & phonetic matching of strings.

  Source: [https://github.com/jamesturk/jellyfish](https://github.com/jamesturk/jellyfish)

  Documentation: [https://jamesturk.github.io/jellyfish/](https://jamesturk.github.io/jellyfish/)

  Issues: [https://github.com/jamesturk/jellyfish/issues](https://github.com/jamesturk/jellyfish/issues)

  [![PyPI badge](https://badge.fury.io/py/jellyfish.svg)](https://badge.fury.io/py/jellyfish)
  [![Test badge](https://github.com/jamesturk/jellyfish/workflows/Python%20package/badge.svg)](https://github.com/jamesturk/jellyfish/actions?query=workflow%3A%22Python+package)
  [![Coveralls](https://coveralls.io/repos/jamesturk/jellyfish/badge.png?branch=master)](https://coveralls.io/r/jamesturk/jellyfish)




  String comparison:

  * Levenshtein Distance
  * Damerau-Levenshtein Distance
  * Jaro Distance
  * Jaro-Winkler Distance
  * Match Rating Approach Comparison
  * Hamming Distance

  Phonetic encoding:

  * American Soundex
  * Metaphone
  * NYSIIS (New York State Identification and Intelligence System)
  * Match Rating Codex



  ``` python
  >>> import jellyfish
  >>> jellyfish.levenshtein_distance(u'jellyfish', u'smellyfish')
  2
  >>> jellyfish.jaro_distance(u'jellyfish', u'smellyfish')
  0.89629629629629637
  >>> jellyfish.damerau_levenshtein_distance(u'jellyfish', u'jellyfihs')
  1

  >>> jellyfish.metaphone(u'Jellyfish')
  'JLFX'
  >>> jellyfish.soundex(u'Jellyfish')
  'J412'
  >>> jellyfish.nysiis(u'Jellyfish')
  'JALYF'
  >>> jellyfish.match_rating_codex(u'Jellyfish')
  'JLLFSH'
  ```


pkgId: 1edc24215859c03e2514917af6b259b6cfad87ca1f841bfee39131f8e0139f6a
name: python-jellyfish-debuginfo
arch: aarch64
version: 0.9.0
epoch: 0
release: 1
summary: Debug information for package python-jellyfish
url: http://github.com/jamesturk/jellyfish
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-559cd875-53f3-4b44-bd18-6426186e9a0c
rpm_sourcerpm: python-jellyfish-0.9.0-1.src.rpm
location_href: 00003957-python-jellyfish/python-jellyfish-debuginfo-0.9.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-jellyfish.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: efd288252488b040226f36e25d26857a49e3c8ce701b7e16c2e6113762e2183d
name: python-jellyfish-debugsource
arch: aarch64
version: 0.9.0
epoch: 0
release: 1
summary: Debug sources for package python-jellyfish
url: http://github.com/jamesturk/jellyfish
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-559cd875-53f3-4b44-bd18-6426186e9a0c
rpm_sourcerpm: python-jellyfish-0.9.0-1.src.rpm
location_href: 00003957-python-jellyfish/python-jellyfish-debugsource-0.9.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-jellyfish.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 3a8fdae41ec1cccd704bbfc40f0e06154b5517048c9d1c08ce57744e52384d94
name: python-jenkins-job-builder
arch: src
version: 4.3.0
epoch: 0
release: 1
summary: Manage Jenkins jobs with YAML
url: https://jenkins-job-builder.readthedocs.io/en/latest/
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0fecee6c-06fc-49db-a709-2bc57a219bad
location_href: 00003959-python-jenkins-job-builder/python-jenkins-job-builder-4.3.0-1.src.rpm
checksum_type: sha256
description:
  Jenkins Job Builder takes simple descriptions of Jenkins_ jobs in YAML_ or JSON_
  format and uses them to configure Jenkins. You can keep your job descriptions in
  human readable text format in a version control system to make changes and
  auditing easier. It also has a flexible template system, so creating many
  similarly configured jobs is easy.
  To install::
      $ pip install --user jenkins-job-builder
  Online documentation:
  * https://jenkins-job-builder.readthedocs.io/en/latest/


pkgId: 63c07e3217132148629c8400e643bd40a36dc1a582d464da5c6759da53b5cc49
name: python-jep
arch: src
version: 4.1.1
epoch: 0
release: 1
summary: Jep embeds CPython in Java
url: https://github.com/ninia/jep
rpm_license: zlib/libpng
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fe4365f1-bd9b-48f7-8fc1-e1a6c31539cb
location_href: 00003960-python-jep/python-jep-4.1.1-1.src.rpm
checksum_type: sha256
description:
  Jep embeds CPython in Java through JNI.
  Some benefits of embedding CPython in a JVM:
  * Using the native Python interpreter may be much faster than
    alternatives.
  * Python is mature, well supported, and well documented.
  * Access to high quality Python modules, both native CPython
    extensions and Python-based.
  * Compilers and assorted Python tools are as mature as the language.
  * Python is an interpreted language, enabling scripting of established
    Java code without requiring recompilation.
  * Both Java and Python are cross platform, enabling deployment to
    different operating systems.


pkgId: d05bd28f848f4168381602d4b89f6b795de03cf173d18a85d4d0981efe3492d4
name: python-jieba
arch: src
version: 0.42.1
epoch: 0
release: 1
summary: Chinese Words Segmentation Utilities
url: https://github.com/fxsjy/jieba
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d8850325-7a51-4d76-b2c5-cfa8efdd023c
location_href: 00010005-python-jieba/python-jieba-0.42.1-1.src.rpm
checksum_type: sha256
description:
  “结巴”中文分词：做最好的 Python 中文分词组件
  "Jieba" (Chinese for "to stutter") Chinese text segmentation: built to
  be the best Python Chinese word segmentation module.
  完整文档见 ``README.md``
  GitHub: https://github.com/fxsjy/jieba


pkgId: 20170fb7d788cc4275d3a4acd1f0c35f685d64a54b5044f26b63cc4927e6dc08
name: python-jikanpy
arch: src
version: 4.3.2
epoch: 0
release: 1
summary: Python wrapper for the Jikan API
url: https://github.com/abhinavk99/jikanpy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fba47e51-d76e-4d49-a1ae-9bf38def46e3
location_href: 00009524-python-jikanpy/python-jikanpy-4.3.2-1.src.rpm
checksum_type: sha256
description:
  [![Travis (.com)](https://img.shields.io/travis/com/abhinavk99/jikanpy?style=flat-square)](https://travis-ci.com/abhinavk99/jikanpy)
  [![Codecov](https://img.shields.io/codecov/c/github/abhinavk99/jikanpy.svg?style=flat-square)](https://codecov.io/gh/abhinavk99/jikanpy/)
  [![pypi Version](https://img.shields.io/pypi/v/jikanpy.svg?style=flat-square)](https://pypi.org/project/jikanpy/)
  [![PyPi downloads](https://img.shields.io/pypi/dm/jikanpy?style=flat-square)](https://pypi.org/project/jikanpy/)
  [![Documentation](https://readthedocs.org/projects/jikanpy/badge/?version=latest&style=flat-square)](https://jikanpy.readthedocs.io/en/latest/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg?style=flat-square)](https://github.com/ambv/black)
  [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)

  JikanPy is a Python wrapper for [Jikan](https://github.com/jikan-me/jikan),
  providing bindings for all API functionality, and supports Python 3.6+. Because
  it is intended to be pretty much identical, please consult [Jikan's
  documentation](https://jikan.docs.apiary.io/#) for thornier details on how it is
  meant to be used. Perhaps most importantly, JikanPy does not make any attempts
  to rate limit itself, so use it as responsibly as you would use the API
  primitively and remember that Jikan API has limitations, check out
  [this section](https://jikan.docs.apiary.io/#introduction/information/rate-limiting)
  of documentation in order to see to what extent the API is limited or throttled.

  You can use either Jikan or AioJikan depending on whether you want a synchronous
  wrapper class or an asynchronous wrapper class respectively. More usage examples
  are below.

  In addition to the typical response from the Jikan API, each response contains
  two additional fields:

  - `jikan_url`: The URL that was requested; for example: `https://api.jikan.moe/v3/anime/1`.
  - `headers`: The response headers from Jikan, detailed [here](https://jikan.docs.apiary.io/#introduction/information/caching).



  ```shell
  $ pip install jikanpy
  ```



  Below are some basic examples of how to use Jikan and AioJikan. Please read the
  [documentation below](https://github.com/abhinavk99/jikanpy#documentation) to see all the methods and more examples.



  ```python
  from jikanpy import Jikan
  jikan = Jikan()

  mushishi = jikan.anime(457)
  mushishi_with_eps = jikan.anime(457, extension='episodes')

  search_result = jikan.search('anime', 'Mushishi', page=2)

  winter_2018_anime = jikan.season(year=2018, season='winter')

  archive = jikan.season_archive()
  ```



  ```python
  import asyncio
  from jikanpy import AioJikan

  async def main():
      async with AioJikan() as aio_jikan:
          mushishi = await aio_jikan.anime(457)
          fma = await aio_jikan.manga(25)
          ginko = await aio_jikan.character(425)
          kana_hanazawa = await aio_jikan.person(185)
          naruto = await aio_jikan.search(search_type='anime', query='naruto')

      
      aio_jikan_2 = AioJikan()
      mushishi = await aio_jikan.anime(457)
      await aio_jikan_2.close()

  asyncio.run(main())
  ```



  Check out the documentation [here](https://jikanpy.readthedocs.io).



  If you're running an instance of [jikan-rest](https://github.com/jikan-me/jikan-rest)
  on your system, and want to use that instead of [api.jikan.moe](https://jikan.moe/),
  you can pass that to Jikan:

  ```python
  from jikanpy import Jikan
  jikan = Jikan(selected_base='http://localhost:8000/v3')
  ```

  If you want to use your own Requests session, you can do that too.

  ```python
  import requests
  from jikanpy import Jikan

  session = requests.Session()

  session.headers.update({'x-test': 'true'})

  jikan = Jikan(session=session)
  ```

  You can use any or all of these constructor arguments when creating an instance
  of Jikan.

  AioJikan also has `selected_base` and `session` (although AioJikan uses AioHTTP
  session, not Requests).

  ```python
  import aiohttp
  import asyncio

  from jikanpy import AioJikan

  async def main():
      
      session = aiohttp.ClientSession(headers={'x-test': 'true'})
      aio_jikan = AioJikan(selected_base='http://localhost:8000/v3', session=session)
      await session.close()

  asyncio.run(main())
  ```



  ```shell

  $ pytest
  ```






  - Don't include the CHANGELOG.md as a `data_file`, just read it while building releases. Previously this could cause CHANGELOG.md to be installed into the users data dir (`/usr/` or `~/.local/` depending on how its installed). See [#90](https://github.com/abhinavk99/jikanpy/issues/90)





  - Updated aiohttp to 3.7.4





  - Calling season method with no arguments defaults to current season





  - Bug where downloading jikanpy from the distribution would fail because CHANGELOG.md wasn't included and setup.py uses it





  - Bug where simplejson wasn't being installed as a dependency





  - Revamped how APIException works so it displays more information whether or not the HTTP response is JSON



  - Some refactoring to fix typing and linting errors from mypy, flake8, and pylint
  - Updated some unit tests and commented out ones that don't work because of Jikan 503 errors



  - Bug where jikanpy would crash when the JSON response can't be decoded with the simplejson JSON parser
  - Bug where jikanpy would crash when the JSON response is a list instead of a dict





  - Bug where selected_base wasn't being used
  - Bug where trailing slash or whitespace in selected_base argument wouldn't work





  - Documentation at https://jikanpy.readthedocs.io
  - AioJikan can be constructed using 'async with' technique
  - Optional page argument to club method



  - AbstractJikan rewritten as utility methods
  - Docstrings rewritten to follow Google style guide
  - Updated all requirements to current versions



  - Removed checking arguments and throwing ClientException from invalid arguments
  - Removed ClientException because it isn't being raised anymore
  - Removed use_ssl argument so only HTTPS Jikan URL is available
  - Removed loop argument for AioJikan
  - Unnecessary type hints for variable instantiations



  - Lazy construct aiohttp session in AioJikan to stop DeprecationWarning
  - Issue where page couldn't be added to user method URL when argument not passed in





  - Added extension forum/episodes for anime endpoint





  - Added MIT license to Jikanpy





  - Added Jikanpy to PyPI





  - Ability to pass in own Requests session to Jikan in constructor



  - Made type hints for session and loop in constructors more accurate





  - Jikan URL and response headers to Jikanpy response



  - Error handling when type or period argument is None for meta method
  - Bug in which letter argument for search method didn't allow the character .





  - This changelog





  - Bug when passing in genre_exclude as boolean





  - selected_base constructor arg to aio_jikan



  - search and user methods to adhere with REST 3.3





  - Bug where search method didn't check genre parameter correctly





  - Bug where check_response didn't handle when there was no error in the response json





  - Type hints (only works in Python 3.6+)
  - Options `other` and `unknown` for the parameter `day` in schedule method
  - Errors thrown when `status` request is called with arguments in meta method
  - `page` parameter to manga endpoint



  - No more support for Python versions before 3.6



  - Bug where parameters weren't being added to search url correctly
  - Argument checks for user method
  - meta not implemented test





  - Tests to reach 100% coverage



  - Abstract methods raise `NotImplementedError`





  - Option to provide base url to Jikanpy to use for endpoint



  - README examples for user method





  - Codecov integration
  - Error if top method if subtype is provided without page
  - async/await examples in examples.py





  - Tests and examples for person method





  - club and season later methods (for REST v3.2)
  - reviews, recommendations, and user updates extensions (for REST v3.2)



  - Bug where page wasn't added to url correctly for extension `episodes`





  - Travis integration
  - Support for multiple query parameters in search method



  - No more support for Python versions before 3.5





  - Subtypes checking for top endpoint





  - Bug when adding query parameter to url before converting it to a string in search method





  - Checking key and value in search method





  - animelist and mangalist support in user endpoint (REST v3.1)
  - search archive method (REST v3.1)





  - genre, producer, magazine, and user methods (REST v3)



  - Base endpoint url to `api.jikan.moe/v3`





  - Bug where page was added to url before converting it to a string





  - semver for versioning
  - setup.py





  - AioJikan async wrapper for Jikan





  - season, schedule, top, and meta methods (REST v2.2)



  - Generalized error checking





  - page support to anime, manga, character, and person methods (REST v2.2)
  - query parameter to search method (REST v2.2)





  - search method (REST v2.1)
  - examples.py for example usage



  - Base endpoint url to `api.jikan.moe`
  - Extensions for anime, manga, character, and person methods (REST v2.1)
  - Limit warning in docstring to the new limit, 5000
  - Link to Jikan docs in README



  - user list method





  - DeprecationWarning to DeprecatedEndpoint



  - ID typos in README usage





  - character, person, and user list methods
  - Tests for anime and manga methods
  - DeprecationWarning exception
  - Usage info in README





  - Initial version with anime and manga methods and exceptions


pkgId: 5a379a2fc1a2f7975dcd9387e5e2ed9e203baafb2501bfdb8c89a51b81cbc4fd
name: python-jina
arch: src
version: 3.14.1
epoch: 0
release: 1
summary: Build multimodal AI services via cloud native technologies · Neural Search · Generative AI · MLOps
url: https://github.com/jina-ai/jina/
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-53800f7d-66a3-4356-9364-b5ba3e797985
location_href: 00012459-python-jina/python-jina-3.14.1-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
  <a href="https://docs.jina.ai"><img src="https://github.com/jina-ai/jina/blob/master/.github/readme/streamline-banner.png?raw=true" alt="Jina: Streamline AI & ML Product Delivery" width="100%"></a>
  </p>

  <!-- start build-ai-services -->
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/jina-ai/jina/blob/master/.github/getting-started/notebook.ipynb)
  Let's build a fast, reliable and scalable gRPC-based AI service. In Jina we call this an **[Executor](https://docs.jina.ai/concepts/executor/)**. Our simple Executor will use Facebook's mBART-50 model to translate French to English. We'll then use a **Deployment** to serve it.
  > **Note**
  > A Deployment serves just one Executor. To combine multiple Executors into a pipeline and serve that, use a [Flow](#build-a-pipeline).
  > **Note**
  > Run the [code in Colab](https://colab.research.google.com/assets/colab-badge.svg) to install all dependencies.
  Let's implement the service's logic:
  <table>
  <tr>
  <th><code>translate_executor.py</code> </th>
  <tr>
  <td>
  ```python
  from docarray import DocumentArray
  from jina import Executor, requests
  from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
  class Translator(Executor):
      def __init__(self, **kwargs):
          super().__init__(**kwargs)
          self.tokenizer = AutoTokenizer.from_pretrained(
              "facebook/mbart-large-50-many-to-many-mmt", src_lang="fr_XX"
          )
          self.model = AutoModelForSeq2SeqLM.from_pretrained(
              "facebook/mbart-large-50-many-to-many-mmt"
          )
      @requests
      def translate(self, docs: DocumentArray, **kwargs):
          for doc in docs:
              doc.text = self._translate(doc.text)
      def _translate(self, text):
          encoded_en = self.tokenizer(text, return_tensors="pt")
          generated_tokens = self.model.generate(
              **encoded_en, forced_bos_token_id=self.tokenizer.lang_code_to_id["en_XX"]
          )
          return self.tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[
              0
          ]
  ```
  </td>
  </tr>
  </table>
  Then we deploy it with either the Python API or YAML:
  <div class="table-wrapper">
  <table>
  <tr>
  <th> Python API: <code>deployment.py</code> </th>
  <th> YAML: <code>deployment.yml</code> </th>
  </tr>
  <tr>
  <td>
  ```python
  from jina import Deployment
  with Deployment(uses=Translator, timeout_ready=-1) as dep:
      dep.block()
  ```
  </td>
  <td>
  ```yaml
  jtype: Deployment
  with:
    uses: Translator
    py_modules:
      - translate_executor.py # name of the module containing Translator
    timeout_ready: -1
  ```
  And run the YAML Deployment with the CLI: `jina deployment --uses deployment.yml`
  </td>
  </tr>
  </table>
  </div>
  ```text
  ──────────────────────────────────────── 🎉 Deployment is ready to serve! ─────────────────────────────────────────
  ╭────────────── 🔗 Endpoint ───────────────╮
  │  ⛓      Protocol                   GRPC │
  │  🏠        Local          0.0.0.0:12345  │
  │  🔒      Private      172.28.0.12:12345  │
  │  🌍       Public    35.230.97.208:12345  │
  ╰──────────────────────────────────────────╯
  ```
  Use [Jina Client](https://docs.jina.ai/concepts/client/) to make requests to the service:
  ```python
  from docarray import Document
  from jina import Client
  french_text = Document(
      text='un astronaut est en train de faire une promenade dans un parc'
  )
  client = Client(port=12345)  # use port from output above
  response = client.post(on='/', inputs=[french_text])
  print(response[0].text)
  ```
  ```text
  an astronaut is walking in a park
  ```
  <!-- end build-ai-services -->

  <!-- start build-pipelines -->
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/jina-ai/jina/blob/docs-readme-changes/.github/getting-started/notebook.ipynb)
  Sometimes you want to chain microservices together into a pipeline. That's where a [Flow](https://docs.jina.ai/concepts/flow/) comes in.
  A Flow is a [DAG](https://de.wikipedia.org/wiki/DAG) pipeline, composed of a set of steps, It orchestrates a set of [Executors](https://docs.jina.ai/concepts/executor/) and a [Gateway](https://docs.jina.ai/concepts/gateway/) to offer an end-to-end service.
  > **Note**
  > If you just want to serve a single Executor, you can use a [Deployment](#build-ai--ml-services).
  For instance, let's combine [our French translation service](#build-ai--ml-services) with a Stable Diffusion image generation service from Jina AI's [Executor Hub](https://cloud.jina.ai/executors). Chaining these services together into a [Flow](https://docs.jina.ai/concepts/flow/) will give us a multilingual image generation service.
  Build the Flow with either Python or YAML:
  <div class="table-wrapper">
  <table>
  <tr>
  <th> Python API: <code>flow.py</code> </th>
  <th> YAML: <code>flow.yml</code> </th>
  </tr>
  <tr>
  <td>
  ```python
  from jina import Flow
  flow = (
      Flow()
      .add(uses=Translator, timeout_ready=-1)
      .add(
          uses='jinaai://jina-ai/TextToImage',
          timeout_ready=-1,
          install_requirements=True,
      )
  )  # use the Executor from Executor hub
  with flow:
      flow.block()
  ```
  </td>
  <td>
  ```yaml
  jtype: Flow
  executors:
    - uses: Translator
      timeout_ready: -1
      py_modules:
        - translate_executor.py
    - uses: jinaai://jina-ai/TextToImage
      timeout_ready: -1
      install_requirements: true
  ```
  Then run the YAML Flow with the CLI: `jina flow --uses flow.yml`
  </td>
  </tr>
  </table>
  </div>
  ```text
  ─────────────────────────────────────────── 🎉 Flow is ready to serve! ────────────────────────────────────────────
  ╭────────────── 🔗 Endpoint ───────────────╮
  │  ⛓      Protocol                   GRPC  │
  │  🏠        Local          0.0.0.0:12345  │
  │  🔒      Private      172.28.0.12:12345  │
  │  🌍       Public    35.240.201.66:12345  │
  ╰──────────────────────────────────────────╯
  ```
  Then, use [Jina Client](https://docs.jina.ai/concepts/client/) to make requests to the Flow:
  ```python
  from jina import Client, Document
  client = Client(port=12345)  # use port from output above
  french_text = Document(
      text='un astronaut est en train de faire une promenade dans un parc'
  )
  response = client.post(on='/', inputs=[french_text])
  response[0].display()
  ```
  ![stable-diffusion-output.png](https://raw.githubusercontent.com/jina-ai/jina/master/.github/stable-diffusion-output.png)
  You can also deploy a Flow to JCloud.
  First, turn the `flow.yml` file into a [JCloud-compatible YAML](https://docs.jina.ai/concepts/jcloud/yaml-spec/) by specifying resource requirements and using containerized Hub Executors.
  Then, use `jina cloud deploy` command to deploy to the cloud:
  ```shell
  wget https://raw.githubusercontent.com/jina-ai/jina/master/.github/getting-started/jcloud-flow.yml
  jina cloud deploy jcloud-flow.yml
  ```
  ⚠️ **Caution: Make sure to delete/clean up the Flow once you are done with this tutorial to save resources and credits.**
  Read more about [deploying Flows to JCloud](https://docs.jina.ai/concepts/jcloud/#deploy).
  <!-- end build-pipelines -->


pkgId: 0e30333345b71b9cc5a637348667ea1e4b10106df325bbfd877487ebcc7da041
name: python-jinja2-cli
arch: src
version: 0.8.2
epoch: 0
release: 1
summary: A CLI interface to Jinja2
url: https://github.com/mattrobenolt/jinja2-cli
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-47ab7afd-4187-41ae-b0e3-561bcb6a5185
location_href: 00003961-python-jinja2-cli/python-jinja2-cli-0.8.2-1.src.rpm
checksum_type: sha256
description:
    $ jinja2 helloworld.tmpl data.json --format=json
    $ cat data.json | jinja2 helloworld.tmpl
    $ curl -s http://httpbin.org/ip | jinja2 helloip.tmpl
    $ curl -s http://httpbin.org/ip | jinja2 helloip.tmpl > helloip.html


pkgId: 3568ad2df2634cdfaf2baf40defffd327ad0f93a4902e5212f02c58a509cb3e1
name: python-jinjasql
arch: src
version: 0.1.8
epoch: 0
release: 1
summary: Generate SQL Queries and Corresponding Bind Parameters using a Jinja2 Template
url: https://github.com/hashedin/jinjasql
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4067175a-1f05-4858-9f72-9611d2807ba2
location_href: 00010307-python-jinjasql/python-jinjasql-0.1.8-1.src.rpm
checksum_type: sha256
description:
  Generate SQL Queries using a Jinja Template, without worrying about SQL Injection

  JinjaSQL automatically binds parameters that are inserted into the template.
  After JinjaSQL evaluates the template, you get 1) Query with placeholders
  for parameters, and 2) List of values that need to be bound to the query.

  JinjaSQL doesn't actually execute the query - it only prepares the
  query and the bind parameters. You can execute the query using any
  database engine / driver you are working with.


pkgId: 1091f311fa6356049fd7aab21022be1c49f9d949354627c81480bd89d79246e2
name: python-jinxed
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Jinxed Terminal Library
url: https://github.com/Rockhopper-Technologies/jinxed
rpm_license: MPLv2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-78237606-5120-4bfb-ae8d-7c59a71f1287
location_href: 00011122-python-jinxed/python-jinxed-1.2.0-1.src.rpm
checksum_type: sha256
description:
  Jinxed is an implementation of a subset of the Python curses_ library.
  It provides pure Python implementations of terminfo functions such as `tigetstr()`_
  and `tparm()`_ as well as convenience methods for working with Windows terminals.
  Jinxed was initially written to support Blessed_ on Windows, but will work on all platforms.


pkgId: 3f0a38c409b97307c2f62ed033204453c674c437f37203809f0b7fbe6fbaa86d
name: python-jmespath
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: JSON Matching Expressions
url: https://github.com/jmespath/jmespath.py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f04e63d4-bb01-453a-8c9e-aa58cc0e7215
location_href: 00008885-python-jmespath/python-jmespath-1.0.1-1.src.rpm
checksum_type: sha256
description:
  JMESPath (pronounced "james path") allows you to declaratively specify how to
  extract elements from a JSON document.
  For example, given this document::
      {"foo": {"bar": "baz"}}
  The jmespath expression ``foo.bar`` will return "baz".
  JMESPath also supports:
  Referencing elements in a list.  Given the data::
      {"foo": {"bar": ["one", "two"]}}
  The expression: ``foo.bar[0]`` will return "one".
  You can also reference all the items in a list using the ``*``
  syntax::
     {"foo": {"bar": [{"name": "one"}, {"name": "two"}]}}
  The expression: ``foo.bar[*].name`` will return ["one", "two"].
  Negative indexing is also supported (-1 refers to the last element
  in the list).  Given the data above, the expression
  ``foo.bar[-1].name`` will return "two".
  The ``*`` can also be used for hash types::
     {"foo": {"bar": {"name": "one"}, "baz": {"name": "two"}}}
  The expression: ``foo.*.name`` will return ["one", "two"].


pkgId: 86e164eff61035a52714d8f7ca485d3bc2717c26574776e4b198502bf294221e
name: python-joblib
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Lightweight pipelining with Python functions
url: https://joblib.readthedocs.io
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8859a190-8a81-49cc-9e43-d8d2cfda2a39
location_href: 00008947-python-joblib/python-joblib-1.2.0-1.src.rpm
checksum_type: sha256
description:
  To get the latest code using git, simply type::
      git clone git://github.com/joblib/joblib.git
  If you don't have git installed, you can download a zip or tarball
  of the latest code: http://github.com/joblib/joblib/archives/master


pkgId: 120219f8d587ae5abba4050c3c841e004c17fa63b8e86fe89008504bdebf2210
name: python-jobspy
arch: src
version: 0.29.0
epoch: 0
release: 1
summary: Use Redis as a job input/output coordinator.
url: https://github.com/josiahcarlson/jobs
rpm_license: GNU LGPL v2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-33105f2d-487e-4fdf-b058-3c111933ee3b
location_href: 00011819-python-jobspy/python-jobspy-0.29.0-1.src.rpm
checksum_type: sha256
description:
  Input/output locking on multiple *named* keys, called "inputs" and "outputs".
  * All keys are case-sensitive
  * Multiple readers on input keys
  * Exclusive single writer on output keys (no readers or other writers)
  * All inputs must have been an output previously
  * Optional global and per-job history of sanitized input/output edges (enabled
    by default)
  * Lock multiple inputs and outputs simultaneously, e.g. to produce outputs Y and
    Z, I need to consume inputs A, B, C.


pkgId: 7de4da30788bbb7e2e84943e5d0fceebac7c218aef99781e96f1260e9b3beac7
name: python-jose
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: An implementation of the JOSE draft
url: https://github.com/Demonware/jose
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1bfb4c9c-3906-4cb2-8f50-e810979cb7c8
location_href: 00003965-python-jose/python-jose-1.0.0-1.src.rpm
checksum_type: sha256
description:
  JOSE is a framework intended to provide a method to securely transfer
  claims (such as authorization information) between parties. The JOSE framework
  provides a collection of specifications to serve this purpose. A JSON Web
  Token (JWT) contains claims that can be used to allow a system to apply access
  control to resources it owns.
  JWTs can be represented as either JSON Web Signature (JWS) or a JSON Web
  Encryption (JWE) objects. Claims within a JWS can be read as they are simply
  base64-encoded (but carry with them a signature for authentication). Claims
  in a JWE on the other hand, are encrypted and as such, are entirely opaque
  to clients using them as their means of authentication and authorization.
  This library implements JWS and JWEs along with a subset of the
  encryption / authentication algorithms recommended by the JOSE framework.


pkgId: eae45a7eacac6da192a759bbeada6da05898353e9b6d2b5964ef045339cb14bd
name: python-josepy
arch: src
version: 1.13.0
epoch: 0
release: 1
summary: JOSE protocol implementation in Python
url: https://github.com/certbot/josepy
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-199c8ccd-8191-464e-9ea2-f233e5f4c835
location_href: 00003969-python-josepy/python-josepy-1.13.0-1.src.rpm
checksum_type: sha256
description:
  JOSE protocol implementation in Python using cryptography

  .. image:: https://github.com/certbot/josepy/actions/workflows/check.yaml/badge.svg
    :target: https://github.com/certbot/josepy/actions/workflows/check.yaml

  .. image:: https://codecov.io/gh/certbot/josepy/branch/master/graph/badge.svg
    :target: https://codecov.io/gh/certbot/josepy

  .. image:: https://readthedocs.org/projects/josepy/badge/?version=latest
    :target: http://josepy.readthedocs.io/en/latest/?badge=latest

  Originally developed as part of the ACME_ protocol implementation.

  .. _ACME: https://pypi.python.org/pypi/acme


pkgId: 4962e85af9f7d4d1617e34990d6d18172c89bd03bc500daff687bd82817405c1
name: python-journal-brief
arch: src
version: 1.1.8
epoch: 0
release: 1
summary: Show interesting new systemd journal entries since last run
url: https://github.com/twaugh/journal-brief
rpm_license: GPLv2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5aaa3d05-481e-4d57-b9d8-6660556f10fd
location_href: 00003970-python-journal-brief/python-journal-brief-1.1.8-1.src.rpm
checksum_type: sha256
description:
  This can be run from cron to get a daily or hourly
  briefing of interesting new systemd journal entries.

  Inclusion and exclusion criteria define what an "interesting" journal
  entry is, and exclusion rules can be built automatically.


pkgId: a321ae2a3b0a723bef4f4f9b9ef5a167eaec1c015bf7d47573e09720ec285bd0
name: python-jplephem
arch: src
version: 2.18
epoch: 0
release: 1
summary: Use a JPL ephemeris to predict planet positions.
url: https://github.com/brandon-rhodes/python-jplephem/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-56fb4aee-bda5-466b-8d6c-a5a2af3e81e3
location_href: 00011306-python-jplephem/python-jplephem-2.18-1.src.rpm
checksum_type: sha256
description:
  The only third-party package that ``jplephem`` depends on is `NumPy
  <http://www.numpy.org/>`_, which ``pip`` will automatically attempt to
  install alongside ``pyephem`` when you run::
      $ pip install jplephem
  If you see NumPy compilation errors, then try downloading and installing
  NumPy directly from `its web site <http://www.numpy.org/>`_ or simply
  use a distribution of Python with science tools already installed, like
  `Anaconda <http://continuum.io/downloads>`_.
  Note that ``jplephem`` offers only the logic necessary to produce plain
  three-dimensional vectors.  Most programmers interested in astronomy
  will want to look at `Skyfield <http://rhodesmill.org/skyfield/>`_
  instead, which uses ``jplephem`` but converts the numbers into more
  traditional measurements like right ascension and declination.
  Most users will use ``jplephem`` with the Satellite Planet Kernel (SPK)
  files that the NAIF facility at NASA JPL offers for use with their own
  SPICE toolkit.  They have collected their most useful kernels beneath
  the directory:
  http://naif.jpl.nasa.gov/pub/naif/generic_kernels/spk/
  To learn more about SPK files, the official `SPK Required Reading
  <http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/FORTRAN/req/spk.html>`_
  document is available from the NAIF facility’s web site under the NASA
  JPL domain.


pkgId: 7b99c58c490539b25dd1975127c98b88809e3e9eca108657ad10ef836bfb167b
name: python-json-logging-py
arch: src
version: 0.2
epoch: 0
release: 1
summary: JSON / Logstash formatters for Python logging
url: https://github.com/sebest/json-logging-py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-50e22422-126c-43bc-8fda-ee56fd8cec04
location_href: 00010538-python-json-logging-py/python-json-logging-py-0.2-1.src.rpm
checksum_type: sha256
description:
  This library provides Python logging formatters to output JSON, 2
  formatters are specific for Logstash message format version 0 or 1.


pkgId: 8994160b609c6b4959d1bb5591966527a7238c34bfb097ab8d4ee06de57822dc
name: python-json-rpc
arch: src
version: 1.14.0
epoch: 0
release: 1
summary: JSON-RPC transport implementation
url: https://github.com/pavlov99/json-rpc
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-96ab18e0-6268-4268-be1b-061c105f0afd
location_href: 00009643-python-json-rpc/python-json-rpc-1.14.0-1.src.rpm
checksum_type: sha256
description:
  `JSON-RPC2.0 <http://www.jsonrpc.org/specification>`_ and `JSON-RPC1.0 <http://json-rpc.org/wiki/specification>`_ transport specification implementation.
  Supports Python 2.6+, Python 3.3+, PyPy. Has optional Django and Flask support. 200+ tests.


pkgId: cc54eebe735540fafbe6d66c450e5554ccadb2ca8eef0da6a295bf765f4fa6b2
name: python-json-schema-for-humans
arch: src
version: 0.44.4
epoch: 0
release: 1
summary: Generate static HTML documentation from JSON schemas
url: https://github.com/coveooss/json-schema-for-humans
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-10c2ce3c-2473-4304-bca6-d3a716a12cda
location_href: 00011462-python-json-schema-for-humans/python-json-schema-for-humans-0.44.4-1.src.rpm
checksum_type: sha256
description:
  generate_from_schema | `schema_file` as str or `pathlib.Path` | Rendered doc as a str | No
  generate_from_filename | `schema_file_name` as str or `pathlib.Path` | Rendered doc written to the file at path `result_file_name` | Yes
  generate_from_file_object | `schema_file` as an open file object (read mode) | Rendered doc written to the file at `result_file`, which must be an open file object (in write mode) | Yes
  Notes:
  - When using file objects, it is assumed that files are opened with encoding "utf-8"
  - CSS and JS files are copied to the current working directory with names "schema_doc.css" and "schema_doc.min.js" respectively, if necessary
  - Other parameters of these methods are analogous to the CLI parameters documented above.

  To reduce the number of parameters to pass from function to function in the code, there is a `GenerationConfiguration` object that should be used for providing options.
  Example:
  ```python
  from json_schema_for_humans.generate import generate_from_filename
  from json_schema_for_humans.generation_configuration import GenerationConfiguration
  config = GenerationConfiguration(copy_css=False, expand_buttons=True)
  generate_from_filename("my_schema.json", "schema_doc.html", config=config)


  ```

  `generate_from_schema` has a `loaded_schemas` parameter that can be used to pre-load schemas. This must be a dict with the key being the real path of the schema file and the value being the result of loading the schema (with `json.load` or `yaml.safe_load`, for example).
  This should not be necessary in normal scenarios.

  See the excellent [Understanding JSON Schema](https://json-schema.org/understanding-json-schema/index.html) to understand what are those checks
  The following are supported:
  - Types
  - Regular expressions
  - String length
  - String format
  - Numeric types multiples and range
  - Constant and enumerated values
  - Required properties
  - Pattern properties
  - Default values
  - Array `minItems`, `maxItems`, `uniqueItems`, `items`, `prefixItems`, and `contains`
  - Combining schema with `oneOf`, `allOf`, `anyOf`, and `not`
  - Examples
  - Conditional subschemas
  These are **not** supported at the moment (PRs welcome!):
  - Property names and size
  - Property dependencies
  - Media

  References are supported:
  - To another part of the schema, e.g. `{ $ref: "#/definitions/something" }`
  - To a local file, `{"$ref": "references.json"}`, `{"$ref": "references.json#/definitions/something"}`
  - To a URL, `{"$ref": "http://example.com/schema.json"}`, `{"$ref": "http://example.com/schema.json#/definitions/something"}`
  You _can_ have a `description` next to a `$ref`, it will be displayed in priority to the description from the referenced element.
  If you have several attributes using the same definition, the definition will only be rendered once.
  All other usages of the same definition will be replaced with an anchor link to the first render of the definition.
  This can be turned off using `--config no_link_to_reused_ref`. See `With references` in the examples.

  Templates control the style of the generated documentation.

  This is the default template. It uses Bootstrap along with minimal Javascript to allow for the following:
  - Properties are in expandable dynamic sections. You can include a button to expand or collapse all. (See doc: [HTML version](https://coveooss.github.io/json-schema-for-humans/examples/examples_js_default/Configuration.html#expand_buttons) - [Markdown version](https://github.com/coveooss/json-schema-for-humans/blob/main/docs/examples/examples_md_default/Configuration.md#expand_buttons))
  - Conditional subschemas (`anyOf`, `oneOf`, `allOf`) are in tabbed sections
  - Anchor links will scroll to, expand, and animate the target section
  - Long descriptions are collapsed by default
  When using this template, you need to include the Javascript file (`schema_doc.min.js`) that is automatically copied next to the output HTML file (`schema_doc.html` by default).

  *Note*: This template is a work in progress
  It is sometimes not possible or desirable to include custom Javascript in documentation. This template addresses this issue by removing interactive elements in favor of simpler HTML.
  At the moment, this means the whole documentation is generated without any collapsible sections, which may make it hard to understand the schema structure. Contributions are welcomed to improve it!

  *Note*: This template is a work in progress
  This template allows users to publish the generated documentation without hosting an HTTP server.
  On GitHub, this format is rendered directly when browsing code.
  A table of content is provided at the beginning of the file for easy navigation.
  You can display some important information as badge using an option.
  See doc: [HTML version](https://coveooss.github.io/json-schema-for-humans/examples/examples_js_default/Configuration.html#template_md_options_badge_as_image) - [Markdown version](https://github.com/coveooss/json-schema-for-humans/blob/main/docs/examples/examples_md_default/Configuration.md#template_md_options_badge_as_image)
  Contributions are welcomed to improve it!

  [See CONTRIBUTING.md](CONTRIBUTING.md)


pkgId: 17709b1950f4525b349388ac67c026a60a27e93d143bf7e1fa441c4db4b230f5
name: python-json2table
arch: src
version: 1.1.5
epoch: 0
release: 1
summary: Convert JSON to an HTML table
url: https://github.com/latture/json2table
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4d8a3e5a-54f0-48ae-834f-96b48d9cf188
location_href: 00003976-python-json2table/python-json2table-1.1.5-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Coverage Status|
  This is a simple Python package that allows a JSON object to be converted to HTML. It provides a ``convert`` function that accepts a ``dict`` instance and returns a string of converted HTML. For example, the simple JSON object ``{"key" : "value"}`` can be converted to HTML via:
      >>> from json2table import convert
      >>> json_object = {"key" : "value"}
      >>> build_direction = "LEFT_TO_RIGHT"
      >>> table_attributes = {"style" : "width:100%"}
      >>> html = convert(json_object, build_direction=build_direction, table_attributes=table_attributes)
      >>> print(html)
      '<table style="width:100%"><tr><th>key</th><td>value</td></tr></table>'
  The resulting table will resemble
  +---------+-------+
  | **key** | value |
  +---------+-------+
  More complex parsing is also possible. If a list of ``dict``'s provides the same list of keys, the generated HTML with gather items by key and display them in the same column.
      {"menu": {
        "id": "file",
        "value": "File",
          "menuitem": [
            {"value": "New", "onclick": "CreateNewDoc()"},
            {"value": "Open", "onclick": "OpenDoc()"},
            {"value": "Close", "onclick": "CloseDoc()"}
          ]
        }
      }
  Output:
  +----------+--------------+----------------+-----------+
  | **menu** | **menuitem** | **onclick**    | **value** |
  +          +              +----------------+-----------+
  |          |              | CreateNewDoc() | New       |
  +          +              +----------------+-----------+
  |          |              | OpenDoc()      | Open      |
  +          +              +----------------+-----------+
  |          |              | CloseDoc()     | Close     |
  +          +--------------+----------------+-----------+
  |          | **id**       | file                       |
  +          +--------------+----------------+-----------+
  |          | **value**    | File                       |
  +----------+--------------+----------------+-----------+
  It might, however, be more readable if we were able to build the table from top-to-bottom instead of the default left-to-right. Changing the ``build_direction`` to ``"TOP_TO_BOTTOM"`` yields:
  +----------------+-----------+-------+-----------+
  | **menu**                                       |
  +----------------+-----------+-------+-----------+
  | **menuitem**               | **id**| **value** |
  +----------------+-----------+-------+-----------+
  | **onclick**    | **value** |  file |   File    |
  +----------------+-----------+       +           +
  | CreateNewDoc() | New       |       |           |
  +----------------+-----------+       +           +
  | OpenDoc()      | Open      |       |           |
  +----------------+-----------+       +           +
  | CloseDoc()     | Close     |       |           |
  +----------------+-----------+-------+-----------+
  Table attributes are added via the ``table_attributes`` parameter. This parameter should be a ``dict`` of ``(key, value)`` pairs to apply to the table in the form ``key="value"``. If in our simple example before we additionally wanted to apply a class attribute of ``"table table-striped"`` we would use the following:
      >>> table_attributes = {"style" : "width:100%", "class" : "table table-striped"}
  and convert just as before:
      >>> html = convert(json_object, build_direction=build_direction, table_attributes=table_attributes)


pkgId: d208c6b9fdede12e1458459abadafb3376885a9677a2f821d958fdb8f08c6ef2
name: python-json5
arch: src
version: 0.9.11
epoch: 0
release: 1
summary: A Python implementation of the JSON5 data format.
url: https://github.com/dpranke/pyjson5
rpm_license: Apache
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c7f2f157-3c19-493f-8d96-7db1e164bd8e
location_href: 00003977-python-json5/python-json5-0.9.11-1.src.rpm
checksum_type: sha256
description:
  A Python implementation of the JSON5 data format.

  [JSON5](https://json5.org) extends the
  [JSON](http://www.json.org) data interchange format to make it
  slightly more usable as a configuration language:

  * JavaScript-style comments (both single and multi-line) are legal.

  * Object keys may be unquoted if they are legal ECMAScript identifiers

  * Objects and arrays may end with trailing commas.

  * Strings can be single-quoted, and multi-line string literals are allowed.

  There are a few other more minor extensions to JSON; see the above page for
  the full details.

  This project implements a reader and writer implementation for Python;
  where possible, it mirrors the
  [standard Python JSON API](https://docs.python.org/library/json.html)
  package for ease of use.

  There is one notable difference from the JSON api: the `load()` and
  `loads()` methods support optionally checking for (and rejecting) duplicate
  object keys; pass `allow_duplicate_keys=False` to do so (duplicates are
  allowed by default).

  This is an early release. It has been reasonably well-tested, but it is
  **SLOW**. It can be 1000-6000x slower than the C-optimized JSON module,
  and is 200x slower (or more) than the pure Python JSON module.

  **Please Note:** This library only handles JSON5 documents, it does not
  allow you to read arbitrary JavaScript. For example, bare integers can
  be legal object keys in JavaScript, but they aren't in JSON5.



  * Did I mention that it is **SLOW**?

  * The implementation follows Python3's `json` implementation where
    possible. This means that the `encoding` method to `dump()` is
    ignored, and unicode strings are always returned.

  * The `cls` keyword argument that `json.load()`/`json.loads()` accepts
    to specify a custom subclass of ``JSONDecoder`` is not and will not be
    supported, because this implementation uses a completely different
    approach to parsing strings and doesn't have anything like the
    `JSONDecoder` class.

  * The `cls` keyword argument that `json.dump()`/`json.dumps()` accepts
    is also not supported, for consistency with `json5.load()`. The `default`
    keyword *is* supported, though, and might be able to serve as a
    workaround.


  To run the tests, setup a venv and install the required dependencies with
  `pip install -e '.[dev]'`, then run the tests with `python setup.py test`.




  * v0.9.11 (2023-01-02)
      * [GitHub issue #60](https://github.com/dpranke/pyjson5/issues/60)
        Fixed minor Python2 compatibility issue by referring to
        `float("inf")` instead of `math.inf`.
  * v0.9.10 (2022-08-18)
      * [GitHub issue #58](https://github.com/dpranke/pyjson5/issues/58)
        Updated the //README.md to be clear that parsing arbitrary JS
        code may not work.
      * Otherwise, no code changes.
  * v0.9.9 (2022-08-01)
      * [GitHub issue #57](https://github.com/dpranke/pyjson5/issues/57)
        Fixed serialization for objects that subclass `int` or `float`:
        Previously we would use the objects __str__ implementation, but
        that might result in an illegal JSON5 value if the object had
        customized __str__ to return something illegal. Instead,
        we follow the lead of the `JSON` module and call `int.__repr__`
        or `float.__repr__` directly.
      * While I was at it, I added tests for dumps(-inf) and dumps(nan)
        when those were supposed to be disallowed by `allow_nan=False`.
  * v0.9.8 (2022-05-08)
      * [GitHub issue #47](https://github.com/dpranke/pyjson5/issues/47)
        Fixed error reporting in some cases due to how parsing was handling
        nested rules in the grammar - previously the reported location for
        the error could be far away from the point where it actually happened.

  * v0.9.7 (2022-05-06)
      * [GitHub issue #52](https://github.com/dpranke/pyjson5/issues/52)
        Fixed behavior of `default` fn in `dump` and `dumps`. Previously
        we didn't require the function to return a string, and so we could
        end up returning something that wasn't actually valid. This change
        now matches the behavior in the `json` module. *Note: This is a
        potentially breaking change.*
  * v0.9.6 (2021-06-21)
      * Bump development status classifier to 5 - Production/Stable, which
        the library feels like it is at this point. If I do end up significantly
        reworking things to speed it up and/or to add round-trip editing,
        that'll likely be a 2.0. If this version has no reported issues,
        I'll likely promote it to 1.0.
      * Also bump the tested Python versions to 2.7, 3.8 and 3.9, though
        earlier Python3 versions will likely continue to work as well.
      * [GitHub issue #46](https://github.com/dpranke/pyjson5/issues/36)
        Fix incorrect serialization of custom subtypes
      * Make it possible to run the tests if `hypothesis` isn't installed.

  * v0.9.5 (2020-05-26)
      * Miscellaneous non-source cleanups in the repo, including setting
        up GitHub Actions for a CI system. No changes to the library from
        v0.9.4, other than updating the version.

  * v0.9.4 (2020-03-26)
      * [GitHub pull #38](https://github.com/dpranke/pyjson5/pull/38)
        Fix from fredrik@fornwall.net for dumps() crashing when passed
        an empty string as a key in an object.

  * v0.9.3 (2020-03-17)
      * [GitHub pull #35](https://github.com/dpranke/pyjson5/pull/35)
        Fix from pastelmind@ for dump() not passing the right args to dumps().
      * Fix from p.skouzos@novafutur.com to remove the tests directory from
        the setup call, making the package a bit smaller.

  * v0.9.2 (2020-03-02)
      * [GitHub pull #34](https://github.com/dpranke/pyjson5/pull/34)
        Fix from roosephu@ for a badly formatted nested list.

  * v0.9.1 (2020-02-09)
      * [GitHub issue #33](https://github.com/dpranke/pyjson5/issues/33):
         Fix stray trailing comma when dumping an object with an invalid key.

  * v0.9.0 (2020-01-30)
      * [GitHub issue #29](https://github.com/dpranke/pyjson5/issues/29):
         Fix an issue where objects keys that started with a reserved
         word were incorrectly quoted.
      * [GitHub issue #30](https://github.com/dpranke/pyjson5/issues/30):
         Fix an issue where dumps() incorrectly thought a data structure
         was cyclic in some cases.
      * [GitHub issue #32](https://github.com/dpranke/pyjson5/issues/32):
         Allow for non-string keys in dicts passed to ``dump()``/``dumps()``.
         Add an ``allow_duplicate_keys=False`` to prevent possible
         ill-formed JSON that might result.

  * v0.8.5 (2019-07-04)
      * [GitHub issue #25](https://github.com/dpranke/pyjson5/issues/25):
        Add LICENSE and README.md to the dist.
      * [GitHub issue #26](https://github.com/dpranke/pyjson5/issues/26):
        Fix printing of empty arrays and objects with indentation, fix
        misreporting of the position on parse failures in some cases.

  * v0.8.4 (2019-06-11)
      * Updated the version history, too.

  * v0.8.3 (2019-06-11)
      * Tweaked the README, bumped the version, forgot to update the version
        history :).

  * v0.8.2 (2019-06-11)
      * Actually bump the version properly, to 0.8.2.

  * v0.8.1 (2019-06-11)
      * Fix bug in setup.py that messed up the description. Unfortunately,
        I forgot to bump the version for this, so this also identifies as 0.8.0.

  * v0.8.0 (2019-06-11)
      * Add `allow_duplicate_keys=True` as a default argument to
        `json5.load()`/`json5.loads()`. If you set the key to `False`, duplicate
        keys in a single dict will be rejected. The default is set to `True`
        for compatibility with `json.load()`, earlier versions of json5, and
        because it's simply not clear if people would want duplicate checking
        enabled by default.

  * v0.7 (2019-03-31)
      * Changes dump()/dumps() to not quote object keys by default if they are
        legal identifiers. Passing `quote_keys=True` will turn that off
        and always quote object keys.
      * Changes dump()/dumps() to insert trailing commas after the last item
        in an array or an object if the object is printed across multiple lines
        (i.e., if `indent` is not None). Passing `trailing_commas=False` will
        turn that off.
      * The `json5.tool` command line tool now supports the `--indent`,
        `--[no-]quote-keys`, and `--[no-]trailing-commas` flags to allow
        for more control over the output, in addition to the existing
        `--as-json` flag.
      * The `json5.tool` command line tool no longer supports reading from
        multiple files, you can now only read from a single file or
        from standard input.
      * The implementation no longer relies on the standard `json` module
        for anything. The output should still match the json module (except
        as noted above) and discrepancies should be reported as bugs.

  * v0.6.2 (2019-03-08)
      * Fix [GitHub issue #23](https://github.com/dpranke/pyjson5/issues/23) and
        pass through unrecognized escape sequences.

  * v0.6.1 (2018-05-22)
      * Cleaned up a couple minor nits in the package.

  * v0.6.0 (2017-11-28)
      * First implementation that attempted to implement 100% of the spec.

  * v0.5.0 (2017-09-04)
      * First implementation that supported the full set of kwargs that
        the `json` module supports.


pkgId: d204452084456a9864185b4864807ddaa1c30e50acc02683b6a0b12a4a6b7645
name: python-jsonargparse
arch: src
version: 4.20.1
epoch: 0
release: 1
url: https://github.com/omni-us/jsonargparse
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6b59a9d4-3697-4dad-ba87-eb3c95e1ac06
location_href: 00011675-python-jsonargparse/python-jsonargparse-4.20.1-1.src.rpm
checksum_type: sha256
summary:
  Implement minimal boilerplate CLIs derived from type hints and parse from command line, config files and environment variables.

description:
  https://github.com/omni-us/jsonargparse/
  This package is an extension to python's argparse which simplifies parsing of
  configuration options from command line arguments, json configuration files
  (`yaml <https://yaml.org/>`__ or `jsonnet <https://jsonnet.org/>`__ supersets),
  environment variables and hard-coded defaults.
  The aim is similar to other projects such as `configargparse
  <https://pypi.org/project/ConfigArgParse/>`__, `yconf
  <https://pypi.org/project/yconf/>`__, `confuse
  <https://pypi.org/project/confuse/>`__, `typer
  <https://pypi.org/project/typer/>`__, `OmegaConf
  <https://pypi.org/project/omegaconf/>`__, `Fire
  <https://pypi.org/project/fire/>`__ and `click
  <https://pypi.org/project/click/>`__. The obvious question is, why yet another
  package similar to many already existing ones? The answer is simply that none of
  the existing projects had the exact features we wanted and after analyzing the
  alternatives it seemed simpler to start a new project.


pkgId: 6b44b6dd528b61021806c354555a2bd22a75a2f044e465901d61731f9ef17e35
name: python-jsonfield
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: A reusable Django field that allows you to store validated JSON in your model.
url: https://github.com/rpkilby/jsonfield/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-037d8e62-540e-4316-84c3-7b1e541ec0e4
location_href: 00003978-python-jsonfield/python-jsonfield-3.1.0-1.src.rpm
checksum_type: sha256
description:
  **jsonfield** is a reusable model field that allows you to store validated JSON, automatically handling
  serialization to and from the database. To use, add ``jsonfield.JSONField`` to one of your models.
  **Note:** `django.contrib.postgres`_ now supports PostgreSQL's jsonb type, which includes extended querying
  capabilities. If you're an end user of PostgreSQL and want full-featured JSON support, then it is
  recommended that you use the built-in JSONField. However, jsonfield is still useful when your app
  needs to be database-agnostic, or when the built-in JSONField's extended querying is not being leveraged.
  e.g., a configuration field.


pkgId: 0b6409b7729a5c27f71b984f62f1c77684974608194095b6946cd0cec9d2096d
name: python-jsonformatter
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Python log in json format.
url: https://github.com/MyColorfulDays/jsonformatter.git
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-860fa54e-6ebe-41e2-9e2b-76140870fdd9
location_href: 00009682-python-jsonformatter/python-jsonformatter-0.3.2-1.src.rpm
checksum_type: sha256
description:
  - [jsonformatter -- for python log json](#jsonformatter----for-python-log-json)
      - [Installation](#installation)
      - [Basic Usage](#basic-usage)
          - [Case 1. Initial root logger like `logging.basicConfig`](#case-1-initial-root-logger-like-loggingbasicconfig)
          - [Case 2. Complete config in python code](#case-2-complete-config-in-python-code)
          - [Case 3. Use config file](#case-3-use-config-file)
          - [Case 4. In `Flask` project, add `LogRecord` attribute for auto output](#case-4-in-flask-project-add-logrecord-attribute-for-auto-output)
          - [Case 5. In `Django` project, config `LOGGING`](#case-5-in-django-project-config-logging)
      - [More Usage](#more-usage)
          - [Case 1. Mix `extra` to output](#case-1-mix-extra-to-output)
          - [Case 2. Output multiple attributes in one key](#case-2-output-multiple-attributes-in-one-key)
          - [Case 3. Support `json.dumps` all optional parameters](#case-3-support-jsondumps-all-optional-parameters)
          - [Case 4. Solve cumtom `LogRecord` attribute is not `JSON serializable`](#case-4-solve-cumtom-logrecord-attribute-is-not-json-serializable)
      - [LogRecord Attributes](#logrecord-attributes)





  **jsonformatter** is a formatter for python output json log, e.g. output **LogStash** needed log.

  Easily **custom(add/replace)** `LogRecord` attribute, e.g. in `Flask` web project, add `username` attribute to `LogRecord`  for auto output username.



  **Python 2.7** and **python 3** are supported from version 0.2.X,  if you are using a version lower than 0.2.X,  Only **python 3** is supported.





  jsonformatter is available on PyPI.
  Use pip to install:

  ```shell
  $ pip install jsonformatter
  ```
  or:

  ```shell
  $ git clone https://github.com/MyColorfulDays/jsonformatter.git
  $ cd jsonformatter
  $ python setup.py install
  ```






  ```python
  import logging

  from jsonformatter import basicConfig


  basicConfig(level=logging.INFO)
  logging.info('hello, jsonformatter')
  ```

  output:

  ```shell
  {"levelname": "INFO", "name": "root", "message": "hello, jsonformatter"}
  ```





  ```python
  import logging

  from jsonformatter import JsonFormatter





  STRING_FORMAT = '''{
      "Name":            "name",
      "Levelno":         "levelno",
      "Levelname":       "levelname",
      "Pathname":        "pathname",
      "Filename":        "filename",
      "Module":          "module",
      "Lineno":          "lineno",
      "FuncName":        "funcName",
      "Created":         "created",
      "Asctime":         "asctime",
      "Msecs":           "msecs",
      "RelativeCreated": "relativeCreated",
      "Thread":          "thread",
      "ThreadName":      "threadName",
      "Process":         "process",
      "Message":         "message"
  }'''

  root = logging.getLogger()
  root.setLevel(logging.INFO)

  formatter = JsonFormatter(STRING_FORMAT)

  sh = logging.StreamHandler()
  sh.setFormatter(formatter)
  sh.setLevel(logging.INFO)

  root.addHandler(sh)

  root.info("test %s format", 'string')
  ```

  output:

  ```shell
  {"Name": "root", "Levelno": 20, "Levelname": "INFO", "Pathname": "test.py", "Filename": "test.py", "Module": "test", "Lineno": 75, "FuncName": "test_string_format", "Created": 1588185267.3198836, "Asctime": "2020-04-30 02:34:27,319", "Msecs": 319.8835849761963, "RelativeCreated": 88.2880687713623, "Thread": 16468, "ThreadName": "MainThread", "Process": 16828, "Message": "test string format"}
  ```





  config file:
  ```shell
  $ cat logger_config.ini
  [loggers]
  keys=root

  [logger_root]
  level=INFO
  handlers=infohandler




  [handlers]
  keys=infohandler

  [handler_infohandler]
  class=StreamHandler
  level=INFO
  formatter=form01
  args=(sys.stdout,)



  [formatters]
  keys=form01

  [formatter_form01]
  class=jsonformatter.JsonFormatter
  format={"name": "name","levelno": "levelno","levelname": "levelname","pathname": "pathname","filename": "filename","module": "module","lineno": "lineno","funcName": "funcName","created": "created","asctime": "asctime","msecs": "msecs","relativeCreated": "relativeCreated","thread": "thread","threadName": "threadName","process": "process","message": "message"}
  ```
  python code:
  ```python3
  import logging
  import os
  from logging.config import fileConfig

  fileConfig(os.path.join(os.path.dirname(__file__), 'logger_config.ini'))
  root = logging.getLogger('root')
  root.info('test file config')

  ```

  output:

  ```shell
  {"name": "root", "levelno": 20, "levelname": "INFO", "pathname": "test.py", "filename": "test.py", "module": "test", "lineno": 315, "funcName": "test_file_config", "created": 1588185267.3020294, "asctime": "2020-04-30 02:34:27", "msecs": 302.0293712615967, "relativeCreated": 70.4338550567627, "thread": 16468, "threadName": "MainThread", "process": 16828, "message": "test file config"}
  ```





  flask_demo.py

  ```python
  import datetime
  import json
  import logging
  import random
  from collections import OrderedDict

  from jsonformatter import JsonFormatter
  from flask import Flask, has_request_context, request, session
  from flask.logging import default_handler

  app = Flask(__name__)



  RECORD_CUSTOM_ATTRS = {
      
      'url': lambda: request.url if has_request_context() else None,
      'username': lambda: session['username'] if has_request_context() and ('username' in session) else None,
      
      'status': lambda **record_attrs: 'failed' if record_attrs['levelname'] in ['ERROR', 'CRITICAL'] else 'success'
  }

  RECORD_CUSTOM_FORMAT = OrderedDict([
      
      ("Url", "url"),
      ("Username", "username"),
      ("Status", "status"),
      
      ("Name", "name"),
      ("Levelno", "levelno"),
      ("Levelname", "levelname"),
      ("Pathname", "pathname"),
      ("Filename", "filename"),
      ("Module", "module"),
      ("Lineno", "lineno"),
      ("FuncName", "funcName"),
      ("Created", "created"),
      ("Asctime", "asctime"),
      ("Msecs", "msecs"),
      ("RelativeCreated", "relativeCreated"),
      ("Thread", "thread"),
      ("ThreadName", "threadName"),
      ("Process", "process"),
      ("Message", "message")
  ])


  formatter = JsonFormatter(
      RECORD_CUSTOM_FORMAT,
      record_custom_attrs=RECORD_CUSTOM_ATTRS
  )

  default_handler.setFormatter(formatter)
  app.logger.warning('hello, jsonformatter')
  ```

  output:

  ```shell
  {"Url": null, "Username": null, "Status": "success", "Name": "flask_demo", "Levelno": 30, "Levelname": "WARNING", "Pathname": "flask_demo.py", "Filename": "flask_demo.py", "Module": "flask_demo", "Lineno": 54, "FuncName": "<module>", "Created": 1595781463.3557186, "Asctime": "2020-07-27 00:37:43,355", "Msecs": 355.71861267089844, "RelativeCreated": 858.7081432342529, "Thread": 15584, "ThreadName": "MainThread", "Process": 17560, "Message": "hello, jsonformatter"}
  ```





  settings.py

  ```python
  LOGGING = {
      'version': 1,
      'disable_existing_loggers': False,
      'formatters': {
          'standard': {
              'class': 'jsonformatter.JsonFormatter',
              'format': OrderedDict([
                  ("Name", "name"),
                  ("Levelno", "levelno"),
                  ("Levelname", "levelname"),
                  ("Pathname", "pathname"),
                  ("Filename", "filename"),
                  ("Module", "module"),
                  ("Lineno", "lineno"),
                  ("FuncName", "funcName"),
                  ("Created", "created"),
                  ("Asctime", "asctime"),
                  ("Msecs", "msecs"),
                  ("RelativeCreated", "relativeCreated"),
                  ("Thread", "thread"),
                  ("ThreadName", "threadName"),
                  ("Process", "process"),
                  ("Message", "message")
              ])
          },
      },
      'handlers': {
          'console': {
              'level': 'INFO',
              'formatter': 'standard',
              'class': 'logging.StreamHandler',
          },
      },
      'loggers': {
          'django': {
              'handlers': ['console'],
              'level': 'INFO',
              'propagate': False
          },
      }
  }
  ```







  ```python
  import logging

  from jsonformatter import JsonFormatter

  root = logging.getLogger()
  root.setLevel(logging.INFO)

  sh = logging.StreamHandler()
  formatter = JsonFormatter(
      ensure_ascii=False,
      mix_extra=True,
      mix_extra_position='tail' # optional: head, mix
  )
  sh.setFormatter(formatter)
  sh.setLevel(logging.INFO)
  root.addHandler(sh)

  root.info(
      'test mix extra in fmt',
      extra={
          'extra1': 'extra content 1',
          'extra2': 'extra content 2'
      })
  root.info(
      'test mix extra in fmt',
      extra={
          'extra3': 'extra content 3',
          'extra4': 'extra content 4'
      })
  ```

  output:

  ```shell
  {"levelname": "INFO", "name": "root", "message": "test mix extra in fmt", "extra1": "extra content 1", "extra2": "extra content 2"}
  {"levelname": "INFO", "name": "root", "message": "test mix extra in fmt", "extra3": "extra content 3", "extra4": "extra content 4"}
  ```




  ```python
  import logging

  from jsonformatter import JsonFormatter

  MULTI_ATTRIBUTES_FORMAT = '''{
      "multi attributes in one key": "s - s - s - s - s - s - d - s - f - s - d - d - d - s - d - s"
  }
  '''


  root = logging.getLogger()
  root.setLevel(logging.INFO)

  formatter = JsonFormatter(MULTI_ATTRIBUTES_FORMAT)

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

  sh.setLevel(logging.INFO)

  root.addHandler(sh)
  root.info('test multi attributes in one key')
  ```





  ```python
  import logging

  from jsonformatter import JsonFormatter

  STRING_FORMAT = '''{
      "Name":            "name",
      "Levelno":         "levelno",
      "Levelname":       "levelname",
      "Pathname":        "pathname",
      "Filename":        "filename",
      "Module":          "module",
      "Lineno":          "lineno",
      "FuncName":        "funcName",
      "Created":         "created",
      "Asctime":         "asctime",
      "Msecs":           "msecs",
      "RelativeCreated": "relativeCreated",
      "Thread":          "thread",
      "ThreadName":      "threadName",
      "Process":         "process",
      "Message":         "message"
  }'''

  root = logging.getLogger()
  root.setLevel(logging.INFO)


  formatter = JsonFormatter(STRING_FORMAT, indent=4, ensure_ascii=False)

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

  sh.setLevel(logging.INFO)

  root.addHandler(sh)

  root.info('test json optional paramter: 中文')
  ```





  ```python
  import datetime
  import json
  import logging
  import random
  from collections import OrderedDict

  from jsonformatter import JsonFormatter



  RECORD_CUSTOM_ATTRS = {
      
      
      
      
      
      'asctime': lambda: datetime.datetime.today(),
      'user id': lambda: str(random.random())[2:10]
  }

  RECORD_CUSTOM_FORMAT = OrderedDict([
      ("User id",         "user id"),  # new custom attrs
      ("Name",            "name"),
      ("Levelno",         "levelno"),
      ("Levelname",       "levelname"),
      ("Pathname",        "pathname"),
      ("Filename",        "filename"),
      ("Module",          "module"),
      ("Lineno",          "lineno"),
      ("FuncName",        "funcName"),
      ("Created",         "created"),
      ("Asctime",         "s"),  # use `LogRecord` attribute `Format` to find matched key from RECORD_CUSTOM_ATTRS and call it value.
      ("Msecs",           "msecs"),
      ("RelativeCreated", "relativeCreated"),
      ("Thread",          "thread"),
      ("ThreadName",      "threadName"),
      ("Process",         "process"),
      ("Message",         "message")
  ])



  def DEFAULT_SOLUTION(o):
      if not isinstance(o, (str, int, float, bool, type(None))):
          return str(o)
      else:
          return o


  class CLS_SOLUTION(json.JSONEncoder):
      def default(self, o):
          if isinstance(o, datetime.datetime):
              return o.isoformat()

          return json.JSONEncoder.default(self, o)

  root = logging.getLogger()
  root.setLevel(logging.INFO)

  formatter = JsonFormatter(RECORD_CUSTOM_FORMAT, record_custom_attrs=RECORD_CUSTOM_ATTRS, default=DEFAULT_SOLUTION, cls=CLS_SOLUTION)

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

  sh.setLevel(logging.INFO)

  root.addHandler(sh)
  root.info('record custom attrs')
  ```





  Offical url: https://docs.python.org/3/library/logging.html#logrecord-attributes

  Attribute name|Format|Description
  -|-|-
  args|You shouldn’t need to format this yourself.|The tuple of arguments merged into msg to produce message, or a dict whose values are used for the merge (when there is only one argument, and it is a dictionary).
  asctime|s|Human-readable time when the LogRecord was created. By default this is of the form ‘2003-07-08 16:49:45,896’ (the numbers after the comma are millisecond portion of the time).
  created|f|Time when the LogRecord was created (as returned by time.time()).
  exc_info|You shouldn’t need to format this yourself.|Exception tuple (à la sys.exc_info) or, if no exception has occurred, None.
  filename|s|Filename portion of pathname.
  funcName|s|Name of function containing the logging call.
  levelname|s|Text logging level for the message ('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL').
  levelno|s|Numeric logging level for the message (DEBUG, INFO, WARNING, ERROR, CRITICAL).
  lineno|d|Source line number where the logging call was issued (if available).
  message|s|The logged message, computed as msg % args. This is set when Formatter.format() is invoked.
  module|s|Module (name portion of filename).
  msecs|d|Millisecond portion of the time when the LogRecord was created.
  msg|You shouldn’t need to format this yourself.|The format string passed in the original logging call. Merged with args to produce message, or an arbitrary object (see Using arbitrary objects as messages).
  name|s|Name of the logger used to log the call.
  pathname|s|Full pathname of the source file where the logging call was issued (if available).
  process|d|Process ID (if available).
  processName|s|Process name (if available).
  relativeCreated|d|Time in milliseconds when the LogRecord was created, relative to the time the logging module was loaded.
  stack_info|You shouldn’t need to format this yourself.|Stack frame information (where available) from the bottom of the stack in the current thread, up to and including the stack frame of the logging call which resulted in the creation of this record.
  thread|d|Thread ID (if available).
  threadName|s|Thread name (if available).


pkgId: 1cd247c486ea339bb0c184146520b5d886519c64bf4629095b311455f1050533
name: python-jsonpath
arch: src
version: 0.82
epoch: 0
release: 1
summary: An XPath for JSON
url: http://www.ultimate.com/phil/python/#jsonpath
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-467e9f89-2722-44ef-929b-646e85d41e74
location_href: 00011810-python-jsonpath/python-jsonpath-0.82-1.src.rpm
checksum_type: sha256
description:
  A port of the Perl, and JavaScript versions of JSONPath
  see http://goessner.net/articles/JsonPath/

  Based on on JavaScript version by Stefan Goessner at:
          https://goessner.net/articles/JsonPath/
          http://code.google.com/p/jsonpath/
  and Perl version by Kate Rhodes at:
          http://github.com/masukomi/jsonpath-perl/tree/master

  Python3 compatibily by Per J. Sandstrom


pkgId: 3eb900448e605b21f354bb19f5f266755d5d28c0cc5548f268181eccb9c0a22c
name: python-jsonpath-ng
arch: src
version: 1.5.3
epoch: 0
release: 1
url: https://github.com/h2non/jsonpath-ng
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ddddb906-618a-45d3-a0d0-7fb777e5b5cf
location_href: 00003980-python-jsonpath-ng/python-jsonpath-ng-1.5.3-1.src.rpm
checksum_type: sha256
summary:
  A final implementation of JSONPath for Python that aims to be standard compliant, including arithmetic and binary comparison operators and providing clear AST for metaprogramming.

description:
  A final implementation of JSONPath for Python that aims to be standard compliant, including arithmetic
  and binary comparison operators, as defined in the original `JSONPath proposal`_.
  This packages merges both `jsonpath-rw`_ and `jsonpath-rw-ext`_ and
  provides several AST API enhancements, such as the ability to update or removes nodes in the tree.


pkgId: d2ecd2745072fa5b069af42856c81a9051327e4590984c0d2320c7ca2f23427a
name: python-jsonpath-rw
arch: src
version: 1.4.0
epoch: 0
release: 1
url: https://github.com/kennknowles/python-jsonpath-rw
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-39077064-3f77-4182-b07e-3de9b38a6b3d
location_href: 00003981-python-jsonpath-rw/python-jsonpath-rw-1.4.0-1.src.rpm
checksum_type: sha256
summary:
  A robust and significantly extended implementation of JSONPath for Python, with a clear AST for metaprogramming.

description:
  https://github.com/kennknowles/python-jsonpath-rw
  |Build Status| |Test coverage| |PyPi version| |PyPi downloads|
  This library provides a robust and significantly extended implementation
  of JSONPath for Python. It is tested with Python 2.6, 2.7, 3.2, 3.3.
  *(On travis-ci there is a segfault when running the tests with pypy; I don't think the problem lies with this library)*.
  This library differs from other JSONPath implementations in that it is a
  full *language* implementation, meaning the JSONPath expressions are
  first class objects, easy to analyze, transform, parse, print, and
  extend. (You can also execute them :-)


pkgId: 727128470e6122f097c895559b71fc5265e14b9319565945813feb4ecaf2f114
name: python-jsonpointer
arch: src
version: 2.3
epoch: 0
release: 1
summary: Identify specific nodes in a JSON document (RFC 6901)
url: https://github.com/stefankoegl/python-json-pointer
rpm_license: Modified BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2337df0a-be5a-4e9f-a113-c7b6937cdac8
location_href: 00009152-python-jsonpointer/python-jsonpointer-2.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/jsonpointer.svg)](https://pypi.python.org/pypi/jsonpointer/)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/jsonpointer.svg)](https://pypi.python.org/pypi/jsonpointer/)
  [![Build Status](https://travis-ci.org/stefankoegl/python-json-pointer.svg?branch=master)](https://travis-ci.org/stefankoegl/python-json-pointer)
  [![Coverage Status](https://coveralls.io/repos/stefankoegl/python-json-pointer/badge.svg?branch=master)](https://coveralls.io/r/stefankoegl/python-json-pointer?branch=master)


pkgId: 4aa1ff47adabf9aaa64fa33148fc08e76f92f5762d7bbd862c29471785e04fcc
name: python-jsonref
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: jsonref is a library for automatic dereferencing of JSON Reference objects for Python.
url: https://pypi.org/project/jsonref/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d306ae11-296b-431a-bc16-ce3221ef6c91
location_href: 00003984-python-jsonref/python-jsonref-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![image](https://github.com/gazpachoking/jsonref/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/gazpachoking/jsonref/actions/workflows/test.yml?query=branch%3Amaster)
  [![image](https://readthedocs.org/projects/jsonref/badge/?version=latest)](https://jsonref.readthedocs.io/en/latest/)
  [![image](https://coveralls.io/repos/gazpachoking/jsonref/badge.png?branch=master)](https://coveralls.io/r/gazpachoking/jsonref)
  [![image](https://img.shields.io/pypi/v/jsonref?color=%2334D058&label=pypi%20package)](https://pypi.org/project/jsonref)

  `jsonref` is a library for automatic dereferencing of [JSON
  Reference](https://datatracker.ietf.org/doc/html/draft-pbryan-zyp-json-ref-03)
  objects for Python (supporting Python 3.7+).

  This library lets you use a data structure with JSON reference objects,
  as if the references had been replaced with the referent data.

  ```python console
  >>> from pprint import pprint
  >>> import jsonref

  >>> # An example json document
  >>> json_str = """{"real": [1, 2, 3, 4], "ref": {"$ref": "#/real"}}"""
  >>> data = jsonref.loads(json_str)
  >>> pprint(data)  # Reference is not evaluated until here
  {'real': [1, 2, 3, 4], 'ref': [1, 2, 3, 4]}
  ```



  -   References are evaluated lazily. Nothing is dereferenced until it is
      used.
  -   Recursive references are supported, and create recursive python data
      structures.

  References objects are actually replaced by lazy lookup proxy objects
  which are almost completely transparent.

  ```python console
  >>> data = jsonref.loads('{"real": [1, 2, 3, 4], "ref": {"$ref": "#/real"}}')
  >>> # You can tell it is a proxy by using the type function
  >>> type(data["real"]), type(data["ref"])
  (<class 'list'>, <class 'jsonref.JsonRef'>)
  >>> # You have direct access to the referent data with the __subject__
  >>> # attribute
  >>> type(data["ref"].__subject__)
  <class 'list'>
  >>> # If you need to get at the reference object
  >>> data["ref"].__reference__
  {'$ref': '#/real'}
  >>> # Other than that you can use the proxy just like the underlying object
  >>> ref = data["ref"]
  >>> isinstance(ref, list)
  True
  >>> data["real"] == ref
  True
  >>> ref.append(5)
  >>> del ref[0]
  >>> # Actions on the reference affect the real data (if it is mutable)
  >>> pprint(data)
  {'real': [2, 3, 4, 5], 'ref': [2, 3, 4, 5]}
  ```


pkgId: 462041cedbb97c00849b37e47b8a63324932932533071755a8139728c2703b82
name: python-jsonrpcserver
arch: src
version: 5.0.9
epoch: 0
release: 1
summary: Process JSON-RPC requests
url: https://github.com/explodinglabs/jsonrpcserver
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a95dcda7-8acf-4516-8a7e-bad7ea18166e
location_href: 00003987-python-jsonrpcserver/python-jsonrpcserver-5.0.9-1.src.rpm
checksum_type: sha256
description:
  <img
      alt="jsonrpcserver"
      style="margin: 0 auto;"
      src="https://github.com/explodinglabs/jsonrpcserver/blob/main/docs/logo.png?raw=true"
  />

  ![PyPI](https://img.shields.io/pypi/v/jsonrpcserver.svg)
  ![Code Quality](https://github.com/explodinglabs/jsonrpcserver/actions/workflows/code-quality.yml/badge.svg)
  ![Coverage Status](https://coveralls.io/repos/github/explodinglabs/jsonrpcserver/badge.svg?branch=main)
  ![Downloads](https://img.shields.io/pypi/dw/jsonrpcserver)

  Process incoming JSON-RPC requests in Python.

  ```python
  from jsonrpcserver import method, serve, Success

  @method
  def ping():
      return Success("pong")

  if __name__ == "__main__":
      serve()
  ```

  Or use `dispatch` instead of `serve`:
  ```python
  response = dispatch('{"jsonrpc": "2.0", "method": "ping", "id": 1}')

  ```

  [Watch a video on how to use it.](https://www.youtube.com/watch?v=3_BMmgJaFHQ)

  Full documentation is at [jsonrpcserver.com](https://www.jsonrpcserver.com/).

  See also: [jsonrpcclient](https://github.com/explodinglabs/jsonrpcclient)


pkgId: 634f2e151f3e64a049499f59aff8ab31b1e98a60f448636f6be57d2eccca72fc
name: python-jsons
arch: src
version: 1.6.3
epoch: 0
release: 1
summary: For serializing Python objects to JSON (dicts) and back
url: https://github.com/ramonhagenaars/jsons
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9414d039-c61e-48da-9e67-58ef84080470
location_href: 00003988-python-jsons/python-jsons-1.6.3-1.src.rpm
checksum_type: sha256
description:
  [![Python versions](https://img.shields.io/pypi/pyversions/jsons.svg)](https://img.shields.io/pypi/pyversions/jsons.svg)
  [![Downloads](https://pepy.tech/badge/jsons)](https://pepy.tech/project/jsons)
  [![PyPI version](https://badge.fury.io/py/jsons.svg)](https://badge.fury.io/py/jsons)
  [![Code Coverage](https://codecov.io/gh/ramonhagenaars/jsons/branch/master/graph/badge.svg)](https://codecov.io/gh/ramonhagenaars/jsons)
  [![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/ramonhagenaars/jsons/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/ramonhagenaars/jsons/?branch=master)


  <p align='center'>
    <a href='https://jsons.readthedocs.io/en/latest/'>
      <img width='150' src='https://github.com/ramonhagenaars/jsons/raw/master/resources/jsons-logo.svg?sanitize=true' />
    </a>
  </p>

    - *Turn Python objects into dicts or (json)strings and back*
    - *No changes required to your objects*
    - *Easily customizable and extendable*
    - *Works with dataclasses, attrs and POPOs*

  ðŸ’— this lib? Leave a â˜… and tell your colleagues!

  Example of a model to serialize:

  ```python
  >>> @dataclass
  ... class Person:
  ...    name: str
  ...    birthday: datetime
  ...
  >>> p = Person('Guido van Rossum', birthday_guido)
  ```

  Example of using jsons to serialize:

  ```python
  >>> out = jsons.dump(p)
  >>> out
  {'birthday': '1956-01-31T12:00:00Z', 'name': 'Guido van Rossum'}
  ```

  Example of using jsons to deserialize:

  ```python
  >>> p2 = jsons.load(out, Person)
  >>> p2
  Person(name='Guido van Rossum', birthday=datetime.datetime(1956, 1, 31, 12, 0, tzinfo=datetime.timezone.utc))
  ```



      pip install jsons



  ```python
  import jsons

  some_instance = jsons.load(some_dict, SomeClass)  # Deserialization
  some_dict = jsons.dump(some_instance)  # Serialization
  ```

  In some cases, you have instances that contain other instances that need (de)serialization, for instance with lists or dicts. You can use the
  `typing` classes for this as is demonstrated below.

  ```python
  from typing import List, Tuple
  import jsons


  list_of_tuples = jsons.load(some_dict, List[Tuple[AClass, AnotherClass]])
  ```

  (For more examples, see the
  [FAQ](https://jsons.readthedocs.io/en/latest/faq.html))



    - [Main documentation](https://jsons.readthedocs.io/en/latest/)
    - [API docs](https://jsons.readthedocs.io/en/latest/api.html)
    - [FAQ](https://jsons.readthedocs.io/en/latest/faq.html)







  - Bugfix: a string was sometimes unintentionally parsed into a datetime.



  - Bugfix: `fork_inst`s were not propagated in `default_list_deserializer` (thanks to patrickguenther).



  - Bugfix: Loading dicts with hashed keys could cause an error due to being loaded twice (thanks to georgeharker).
  - Bugfix: IntEnums were not serialized with their names when `use_enum_name=True` (thanks to georgeharker).
  - Bugfix: Named tuples did not use `typing.get_type_hints` for getting the types, causing trouble in future annotations (thanks to georgeharker).



  - Feature: Support for Python3.10.
  - Feature: Support for `attrs`.



  - Bugfix: `ZoneInfo` failed to dump if attached to a `datetime`.



  - Feature: Support for `ZoneInfo` on Python3.9+.
  - Change: microseconds are no longer stripped by default (thanks to pietrodn).



  - Bugfix: get_origin did not work with python3.9+ parameterized collections (e.g. `dict[str, str]`).



  - Bugfix: Types of attributes that are not in the constructor were not properly looked for. See issue #128.



  - Feature: DefaultDicts can now be deserialized.
  - Feature: Dicts with any (hashable) key can now be dumped and loaded.
  - Feature: Suppress specific warnings.
  - Bugfix: Loading a verbose-serialized object in a list could sometimes deserialize that object as a parent class.
  - Bugfix: Unwanted stringification of NoneValues is now prevented in Optionals and Unions with NoneType.
  - Bugfix: Fixed a bug with postponed annotations and dataclasses. See also [Issue34776](https://bugs.python.org/issue34776).
  - Bugfix: Types of attributes that are not in the constructor are now looked for in __annotations__.



  - Bugfix: Fixed bug where classmethods were included in the serialized result.



  - Feature: Added `warn_on_fail` parameter to `default_list_deserializer` that allows to continue deserialization upon errors.
  - Feature: Added `transform` that can transform an object to an object of another type.
  - Feature: Added serializer and deserializer for `pathlib.Path` (thanks to alexmirrington).
  - Change: When loading a list fails, the error message now points to the failing index.
  - Bugfix: Fixed bug when dumping an object with an innerclass.



  - Bugfix: Fixed bug with postponed typehints (PEP-563).
  - Bugfix: Loading an invalid value targeting an optional did not raise.
  - Bugfix: Loading a dict did not properly pass key_transformers.
  - Bugfix: Loading a namedtuple did not properly use key_transformers.
  - Bugfix: Utilized `__annotations__` in favor `_field_types` because of deprecation as of 3.8.



  - Feature: Added `__version__` which can be imported from `jsons`
  - Bugfix: Dumping a tuple with ellipsis failed in strict mode.



    - Feature: Added a serializer for ``Union`` types.
    - Change: Exceptions are more clear upon deserialization failure (thanks to haluzpav).
    - Change: You can no longer announce a class with a custom name.
    - Bugfix: Fixed dumping optional attributes.
    - Bugfix: Dataclasses inheriting from ``JsonSerializable`` always dumped their attributes as if in strict mode.



    - Feature: Added ``strict`` parameter to ``dump`` to indicate that dumping a certain ``cls`` will ignore any extra data.
    - Feature: When using ``dump(obj, cls=x)``, ``x`` can now be any class (previously, only a class with ``__slots__``).
    - Feature: Support for dumping ``Decimal`` (thanks to herdigiorgi).
    - Feature: Primitives are now cast if possible when dumping (e.g. ``dump(5, str)``).
    - Feature: Dumping iterables with generic types (e.g. ``dump(obj, List[str])``) will now dump with respect to that types (if ``strict``)
    - Feature: The ``default_dict`` serializer now optionally accepts types: ``Optional[Dict[str, type]]``.
    - Change: Improved performance when dumping using ``strict=True`` (up to 4 times faster!).
    - Bugfix: ``set_validator`` with multiple types did not work.



    - Feature: Added a serializer/deserializer for `time`.
    - Feature: Added a serializer/deserializer for `timezone`.
    - Feature: Added a serializer/deserializer for `timedelta`.
    - Feature: Added a serializer/deserializer for `date`.
    - Bugfix: Dumping verbose did not store the types of dicts (`Dict[K,
      V]`).
    - Bugfix: Loading with `List` (no generic type) failed.
    - Bugfix: Loading with `Dict` (no generic type) failed.
    - Bugfix: Loading with `Tuple` (no generic type) failed.




  Special thanks to the following contributors of code, discussions or
  suggestions:

  [patrickguenther](https://github.com/patrickguenther),
  [davetapley](https://github.com/davetapley),
  [pietrodn](https://github.com/pietrodn),
  [georgeharker](https://github.com/georgeharker),
  [aecay](https://github.com/aecay),
  [bibz](https://github.com/bibz),
  [thijss](https://github.com/Thijss),
  [alexmirrington](https://github.com/alexmirrington),
  [tirkarthi](https://github.com/tirkarthi),
  [marksomething](https://github.com/marksomething),
  [herdigiorgi](https://github.com/herdigiorgi),
  [jochembroekhoff](https://github.com/jochembroekhoff),
  [robinklaassen](https://github.com/robinklaassen),
  [ahmetkucuk](https://github.com/ahmetkucuk),
  [casparjespersen](https://github.com/casparjespersen),
  [cypreess](https://github.com/cypreess),
  [gastlich](https://github.com/gastlich),
  [jmolinski](https://github.com/jmolinski),
  [haluzpav](https://github.com/haluzpav),
  [finetuned89](https://github.com/finetuned89)


pkgId: 0b24cca317bb9bb7c926644b46a380685f55acbe3acb232425efd08a9554a619
name: python-julia
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Julia/Python bridge with IPython support.
url: http://julialang.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-72819e0d-1276-406a-a4b4-94706218f688
location_href: 00013083-python-julia/python-julia-0.6.1-1.src.rpm
checksum_type: sha256
description:
  [![Stable documentation](https://img.shields.io/badge/docs-stable-blue.svg)](https://pyjulia.readthedocs.io/en/stable/)
  [![Latest documentation](https://img.shields.io/badge/docs-latest-blue.svg)](https://pyjulia.readthedocs.io/en/latest/)
  [![Main workflow](https://github.com/JuliaPy/pyjulia/workflows/Main%20workflow/badge.svg)](https://github.com/JuliaPy/pyjulia/actions?query=workflow%3A%22Main+workflow%22)
  [![DOI](https://zenodo.org/badge/14576985.svg)](https://zenodo.org/badge/latestdoi/14576985)
  Experimenting with developing a better interface to [Julia language](https://julialang.org/) that works with [Python](https://www.python.org/) 3 and Julia v1.4+.


pkgId: 74fe936bf1df806f6e8d45a336d9375243d397a564925aa5761ef91731f0da5c
name: python-junit-xml-2
arch: src
version: 1.9
epoch: 0
release: 1
summary: Fork of https://github.com/kyrus/python-junit-xml that has tarball published to pypi
url: https://github.com/returntocorp/python-junit-xml
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bd2d7a06-ac56-4aeb-bfd1-107985204aa0
location_href: 00013588-python-junit-xml-2/python-junit-xml-2-1.9-1.src.rpm
checksum_type: sha256
description:
  Fork of https://github.com/kyrus/python-junit-xml to publish on pypi as tarball so
  https://github.com/Homebrew/homebrew-core/blob/master/Formula/semgrep.rb can rely on this as a pypi package


pkgId: f433a93523f8b72a2de1ab55cd0259816b1370b4fef9fd7469af23e88ec4bb98
name: python-jupyter_highlight_selected_word
arch: src
version: 0.2.0
epoch: 0
release: 1
url: https://github.com/jcb91/jupyter_highlight_selected_word.git
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f134ebc2-b5cb-46d1-8b7d-99f48ee46bab
checksum_type: sha256
summary:
  Jupyter notebook extension that enables highlighting every instance of the current word in the notebook.

description:
  Jupyter notebook extension that enables highlighting of all instances of the
  currently-selected or cursor-adjecent word in either the current cell's editor,
  or in the whole notebook.
  Based on the  CodeMirror addon
  `Match Highlighter <https://codemirror.net/demo/matchhighlighter.html>`_,
  extended to work across multiple editors.

location_href:
  00010397-python-jupyter-highlight-selected-word/python-jupyter_highlight_selected_word-0.2.0-1.src.rpm


pkgId: 436b9967ae5857beb5e18a9b340492cfd0cfcbe5eb6860e60e740cd31d586177
name: python-jupyter_highlight_selected_word-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for jupyter_highlight_selected_word
url: https://github.com/jcb91/jupyter_highlight_selected_word.git
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f134ebc2-b5cb-46d1-8b7d-99f48ee46bab
rpm_sourcerpm: python-jupyter_highlight_selected_word-0.2.0-1.src.rpm
checksum_type: sha256
description:
  Jupyter notebook extension that enables highlighting of all instances of the
  currently-selected or cursor-adjecent word in either the current cell's editor,
  or in the whole notebook.
  Based on the  CodeMirror addon
  `Match Highlighter <https://codemirror.net/demo/matchhighlighter.html>`_,
  extended to work across multiple editors.

location_href:
  00010397-python-jupyter-highlight-selected-word/python-jupyter_highlight_selected_word-help-0.2.0-1.noarch.rpm


pkgId: 1af23d59c74be89951f8257556e22cc8a09e06dc98cb21b93db0ceec3fabcec5
name: python-jupyter_latex_envs
arch: src
version: 1.4.6
epoch: 0
release: 1
url: https://github.com/jfbercher/jupyter_latex_envs
rpm_license: Modified BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9d5eb10c-8b5e-4f61-a3bf-be73174f45b1
location_href: 00010393-python-jupyter-latex-envs/python-jupyter_latex_envs-1.4.6-1.src.rpm
checksum_type: sha256
summary:
  Jupyter notebook extension which supports (some) LaTeX environments within markdown cells. Also provides support for labels and crossreferences, document wide numbering, bibliography, and more...

description:
  This extension for Jupyter notebook enables the use of some LaTeX
  commands and environments markdown cells.
  1. **LaTeX commands and environments**
     -  support for some LaTeX commands within markdown cells, *e.g.*
        ``\textit``, ``\textbf``, ``\underline``.
     -  support for **theorems-like environments**, support for labels and
        cross references
     -  support for **lists**: *enumerate, itemize*,
     -  limited support for a **figure environment**,
     -  support for an environment *listing*,
     -  additional *textboxa* environment
  2. **Citations and bibliography**
     -  support for ``\cite`` with creation of a References section
  3. **Document-wide numbering of equations and environments, support for
     ``\label`` and ``\ref``**
  4. **Configuration toolbar**
  5. **LaTeX\_envs dropdown menu for a quick insertion of environments**
  6. **User's LaTeX definitions** file can be loaded and used
  7. **Export to plain HTML, Slides and LaTeX with a customized exporter**
  8. Environments title/numbering can be customized by users in
     ``user_envs.json`` config file.
  9. Styles can be customized in the ``latex_env.css`` stylesheet
  10. **Autocompletion** for \$, (, {, [, for LaTeX commands and environments
  More environments can be simply added in ``user_envs.json`` or in the
  source file (``thmsInNb4.js``).
  It is possible to export the notebooks to plain :math:`\LaTeX` and html
  while keeping all the features of the ``latex_envs`` notebook extension
  in the converted version. We provide specialized exporters, pre and post
  processors, templates. We also added entry-points to simplify the
  conversion process. It is now as simple as
      jupyter nbconvert --to html_with_lenvs FILE.ipynb
  or
      jupyter nbconvert --to latex_with_lenvs FILE.ipynb
  to convert ``FILE.ipynb`` into html/latex while keeping all the features
  of the ``latex_envs`` notebook extension in the converted version. Other options are
  ``slides_with_lenvs`` for converting to reveal-js presentations, and ``html_with_toclenvs`` to include a
  table of contents. The
  LaTeX converter also expose several conversion options (read the
  `docs <https://rawgit.com/jfbercher/jupyter_latex_envs/master/src/latex_envs/static/doc/latex_env_doc.html>`__).


pkgId: 880dda127da5bf165ae3ff0c29d93355b95ab323715dc214fe65666ce88043df
name: python-jupyterhub-kubespawner
arch: src
version: 4.3.0
epoch: 0
release: 1
summary: JupyterHub Spawner for Kubernetes
url: http://github.com/jupyterhub/kubespawner
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-31472d09-920e-4416-9746-3b6634916bec
location_href: 00011324-python-jupyterhub-kubespawner/python-jupyterhub-kubespawner-4.3.0-1.src.rpm
checksum_type: sha256
description:
  [![Documentation status](https://img.shields.io/readthedocs/jupyterhub-kubespawner?logo=read-the-docs)](https://jupyterhub-kubespawner.readthedocs.io/en/latest/?badge=latest)
  [![GitHub Workflow Status](https://img.shields.io/github/workflow/status/jupyterhub/kubespawner/Test?logo=github)](https://github.com/jupyterhub/kubespawner/actions)
  [![Code coverage](https://codecov.io/gh/jupyterhub/kubespawner/branch/main/graph/badge.svg)](https://codecov.io/gh/jupyterhub/kubespawner)
  [![](https://img.shields.io/pypi/v/jupyterhub-kubespawner.svg?logo=pypi)](https://pypi.python.org/pypi/jupyterhub-kubespawner)

  The _kubespawner_ (also known as JupyterHub Kubernetes Spawner) enables JupyterHub to spawn
  single-user notebook servers on a [Kubernetes](https://kubernetes.io/)
  cluster.

  See the [KubeSpawner documentation](https://jupyterhub-kubespawner.readthedocs.io) for more
  information about features and usage. In particular, here is [a list of all the spawner options](https://jupyterhub-kubespawner.readthedocs.io/en/latest/spawner.html#module-kubespawner.spawner).



  Kubernetes is an open-source system for automating deployment, scaling, and
  management of containerized applications. If you want to run a JupyterHub
  setup that needs to scale across multiple nodes (anything with over ~50
  simultaneous users), Kubernetes is a wonderful way to do it. Features include:

  - Easily and elasticly run anywhere between 2 and thousands of nodes with the
    same set of powerful abstractions. Scale up and down as required by simply
    adding or removing nodes.

  - Run JupyterHub itself inside Kubernetes easily. This allows you to manage
    many JupyterHub deployments with only Kubernetes, without requiring an extra
    layer of Ansible / Puppet / Bash scripts. This also provides easy integrated
    monitoring and failover for the hub process itself.

  - Spawn multiple hubs in the same kubernetes cluster, with support for
    [namespaces](https://kubernetes.io/docs/admin/namespaces/). You can limit the
    amount of resources each namespace can use, effectively limiting the amount
    of resources a single JupyterHub (and its users) can use. This allows
    organizations to easily maintain multiple JupyterHubs with just one
    kubernetes cluster, allowing for easy maintenance & high resource
    utilization.

  - Provide guarantees and limits on the amount of resources (CPU / RAM) that
    single-user notebooks can use. Kubernetes has comprehensive [resource control](https://kubernetes.io/docs/user-guide/compute-resources/) that can
    be used from the spawner.

  - Mount various types of [persistent volumes](https://kubernetes.io/docs/user-guide/persistent-volumes/)
    onto the single-user notebook's container.

  - Control various security parameters (such as userid/groupid, SELinux, etc)
    via flexible [Pod Security Policies](https://kubernetes.io/docs/user-guide/pod-security-policy/).

  - Run easily in multiple clouds (or on your own machines). Helps avoid vendor
    lock-in. You can even spread out your cluster across
    [multiple clouds at the same time](https://kubernetes.io/docs/user-guide/federation/).

  In general, Kubernetes provides a ton of well thought out, useful features -
  and you can use all of them along with this spawner.





  Everything should work from Kubernetes v1.6+.

  The [Kube DNS addon](https://kubernetes.io/docs/user-guide/connecting-applications/#dns)
  is not strictly required - the spawner uses
  [environment variable](https://kubernetes.io/docs/user-guide/connecting-applications/#environment-variables)
  based discovery instead. Your kubernetes cluster will need to be configured to
  support the types of volumes you want to use.

  If you are just getting started and want a kubernetes cluster to play with,
  [Google Container Engine](https://cloud.google.com/container-engine/) is
  probably the nicest option. For AWS/Azure,
  [kops](https://github.com/kubernetes/kops) is probably the way to go.



  We encourage you to ask questions on the
  [Jupyter mailing list](https://groups.google.com/forum/#!forum/jupyter).
  You can also participate in development discussions or get live help on
  [Gitter](https://gitter.im/jupyterhub/jupyterhub).



  We use a shared copyright model that enables all contributors to maintain the
  copyright on their contributions.

  All code is licensed under the terms of the revised BSD license.





  - [Reporting Issues](https://github.com/jupyterhub/kubespawner/issues)
  - [Documentation for JupyterHub](https://jupyterhub.readthedocs.io)
  - [Documentation for JupyterHub's REST API](https://petstore.swagger.io/?url=https://raw.githubusercontent.com/jupyter/jupyterhub/master/docs/rest-api.yml#/default)



  - [Documentation for Project Jupyter](https://jupyter.readthedocs.io/en/latest/index.html) | [PDF](https://media.readthedocs.org/pdf/jupyter/latest/jupyter.pdf)
  - [Project Jupyter website](https://jupyter.org)


pkgId: 70ef3cf163a36deb815be900bcb2e24957bb988bbc3d61420e37af729d3c2f3b
name: python-jupyterlab-pygments
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Pygments theme using JupyterLab CSS variables
url: https://github.com/jupyterlab/jupyterlab_pygments
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-47d02305-cf5a-4187-9530-879b0262eb4d
location_href: 00004000-python-jupyterlab_pygments/python-jupyterlab-pygments-0.2.2-1.src.rpm
checksum_type: sha256
description:
  This package contains a syntax coloring theme for [pygments](http://pygments.org/) making use of
  the JupyterLab CSS variables.

  The goal is to enable the use of JupyterLab's themes with pygments-generated HTML.



  In the following screencast, we demonstrate how Pygments-highlighted code can make use of the JupyterLab theme.

  ![pygments screencast](pygments.gif)



  `jupyterlab_pygments` can be installed with the conda package manager

  ```
  conda install -c conda-forge jupyterlab_pygments
  ```

  or from pypi

  ```
  pip install jupyterlab_pygments
  ```



  - `jupyterlab_pygments` requires [pygments](http://pygments.org) version `2.4.1`.
  - The CSS variables used by the theme correspond to the CodeMirror syntex coloring
    theme defined in the NPM package [@jupyterlab/codemirror](https://www.npmjs.com/package/@jupyterlab/codemirror). Supported versions for `@jupyterlab/codemirror`'s CSS include `0.19.1`, `^1.0`, and, `^2.0`.



  Pygments-generated HTML and CSS classes are not granular enough to reproduce
  all of the details of codemirror (the JavaScript text editor used by JupyterLab).

  This includes the ability to differentiate properties from general names.



  `jupyterlab_pygments` uses a shared copyright model that enables all contributors to maintain the
  copyright on their contributions. All code is licensed under the terms of the revised [BSD license](LICENSE).


pkgId: 5b3dc8aaef891d31f55fc791e0bfdb28d31c1f13e14c93e952e9ee7fad3dfb73
name: python-justbytes
arch: src
version: 0.15
epoch: 0
release: 1
summary: computing with and displaying bytes
url: http://pythonhosted.org/justbytes/
rpm_license: LGPLv2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bd25b00e-001e-4208-867a-c0fcb52c70a4
location_href: 00004002-python-justbytes/python-justbytes-0.15-1.src.rpm
checksum_type: sha256
description:
  Justbytes is a module for handling computation with
  address ranges expressed in bytes. Its principle feature is a Range class from
  which can be constructed Range objects which represent a precise and finite
  address range in bytes. Various arithmetic operations are defined for Range
  objects.
  Its sole purpose is the representation of real address ranges on real
  machines. For that reason, it does not allow powers of ranges, imprecise
  ranges, or non-finite ranges. In order that the
  usual laws of arithmetic can be maintained, it does allow fractional ranges.


pkgId: b3f9ce0d4b33787c8e641156cc2a6d7cd916e03904e7d1fa0c8ec4aeefac413b
name: python-jwcrypto
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: Implementation of JOSE Web standards
url: https://github.com/latchset/jwcrypto
rpm_license: LGPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9c7e3a65-5c85-44bc-b8e3-a05d5f1f9cb9
location_href: 00009637-python-jwcrypto/python-jwcrypto-1.4.2-1.src.rpm
checksum_type: sha256
description:
  An implementation of the JOSE Working Group documents:
  - RFC 7515 - JSON Web Signature (JWS)
  - RFC 7516 - JSON Web Encryption (JWE)
  - RFC 7517 - JSON Web Key (JWK)
  - RFC 7518 - JSON Web Algorithms (JWA)
  - RFC 7519 - JSON Web Token (JWT)
  - RFC 7520 - Examples of Protecting Content Using JSON Object Signing and
    Encryption (JOSE)


pkgId: 1a8dbbe619978bd66fe593636ef841e22c8151fa1617389106f1f7a82f346a27
name: python-jws
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: JSON Web Signatures implementation in Python
url: http://github.com/brianloveswords/python-jws
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e8481834-03f8-4ec1-9e52-bfbb8d2a56bd
location_href: 00011684-python-jws/python-jws-0.1.3-1.src.rpm
checksum_type: sha256
description:
  A Python implementation of [JSON Web Signatures draft 02](http://self-issued.info/docs/draft-jones-json-web-signature.html)
  Also now works on Python 3.3+ as well as Python 2.7+.  However, it's a naive conversion to support both Python 2 and Python 3 so there may well be hidden bugs.


pkgId: 866cf1aba5252e4f276f723187a98e8cb8489fd37ae7a3fa1a65ae4e3dfeef71
name: python-kafka-python
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: Pure Python client for Apache Kafka
url: https://github.com/dpkp/kafka-python
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f97a0985-3922-4997-b850-daf566227560
location_href: 00009156-python-kafka-python/python-kafka-python-2.0.2-1.src.rpm
checksum_type: sha256
description:
  Python client for the Apache Kafka distributed stream processing system.
  kafka-python is designed to function much like the official java client, with a
  sprinkling of pythonic interfaces (e.g., consumer iterators).
  kafka-python is best used with newer brokers (0.9+), but is backwards-compatible with
  older versions (to 0.8.0). Some features will only be enabled on newer brokers.
  For example, fully coordinated consumer groups -- i.e., dynamic partition
  assignment to multiple consumers in the same group -- requires use of 0.9+ kafka
  brokers. Supporting this feature for earlier broker releases would require
  writing and maintaining custom leadership election and membership / health
  check code (perhaps using zookeeper or consul). For older brokers, you can
  achieve something similar by manually assigning different partitions to each
  consumer instance with config management tools like chef, ansible, etc. This
  approach will work fine, though it does not support rebalancing on failures.
  See <https://kafka-python.readthedocs.io/en/master/compatibility.html>
  for more details.
  Please note that the master branch may contain unreleased features. For release
  documentation, please see readthedocs and/or python's inline help.
  >>> pip install kafka-python
  KafkaConsumer
  *************
  KafkaConsumer is a high-level message consumer, intended to operate as similarly
  as possible to the official java client. Full support for coordinated
  consumer groups requires use of kafka brokers that support the Group APIs: kafka v0.9+.
  See <https://kafka-python.readthedocs.io/en/master/apidoc/KafkaConsumer.html>
  for API and configuration details.
  The consumer iterator returns ConsumerRecords, which are simple namedtuples
  that expose basic message attributes: topic, partition, offset, key, and value:
  >>> from kafka import KafkaConsumer
  >>> consumer = KafkaConsumer('my_favorite_topic')
  >>> for msg in consumer:
  >>> # join a consumer group for dynamic partition assignment and offset commits
  >>> from kafka import KafkaConsumer
  >>> consumer = KafkaConsumer('my_favorite_topic', group_id='my_favorite_group')
  >>> for msg in consumer:
  >>> # manually assign the partition list for the consumer
  >>> from kafka import TopicPartition
  >>> consumer = KafkaConsumer(bootstrap_servers='localhost:1234')
  >>> consumer.assign([TopicPartition('foobar', 2)])
  >>> msg = next(consumer)
  >>> # Deserialize msgpack-encoded values
  >>> consumer = KafkaConsumer(value_deserializer=msgpack.loads)
  >>> consumer.subscribe(['msgpackfoo'])
  >>> for msg in consumer:
  >>> # Access record headers. The returned value is a list of tuples
  >>> # with str, bytes for key and value
  >>> for msg in consumer:
  >>> # Get consumer metrics
  >>> metrics = consumer.metrics()
  KafkaProducer
  *************
  KafkaProducer is a high-level, asynchronous message producer. The class is
  intended to operate as similarly as possible to the official java client.
  See <https://kafka-python.readthedocs.io/en/master/apidoc/KafkaProducer.html>
  for more details.
  >>> from kafka import KafkaProducer
  >>> producer = KafkaProducer(bootstrap_servers='localhost:1234')
  >>> for _ in range(100):
  >>> # Block until a single message is sent (or timeout)
  >>> future = producer.send('foobar', b'another_message')
  >>> result = future.get(timeout=60)
  >>> # Block until all pending messages are at least put on the network
  >>> # NOTE: This does not guarantee delivery or success! It is really
  >>> # only useful if you configure internal batching using linger_ms
  >>> producer.flush()
  >>> # Use a key for hashed-partitioning
  >>> producer.send('foobar', key=b'foo', value=b'bar')
  >>> # Serialize json messages
  >>> import json
  >>> producer = KafkaProducer(value_serializer=lambda v: json.dumps(v).encode('utf-8'))
  >>> producer.send('fizzbuzz', {'foo': 'bar'})
  >>> # Serialize string keys
  >>> producer = KafkaProducer(key_serializer=str.encode)
  >>> producer.send('flipflap', key='ping', value=b'1234')
  >>> # Compress messages
  >>> producer = KafkaProducer(compression_type='gzip')
  >>> for i in range(1000):
  >>> # Include record headers. The format is list of tuples with string key
  >>> # and bytes value.
  >>> producer.send('foobar', value=b'c29tZSB2YWx1ZQ==', headers=[('content-encoding', b'base64')])
  >>> # Get producer performance metrics
  >>> metrics = producer.metrics()
  Thread safety
  *************
  The KafkaProducer can be used across threads without issue, unlike the
  KafkaConsumer which cannot.
  While it is possible to use the KafkaConsumer in a thread-local manner,
  multiprocessing is recommended.
  Compression
  ***********
  kafka-python supports gzip compression/decompression natively. To produce or consume lz4
  compressed messages, you should install python-lz4 (pip install lz4).
  To enable snappy compression/decompression install python-snappy (also requires snappy library).
  See <https://kafka-python.readthedocs.io/en/master/install.html#optional-snappy-install>
  for more information.
  Optimized CRC32 Validation
  **************************
  Kafka uses CRC32 checksums to validate messages. kafka-python includes a pure
  python implementation for compatibility. To improve performance for high-throughput
  applications, kafka-python will use `crc32c` for optimized native code if installed.
  See https://pypi.org/project/crc32c/
  Protocol
  ********
  A secondary goal of kafka-python is to provide an easy-to-use protocol layer
  for interacting with kafka brokers via the python repl. This is useful for
  testing, probing, and general experimentation. The protocol support is
  leveraged to enable a KafkaClient.check_version() method that
  probes a kafka broker and attempts to identify which version it is running
  (0.8.0 to 2.4+).


pkgId: a61f4fd0a1321bca53708a39b22b4415dd491354891ad55713a4f843d91f6df6
name: python-kaggle
arch: src
version: 1.5.13
epoch: 0
release: 1
summary: Kaggle API
url: https://github.com/Kaggle/kaggle-api
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-01df395c-9707-4db3-9e93-2ec075d3cc75
location_href: 00010162-python-kaggle/python-kaggle-1.5.13-1.src.rpm
checksum_type: sha256
description:
  Official API for https://www.kaggle.com, accessible using a command line tool implemented in Python. Beta release - Kaggle reserves the right to modify the API functionality currently offered.


pkgId: 5805ead832d0a4e071d6f75ef01805cf13353de0fedeef23908a30f1b970323e
name: python-kaggle-environments
arch: src
version: 1.13.0
epoch: 0
release: 1
summary: Kaggle Environments
url: https://github.com/Kaggle/kaggle-environments
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-80b44886-f9e3-4d6b-a9ff-14552ca6a1b7
location_href: 00012299-python-kaggle-environments/python-kaggle-environments-1.13.0-1.src.rpm
checksum_type: sha256
description:
  ```bash
  pip install kaggle-environments
  ```



  ```python
  from kaggle_environments import make


  env = make("tictactoe")


  def my_agent(obs):
    return [c for c in range(len(obs.board)) if obs.board[c] == 0][0]


  env.run([my_agent, "random"])


  env.render(mode="ipython")
  ```



  Kaggle Environments was created to evaluate episodes. While other libraries have set interface precedents (such as Open.ai Gym), the emphasis of this library focuses on:

  1. Episode evaluation (compared to training agents).
  2. Configurable environment/agent lifecycles.
  3. Simplified agent and environment creation.
  4. Cross language compatible/transpilable syntax/interfaces.



  ```python

  from kaggle_environments import make
  help(make)
  env = make("tictactoe")
  dir(env)
  help(env.reset)
  ```



  > A function which given an observation generates an action.



  Agent functions can have observation and configuration parameters and must return a valid action. Details about the observation, configuration, and actions can seen by viewing the specification.

  ```python
  from kaggle_environments import make
  env = make("connectx", {"rows": 10, "columns": 8, "inarow": 5})

  def agent(observation, configuration):
    print(observation) # {board: [...], mark: 1}
    print(configuration) # {rows: 10, columns: 8, inarow: 5}
    return 3 # Action: always place a mark in the 3rd column.


  env.run([agent, "random"])


  print(env.specification.observation)
  print(env.specification.configuration)
  print(env.specification.action)
  ```



  Agents are always functions, however there are some shorthand syntax options to make generating/using them easier.

  ```python

  def agent1(obs):
    return [c for c in range(len(obs.board)) if obs.board[c] == 0][0]


  agent2 = "random"


  agent3 = """
  def act(obs):
    return [c for c in range(len(obs.board)) if obs.board[c] == 0][0]
  """


  agent4 = "C:\path\file.py"


  agent5 = 3


  agent6 = "http://localhost:8000/run/agent"
  ```



  Most environments contain default agents to play against. To see the list of available agents for a specific environment run:

  ```python
  from kaggle_environments import make
  env = make("tictactoe")


  print(*env.agents)


  env.run(["random", "reaction"])
  ```



  Open AI Gym interface is used to assist with training agents. The `None` keyword is used below to denote which agent to train (i.e. train as first or second player of connectx).

  ```python
  from kaggle_environments import make

  env = make("connectx", debug=True)


  trainer = env.train([None, "random"])

  obs = trainer.reset()
  for _ in range(100):
      env.render()
      action = 0 # Action for the agent being trained.
      obs, reward, done, info = trainer.step(action)
      if done:
          obs = trainer.reset()
  ```



  There are 3 types of errors which can occur from agent execution:

  1. **Timeout** - the agent runtime exceeded the allowed limit. There are 2 timeouts:
     1. `agentTimeout` - Used for initialization of an agent on first "act".
     2. `actTimeout` - Used for obtaining an action.
  2. **Error** - the agent raised and error during execution.
  3. **Invalid** - the agent action response didn't match the action specification or the environment deemed it invalid (i.e. playing twice in the same cell in tictactoe).

  To help debug your agent and why it threw the errors above, add the `debug` flag when setting up the environment.

  ```python
  from kaggle_environments import make

  def agent():
    return "Something Bad"

  env = make("tictactoe", debug=True)

  env.run([agent, "random"])

  ```



  > A function which given a state and agent actions generates a new state.

  | Name      | Description                          | Make                      |
  | --------- | ------------------------------------ | ------------------------- |
  | connectx  | Connect 4 in a row but configurable. | `env = make("connectx")`  |
  | tictactoe | Classic Tic Tac Toe                  | `env = make("tictactoe")` |
  | identity  | For debugging, action is the reward. | `env = make("identity")`  |



  An environment instance can be made from an existing specification (such as those listed above).

  ```python
  from kaggle_environments import make


  env = make(
    
    "connectx",

    
    configuration={"rows": 9, "columns": 10},

    
    steps=[],

    
    debug=True
  )
  ```



  There are two types of configuration: Defaults applying to every environment and those specific to the environment. The following is a list of the default configuration:

  | Name         | Description                                                     |
  | ------------ | --------------------------------------------------------------- |
  | episodeSteps | Maximum number of steps in the episode.                         |
  | agentTimeout | Maximum runtime (seconds) to initialize an agent.               |
  | actTimeout   | Maximum runtime (seconds) to obtain an action from an agent.    |
  | runTimeout   | Maximum runtime (seconds) of an episode (not necessarily DONE). |
  | maxLogLength | Maximum log length (number of characters, `None` -> no limit)   |

  ```python
  env = make("connectx", configuration={
    "columns": 19, # Specific to ConnectX.
    "actTimeout": 10,
  })
  ```



  Environments are reset by default after "make" (unless starting steps are passed in) as well as when calling "run". Reset can be called at anytime to clear the environment.

  ```python
  num_agents = 2
  reset_state = env.reset(num_agents)
  ```



  Execute an episode against the environment using the passed in agents until they are no longer running (i.e. status != ACTIVE).

  ```python
  steps = env.run([agent1, agent2])
  print(steps)
  ```



  Evaluation is used to run an episode (environment + agents) multiple times and just return the rewards.

  ```python
  from kaggle_environments import evaluate


  environment = "connectx"
  configuration = {"rows": 10, "columns": 8, "inarow": 5}
  steps = []


  agents = ["random", agent1]


  num_episodes = 10

  rewards = evaluate(environment, agents, configuration, steps, num_episodes)
  ```



  Running above essentially just steps until no agent is still active. To execute a singular game loop, pass in actions directly for each agent. Note that this is normally used for training agents (most useful in a single agent setup such as using the gym interface).

  ```python
  agent1_action = agent1(env.state[0].observation)
  agent2_action = agent2(env.state[1].observation)
  state = env.step([agent1_action, agent2_action])
  ```



  A few environments offer an interactive play against agents within jupyter notebooks. An example of this is using connectx:

  ```python
  from kaggle_environments import make

  env = make("connectx")

  env.play([None, "random"])
  ```



  The following rendering modes are supported:

  - json - Same as doing a json dump of `env.toJSON()`
  - ansi - Ascii character representation of the environment.
  - human - ansi just printed to stdout
  - html - HTML player representation of the environment.
  - ipython - html just printed to the output of a ipython notebook.

  ```python
  out = env.render(mode="ansi")
  print(out)
  ```



  ```sh
  > python main.py -h
  ```



  ```sh
  > python main.py list
  ```



  ```sh
  python main.py evaluate --environment tictactoe --agents random random --episodes 10
  ```



  ```sh
  > python main.py run --environment tictactoe --agents random /pathtomy/agent.py --debug True
  ```



  This is useful when converting an episode json output into html.

  ```sh
  python main.py load --environment tictactoe --steps [...] --render '{"mode": "html"}'
  ```



  The HTTP server contains the same interface/actions as the CLI above merging both POST body and GET params.



  ```bash
  python main.py http-server --port=8012 --host=0.0.0.0
  ```



  ```python

  import requests
  import json

  path_to_agent1 = "/home/ajeffries/git/playground/agent1.py"
  path_to_agent2 = "/home/ajeffries/git/playground/agent2.py"

  agent1_url = f"http://localhost:5001?agents[]={path_to_agent1}"
  agent2_url = f"http://localhost:5002?agents[]={path_to_agent2}"

  body = {
      "action": "run",
      "environment": "tictactoe",
      "agents": [agent1_url, agent2_url]
  }
  resp = requests.post(url="http://localhost:5000", data=json.dumps(body)).json()


  from kaggle_environments import make
  env = make("tictactoe", steps=resp["steps"], debug=True)
  env.render(mode="ipython")
  print(resp)
  ```


pkgId: 5dd1a7b630045f459f71b70fc31af666f354b70c0890213f37e9ee36d973a30c
name: python-kaitaistruct
arch: src
version: 0.10
epoch: 0
release: 1
summary: Kaitai Struct declarative parser generator for binary data: runtime library for Python
url: https://kaitai.io
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2485f690-89df-4ef1-8aec-6a25b497e062
location_href: 00004005-python-kaitaistruct/python-kaitaistruct-0.10-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/kaitaistruct)](https://pypi.org/project/kaitaistruct/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/kaitaistruct)](https://pypi.org/project/kaitaistruct/#:~:text=Programming%20Language)

  This library implements Kaitai Struct API for Python.

  [Kaitai Struct](https://kaitai.io/) is a declarative language used for
  describe various binary data structures, laid out in files or in memory:
  i.e. binary file formats, network stream packet formats, etc.

  It is similar to [Python's Construct 2.10](https://construct.readthedocs.io/en/latest/)
  but it is language-agnostic. The format description is done in YAML-based .ksy
  format, which then can be compiled into a wide range of target languages.

  Further reading:

  * [About Kaitai Struct](https://kaitai.io/)
  * [About API implemented in this library](https://doc.kaitai.io/stream_api.html)
  * [Python-specific notes](https://doc.kaitai.io/lang_python.html) in KS
    documentation discuss installation and usage of this runtime


pkgId: 67b85d940f50875ed719d27032a4bbe301670d700e0c8abd5f4e23842b11cf55
name: python-kajiki
arch: src
version: 0.9.2
epoch: 0
release: 1
summary: Fast XML-based template engine with Genshi syntax and Jinja blocks
url: https://github.com/jackrosenthal/kajiki
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a978c7cf-76bc-4944-b3de-848caa3d4029
location_href: 00004006-python-kajiki/python-kajiki-0.9.2-1.src.rpm
checksum_type: sha256
description:
  Because Kajiki's input is XML, it can ensure that your HTML/XML output is
  well-formed. The Genshi-like syntax, based on XML attributes or tags, is simply
  beautiful and easily understood (or ignored) by web designers.
  But instead of the slow performance of Genshi_, Kajiki compiles
  templates to Python code that renders with blazing-fast speed, so Kajiki can
  compete with the speed of Jinja_, Mako_, Chameleon_ and others.
  Also, one of Genshi's misfeatures -- py:match -- is replaced with blocks which
  work like Jinja's blocks.
  By combining the best ideas out there -- XML input,
  Genshi's syntax and features, Jinja's template inheritance and final
  compilation to Python --, Kajiki is ready to become
  the most widely used templating engine for web development in Python.
  And more features are coming soon; stay tuned!


pkgId: c26e52540f1017dc773f4e3d7b9941b4f7130c383ac14ee7447222248e692495
name: python-kazoo
arch: src
version: 2.9.0
epoch: 0
release: 1
summary: "Higher Level Zookeeper Client"
url: https://kazoo.readthedocs.io
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-25b83c5c-2551-4da1-9a38-c11e9a856f78
location_href: 00004008-python-kazoo/python-kazoo-2.9.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/python-zk/kazoo.svg?branch=master)](https://travis-ci.org/python-zk/kazoo)
  [![Latest Version](https://img.shields.io/pypi/v/kazoo.svg)](https://pypi.org/project/kazoo/)
  [![Reviewed by Hound](https://img.shields.io/badge/Reviewed_by-Hound-8E64B0.svg)](https://houndci.com)
  `kazoo` implements a higher level API to [Apache
  Zookeeper](http://zookeeper.apache.org/) for Python clients.
  See [the full docs](http://kazoo.rtfd.org/) for more information.


pkgId: 2efbb849663d6ec19fc5f801f2e264f78e986ce029998e2c99090ed2abb8405f
name: python-kazurator
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Inter process lock recipes that play nice with curator
url: https://github.com/pseudomuto/kazurator
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5c8cfbd1-61b8-4386-8b9a-e03d388e02f7
location_href: 00011105-python-kazurator/python-kazurator-0.2.0-1.src.rpm
checksum_type: sha256
description:
  |PyPI| |Build Status|
  A python port of the `Shared Reentrant Read Write Lock`_ recipe from `curator`_. This package dependends on `kazoo`_ for
  handling the zookeeper bits.
  At this point, you're probably wondering why I didn't just use the existing locks recipe from `kazoo`_. The original
  goal was to make `curator`_ and `kazoo`_ respect each other's locks such that:
  1. Either could acquire a read lock, so long as neither held a write
     lock
  2. Either could acquire a write lock, and block either from acquiring
     either read/write locks
  I first attempted to patch the locks recipe in `kazoo`_, but the internals are a bit different. (**READ**: *I wasn't
  able to make it work right*).
  The reason this is necessary (at least for me), is that some code was running Scala and using `curator`_, and other code
  was running Python using `kazoo`_.


pkgId: c144cc8cd0dc820a6cc724f8a1acdd7ca3564445f80730f1b413b7f9c11cbd2d
name: python-keep-alive
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: A package to keep an application online with HTTPS requests.
url: https://github.com/codebankco/keep-alive
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-792a7c96-094d-4548-bf6b-f741b650b66e
location_href: 00012065-python-keep-alive/python-keep-alive-0.0.1-1.src.rpm
checksum_type: sha256
description:
  A system for keeping an application alive with a webserver.

  Install with: pip install keep-alive.


pkgId: 2c88465c1fffc079887ee97845db574be16f3b0d456e8e885772a3aaac0a6516
name: python-keras-self-attention
arch: src
version: 0.51.0
epoch: 0
release: 1
summary: Attention mechanism for processing sequential data that considers the context for each timestamp
url: https://github.com/CyberZHG/keras-self-attention
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7f061e87-5b27-4e05-b770-54d097e59da7
location_href: 00013544-python-keras-self-attention/python-keras-self-attention-0.51.0-1.src.rpm
checksum_type: sha256
description:
  [![Version](https://img.shields.io/pypi/v/keras-self-attention.svg)](https://pypi.org/project/keras-self-attention/)
  ![License](https://img.shields.io/pypi/l/keras-self-attention.svg)

  \[[中文](https://github.com/CyberZHG/keras-self-attention/blob/master/README.zh-CN.md)|[English](https://github.com/CyberZHG/keras-self-attention/blob/master/README.md)\]

  Attention mechanism for processing sequential data that considers the context for each timestamp.

  * ![](https://user-images.githubusercontent.com/853842/44248592-1fbd0500-a21e-11e8-9fe0-52a1e4a48329.gif)
  * ![](https://user-images.githubusercontent.com/853842/44248591-1e8bd800-a21e-11e8-9ca8-9198c2725108.gif)
  * ![](https://user-images.githubusercontent.com/853842/44248590-1df34180-a21e-11e8-8ff1-268217f466ba.gif)
  * ![](https://user-images.githubusercontent.com/853842/44249018-8ba06d00-a220-11e8-80e3-802677b658ed.gif)



  ```bash
  pip install keras-self-attention
  ```





  By default, the attention layer uses additive attention and considers the whole context while calculating the relevance. The following code creates an attention layer that follows the equations in the first section (`attention_activation` is the activation function of `e_{t, t'}`):

  ```python
  import keras
  from keras_self_attention import SeqSelfAttention


  model = keras.models.Sequential()
  model.add(keras.layers.Embedding(input_dim=10000,
                                   output_dim=300,
                                   mask_zero=True))
  model.add(keras.layers.Bidirectional(keras.layers.LSTM(units=128,
                                                         return_sequences=True)))
  model.add(SeqSelfAttention(attention_activation='sigmoid'))
  model.add(keras.layers.Dense(units=5))
  model.compile(
      optimizer='adam',
      loss='categorical_crossentropy',
      metrics=['categorical_accuracy'],
  )
  model.summary()
  ```



  The global context may be too broad for one piece of data. The parameter `attention_width` controls the width of the local context:

  ```python
  from keras_self_attention import SeqSelfAttention

  SeqSelfAttention(
      attention_width=15,
      attention_activation='sigmoid',
      name='Attention',
  )
  ```



  You can use multiplicative attention by setting `attention_type`:

  ![](https://user-images.githubusercontent.com/853842/44253887-a03a3080-a233-11e8-9d49-3fd7e622a0f7.gif)

  ```python
  from keras_self_attention import SeqSelfAttention

  SeqSelfAttention(
      attention_width=15,
      attention_type=SeqSelfAttention.ATTENTION_TYPE_MUL,
      attention_activation=None,
      kernel_regularizer=keras.regularizers.l2(1e-6),
      use_attention_bias=False,
      name='Attention',
  )
  ```



  ![](https://user-images.githubusercontent.com/853842/44250188-f99b6300-a225-11e8-8fab-8dcf0d99616e.gif)

  To use the regularizer, set `attention_regularizer_weight` to a positive number:

  ```python
  import keras
  from keras_self_attention import SeqSelfAttention

  inputs = keras.layers.Input(shape=(None,))
  embd = keras.layers.Embedding(input_dim=32,
                                output_dim=16,
                                mask_zero=True)(inputs)
  lstm = keras.layers.Bidirectional(keras.layers.LSTM(units=16,
                                                      return_sequences=True))(embd)
  att = SeqSelfAttention(attention_type=SeqSelfAttention.ATTENTION_TYPE_MUL,
                         kernel_regularizer=keras.regularizers.l2(1e-4),
                         bias_regularizer=keras.regularizers.l1(1e-4),
                         attention_regularizer_weight=1e-4,
                         name='Attention')(lstm)
  dense = keras.layers.Dense(units=5, name='Dense')(att)
  model = keras.models.Model(inputs=inputs, outputs=[dense])
  model.compile(
      optimizer='adam',
      loss={'Dense': 'sparse_categorical_crossentropy'},
      metrics={'Dense': 'categorical_accuracy'},
  )
  model.summary(line_length=100)
  ```



  Make sure to add `SeqSelfAttention` to custom objects:

  ```python
  import keras

  keras.models.load_model(model_path, custom_objects=SeqSelfAttention.get_custom_objects())
  ```



  Set `history_only` to `True` when only historical data could be used:

  ```python
  SeqSelfAttention(
      attention_width=3,
      history_only=True,
      name='Attention',
  )
  ```



  Please refer to [keras-multi-head](https://github.com/CyberZHG/keras-multi-head).


pkgId: f10c15a86564896c5ba9d4f4557354532eb29772de74aee3fca06ec4028634fe
name: python-keyboard
arch: src
version: 0.13.5
epoch: 0
release: 1
summary: Hook and simulate keyboard events on Windows and Linux
url: https://github.com/boppreh/keyboard
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bca035a6-7968-485c-aec0-05e5a646a8b4
location_href: 00010791-python-keyboard/python-keyboard-0.13.5-1.src.rpm
checksum_type: sha256
description:
  Take full control of your keyboard with this small Python library. Hook global events, register hotkeys, simulate key presses and much more.

  - **Global event hook** on all keyboards (captures keys regardless of focus).
  - **Listen** and **send** keyboard events.
  - Works with **Windows** and **Linux** (requires sudo), with experimental **OS X** support (thanks @glitchassassin!).
  - **Pure Python**, no C modules to be compiled.
  - **Zero dependencies**. Trivial to install and deploy, just copy the files.
  - **Python 2 and 3**.
  - Complex hotkey support (e.g. `ctrl+shift+m, ctrl+space`) with controllable timeout.
  - Includes **high level API** (e.g. [record](#keyboard.record) and [play](#keyboard.play), [add_abbreviation](#keyboard.add_abbreviation)).
  - Maps keys as they actually are in your layout, with **full internationalization support** (e.g. `Ctrl+ç`).
  - Events automatically captured in separate thread, doesn't block main program.
  - Tested and documented.
  - Doesn't break accented dead keys (I'm looking at you, pyHook).
  - Mouse support available via project [mouse](https://github.com/boppreh/mouse) (`pip install mouse`).

  Install the [PyPI package](https://pypi.python.org/pypi/keyboard/):
      pip install keyboard
  or clone the repository (no installation required, source files are sufficient):
      git clone https://github.com/boppreh/keyboard
  or [download and extract the zip](https://github.com/boppreh/keyboard/archive/master.zip) into your project folder.
  Then check the [API docs below](https://github.com/boppreh/keyboard#api) to see what features are available.

  ```py
  import keyboard
  keyboard.press_and_release('shift+s, space')
  keyboard.write('The quick brown fox jumps over the lazy dog.')
  keyboard.add_hotkey('ctrl+shift+a', print, args=('triggered', 'hotkey'))

  keyboard.add_hotkey('page up, page down', lambda: keyboard.write('foobar'))

  keyboard.wait('esc')

  recorded = keyboard.record(until='esc')

  keyboard.play(recorded, speed_factor=3)

  keyboard.add_abbreviation('@@', 'my.long.email@example.com')

  keyboard.wait()
  ```

  - Events generated under Windows don't report device id (`event.device == None`). [#21](https://github.com/boppreh/keyboard/issues/21)
  - Media keys on Linux may appear nameless (scan-code only) or not at all. [#20](https://github.com/boppreh/keyboard/issues/20)
  - Key suppression/blocking only available on Windows. [#22](https://github.com/boppreh/keyboard/issues/22)
  - To avoid depending on X, the Linux parts reads raw device files (`/dev/input/input*`)
  but this requires root.
  - Other applications, such as some games, may register hooks that swallow all
  key events. In this case `keyboard` will be unable to report events.
  - This program makes no attempt to hide itself, so don't use it for keyloggers or online gaming bots. Be responsible.


pkgId: eb12d3c88f3701124160e5c4b9cc9eb934eddb4d754591637362a5d01e919ec4
name: python-keyrings.cryptfile
arch: src
version: 1.3.9
epoch: 0
release: 1
summary: Encrypted file keyring backend
url: https://github.com/frispete/keyrings.cryptfile
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1ca0d863-2f7a-4646-8abe-e0312dc2dfb1
location_href: 00013033-python-keyrings-cryptfile/python-keyrings.cryptfile-1.3.9-1.src.rpm
checksum_type: sha256
description:
  Encrypted plain file keyring backend for use with the
  [keyring](https://pypi.python.org/pypi/keyring)  package.


pkgId: c6b977549e5888513cc56fc21b7ac97c45639999016d0d807df3efefefa4413a
name: python-kfp-server-api
arch: src
version: 1.8.5
epoch: 0
release: 1
summary: Kubeflow Pipelines API
url: https://github.com/kubeflow/pipelines
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-62ae27d4-2a3a-422b-adca-18e9ef7fa72f
location_href: 00009725-python-kfp-server-api/python-kfp-server-api-1.8.5-1.src.rpm
checksum_type: sha256
description:
      This file contains REST API specification for Kubeflow Pipelines. The file is autogenerated from the swagger definition.  # noqa: E501


pkgId: cf095a13e5254a64d4a13e18fecbb9577002fde13f759d4c2dfe13e67ecbf187
name: python-kitchen
arch: src
version: 1.2.6
epoch: 0
release: 1
summary: Kitchen contains a cornucopia of useful code
url: https://fedorahosted.org/kitchen
rpm_license: LGPLv2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dc357ded-782a-494b-980d-3c696662d558
location_href: 00012398-python-kitchen/python-kitchen-1.2.6-1.src.rpm
checksum_type: sha256
description:
  We've all done it.  In the process of writing a brand new application we've
  discovered that we need a little bit of code that we've invented before.
  Perhaps it's something to handle unicode text.  Perhaps it's something to make
  a bit of python-2.5 code run on python-2.3.  Whatever it is, it ends up being
  a tiny bit of code that seems too small to worry about pushing into its own
  module so it sits there, a part of your current project, waiting to be cut and
  pasted into your next project.  And the next.  And the next.  And since that
  little bittybit of code proved so useful to you, it's highly likely that it
  proved useful to someone else as well.  Useful enough that they've written it
  and copy and pasted it over and over into each of their new projects.

  Well, no longer!  Kitchen aims to pull these small snippets of code into a few
  python modules which you can import and use within your project.  No more copy
  and paste!  Now you can let someone else maintain and release these small
  snippets so that you can get on with your life.


pkgId: c5f9fff96f2e54b2faf365cf21b2be175aab8740b8d174b31a358ffe64d218a1
name: python-kiwi-boxed-plugin
arch: src
version: 0.2.24
epoch: 0
release: 1
summary: KIWI - Boxed Build Plugin
url: https://github.com/OSInside/kiwi-boxed-plugin
rpm_license: GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-25954d40-c4fc-4920-bbe1-8e25e43b3b3a
location_href: 00004015-python-kiwi-boxed-plugin/python-kiwi-boxed-plugin-0.2.24-1.src.rpm
checksum_type: sha256
description:
  |GitHub CI Action|
  KIWI plugin to provide self contained build support. For further
  details see:
  `Building in a Self-Contained Environment <https://osinside.github.io/kiwi/plugins/self_contained.html>`__


pkgId: ac74c537545f65ce7e3c2c80d3afc1bfe61ebe0d1d3b2be3de52aea969b06bed
name: python-klusta
arch: src
version: 3.0.16
epoch: 0
release: 1
summary: Spike detection and automatic clustering for spike sorting
url: https://klusta.cortexlab.net
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e3ebf27e-b22a-4466-acd8-da09a276d8f3
location_href: 00004017-python-klusta/python-klusta-3.0.16-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://img.shields.io/travis/kwikteam/klusta.svg)](https://travis-ci.org/kwikteam/klusta)
  [![codecov.io](https://img.shields.io/codecov/c/github/kwikteam/klusta.svg)](http://codecov.io/github/kwikteam/klusta?branch=master)
  [![Documentation Status](https://readthedocs.org/projects/klusta/badge/?version=latest)](http://klusta.readthedocs.org/en/latest/)
  [![PyPI release](https://img.shields.io/pypi/v/klusta.svg)](https://pypi.python.org/pypi/klusta)
  [![GitHub release](https://img.shields.io/github/release/kwikteam/klusta.svg)](https://github.com/kwikteam/klusta/releases/latest)

  [**klusta**](https://github.com/kwikteam/klusta) is an open source package for automatic spike sorting of multielectrode neurophysiological recordings made with probes containing up to a few dozens of sites.

  We are also working actively on more sophisticated algorithms that will scale to hundreds/thousands of channels. This work is being done within the [phy project](https://github.com/kwikteam/phy), which is still experimental at this point.



  **klusta** implements the following features:

  * **Kwik**: An HDF5-based file format that stores the results of a spike sorting session.
  * **Spike detection** (also known as SpikeDetekt): an algorithm designed for probes containing tens of channels, based on a flood-fill algorithm in the adjacency graph formed by the recording sites in the probe.
  * **Automatic clustering** (also known as Masked KlustaKwik): an automatic clustering algorithm designed for high-dimensional structured datasets.




  You will need a GUI to visualize the spike sorting results.

  We have developed two GUI programs with the same features:

  * **phy KwikGUI**: newer project, scales to hundreds/thousands of channels, still relatively experimental. **It will be automatically installed if you follow the install instructions below.**
  * **[KlustaViewa](https://github.com/klusta-team/klustaviewa)**: widely used, but older and a bit hard to install since it relies on very old dependencies.

  Both GUIs work with the same **Kwik** format.




  The following instructions will install both **klusta** and the **phy KwikGUI**.

  1. Make sure that you have [**miniconda**](http://conda.pydata.org/miniconda.html) installed. You can choose the Python 3.5 64-bit version for your operating system (Linux, Windows, or OS X).
  2. [Download the environment file.](https://raw.githubusercontent.com/kwikteam/klusta/master/installer/environment.yml)
  3. Open a terminal (on Windows, `cmd`, not Powershell) in the directory where you saved the file and type:

      ```bash
      conda env create -n klusta -f environment.yml
      ```

  4. **Done**! Now, to use klusta and the phy KwikGUI, enter the directory that contains your files and type:

      ```bash
      source activate klusta  # omit the `source` on Windows
      klusta yourfile.prm  # spikesort your data with a PRM file
      phy kwik-gui yourfile.kwik  # open the GUI
      ```

      See the documentation for more details.




  To get the latest version of the software, open a terminal and type:

  ```
  source activate klusta  # omit the `source` on Windows
  pip install klusta phy phycontrib --upgrade
  ```




  **klusta** is written in pure Python. The clustering code, written in Python and Cython, currently lives in [another repository](https://github.com/kwikteam/klustakwik2/).




  * [Documentation](http://klusta.readthedocs.org/en/latest/) (work in progress)
  * [Paper in Nature Neuroscience (April 2016)](http://www.nature.com/neuro/journal/vaop/ncurrent/full/nn.4268.html)
  * [Mailing list](https://groups.google.com/forum/#!forum/klustaviewas)
  * [Sample data repository](http://phy.cortexlab.net/data/) (work in progress)




  **klusta** is developed by [Cyrille Rossant](http://cyrille.rossant.net), [Shabnam Kadir](https://iris.ucl.ac.uk/iris/browse/profile?upi=SKADI56), [Dan Goodman](http://thesamovar.net/), [Max Hunter](https://iris.ucl.ac.uk/iris/browse/profile?upi=MLDHU99), and [Kenneth Harris](https://iris.ucl.ac.uk/iris/browse/profile?upi=KDHAR02), in the [Cortexlab](https://www.ucl.ac.uk/cortexlab), University College London.


pkgId: 557529eb7a140b45925e49d22cb06060eabe3b172cf4b472278cca0dfbad01e3
name: python-kmodes
arch: src
version: 0.12.2
epoch: 0
release: 1
url: https://github.com/nicodv/kmodes
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-96cb34f1-fa27-42a1-8a0d-9156c5055946
location_href: 00010462-python-kmodes/python-kmodes-0.12.2-1.src.rpm
checksum_type: sha256
summary:
  Python implementations of the k-modes and k-prototypes clustering algorithms for clustering categorical data.


pkgId: ddeeed4c24164d715cf015e744201208dfccc8b3428b7f28fa901a62cb2341fb
name: python-koalas
arch: src
version: 1.8.2
epoch: 0
release: 1
summary: Koalas: pandas API on Apache Spark
url: https://github.com/databricks/koalas
rpm_license: http://www.apache.org/licenses/LICENSE-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a07b3690-aa7f-42b3-9f3b-17b3c477a8fb
location_href: 00009289-python-koalas/python-koalas-1.8.2-1.src.rpm
checksum_type: sha256
description:
  **NOTE**: Koalas supports Apache Spark 3.1 and below as it will be [officially included to PySpark in the upcoming Apache Spark 3.2](http://apache-spark-developers-list.1001551.n3.nabble.com/VOTE-SPIP-Support-pandas-API-layer-on-PySpark-td30996.html). This repository is now in maintenance mode. For Apache Spark 3.2 and above, please use PySpark directly.

  <p align="center">
    <img src="https://raw.githubusercontent.com/databricks/koalas/master/icons/koalas-logo.png" width="140"/>
  </p>

  <p align="center">
    pandas API on Apache Spark
    <br/>
    <a href="https://koalas.readthedocs.io/en/latest/?badge=latest"><strong>Explore Koalas docs »</strong></a>
    <br/>
    <br/>
    <a href="https://mybinder.org/v2/gh/databricks/koalas/master?filepath=docs%2Fsource%2Fgetting_started%2F10min.ipynb">Live notebook</a>
    ·
    <a href="https://github.com/databricks/koalas/issues">Issues</a>
    ·
    <a href="https://groups.google.com/forum/#!forum/koalas-dev">Mailing list</a>
    <br/>
    <strong><a href="https://www.gofundme.com/f/help-thirsty-koalas-devastated-by-recent-fires">Help Thirsty Koalas Devastated by Recent Fires</a></strong>
  </p>

  The Koalas project makes data scientists more productive when interacting with big data, by implementing the pandas DataFrame API on top of Apache Spark.

  pandas is the de facto standard (single-node) DataFrame implementation in Python, while Spark is the de facto standard for big data processing. With this package, you can:
   - Be immediately productive with Spark, with no learning curve, if you are already familiar with pandas.
   - Have a single codebase that works both with pandas (tests, smaller datasets) and with Spark (distributed datasets).

  We would love to have you try it and give us feedback, through our [mailing lists](https://groups.google.com/forum/#!forum/koalas-dev) or [GitHub issues](https://github.com/databricks/koalas/issues).

  Try the Koalas 10 minutes tutorial on a live Jupyter notebook [here](https://mybinder.org/v2/gh/databricks/koalas/master?filepath=docs%2Fsource%2Fgetting_started%2F10min.ipynb). The initial launch can take up to several minutes.

  [![Github Actions](https://github.com/databricks/koalas/workflows/master/badge.svg)](https://github.com/databricks/koalas/actions)
  [![codecov](https://codecov.io/gh/databricks/koalas/branch/master/graph/badge.svg)](https://codecov.io/gh/databricks/koalas)
  [![Documentation Status](https://readthedocs.org/projects/koalas/badge/?version=latest)](https://koalas.readthedocs.io/en/latest/?badge=latest)
  [![Latest Release](https://img.shields.io/pypi/v/koalas.svg)](https://pypi.org/project/koalas/)
  [![Conda Version](https://img.shields.io/conda/vn/conda-forge/koalas.svg)](https://anaconda.org/conda-forge/koalas)
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/databricks/koalas/master?filepath=docs%2Fsource%2Fgetting_started%2F10min.ipynb)
  [![Downloads](https://pepy.tech/badge/koalas)](https://pepy.tech/project/koalas)




  Koalas can be installed in many ways such as Conda and pip.

  ```bash

  conda install koalas -c conda-forge
  ```

  ```bash

  pip install koalas
  ```

  See [Installation](https://koalas.readthedocs.io/en/latest/getting_started/install.html) for more details.

  For Databricks Runtime, Koalas is pre-installed in Databricks Runtime 7.1 and above. Try [Databricks Community Edition](https://community.cloud.databricks.com/) for free. You can also follow these [steps](https://docs.databricks.com/libraries/index.html) to manually install a library on Databricks.

  Lastly, if your PyArrow version is 0.15+ and your PySpark version is lower than 3.0, it is best for you to set `ARROW_PRE_0_15_IPC_FORMAT` environment variable to `1` manually.
  Koalas will try its best to set it for you but it is impossible to set it if there is a Spark context already launched.

  Now you can turn a pandas DataFrame into a Koalas DataFrame that is API-compliant with the former:

  ```python
  import databricks.koalas as ks
  import pandas as pd

  pdf = pd.DataFrame({'x':range(3), 'y':['a','b','b'], 'z':['a','b','b']})


  df = ks.from_pandas(pdf)


  df.columns = ['x', 'y', 'z1']


  df['x2'] = df.x * df.x
  ```

  For more details, see [Getting Started](https://koalas.readthedocs.io/en/latest/getting_started/index.html) and [Dependencies](https://koalas.readthedocs.io/en/latest/getting_started/install.html#dependencies) in the official documentation.




  See [Contributing Guide](https://koalas.readthedocs.io/en/latest/development/contributing.html) and [Design Principles](https://koalas.readthedocs.io/en/latest/development/design.html) in the official documentation.




  See [FAQ](https://koalas.readthedocs.io/en/latest/user_guide/faq.html) in the official documentation.




  See [Best Practices](https://koalas.readthedocs.io/en/latest/user_guide/best_practices.html) in the official documentation.




  See [Koalas Talks and Blogs](https://koalas.readthedocs.io/en/latest/getting_started/videos_blogs.html) in the official documentation.


pkgId: 0a03111b2064405b6351ba7b6722489a253ffb2aca8390ff33d6ef87c4414893
name: python-koan
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: Kickstart over a Network Client for Cobbler
url: https://www.github.com/cobbler/koan
rpm_license: GPLv2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-efd64d2f-b85c-40fd-bb8f-90f845e8355a
location_href: 00004018-python-koan/python-koan-3.0.1-1.src.rpm
checksum_type: sha256
description:
  This client can initiate and prepare a reinstallation of your operation system with the help ofcobbler.


pkgId: 50a078f56b414cf5377a625df20670a063be7738fb16f785866dfc24044bacde
name: python-kodexa
arch: src
version: 6.1.14616669258
epoch: 0
release: 1
summary: Python SDK for the Kodexa Platform
url: https://pypi.org/project/kodexa/
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ffc8891b-5b6d-41cb-b85d-a1c8acce75fb
location_href: 00013157-python-kodexa/python-kodexa-6.1.14616669258-1.src.rpm
checksum_type: sha256
description:
  [![Build and Package with Poetry](https://github.com/kodexa-ai/kodexa/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/kodexa-ai/kodexa/actions/workflows/main.yml)

  ![img.png](https://docs.kodexa.com/img.png)

  Kodexa is a platform for building intelligent document processing pipelines. It is a set of tools and services that
  allow you to build a pipeline that can take a document, extract the content, and then process it to extract the
  information you need.

  It is built on a set of core principles:

  * **Document Centric** - Kodexa is built around the idea of a document. A document is a collection of content
    nodes that are connected together. This is a powerful model that allows you to build pipelines that can
    extract content from a wide range of sources.

  * **Pipeline Oriented** - Kodexa is built around the idea of a pipeline. A pipeline is a series of steps that
    can be executed on a document. This allows you to build a pipeline that can extract content from a wide range
    of sources.

  * **Extensible** - Kodexa is built around the idea of a pipeline. A pipeline is a series of steps that can be executed
    on a document. This allows you to build a pipeline that can extract content from a wide range of sources.

  * **Label Driven** - Kodexa focuses on the idea of labels. Labels are a way to identify content within a document
    and then use that content to drive the processing of the document.



  This repository contains the Python SDK for Kodexa. The SDK is the primary way to interact with Kodexa. It allows you to
  define actions, models, and pipelines that can be executed on Kodexa. It also includes a complete SDK client for
  working with a Kodexa platform instance.



  Documentation is available at the [Kodexa Documentation Portal](https://docs.kodexa.com)



  [//]: # (Replace it with the diagrams and descriptions for build releases)
  **BUILD VERSION FLOW**
  ![build-version-flow.png](docs%2Fbuild-version-flow.png)
  Build version will differ based on the branches that are published to pypi.

  **GITHUB PROCESS**
  ![github-process.png](docs%2Fgithub-process.png)
  Changes that contain bugs, features, and fixes should first be pushed to the test branch.
  Once these changes are thoroughly tested, they can be submitted as a pull request to the main branch. The pull request should be reviewed and approved by an appropriate person before the changes can be merged.



  We use poetry to manage our dependencies, so you can install them with:

      poetry install

  You can then run the tests with:

      poetry run pytest



  We welcome contributions to the Kodexa platform. Please see our [contributing guide](CONTRIBUTING.md) for more details.



  Apache 2.0


pkgId: 90c21e5e9d9af809a004f12bb915433c4c8461b307aafba64ee2ee71b946c17a
name: python-koji
arch: src
version: 1.32.0
epoch: 0
release: 1
url: http://pagure.io/koji/
rpm_license: LGPLv2 and GPLv2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-74ead7d7-4cba-4088-b07a-7ff039ae4e02
location_href: 00004026-python-koji/python-koji-1.32.0-1.src.rpm
checksum_type: sha256
summary:
  Koji is a system for building and tracking RPMS. The base package contains shared libraries and the command-line interface.

description:
  Koji is an RPM-based build system. The Fedora Project uses Koji for [their build system](https://koji.fedoraproject.org/koji/), as do [several other projects](https://fedoraproject.org/wiki/Koji/RunsHere).
  Koji's goal is to provide a flexible, secure, and reproducible way to build software.
  Key features:
  * New buildroot for each build
  * Robust XML-RPC APIs for easy integration with other tools
  * Web interface with SSL and Kerberos authentication
  * Thin, portable command line client
  * Users can create local buildroots
  * Buildroot contents are tracked in the database
  * Versioned data


pkgId: 9a63ad855a70d18ce85ff5bb481819ebd0837399bb63e06d0086fcac2881d284
name: python-konoha
arch: src
version: 5.4.0
epoch: 0
release: 1
summary: A tiny sentence/word tokenizer for Japanese text written in Python
url: https://pypi.org/project/konoha/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-59747243-163b-4d3e-a9eb-2cd72fd47312
location_href: 00012202-python-konoha/python-konoha-5.4.0-1.src.rpm
checksum_type: sha256
description:
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/himkt/konoha/blob/main/example/Konoha_Example.ipynb)
  <p align="center"><img src="https://user-images.githubusercontent.com/5164000/120913279-e7d62380-c6d0-11eb-8d17-6571277cdf27.gif" width="95%"></p>

  [![GitHub stars](https://img.shields.io/github/stars/himkt/konoha?style=social)](https://github.com/himkt/konoha/stargazers)

  [![Downloads](https://pepy.tech/badge/konoha)](https://pepy.tech/project/konoha)
  [![Downloads](https://pepy.tech/badge/konoha/month)](https://pepy.tech/project/konoha/month)
  [![Downloads](https://pepy.tech/badge/konoha/week)](https://pepy.tech/project/konoha/week)

  [![Build Status](https://github.com/himkt/konoha/workflows/Python%20package/badge.svg?style=flat-square)](https://github.com/himkt/konoha/actions)
  [![Documentation Status](https://readthedocs.org/projects/konoha/badge/?version=latest)](https://konoha.readthedocs.io/en/latest/?badge=latest)
  ![Python](https://img.shields.io/badge/python-3.6%20%7C%203.7%20%7C%203.8-blue?logo=python)
  [![PyPI](https://img.shields.io/pypi/v/konoha.svg)](https://pypi.python.org/pypi/konoha)
  [![GitHub Issues](https://img.shields.io/github/issues/himkt/konoha.svg?cacheSeconds=60&color=yellow)](https://github.com/himkt/konoha/issues)
  [![GitHub Pull Requests](https://img.shields.io/github/issues-pr/himkt/konoha.svg?cacheSeconds=60&color=yellow)](https://github.com/himkt/konoha/issues)

  `Konoha` is a Python library for providing easy-to-use integrated interface of various Japanese tokenizers,
  which enables you to switch a tokenizer and boost your pre-processing.



  <a href="https://github.com/buruzaemon/natto-py"><img src="https://img.shields.io/badge/MeCab-natto--py-ff69b4"></a>
  <a href="https://github.com/chezou/Mykytea-python"><img src="https://img.shields.io/badge/KyTea-Mykytea--python-ff69b4"></a>
  <a href="https://github.com/mocobeta/janome"><img src="https://img.shields.io/badge/Janome-janome-ff69b4"></a>
  <a href="https://github.com/WorksApplications/SudachiPy"><img src="https://img.shields.io/badge/Sudachi-sudachipy-ff69b4"></a>
  <a href="https://github.com/google/sentencepiece"><img src="https://img.shields.io/badge/Sentencepiece-sentencepiece-ff69b4"></a>
  <a href="https://github.com/taishi-i/nagisa"><img src="https://img.shields.io/badge/nagisa-nagisa-ff69b4"></a>

  Also, `konoha` provides rule-based tokenizers (whitespace, character) and a rule-based sentence splitter.




  Simply run followings on your computer:

  ```bash
  docker run --rm -p 8000:8000 -t himkt/konoha  # from DockerHub
  ```

  Or you can build image on your machine:

  ```bash
  git clone https://github.com/himkt/konoha  # download konoha
  cd konoha && docker-compose up --build  # build and launch container
  ```

  Tokenization is done by posting a json object to `localhost:8000/api/v1/tokenize`.
  You can also batch tokenize by passing `texts: ["１つ目の入力", "２つ目の入力"]` to `localhost:8000/api/v1/batch_tokenize`.

  (API documentation is available on `localhost:8000/redoc`, you can check it using your web browser)

  Send a request using `curl` on your terminal.
  Note that a path to an endpoint is changed in v4.6.4.
  Please check our release note (https://github.com/himkt/konoha/releases/tag/v4.6.4).

  ```json
  $ curl localhost:8000/api/v1/tokenize -X POST -H "Content-Type: application/json" \
      -d '{"tokenizer": "mecab", "text": "これはペンです"}'

  {
    "tokens": [
      [
        {
          "surface": "これ",
          "part_of_speech": "名詞"
        },
        {
          "surface": "は",
          "part_of_speech": "助詞"
        },
        {
          "surface": "ペン",
          "part_of_speech": "名詞"
        },
        {
          "surface": "です",
          "part_of_speech": "助動詞"
        }
      ]
    ]
  }
  ```





  I recommend you to install konoha by `pip install 'konoha[all]'`.

  - Install konoha with a specific tokenizer: `pip install 'konoha[(tokenizer_name)]`.
  - Install konoha with a specific tokenizer and remote file support: `pip install 'konoha[(tokenizer_name),remote]'`

  If you want to install konoha with a tokenizer, please install konoha with a specific tokenizer
  (e.g. `konoha[mecab]`, `konoha[sudachi]`, ...etc) or install tokenizers individually.






  ```python
  from konoha import WordTokenizer

  sentence = '自然言語処理を勉強しています'

  tokenizer = WordTokenizer('MeCab')
  print(tokenizer.tokenize(sentence))


  tokenizer = WordTokenizer('Sentencepiece', model_path="data/model.spm")
  print(tokenizer.tokenize(sentence))

  ```

  For more detail, please see the `example/` directory.



  Konoha supports dictionary and model on cloud storage (currently supports Amazon S3).
  It requires installing konoha with the `remote` option, see [Installation](#installation).

  ```python

  word_tokenizer = WordTokenizer("mecab", user_dictionary_path="s3://abc/xxx.dic")
  print(word_tokenizer.tokenize(sentence))


  word_tokenizer = WordTokenizer("mecab", system_dictionary_path="s3://abc/yyy")
  print(word_tokenizer.tokenize(sentence))


  word_tokenizer = WordTokenizer("sentencepiece", model_path="s3://abc/zzz.model")
  print(word_tokenizer.tokenize(sentence))
  ```



  ```python
  from konoha import SentenceTokenizer

  sentence = "私は猫だ。名前なんてものはない。だが，「かわいい。それで十分だろう」。"

  tokenizer = SentenceTokenizer()
  print(tokenizer.tokenize(sentence))

  ```

  You can change symbols for a sentence splitter and bracket expression.

  1. sentence splitter

  ```python
  sentence = "私は猫だ。名前なんてものはない．だが，「かわいい。それで十分だろう」。"

  tokenizer = SentenceTokenizer(period="．")
  print(tokenizer.tokenize(sentence))

  ```

  2. bracket expression

  ```python
  sentence = "私は猫だ。名前なんてものはない。だが，『かわいい。それで十分だろう』。"

  tokenizer = SentenceTokenizer(
      patterns=SentenceTokenizer.PATTERNS + [re.compile(r"『.*?』")],
  )
  print(tokenizer.tokenize(sentence))

  ```




  ```
  python -m pytest
  ```



  - [トークナイザをいい感じに切り替えるライブラリ konoha を作った](https://qiita.com/klis/items/bb9ffa4d9c886af0f531)
  - [日本語解析ツール Konoha に AllenNLP 連携機能を実装した](https://qiita.com/klis/items/f1d29cb431d1bf879898)



  Sentencepiece model used in test is provided by @yoheikikuta. Thanks!


pkgId: 3220ba95dcdad9174b039d55161b970865e81316dc61580ac8cfee434f56c729
name: python-kopf
arch: src
version: 1.36.0
epoch: 0
release: 1
summary: Kubernetes Operator Pythonic Framework (Kopf)
url: https://github.com/nolar/kopf
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f7c9b349-d997-4e56-a60b-7cb7153962bc
location_href: 00011540-python-kopf/python-kopf-1.36.0-1.src.rpm
checksum_type: sha256
description:
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/kopf.svg)](https://pypi.org/project/kopf/)
  [![CI](https://github.com/nolar/kopf/workflows/Thorough%20tests/badge.svg)](https://github.com/nolar/kopf/actions/workflows/thorough.yaml)
  [![codecov](https://codecov.io/gh/nolar/kopf/branch/main/graph/badge.svg)](https://codecov.io/gh/nolar/kopf)
  [![Coverage Status](https://coveralls.io/repos/github/nolar/kopf/badge.svg?branch=main)](https://coveralls.io/github/nolar/kopf?branch=main)
  [![Total alerts](https://img.shields.io/lgtm/alerts/g/nolar/kopf.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/nolar/kopf/alerts/)
  [![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/nolar/kopf.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/nolar/kopf/context:python)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)

  **Kopf** —Kubernetes Operator Pythonic Framework— is a framework and a library
  to make Kubernetes operators development easier, just in a few lines of Python code.

  The main goal is to bring the Domain-Driven Design to the infrastructure level,
  with Kubernetes being an orchestrator/database of the domain objects (custom resources),
  and the operators containing the domain logic (with no or minimal infrastructure logic).

  The project was originally started as `zalando-incubator/kopf` in March 2019,
  and then forked as `nolar/kopf` in August 2020: but it is the same codebase,
  the same packages, the same developer(s).




  * https://kopf.readthedocs.io/




  * Simple, but powerful:
    * A full-featured operator in just 2 files: a `Dockerfile` + a Python file (*).
    * Handling functions registered via decorators with a declarative approach.
    * No infrastructure boilerplate code with K8s API communication.
    * Both sync and async handlers, with sync ones being threaded under the hood.
    * Detailed documentation with examples.
  * Intuitive mapping of Python concepts to Kubernetes concepts and back:
    * Marshalling of resources' data to the handlers' kwargs.
    * Marshalling of handlers' results to the resources' statuses.
    * Publishing of logging messages as Kubernetes events linked to the resources.
  * Support anything that exists in K8s:
    * Custom K8s resources.
    * Builtin K8s resources (pods, namespaces, etc).
    * Multiple resource types in one operator.
    * Both cluster and namespaced operators.
  * All the ways of handling that a developer can wish for:
    * Low-level handlers for events received from K8s APIs "as is" (an equivalent of _informers_).
    * High-level handlers for detected causes of changes (creation, updates with diffs, deletion).
    * Handling of selected fields only instead of the whole objects (if needed).
    * Dynamically generated or conditional sub-handlers (an advanced feature).
    * Timers that tick as long as the resource exists, optionally with a delay since the last change.
    * Daemons that run as long as the resource exists (in threads or asyncio-tasks).
    * Validating and mutating admission webhook (with dev-mode tunneling).
    * Live in-memory indexing of resources or their excerpts.
    * Filtering with stealth mode (no logging): by arbitrary filtering functions,
      by labels/annotations with values, presence/absence, or dynamic callbacks.
    * In-memory all-purpose containers to store non-serializable objects for individual resources.
  * Eventual consistency of handling:
    * Retrying the handlers in case of arbitrary errors until they succeed.
    * Special exceptions to request a special retry or to never retry again.
    * Custom limits for the number of attempts or the time.
    * Implicit persistence of the progress that survives the operator restarts.
    * Tolerance to restarts and lengthy downtimes: handles the changes afterwards.
  * Awareness of other Kopf-based operators:
    * Configurable identities for different Kopf-based operators for the same resource kinds.
    * Avoiding double-processing due to cross-pod awareness of the same operator ("peering").
    * Pausing of a deployed operator when a dev-mode operator runs outside of the cluster.
  * Extra toolkits and integrations:
    * Some limited support for object hierarchies with name/labels propagation.
    * Friendly to any K8s client libraries (and is client agnostic).
    * Startup/cleanup operator-level handlers.
    * Liveness probing endpoints and rudimentary metrics exports.
    * Basic testing toolkit for in-memory per-test operator running.
    * Embeddable into other Python applications.
  * Highly configurable (to some reasonable extent).

  (*) _Small font: two files of the operator itself, plus some amount of
  deployment files like RBAC roles, bindings, service accounts, network policies
  — everything needed to deploy an application in your specific infrastructure._




  See [examples](https://github.com/nolar/kopf/tree/main/examples)
  for the examples of the typical use-cases.

  A minimalistic operator can look like this:

  ```python
  import kopf

  @kopf.on.create('kopfexamples')
  def create_fn(spec, name, meta, status, **kwargs):
      print(f"And here we are! Created {name} with spec: {spec}")
  ```

  Numerous kwargs are available, such as `body`, `meta`, `spec`, `status`,
  `name`, `namespace`, `retry`, `diff`, `old`, `new`, `logger`, etc:
  see [Arguments](https://kopf.readthedocs.io/en/latest/kwargs/)

  To run a never-exiting function for every resource as long as it exists:

  ```python
  import time
  import kopf

  @kopf.daemon('kopfexamples')
  def my_daemon(spec, stopped, **kwargs):
      while not stopped:
          print(f"Object's spec: {spec}")
          time.sleep(1)
  ```

  Or the same with the timers:

  ```python
  import kopf

  @kopf.timer('kopfexamples', interval=1)
  def my_timer(spec, **kwargs):
      print(f"Object's spec: {spec}")
  ```

  That easy! For more features, see the [documentation](https://kopf.readthedocs.io/).




  Python 3.7+ is required:
  [CPython](https://www.python.org/) and [PyPy](https://www.pypy.org/)
  are officially supported and tested; other Python implementations can work too.

  We assume that when the operator is executed in the cluster, it must be packaged
  into a docker image with a CI/CD tool of your preference.

  ```dockerfile
  FROM python:3.11
  ADD . /src
  RUN pip install kopf
  CMD kopf run /src/handlers.py --verbose
  ```

  Where `handlers.py` is your Python script with the handlers
  (see `examples/*/example.py` for the examples).

  See `kopf run --help` for other ways of attaching the handlers.




  Please read [CONTRIBUTING.md](https://github.com/nolar/kopf/blob/main/CONTRIBUTING.md)
  for details on our process for submitting pull requests to us, and please ensure
  you follow the [CODE_OF_CONDUCT.md](https://github.com/nolar/kopf/blob/main/CODE_OF_CONDUCT.md).

  To install the environment for the local development,
  read [DEVELOPMENT.md](https://github.com/nolar/kopf/blob/main/DEVELOPMENT.md).




  We use [SemVer](http://semver.org/) for versioning. For the versions available,
  see the [releases on this repository](https://github.com/nolar/kopf/releases).




  This project is licensed under the MIT License —
  see the [LICENSE](https://github.com/nolar/kopf/blob/main/LICENSE) file for details.




  * Thanks to Zalando for starting this project in Zalando's Open-Source Incubator
    in the first place.
  * Thanks to [@side8](https://github.com/side8) and their [k8s-operator](https://github.com/side8/k8s-operator)
    for inspiration.


pkgId: b45671cc2f1fe84dcc311db4a768cd31dacf4023a0422eabfc34182d4c8c76ab
name: python-korean-lunar-calendar
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Korean Lunar Calendar
url: https://github.com/usingsky/korean_lunar_calendar_py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e5b645bb-d507-4e15-8b9a-338fe33d9069
location_href: 00004034-python-korean-lunar-calendar/python-korean-lunar-calendar-0.3.1-1.src.rpm
checksum_type: sha256
description:
  한국 양음력 변환
  Overview
  ^^^^^^^^
  Here is a library to convert Korean lunar-calendar to Gregorian
  calendar.
  Korean calendar and Chinese calendar is same lunar calendar but have
  different date.
  This follow the KARI(Korea Astronomy and Space Science Institute)
  한국 양음력 변환 (한국천문연구원 기준) - 네트워크 연결 불필요
  음력 변환은 1000년 01월 01일 부터 2050년 11월 18일까지 지원
  양력 변환은 1000년 02월 13일 부터 2050년 12월 31일까지 지원
      Gregorian calendar (1000-02-13 ~ 2050-12-31) <--> Korean lunar-calendar (1000-01-01 ~ 2050-11-18)
  Install
  ^^^^^^^
  pip install korean\_lunar\_calendar
  To use
  ^^^^^^
  (0) import module
          from korean_lunar_calendar import KoreanLunarCalendar
  (1) Korean Solar Date -> Korean Lunar Date (양력 -> 음력)
          calendar = KoreanLunarCalendar()
          
          calendar.setSolarDate(2017, 6, 24)
          
          print(calendar.LunarIsoFormat())
          
          print(calendar.getGapJaString())
          
          print(calendar.getChineseGapJaString())
      [Result]
      2017-05-01 Intercalation
      정유년 병오월 임오일 (윤월)
      丁酉年 丙午月 壬午日 (閏月)
  (2) Korean Lunar Date -> Korean Solar Date (음력 -> 양력)
          
          calendar.setLunarDate(1956, 1, 21, False)
          
          print(calendar.SolarIsoFormat())
          
          print(calendar.getGapJaString())
          
          print(calendar.getChineseGapJaString())
      [Result]
      1956-03-03
      병신년 경인월 기사일
      丙申年 庚寅月 己巳日


pkgId: ec8044f858ea1b08a418ae2ad2517c4001d853d0d4f0331ac8b3253a9c74b884
name: python-krbcontext
arch: src
version: 0.10
epoch: 0
release: 1
summary: A Kerberos context manager
url: https://github.com/krbcontext/python-krbcontext
rpm_license: GPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3eaf9409-8184-4763-865e-77729bbf5d0b
location_href: 00004035-python-krbcontext/python-krbcontext-0.10-1.src.rpm
checksum_type: sha256
description:
  ``krbcontext`` provides a Kerberos context that you can put code inside, which
  requires a valid ticket in credential cache.


pkgId: 9adf4cf198aa65f93177299457185d69a36a2ef4855eabdebe61115b2a7240c4
name: python-landslide
arch: src
version: 1.1.9
epoch: 0
release: 1
summary: HTML5 slideshow generator for Markdown, ReST, and Textile
url: http://github.com/adamzap/landslide
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e6f7c945-ce6a-40ac-8419-bf81e0db57e2
location_href: 00004041-python-landslide/python-landslide-1.1.9-1.src.rpm
checksum_type: sha256
description:
  Landslide takes your Markdown, ReST, or Textile file(s) and generates fancy
  HTML5 slideshow like `this <http://landslide.adamzap.com/>`_.

  Read the `README <http://github.com/adamzap/landslide/blob/master/README.md>`_
  for formatting instructions and more information.


pkgId: b36943e8a3833ec40d3e2f1206c81b4e6b2628da02165f92b614e11c252faf41
name: python-langdetect
arch: src
version: 1.0.9
epoch: 0
release: 1
summary: Language detection library ported from Google's language-detection.
url: https://github.com/Mimino666/langdetect
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0f7066f0-7b4c-4ed4-a077-877aef3a6597
location_href: 00009422-python-langdetect/python-langdetect-1.0.9-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/Mimino666/langdetect.svg?branch=master)](https://travis-ci.org/Mimino666/langdetect)
  Port of Nakatani Shuyo's [language-detection](https://github.com/shuyo/language-detection) library (version from 03/03/2014) to Python.


pkgId: 14170b2bea599e88f5f54f1b28b18ab2f914f83eab430aa79f9af110f86f0aa8
name: python-langua
arch: src
version: 1.0.12
epoch: 0
release: 1
summary: Faster port of Language detection built by Shuyo in Python
description:
  $ pip install langua
  Supported Python versions 2.7, 3.4+.

url: https://github.com/whiletruelearn/langua
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-25918adb-6a0e-4593-b297-257b215db0d3
location_href: 00010286-python-langua/python-langua-1.0.12-1.src.rpm
checksum_type: sha256
rpm_license:
  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at


pkgId: 61ac49bf22453e337e4342c02da39376196bd7583a445e914219fd4e2a6e73a1
name: python-lark
arch: src
version: 1.1.5
epoch: 0
release: 1
summary: a modern parsing library
url: https://github.com/lark-parser/lark
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-add09afa-77a9-4fa1-8802-e42f3692cd0c
location_href: 00011549-python-lark/python-lark-1.1.5-1.src.rpm
checksum_type: sha256
description:
  Lark is a modern general-purpose parsing library for Python.

  With Lark, you can parse any context-free grammar, efficiently, with very little code.

  Main Features:
   - Builds a parse-tree (AST) automagically, based on the structure of the grammar
   - Earley parser
      - Can parse all context-free grammars
      - Full support for ambiguous grammars
   - LALR(1) parser
      - Fast and light, competitive with PLY
      - Can generate a stand-alone parser
   - CYK parser, for highly ambiguous grammars
   - EBNF grammar
   - Unicode fully supported
   - Automatic line & column tracking
   - Standard library of terminals (strings, numbers, names, etc.)
   - Import grammars from Nearley.js
   - Extensive test suite
   - And much more!

  Since version 1.0, only Python versions 3.6 and up are supported.


pkgId: b569931e0e7b80a8f985b9d4705f4569eed626fe2ef1d185e248d94416aaab99
name: python-lark-parser
arch: src
version: 0.12.0
epoch: 0
release: 1
summary: a modern parsing library
url: https://github.com/lark-parser/lark
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7e0b2cf3-f593-457b-bfaf-c8b68906bc60
location_href: 00004043-python-lark-parser/python-lark-parser-0.12.0-1.src.rpm
checksum_type: sha256
description:
  Lark is a modern general-purpose parsing library for Python.

  With Lark, you can parse any context-free grammar, efficiently, with very little code.

  Main Features:
   - Builds a parse-tree (AST) automagically, based on the structure of the grammar
   - Earley parser
      - Can parse all context-free grammars
      - Full support for ambiguous grammars
   - LALR(1) parser
      - Fast and light, competitive with PLY
      - Can generate a stand-alone parser
   - CYK parser, for highly ambiguous grammars
   - EBNF grammar
   - Unicode fully supported
   - Python 2 & 3 compatible
   - Automatic line & column tracking
   - Standard library of terminals (strings, numbers, names, etc.)
   - Import grammars from Nearley.js
   - Extensive test suite
   - And much more!


pkgId: d06becd7b8691a8c8317ca8bed363d57c9def56f56d2fa484b7ad49043856114
name: python-lazr.config
arch: src
version: 2.2.3
epoch: 0
release: 1
summary: Create configuration schemas, and process and validate configurations.
url: https://launchpad.net/lazr.config
rpm_license: LGPL v3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-20091a14-a240-4246-adda-ea980c86bbf3
location_href: 00004047-python-lazr-config/python-lazr.config-2.2.3-1.src.rpm
checksum_type: sha256
description:
  The LAZR config system is typically used to manage process configuration.
  Process configuration is for saying how things change when we run systems on
  different machines, or under different circumstances.

  This system uses ini-like file format of section, keys, and values.  The
  config file supports inheritance to minimize duplication of information across
  files. The format supports schema validation.


pkgId: 429e7a8a824fd9814af2a47f23ad891d7aeadc1ec2eb9488d019bb62aa7b473e
name: python-lazr.delegates
arch: src
version: 2.0.4
epoch: 0
release: 1
summary: Easily write objects that delegate behavior
url: https://launchpad.net/lazr.delegates
rpm_license: LGPL v3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5226f8d3-bb32-4ec7-8427-562c70c19941
location_href: 00004048-python-lazr-delegates/python-lazr.delegates-2.0.4-1.src.rpm
checksum_type: sha256
description:
  The ``lazr.delegates`` package makes it easy to write objects that delegate
  behavior to another object. The new object adds some property or behavior on
  to the other object, while still providing the underlying interface, and
  delegating behavior.


pkgId: 91a1f7e2560010c0d5c646a3df280542bde600fe525a49cfd38240244ac19722
name: python-lazr.smtptest
arch: src
version: 2.0.4
epoch: 0
release: 1
summary: A test framework for SMTP based applications
url: https://launchpad.net/lazr.smtptest
rpm_license: LGPL v3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cbd3d5a4-6814-44d5-82d9-fdafdbbd45e3
location_href: 00004050-python-lazr-smtptest/python-lazr.smtptest-2.0.4-1.src.rpm
checksum_type: sha256
description:
  This is LAZR smtptest, a framework for testing SMTP-based applications and
  libraries.  It provides a real, live SMTP server that you can send messages
  to, and from which you can read those test messages.  This can be used to
  ensure proper operation of your applications which send email.


pkgId: 20be56941cca977f5bcd8a1753b3e2b68fd8d9e820adac8a96489fe86c480ce5
name: python-lazy-object-proxy-debuginfo
arch: aarch64
version: 1.9.0
epoch: 0
release: 1
summary: Debug information for package python-lazy-object-proxy
url: https://github.com/ionelmc/python-lazy-object-proxy
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-4b12d867-2199-45d0-9b9e-55e70d5852d8
rpm_sourcerpm: python-lazy-object-proxy-1.9.0-1.src.rpm
location_href: 00009064-python-lazy-object-proxy/python-lazy-object-proxy-debuginfo-1.9.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-lazy-object-proxy.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 63a66f76a2f2e7fdd160ead262b8731efb8619eb928f522dae047cdf58052490
name: python-lazy-object-proxy-debugsource
arch: aarch64
version: 1.9.0
epoch: 0
release: 1
summary: Debug sources for package python-lazy-object-proxy
url: https://github.com/ionelmc/python-lazy-object-proxy
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-4b12d867-2199-45d0-9b9e-55e70d5852d8
rpm_sourcerpm: python-lazy-object-proxy-1.9.0-1.src.rpm
location_href: 00009064-python-lazy-object-proxy/python-lazy-object-proxy-debugsource-1.9.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-lazy-object-proxy.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 2584caafe5746f9cfe03217ecee978ecd6e48ed4806009e16a0b0f0e0e322e3d
name: python-lazyarray
arch: src
version: 0.5.2
epoch: 0
release: 1
url: http://github.com/NeuralEnsemble/lazyarray/
rpm_license: Modified BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-12334cfe-02bc-4c23-84ec-12dc4c303102
location_href: 00004052-python-lazyarray/python-lazyarray-0.5.2-1.src.rpm
checksum_type: sha256
summary:
  a Python package that provides a lazily-evaluated numerical array class, larray, based on and compatible with NumPy arrays.


pkgId: 344bf6500873960b9f9a37b2d03ca86ede1b2bf7875cb23483d9bc1f48c45552
name: python-lbt-dragonfly
arch: src
version: 0.10.75
epoch: 0
release: 1
summary: Collection of all Dragonfly core Python libraries
url: https://github.com/ladybug-tools/lbt-dragonfly
rpm_license: AGPL-3.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-07e6511e-b1f8-4b92-a0da-fd31724084b9
location_href: 00011979-python-lbt-dragonfly/python-lbt-dragonfly-0.10.75-1.src.rpm
checksum_type: sha256
description:
  ![Dragonfly](http://www.ladybug.tools/assets/img/dragonfly.png)

  [![Build Status](https://github.com/ladybug-tools/lbt-dragonfly/workflows/CI/badge.svg)](https://github.com/ladybug-tools/lbt-dragonfly/actions)

  [![Python 2.7](https://img.shields.io/badge/python-2.7-green.svg)](https://www.python.org/downloads/release/python-270/) [![Python 3.6](https://img.shields.io/badge/python-3.6-blue.svg)](https://www.python.org/downloads/release/python-360/) [![IronPython](https://img.shields.io/badge/ironpython-2.7-red.svg)](https://github.com/IronLanguages/ironpython2/releases/tag/ipy-2.7.8/)



  Collection of all Dragonfly core Python libraries.

  Note that this repository and corresponding Python package does not contain any source
  code and it simply exists to provide a shortcut for installing all of the dragonfly
  core libraries and extensions together.



  Running `pip install lbt-dragonfly` will result in the installation of the following
  dragonfly Python packages:

  * [dragonfly-energy](https://github.com/ladybug-tools/dragonfly-energy)
  * [dragonfly-uwg](https://github.com/ladybug-tools/dragonfly-uwg)
  * [dragonfly-doe2](https://github.com/ladybug-tools/dragonfly-doe2)



  Since both dragonfly extensions use the dragonfly core libraries, the following
  dependencies are also included:

  * [dragonfly-core](https://github.com/ladybug-tools/dragonfly-core)
  * [dragonfly-schema](https://github.com/ladybug-tools/dragonfly-schema)



  Since dragonfly uses ladybug and honeybee, the following dependencies are also included:

  * [lbt-ladybug](https://github.com/ladybug-tools/lbt-ladybug)
  * [lbt-honeybee](https://github.com/ladybug-tools/lbt-honeybee)


pkgId: 029e184289133945542ab8088a8e7ff91bc2384e67b22c31ec903b7ea7bfbd1b
name: python-lbt-honeybee
arch: src
version: 0.7.188
epoch: 0
release: 1
summary: Installs a collection of all Honeybee core Python libraries.
url: https://github.com/ladybug-tools/lbt-honeybee
rpm_license: AGPL-3.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-68ff5af1-b0b8-4cbf-a0af-8fe387a32bb8
location_href: 00012668-python-lbt-honeybee/python-lbt-honeybee-0.7.188-1.src.rpm
checksum_type: sha256
description:
  ![Honeybee](http://www.ladybug.tools/assets/img/honeybee.png)

  [![Build Status](https://github.com/ladybug-tools/lbt-honeybee/workflows/CI/badge.svg)](https://github.com/ladybug-tools/lbt-honeybee/actions)

  [![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/)



  A collection of Honeybee core Python libraries and extensions.

  Note that this Python package and corresponding repository does not contain any source
  code and it simply exists to provide a shortcut for installing all of the honeybee
  extension packages together.



  ```console
  pip install -U lbt-honeybee
  ```



  Running `pip install lbt-honeybee -U` will result in the installation of the following
  honeybee Python packages:

  * [honeybee-radiance](https://github.com/ladybug-tools/honeybee-radiance)
  * [honeybee-radiance-postprocess](https://github.com/ladybug-tools/honeybee-radiance-postprocess)
  * [honeybee-radiance-folder](https://github.com/ladybug-tools/honeybee-radiance-folder)
  * [honeybee-radiance-command](https://github.com/ladybug-tools/honeybee-radiance-command)
  * [honeybee-energy](https://github.com/ladybug-tools/honeybee-energy)
  * [honeybee-energy-standards](https://github.com/ladybug-tools/honeybee-energy-standards)
  * [honeybee-display](https://github.com/ladybug-tools/honeybee-display)



  Since both honeybee extensions use the honeybee core libraries, the following
  dependencies are also included:

  * [honeybee-core](https://github.com/ladybug-tools/honeybee-core)
  * [honeybee-schema](https://github.com/ladybug-tools/honeybee-schema)



  Since honeybee uses ladybug, the following is also included:

  * [ladybug-geometry](https://github.com/ladybug-tools/ladybug-geometry)
  * [ladybug-core](https://github.com/ladybug-tools/ladybug)
  * [ladybug-comfort](https://github.com/ladybug-tools/ladybug-comfort)
  * [ladybug-display](https://github.com/ladybug-tools/ladybug-display)


pkgId: ffb68a2ff251ae1fbbeea59ac542b4adcbf14f52ca8ba37ee9d868674a27c475
name: python-ldap3
arch: src
version: 2.9.1
epoch: 0
release: 1
summary: A strictly RFC 4510 conforming LDAP V3 pure Python client library
url: https://github.com/cannatag/ldap3
rpm_license: LGPL v3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4ef89906-423c-414e-bed1-8ac3ec6cd666
location_href: 00004055-python-ldap3/python-ldap3-2.9.1-1.src.rpm
checksum_type: sha256
description:
  ldap3 is a strictly RFC 4510 conforming **LDAP V3 pure Python client** library. The same codebase runs in Python 2, Python 3, PyPy and PyPy3.


pkgId: b29a0dcbf42584309f1c703f34b83cb0e5522a9fdbac5b4e503d36b429bff526
name: python-ldappool
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: A simple connector pool for python-ldap.
url: https://opendev.org/openstack/ldappool
rpm_license: Mozilla Public License 2.0 (MPL 2.0)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-192a65e2-9052-45c4-ac5a-9a08bf2781c3
location_href: 00004057-python-ldappool/python-ldappool-3.0.0-1.src.rpm
checksum_type: sha256
description:
  A simple connector pool for python-ldap.
  The pool keeps LDAP connectors alive and let you reuse them,
  drastically reducing the time spent to initiate a ldap connection.
  The pool has useful features like:
  - transparent reconnection on failures or server restarts
  - configurable pool size and connectors timeouts
  - configurable max lifetime for connectors
  - a context manager to simplify acquiring and releasing a connector
  **You need python-ldap in order to use this library**
  Quickstart
  To work with the pool, you just need to create it, then use it as a
  context manager with the *connection* method::
      from ldappool import ConnectionManager
      cm = ConnectionManager('ldap://localhost')
      with cm.connection('uid=adminuser,ou=logins,dc=mozilla', 'password') as conn:
  The connector returned by *connection* is a LDAPObject, that's binded to the
  server. See https://pypi.org/project/python-ldap/ for details on how to use a connector.
  It is possible to check the state of the pool by representing the pool as a string::
      from ldappool import ConnectionManager
      cm = ConnectionManager('ldap://localhost', size=2)
      print(cm)
  This will result in output similar to this table::
      +--------------+-----------+----------+------------------+--------------------+------------------------------+
      | Slot (2 max) | Connected |  Active  |       URI        | Lifetime (600 max) |           Bind DN            |
      +--------------+-----------+----------+------------------+--------------------+------------------------------+
      |      1       | connected | inactive | ldap://localhost |  0.00496101379395  | uid=tuser,dc=example,dc=test |
      |      2       | connected | inactive | ldap://localhost |  0.00532603263855  | uid=tuser,dc=example,dc=test |
      +--------------+-----------+----------+------------------+--------------------+------------------------------+
  ConnectionManager options
  Here are the options you can use when instanciating the pool:
  - **uri**: ldap server uri **[mandatory]**
  - **bind**: default bind that will be used to bind a connector.
    **default: None**
  - **passwd**: default password that will be used to bind a connector.
    **default: None**
  - **size**: pool size. **default: 10**
  - **retry_max**: number of attempts when a server is down. **default: 3**
  - **retry_delay**: delay in seconds before a retry. **default: .1**
  - **use_tls**: activate TLS when connecting. **default: False**
  - **timeout**: connector timeout. **default: -1**
  - **use_pool**: activates the pool. If False, will recreate a connector
    each time. **default: True**
  The **uri** option will accept a comma or whitespace separated list of LDAP
  server URIs to allow for failover behavior when connection errors are
  encountered.  Connections will be attempted against the servers in order,
  with **retry_max** attempts per URI before failing over to the next server.
  The **connection** method takes two options:
  - **bind**: bind used to connect. If None, uses the pool default's.
    **default: None**
  - **passwd**: password used to connect. If None, uses the pool default's.
    **default: None**


pkgId: c687fe330b132ef5bb7a771ab940a08ade8e6e4f2858bd7772cc3f06a1092295
name: python-leather
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: Python charting for 80% of humans.
url: http://leather.readthedocs.io/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-abe220b0-394c-4642-8161-32eca8e6f403
location_href: 00004061-python-leather/python-leather-0.3.4-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://travis-ci.org/wireservice/leather.png
      :target: https://travis-ci.org/wireservice/leather
      :alt: Build status

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

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

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

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

  Leather is the Python charting library for those who need charts *now* and don't care if they're perfect.

  Leather isn't picky. It's rough. It gets dirty. It looks sexy just hanging on the back of a chair. Leather doesn't need your accessories. Leather is how Snake Plissken would make charts.

  Get it?

  Important links:

  * Documentation:    http://leather.rtfd.io
  * Repository:       https://github.com/wireservice/leather
  * Issues:           https://github.com/wireservice/leather/issues


pkgId: 35376189b469f39dca3cbe89d0ea3168dc70d0ef13aed50431bbd2a1004c0ad1
name: python-lenses
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: A lens library for python
url: https://github.com/ingolemo/python-lenses
rpm_license: GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5f6055c2-b291-4bae-953b-2144c7d71269
location_href: 00010908-python-lenses/python-lenses-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Lenses is a python library that helps you to manipulate large
  data-structures without mutating them. It is inspired by the lenses in
  Haskell, although it's much less principled and the api is more suitable
  for python.


pkgId: 038225f44cef58a3b519d36354228d11e8f351e20d3c6a99f92d61b4b508c58a
name: python-lesscpy
arch: src
version: 0.15.1
epoch: 0
release: 1
summary: Python LESS compiler
url: https://github.com/lesscpy/lesscpy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5aea7502-6977-4752-9f63-a968afd233c5
location_href: 00004062-python-lesscpy/python-lesscpy-0.15.1-1.src.rpm
checksum_type: sha256
description:
  Python LESS Compiler.
  A compiler written in Python for the LESS language. For those of us not willing
  or able to have node.js installed in our environment. Not all features of LESS
  are supported (yet). Some features wil probably never be supported (JavaScript
  evaluation). This program uses PLY (Python Lex-Yacc) to tokenize / parse the
  input and is considerably slower than the NodeJS compiler. The plan is to
  utilize this to build in proper syntax checking and perhaps YUI compressing.
  This is an early version, so you are likely to find bugs.
  For more information on LESS:
    http://lesscss.org/ or https://github.com/cloudhead/less.js
  Development files:
    https://github.com/lesscpy/lesscpy


pkgId: bb5d583ed3d4e9394ab384c0bdd514288486af9cc46b615abc1429ec455a7b6e
name: python-lexicon
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Powerful dict subclass(es) with aliasing & attribute access
url: https://github.com/bitprophet/lexicon#what
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4aa228d1-5b0e-464f-abc4-4b0f3a921240
location_href: 00004064-python-lexicon/python-lexicon-2.0.1-1.src.rpm
checksum_type: sha256
description:
  Lexicon is a simple collection of Python ``dict`` subclasses providing extra
  power:
  - ``AliasDict``, a dictionary supporting both simple and complex key aliasing:
      - Alias a single key to another key, so that e.g. ``mydict['bar']`` points
        to ``mydict['foo']``, for both reads and writes.
      - Alias a single key to a list of other keys, for writing only, e.g. with
        ``active_groups = AliasDict({'ops': True, 'biz': True, 'dev': True,
        'product': True})`` one can make an alias ``'tech'`` mapping to ``('ops',
        'dev')`` and then e.g. ``active_groups['tech'] = False``.
      - Aliasing is recursive: an alias pointing to another alias will behave as
        if it points to the other alias' target.
  - ``AttributeDict``, supporting attribute read & write access, e.g. ``mydict =
    AttributeDict({'foo': 'bar'})`` exhibits ``mydict.foo`` and ``mydict.foo =
    'new value'``.
  - ``Lexicon``, a subclass of both of the above which exhibits both sets of
    behavior.


pkgId: ae78b517847db81a1ce22fde1c3b71d45b124502ddcfdba7b02535b91ccc90de
name: python-libNeuroML
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: A Python library for working with NeuroML descriptions of neuronal models
url: http://libneuroml.readthedocs.org/en/latest/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-09cb4344-e350-4600-9342-7c8aae0557a2
location_href: 00004068-python-libNeuroML/python-libNeuroML-0.4.1-1.src.rpm
checksum_type: sha256
description:
  [![GH Build](https://github.com/NeuralEnsemble/libNeuroML/actions/workflows/ci.yml/badge.svg)](https://github.com/NeuralEnsemble/libNeuroML/actions/workflows/ci.yml)
  [![Documentation Status](https://readthedocs.org/projects/libneuroml/badge/?version=latest)](https://libneuroml.readthedocs.io/en/latest/?badge=latest)
  [![PyPI](https://img.shields.io/pypi/v/libNeuroML)](https://pypi.org/project/libNeuroML/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/libNeuroML)](https://pypi.org/project/libNeuroML/)
  [![GitHub](https://img.shields.io/github/license/NeuralEnsemble/libNeuroML)](https://github.com/NeuralEnsemble/libNeuroML/blob/master/LICENSE)
  [![GitHub pull requests](https://img.shields.io/github/issues-pr/NeuralEnsemble/libNeuroML)](https://github.com/NeuralEnsemble/libNeuroML/pulls)
  [![GitHub issues](https://img.shields.io/github/issues/NeuralEnsemble/libNeuroML)](https://github.com/NeuralEnsemble/libNeuroML/issues)
  [![GitHub Org's stars](https://img.shields.io/github/stars/NeuralEnsemble?style=social)](https://github.com/NeuralEnsemble)
  [![Twitter Follow](https://img.shields.io/twitter/follow/NeuroML?style=social)](https://twitter.com/NeuroML)
  [![Gitter](https://badges.gitter.im/NeuroML/community.svg)](https://gitter.im/NeuroML/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)

  This package provides Python libNeuroML, for working with neuronal models specified in [NeuroML 2](http://neuroml.org/neuromlv2).

  For more about libNeuroML see:

  Michael Vella, Robert C. Cannon, Sharon Crook, Andrew P. Davison, Gautham Ganapathy, Hugh P. C. Robinson, R. Angus Silver and Padraig Gleeson,
  **libNeuroML and PyLEMS: using Python to combine procedural and declarative modeling approaches in computational neuroscience**
  [Frontiers in Neuroinformatics 2014](http://journal.frontiersin.org/Journal/10.3389/fninf.2014.00038/abstract), doi: 10.3389/fninf.2014.00038

  _**PLEASE CITE THE PAPER ABOVE IF YOU USE libNeuroML!**_

  Documentation is available at http://readthedocs.org/docs/libneuroml/en/latest/

  For installation instructions, see http://readthedocs.org/docs/libneuroml/en/latest/install.html

  For an overview of all NeuroML related libraries/documentation/publications see https://docs.neuroml.org



  A related package, **[pyNeuroML](https://github.com/NeuroML/pyNeuroML)** builds on this and provides functionality, scripts and modules for reading, writing, **simulating** and analysing NeuroML2/LEMS models.

  pyNeuroML builds on: [libNeuroML](https://github.com/NeuralEnsemble/libNeuroML) & [PyLEMS](https://github.com/LEMS/pylems) and wraps functionality from [jNeuroML](https://github.com/NeuroML/jNeuroML).




  Most of the work happens in the [development branch](https://github.com/NeuralEnsemble/libNeuroML/tree/development).
  That branch is kept up to date with the development branches for [NeuroML 2](https://github.com/NeuroML/NeuroML2/tree/development) and related libraries.
  See https://docs.neuroml.org/ for an overview of the various NeuroML libraries.




  - Enable Python 3.10 support
  - Regenerate nml.py with generateDS using Python 3
  - Add generic `add` method to all NeuroML ComponentType classes that allows users to easily construct their NeuroML documents.
  - Improve unit tests
  - DEPRECATION notice: `append_to_element` will be deprecated in future releases, please use the `add` method instead



  - Documentation updates for RTD and other minor fixes.



  - Patch release with minor changes under the hood.
  - Use PyTest for testing.
  - Enable CI on GitHub Actions



  - Using Schema for NeuroML v2.1. Better compatibility with Python 3



  - Updated to use the final stable Schema for NeuroML v2.0



  - Updated to use the final stable Schema for NeuroML v2beta5



  - Updated to use the final stable Schema for NeuroML v2beta4
  - Tested with Python 3



  - Updated to use the Schema for NeuroML v2beta4



  - Updated to use the Schema for NeuroML v2beta3
  - Ensures numpy & pytables are only required when using non-XML loaders/writers



  - Updated to use the Schema for NeuroML v2beta2



  - Minor release: Update to latest schema



  - Several Bug fixes and small enhamcements
  - Support for latest NeuroML schema (see change outline)
  - JSON serialization
  - MongoDB backend
  - HDF5 serialization
  - Improved installation process
  - All usage examples are now run on the Travis-CI continuous integration server to confirm that that they do not error.
  - Schema validation utility
  - Improved documentation and documentation new look


  :copyright: Copyright 2021 by the libNeuroML team, see [AUTHORS](AUTHORS). Modified BSD License, see [LICENSE](LICENSE) for details.


  [![Build Status](https://api.travis-ci.org/NeuralEnsemble/libNeuroML.png)](https://travis-ci.org/NeuralEnsemble/libNeuroML)


pkgId: 023efcb88696a89fcc1109eaddf44536bf7957bf5c016aeb190c5c5fdf37a897
name: python-libevdev
arch: src
version: 0.11
epoch: 0
release: 1
summary: Python wrapper for libevdev
url: https://gitlab.freedesktop.org/libevdev/python-libevdev
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-aa9aa675-fffd-4dab-adba-a94f44f343ca
location_href: 00004075-python-libevdev/python-libevdev-0.11-1.src.rpm
checksum_type: sha256
description:
  python-libevdev is a Python wrapper around the libevdev C library. It
  provides a Pythonic API to read events from the Linux kernel's input device
  nodes and to read and/or modify the device's state and capabilities.

  The documentation is available here:
  https://python-libevdev.readthedocs.io/en/latest/


pkgId: ecf3c9b15147d2bed3d13e9275a414bad668c1f07f273295ac121bcbeb352609
name: python-libhoney
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: Python library for sending data to Honeycomb
url: https://github.com/honeycombio/libhoney-py
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ae35291a-2dc5-4a96-9c45-5c16f6d6e6bf
location_href: 00011652-python-libhoney/python-libhoney-2.3.0-1.src.rpm
checksum_type: sha256
description:
  [![OSS Lifecycle](https://img.shields.io/osslifecycle/honeycombio/libhoney-py?color=success)](https://github.com/honeycombio/home/blob/main/honeycomb-oss-lifecycle-and-practices.md)
  [![Build Status](https://circleci.com/gh/honeycombio/libhoney-py.svg?style=svg)](https://app.circleci.com/pipelines/github/honeycombio/libhoney-py)

  Python library for sending events to [Honeycomb](https://honeycomb.io), a service for debugging your software in production.

  - [Usage and Examples](https://docs.honeycomb.io/sdk/python/)

  For tracing support and automatic instrumentation of Django, Flask, AWS Lambda, and other frameworks, check out our [Beeline for Python](https://github.com/honeycombio/beeline-python).



  Features, bug fixes and other changes to libhoney are gladly accepted. Please
  open issues or a pull request with your change. Remember to add your name to the
  CONTRIBUTORS file!

  All contributions will be released under the Apache License 2.0.



  You may need to install the `bump2version` utility by running `pip install bump2version`.

  To update the version number, do

  ```
  bump2version [major|minor|patch|release|build]
  ```

  If you want to release the version publicly, you will need to manually create a tag `v<x.y.z>` and push it in order to
  cause CircleCI to automatically push builds to github releases and PyPI.


pkgId: 62104d7f6496376dabed38d6f12d571f7019bf9419d605f5afd3de77299c1629
name: python-libify
arch: src
version: 0.78
epoch: 0
release: 1
summary: Import Databricks notebooks as libraries/modules
url: https://github.com/vagrantism/libify
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a46f28d3-9d1e-4156-92d6-446041687d8e
location_href: 00010130-python-libify/python-libify-0.78-1.src.rpm
checksum_type: sha256
description:
  ![Build/Push Pipeline](https://github.com/vagrantism/libify/workflows/Build%20and%20Publish%20to%20PyPI%20and%20TestPyPI/badge.svg) ![GitHub issues](https://img.shields.io/github/issues/vagrantism/libify) ![PyPI - Format](https://img.shields.io/pypi/format/libify) ![PyPI version](https://badge.fury.io/py/libify.svg) ![GitHub last commit](https://img.shields.io/github/last-commit/vagrantism/libify) ![GitHub tag (latest by date)](https://img.shields.io/github/v/tag/vagrantism/libify) ![visitors](https://visitor-badge.laobi.icu/badge?page_id=libify_main_ctr) ![Downloads](https://pepy.tech/badge/libify)


pkgId: 3d84e0889556fb3235efa566c616109a4573d4d71574f5b549db54759a187781
name: python-libpysal
arch: src
version: 4.7.0
epoch: 0
release: 1
summary: Core components of PySAL A library of spatial analysis functions.
url: http://pysal.org/libpysal
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8632763e-0657-44bf-b19d-de5c4076d679
location_href: 00004092-python-libpysal/python-libpysal-4.7.0-1.src.rpm
checksum_type: sha256
description:
  ****************
  libpysal modules
  ****************
  - libpysal.cg  Computational geometry
  - libpysal.io  Input and output
  - libpysal.weights  Spatial weights
  - libpysal.examples  Built-in example datasets
  *****************
  Example Notebooks
  *****************
  - `Spatial Weights  <notebooks/weights.ipynb>`_
  - `Voronoi  <notebooks/voronoi.ipynb>`_
  - `Input and Output <notebooks/io.ipynb>`_
  ***********
  Development
  ***********
  libpysal development is hosted on github_.
  Discussions of development occurs on the
  `developer list <http://groups.google.com/group/pysal-dev>`_
  as well as gitter_.
  ************
  Contributing
  ************
  PySAL-libpysal is under active development and contributors are welcome.
  If you have any suggestions, feature requests, or bug reports,
  please open new `issues <https://github.com/pysal/libpysal/issues>`_ on GitHub.
  To submit patches, please review `PySAL's documentation for developers <https://pysal.org/docs/devs/>`_,
  the PySAL `development guidelines <https://github.com/pysal/pysal/wiki>`_,
  the `libpysal contributing guidelines <https://github.com/pysal/libpysal/blob/master/.github/CONTRIBUTING.md>`_
  before  opening a `pull request <https://github.com/pysal/libpysal/pulls>`_.
  Once your changes get merged, you’ll automatically be added to
  the `Contributors List <https://github.com/pysal/libpysal/graphs/contributors>`_.
  ***********
  Bug reports
  ***********
  To search for or report bugs, please see `libpysal's issues <https://github.com/pysal/libpysal/issues>`_.
  *******************
  License information
  *******************
  See the `LICENSE <https://github.com/pysal/libpysal/blob/master/LICENSE.txt>`_
  for information on the history of this software, terms & conditions for usage,
  and a DISCLAIMER OF ALL WARRANTIES.


pkgId: 4610984f10332dc2b765868f096f4243cd530433fa7d20a119e8da376d6939ba
name: python-libs
arch: src
version: 0.0.10
epoch: 0
release: 1
summary: Packages of tools
url: https://github.com/phyng/libs
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c34a0c1d-55e1-4a8e-b83b-6a293ebff862
location_href: 00004097-python-libs/python-libs-0.0.10-1.src.rpm
checksum_type: sha256
description:
  Some library to extend Python Standard Library

  [![Github](https://github.com/phyng/libs/workflows/test/badge.svg)](https://github.com/phyng/libs/actions) [![Pypi](https://img.shields.io/pypi/v/libs.svg?style=flat&label=PyPI)](https://pypi.org/project/libs/)



  https://phyng.com/libs/



  ```bash

  pip install libs


  poetry add libs
  ```



  ```bash
  npm test
  npm test_coverage
  ```


pkgId: 2f625c5b187dc5d2dcf00ca604016024d0bc2cc2f4d33c4ef04883bc476bac0c
name: python-libsass
arch: src
version: 0.22.0
epoch: 0
release: 1
summary: Sass for Python: A straightforward binding of libsass for Python.
url: https://sass.github.io/libsass-python/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d4349636-a906-4a61-a25d-5244a6fae0f7
location_href: 00004099-python-libsass/python-libsass-0.22.0-1.src.rpm
checksum_type: sha256
description:
  This package provides a simple Python extension module ``sass`` which is
  binding LibSass_ (written in C/C++ by Hampton Catlin and Aaron Leung).
  It's very straightforward and there isn't any headache related Python
  distribution/deployment.  That means you can add just ``libsass`` into
  your ``setup.py``'s ``install_requires`` list or ``requirements.txt`` file.
  No need for Ruby nor Node.js.
  It currently supports CPython 3.6+, and PyPy 3!


pkgId: 061a7b8227add5570f950552b3753001b2709426d9d729f035a993c875c319fa
name: python-libsass-debuginfo
arch: aarch64
version: 0.22.0
epoch: 0
release: 1
summary: Debug information for package python-libsass
url: https://sass.github.io/libsass-python/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-d4349636-a906-4a61-a25d-5244a6fae0f7
rpm_sourcerpm: python-libsass-0.22.0-1.src.rpm
location_href: 00004099-python-libsass/python-libsass-debuginfo-0.22.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-libsass.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: e5b8d7575c95410b4117c5035dcd27e4792674cb728d4a78f03cc7e91c09d32a
name: python-libsass-debugsource
arch: aarch64
version: 0.22.0
epoch: 0
release: 1
summary: Debug sources for package python-libsass
url: https://sass.github.io/libsass-python/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-d4349636-a906-4a61-a25d-5244a6fae0f7
rpm_sourcerpm: python-libsass-0.22.0-1.src.rpm
location_href: 00004099-python-libsass/python-libsass-debugsource-0.22.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-libsass.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 673063200d138af3e674f370daffd29d3af46d34573e53eb7e9e43e74910ff35
name: python-libtmux
arch: src
version: 0.21.0
epoch: 0
release: 1
summary: Typed scripting library / ORM / API wrapper for tmux
url: http://github.com/tmux-python/libtmux/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dc998806-bd1f-4622-87ef-412f7a284495
location_href: 00004106-python-libtmux/python-libtmux-0.21.0-1.src.rpm
checksum_type: sha256
description:
          \   ^__^
           \  (oo)\_______
              (__)\       )\/\
                  ||----w |
                  ||     ||
  ```
  Traverse and navigate:
  ```python
  >>> pane.window
  Window(@1 1:..., Session($1 ...))
  >>> pane.window.session
  Session($1 ...)
  ```

  Unsupported / no security releases or bug fixes:
  - Python 2.x: The backports branch is
    [`v0.8.x`](https://github.com/tmux-python/libtmux/tree/v0.8.x).

  Your donations fund development of new features, testing and support.
  Your money will go directly to maintenance and development of the
  project. If you are an individual, feel free to give whatever feels
  right for the value you get out of the project.
  See donation options at <https://git-pull.com/support.html>.

  - tmux support: 1.8+
  - python support: >= 3.7, pypy, pypy3
  - Source: <https://github.com/tmux-python/libtmux>
  - Docs: <https://libtmux.git-pull.com>
  - API: <https://libtmux.git-pull.com/api.html>
  - Changelog: <https://libtmux.git-pull.com/history.html>
  - Issues: <https://github.com/tmux-python/libtmux/issues>
  - Test Coverage: <https://codecov.io/gh/tmux-python/libtmux>
  - pypi: <https://pypi.python.org/pypi/libtmux>
  - Open Hub: <https://www.openhub.net/p/libtmux-python>
  - Repology: <https://repology.org/project/python:libtmux/versions>
  - License: [MIT](http://opensource.org/licenses/MIT).


pkgId: df8568e9e5fdcfe1807f4859c95008f9cbe8427f9e1226dae390e676d7685953
name: python-libusb1
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Pure-python wrapper for libusb-1.0
url: https://github.com/vpelletier/python-libusb1
rpm_license: LGPLv2.1+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-811d8bd8-050b-43f9-8615-2b6d6e23451e
location_href: 00004108-python-libusb1/python-libusb1-3.0.0-1.src.rpm
checksum_type: sha256
description:
  - CPython_ 3.6+, pypy_ 2.0+. Older versions may work, but are not
    recommended as there is no automated regression testing set up for them.
  - libusb-1.0_


pkgId: bae32d275c169c74a55c7dab66f5e9f1776fb464d4495d12cfb28e638c672def
name: python-lifelines
arch: src
version: 0.27.4
epoch: 0
release: 1
summary: Survival analysis in Python, including Kaplan Meier, Nelson Aalen and regression
url: https://github.com/CamDavidsonPilon/lifelines
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cc519ccf-c7c5-471d-ae52-1611755bc129
location_href: 00010344-python-lifelines/python-lifelines-0.27.4-1.src.rpm
checksum_type: sha256
description:
  ![](http://i.imgur.com/EOowdSD.png)

  [![PyPI version](https://badge.fury.io/py/lifelines.svg)](https://badge.fury.io/py/lifelines)
  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/lifelines/badges/version.svg
  )](https://conda.anaconda.org/conda-forge)
  [![DOI](https://zenodo.org/badge/12420595.svg)](https://zenodo.org/badge/latestdoi/12420595)


  [What is survival analysis and why should I learn it?](http://lifelines.readthedocs.org/en/latest/Survival%20Analysis%20intro.html)
   Survival analysis was originally developed and applied heavily by the actuarial and medical community. Its purpose was to answer *why do events occur now versus later* under uncertainty (where *events* might refer to deaths, disease remission, etc.). This is great for researchers who are interested in measuring lifetimes: they can answer questions like *what factors might influence deaths?*

  But outside of medicine and actuarial science, there are many other interesting and exciting applications of survival analysis. For example:
  - SaaS providers are interested in measuring subscriber lifetimes, or time to some first action
  - inventory stock out is a censoring event for true "demand" of a good.
  - sociologists are interested in measuring political parties' lifetimes, or relationships, or marriages
  - A/B tests to determine how long it takes different groups to perform an action.

  *lifelines* is a pure Python implementation of the best parts of survival analysis.




  If you are new to survival analysis, wondering why it is useful, or are interested in *lifelines* examples, API, and syntax, please read the [Documentation and Tutorials page](http://lifelines.readthedocs.org/en/latest/index.html)


   - Start a conversation in our [Discussions room](https://github.com/CamDavidsonPilon/lifelines/discussions).
   - Some users have posted common questions at [stats.stackexchange.com](https://stats.stackexchange.com/search?tab=votes&q=%22lifelines%22%20is%3aquestion)
   - creating an issue in the [Github repository](https://github.com/camdavidsonpilon/lifelines).



  See our [Contributing](https://github.com/CamDavidsonPilon/lifelines/blob/master/.github/CONTRIBUTING.md) guidelines.


pkgId: a9c0171e46268042fe16657166b7e914e34a9dc9884c935ee78b068aaf74edd8
name: python-linkify-it-py
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Links recognition library with FULL unicode support.
url: https://github.com/tsutsu3/linkify-it-py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-76eb86de-b9cb-4b10-bfbb-321c784bc2f0
location_href: 00012928-python-linkify-it-py/python-linkify-it-py-2.0.0-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/tsutsu3/linkify-it-py/workflows/CI/badge.svg?branch=main)](https://github.com/tsutsu3/linkify-it-py/actions)
  [![pypi](https://img.shields.io/pypi/v/linkify-it-py)](https://pypi.org/project/linkify-it-py/)
  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/linkify-it-py/badges/version.svg)](https://anaconda.org/conda-forge/linkify-it-py)
  [![codecov](https://codecov.io/gh/tsutsu3/linkify-it-py/branch/main/graph/badge.svg)](https://codecov.io/gh/tsutsu3/linkify-it-py)
  [![Maintainability](https://api.codeclimate.com/v1/badges/6341fd3ec5f05fde392f/maintainability)](https://codeclimate.com/github/tsutsu3/linkify-it-py/maintainability)

  This is Python port of [linkify-it](https://github.com/markdown-it/linkify-it).

  > Links recognition library with FULL unicode support.
  > Focused on high quality link patterns detection in plain text.

  __[Javascript Demo](http://markdown-it.github.io/linkify-it/)__

  Why it's awesome:

  - Full unicode support, _with astral characters_!
  - International domains support.
  - Allows rules extension & custom normalizers.




  ```bash
  pip install linkify-it-py
  ```

  or

  ```bash
  conda install -c conda-forge linkify-it-py
  ```





  ```python
  from linkify_it import LinkifyIt


  linkify = LinkifyIt()

  print(linkify.test("Site github.com!"))


  print(linkify.match("Site github.com!"))








  ```



  ```python
  from linkify_it import LinkifyIt
  from linkify_it.tlds import TLDS



  linkify = (
      LinkifyIt()
      .tlds(TLDS)               # Reload with full tlds list
      .tlds("onion", True)      # Add unofficial `.onion` domain
      .add("git:", "http:")     # Add `git:` protocol as "alias"
      .add("ftp:", None)        # Disable `ftp:` protocol
      .set({"fuzzy_ip": True})  # Enable IPs in fuzzy links (without schema)
  )
  print(linkify.test("Site tamanegi.onion!"))


  print(linkify.match("Site tamanegi.onion!"))








  ```



  ```python
  from linkify_it import LinkifyIt


  linkify = LinkifyIt()

  def validate(obj, text, pos):
      tail = text[pos:]

      if not obj.re.get("twitter"):
          obj.re["twitter"] = re.compile(
              "^([a-zA-Z0-9_]){1,15}(?!_)(?=$|" + obj.re["src_ZPCc"] + ")"
          )
      if obj.re["twitter"].search(tail):
          if pos > 2 and tail[pos - 2] == "@":
              return False
          return len(obj.re["twitter"].search(tail).group())
      return 0

  def normalize(obj, match):
      match.url = "https://twitter.com/" + re.sub(r"^@", "", match.url)

  linkify.add("@", {"validate": validate, "normalize": normalize})
  ```




  [API documentation](https://linkify-it-py.readthedocs.io/en/latest/)



  Creates new linkifier instance with optional additional schemas.

  By default understands:

  - `http(s)://...` , `ftp://...`, `mailto:...` & `//...` links
  - "fuzzy" links and emails (google.com, foo@bar.com).

  `schemas` is an dict, where each key/value describes protocol/rule:

  - __key__ - link prefix (usually, protocol name with `:` at the end, `skype:`
    for example). `linkify-it-py` makes sure that prefix is not preceded with
    alphanumeric char.
  - __value__ - rule to check tail after link prefix
    - _str_
      - just alias to existing rule
    - _dict_
      - _validate_ - either a `re.Pattern` (start with `^`, and don't include the
        link prefix itself), or a validator `function` which, given arguments
        _self_, _text_ and _pos_, returns the length of a match in _text_
        starting at index _pos_.  _pos_ is the index right after the link prefix.
        _self_ can be used to access the linkify object to cache data.
      - _normalize_ - optional function to normalize text & url of matched result
        (for example, for twitter mentions).

  `options`:

  - __fuzzy_link__ - recognize URL-s without `http(s)://` head. Default `True`.
  - __fuzzy_ip__ - allow IPs in fuzzy links above. Can conflict with some texts
    like version numbers. Default `False`.
  - __fuzzy_email__ - recognize emails without `mailto:` prefix. Default `True`.
  - __---__ - set `True` to terminate link with `---` (if it's considered as long dash).




  Searches linkifiable pattern and returns `True` on success or `False` on fail.




  Quick check if link MAY BE can exist. Can be used to optimize more expensive
  `.test()` calls. Return `False` if link can not be found, `True` - if `.test()`
  call needed to know exactly.




  Similar to `.test()` but checks only specific protocol tail exactly at given
  position. Returns length of found pattern (0 on fail).




  Returns `list` of found link matches or null if nothing found.

  Each match has:

  - __schema__ - link schema, can be empty for fuzzy links, or `//` for
    protocol-neutral links.
  - __index__ - offset of matched text
  - __last_index__ - index of next char after mathch end
  - __raw__ - matched text
  - __text__ - normalized text
  - __url__ - link, generated from matched text



  Checks if a match exists at the start of the string. Returns `Match`
  (see docs for `match(text)`) or null if no URL is at the start.
  Doesn't work with fuzzy links.



  Load (or merge) new tlds list. Those are needed for fuzzy links (without schema)
  to avoid false positives. By default:

  - 2-letter root zones are ok.
  - biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф are ok.
  - encoded (`xn--...`) root zones are ok.

  If that's not enough, you can reload defaults with more detailed zones list.



  Add a new schema to the schemas object. As described in the constructor
  definition, `key` is a link prefix (`skype:`, for example), and `value`
  is a `str` to alias to another schema, or an `dict` with `validate` and
  optionally `normalize` definitions.  To disable an existing rule, use
  `.add(key, None)`.




  Override default options. Missed properties will not be changed.




  [MIT](https://github.com/tsutsu3/linkify-it-py/blob/master/LICENSE)


pkgId: caef403e960f5fe2d7b1e875498fecdf6dfece59099c4979986497ef27d83283
name: python-liquidctl
arch: src
version: 1.12.1
epoch: 0
release: 1
summary: Cross-platform tool and drivers for liquid coolers and other devices
url: https://github.com/liquidctl/liquidctl
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-da2dc455-8492-4ce5-9f8d-a37e2c506160
location_href: 00004115-python-liquidctl/python-liquidctl-1.12.1-1.src.rpm
checksum_type: sha256
description:
  Cross-platform tool and drivers for liquid coolers and other devices.

  Go to the [project homepage] for more information.

  ```
  $ liquidctl list
  Device #0: Corsair Vengeance RGB DIMM2
  Device #1: Corsair Vengeance RGB DIMM4
  Device #2: NZXT Smart Device (V1)
  Device #3: NZXT Kraken X (X42, X52, X62 or X72)


  NZXT Smart Device (V1)
  ├── Firmware version             1.7
  ├── LED accessories                2
  ├── LED accessory type    HUE+ Strip
  └── LED count (total)             20

  NZXT Kraken X (X42, X52, X62 or X72)
  └── Firmware version    6.2


  NZXT Smart Device (V1)
  ├── Fan 1 speed            1499  rpm
  ├── Fan 1 voltage         11.91  V
  ├── Fan 1 current          0.05  A
  ├── Fan 1 control mode      PWM
  ├── Fan 2 [...]
  ├── Fan 3 [...]
  └── Noise level              61  dB

  NZXT Kraken X (X42, X52, X62 or X72)
  ├── Liquid temperature    34.7  °C
  ├── Fan speed              798  rpm
  └── Pump speed            2268  rpm


  Corsair Vengeance RGB DIMM2
  └── Temperature    37.5  °C

  Corsair Vengeance RGB DIMM4
  └── Temperature    37.8  °C





  ```

  [project homepage]: https://github.com/liquidctl/liquidctl


pkgId: b83b67f249e0e601b9235f6ae315992fab9dcc7572c1235a9f114b44dc185056
name: python-litecli
arch: src
version: 1.9.0
epoch: 0
release: 1
summary: CLI for SQLite Databases with auto-completion and syntax highlighting.
url: https://github.com/dbcli/litecli
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-704a8227-58f3-4774-8a4a-af86bb8e5dc7
location_href: 00004117-python-litecli/python-litecli-1.9.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/dbcli/litecli.svg?branch=master)](https://travis-ci.org/dbcli/litecli)

  [Docs](https://litecli.com)

  A command-line client for SQLite databases that has auto-completion and syntax highlighting.

  ![Completion](screenshots/litecli.png)
  ![CompletionGif](screenshots/litecli.gif)



  If you already know how to install python packages, then you can install it via pip:

  You might need sudo on linux.

  ```
  $ pip install -U litecli
  ```

  The package is also available on Arch Linux through AUR in two versions: [litecli](https://aur.archlinux.org/packages/litecli/) is based the latest release (git tag) and [litecli-git](https://aur.archlinux.org/packages/litecli-git/) is based on the master branch of the git repo. You can install them manually or with an AUR helper such as `yay`:

  ```
  $ yay -S litecli
  ```
  or

  ```
  $ yay -S litecli-git
  ```

  For MacOS users, you can also use Homebrew to install it:

  ```
  $ brew install litecli
  ```



  ```
  $ litecli --help

  Usage: litecli [OPTIONS] [DATABASE]

  Examples:
    - litecli sqlite_db_name
  ```

  A config file is automatically created at `~/.config/litecli/config` at first launch. For Windows machines a config file is created at `~\AppData\Local\dbcli\litecli\config` at first launch. See the file itself for a description of all available options.



  Visit: [litecli.com/features](https://litecli.com/features)


pkgId: a9122b2913574e18728d7c33df713ad715a24d380cc803d07de1f5e025d82410
name: python-lithium-reducer
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: Lithium is an automated testcase reduction tool
url: https://github.com/MozillaSecurity/lithium
rpm_license: MPL 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7169f681-24d5-494e-9bfd-9c0fa3a567cd
location_href: 00012603-python-lithium-reducer/python-lithium-reducer-0.6.2-1.src.rpm
checksum_type: sha256
description:
  [![Task Status](https://community-tc.services.mozilla.com/api/github/v1/repository/MozillaSecurity/lithium/master/badge.svg)](https://community-tc.services.mozilla.com/api/github/v1/repository/MozillaSecurity/lithium/master/latest)
  [![codecov](https://codecov.io/gh/MozillaSecurity/lithium/branch/master/graph/badge.svg)](https://codecov.io/gh/MozillaSecurity/lithium)
  [![Matrix](https://img.shields.io/badge/dynamic/json?color=green&label=chat&query=%24.chunk[%3F(%40.canonical_alias%3D%3D%22%23fuzzing%3Amozilla.org%22)].num_joined_members&suffix=%20users&url=https%3A%2F%2Fmozilla.modular.im%2F_matrix%2Fclient%2Fr0%2FpublicRooms&style=flat&logo=matrix)](https://riot.im/app/#/room/#fuzzing:mozilla.org)
  [![PyPI](https://img.shields.io/pypi/v/lithium-reducer)](https://pypi.org/project/lithium-reducer)



  Lithium is an automated testcase reduction tool developed by [Jesse Ruderman](http://www.squarefree.com/).

  Most of what you need to know to use Lithium is in one of these pages:

  - [How to use Lithium to reduce Firefox bugs](src/lithium/docs/using-for-firefox.md).  Lithium has been used it to make reduced testcases for hundreds of Firefox crashes and assertions.
  - [How to create your own "interestingness tests"](src/lithium/docs/creating-tests.md).  Lithium is flexible enough to reduce files for complicated properties such as "parsed differently by Opera and Firefox".  Just supply a small program that determines when a given file has the property.




  By default, Lithium uses a clever algorithm that's efficient at reducing most large testcases.  For a testcase with 2048 lines, it will try removing each chunk of size 1024, permanently removing it if it is still 'interesting'.  It then does the same for each chunk of size 512, then 256, all the way down to chunks of size 1.  It then does as many additional rounds at chunk size 1 as necessary until it completes a round without removing anything, at which point the file is 1-minimal (removing any single line from the file makes it 'uninteresting').

  If *n* is the size of the testcase and *m* is the size of the 1-minimal testcase found by Lithium, then Lithium usually performs O(m &sdot; lg(n)) tests with a total test size of O(m &sdot; n).  See the [analysis of Lithium's algorithm](src/lithium/docs/algorithm.md) for more information and proofs.

  To keep *m* small, make sure Lithium's smallest removals won't introduce fatal syntax errors into the file it is trying to reduce.  For example, don't use --char when trying to reduce a long sequence of JavaScript statements, and don't feed XHTML to Lithium.  (Convert it to HTML first and let Firefox's tag-soup parser sort out the invalidity, or use serializeDOMAsScript.)




      pip install lithium-reducer
      python -m lithium [options] interestingness-test.py [arguments for interestingness test]




  <dl>

  <dt>--testcase=filename</dt>
  <dd>Tells Lithium which file to reduce.  By default, it will assume the last argument to the interestingness test is the file to reduce.</dd>

  <dt>--char (-c)<dt>
  <dd>By default, Lithium treats lines as atomic units.  This is great if each line is a JavaScript statement, but sometimes you want to go further.  Use this option to tell Lithium to treat the file as a sequence of characters instead of a sequence of lines.</dd>

  <dt>--strategy=[check-only,minimize,minimize-balanced,replace-properties-by-globals,replace-arguments-by-globals,minimize-around]</dt>
  <dd>"minimize" is the default, the algorithm described above. "check-only" tries to run Lithium to determine interestingness, without reduction. For the other strategies, check out <a href="https://github.com/MozillaSecurity/lithium/pull/2">this GitHub PR</a>.</dd>

  <dt>--repeat=[always, last, never].</dt>
  <dd>By default, Lithium only repeats at the same chunk size if it just finished the last round (e.g. chunk size 1).  You can use --repeat=always to tell it to repeat any chunk size if something was removed during the round, which can be useful for non-deterministic testcases or non-monotonic situations.  You can use --repeat=never to tell it to exit immediately after a single round at the last chunk size, which can save a little time at the risk of leaving a little bit extra in the file.</dd>

  <dt>--max=n. default: about half of the file.</dt>
  <dt>--min=n. default: 1.</dt>
  <dd>What chunk sizes to test.  Must be powers of two.  --max is useful if you're restarting Lithium after it has already gone through a few rounds.  --min is useful if you're reducing HTML and want to do the final by hand.</dd>

  <dt>--chunk-size=n</dt>
  <dd>Shortcut for "repeat=never, min=n, max=n".  --chunk-size=1 is a quick way to determine whether a file is 1-minimal, for example after making a change that you think might make some lines unnecessary.</dd>

  </dl>




  If you find a non-deterministic bug, don't despair.  Lithium will do fine as long as you make the bug happen at least 70% of the time.  You can repeat the test either within the application, by adding a loop or reload in the testcase (outside of the DDBEGIN/DDEND markers!), or outside of the application, by adding a loop to the "interestingness test" script.




  Lithium is written in [Python](https://www.python.org/) and requires Python 3.5+.



  - [Lithium's testcase reduction algorithm](src/lithium/docs/algorithm.md) is a modified version of the "ddmin" algorithm in Andreas Zeller's paper, [Simplifying and Isolating Failure-Inducing Input](https://www.st.cs.uni-saarland.de/papers/tse2002/).
  - The idea of using an external "interestingness test" program came from [Delta](http://delta.tigris.org/), a similar tool that's [used in clever ways by the GCC project](https://gcc.gnu.org/wiki/A_guide_to_testcase_reduction).
  - [timed_run](src/lithium/interestingness/timed_run.py), used by many of the "interestingness test" scripts that come with Lithium, is based on [timed_run.py](https://web.archive.org/web/20071107032840/http://bclary.com/log/2007/03/07/timed_run), which was written by [Chris Cooper](http://coop.deadsquid.com/) and [Bob Clary](https://bclary.com/).
  - The code was significantly cleaned up and modernized by Jesse Schwartzentruber and Gary Kwong in mid-2017.


pkgId: 8bcf00cbdf00e533997dc34d0a1fa8e8f764624e2fa65746321f711f77c15000
name: python-livelossplot
arch: src
version: 0.5.5
epoch: 0
release: 1
summary: Live training loss plot in Jupyter Notebook for Keras, PyTorch and others.
url: https://github.com/stared/livelossplot
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e78e333a-6513-40db-b274-ae525de759c6
location_href: 00012167-python-livelossplot/python-livelossplot-0.5.5-1.src.rpm
checksum_type: sha256
description:
  [![livelossplot version - PyPI](https://img.shields.io/pypi/v/livelossplot)](https://pypi.org/project/livelossplot/)
  ![PyPI status](https://img.shields.io/pypi/status/livelossplot.svg)
  ![MIT license - PyPI](https://img.shields.io/pypi/l/livelossplot.svg)
  ![Python version - PyPI](https://img.shields.io/pypi/pyversions/livelossplot.svg)
  [![GitHub Workflow Status](https://img.shields.io/github/workflow/status/stared/livelossplot/Python%20package)](https://github.com/stared/livelossplot/actions)
  [![Downloads](http://pepy.tech/badge/livelossplot)](https://pepy.tech/project/livelossplot)
  [![Twitter @pmigdal](https://img.shields.io/twitter/follow/pmigdal)](https://twitter.com/pmigdal)

  Don't train deep learning models blindfolded! Be impatient and look at each epoch of your training!

  ([RECENT CHANGES](CHANGELOG.md), [EXAMPLES IN COLAB](https://colab.research.google.com/github/stared/livelossplot), [API LOOKUP](http://p.migdal.pl/livelossplot/), [CODE](https://github.com/stared/livelossplot))

  A live training loss plot in [Jupyter Notebook](http://jupyter.org/) for [Keras](https://keras.io/), [PyTorch](http://pytorch.org/) and other frameworks. An open-source Python package by [Piotr Migdał](https://p.migdal.pl/), [Bartłomiej Olechno](https://github.com/Bartolo1024/) and [others](https://github.com/stared/livelossplot/graphs/contributors). **Open for collaboration!** (Some tasks are as simple as writing code docstrings, so - no excuses! :))

  ```python
  from livelossplot import PlotLossesKeras

  model.fit(X_train, Y_train,
            epochs=10,
            validation_data=(X_test, Y_test),
            callbacks=[PlotLossesKeras()],
            verbose=0)
  ```

  ![Animated fig for livelossplot tracking log-loss and accuracy](https://raw.githubusercontent.com/stared/livelossplot/master/livelossplot.gif)

  - (The most FA)Q: Why not TensorBoard?
  - A: Jupyter Notebook compatibility (for exploration and teaching). The simplicity of use.



  To install [this version from PyPI](https://pypi.org/project/livelossplot/), type:

  ```bash
  pip install livelossplot
  ```

  To get the newest one from this repo (note that we are in the alpha stage, so there may be frequent updates), type:

  ```bash
  pip install git+git://github.com/stared/livelossplot.git
  ```



  Look at notebook files with full working [examples](https://github.com/stared/livelossplot/blob/master/examples/):

  - [keras.ipynb](https://github.com/stared/livelossplot/blob/master/examples/keras.ipynb) - a Keras callback
  - [minimal.ipynb](https://github.com/stared/livelossplot/blob/master/examples/minimal.ipynb) - a bare API, to use anywhere
  - [bokeh.ipynb](https://github.com/stared/livelossplot/blob/master/examples/bokeh.ipynb) - a bare API, plots with Bokeh ([open it in Colab to see the plots](https://colab.research.google.com/github/stared/livelossplot/blob/master/examples/bokeh.ipynb))
  - [pytorch.ipynb](https://github.com/stared/livelossplot/blob/master/examples/pytorch.ipynb) - a bare API, as applied to PyTorch
  - [2d_prediction_maps.ipynb](https://github.com/stared/livelossplot/blob/master/examples/2d_prediction_maps.ipynb) - example of custom plots - 2d prediction maps (0.4.1+)
  - [poutyne.ipynb](https://github.com/stared/livelossplot/blob/master/examples/poutyne.ipynb) - a Poutyne callback ([Poutyne](https://poutyne.org/) is a Keras-like framework for PyTorch)
  - [torchbearer.ipynb](https://github.com/stared/livelossplot/blob/master/examples/torchbearer.ipynb) - an example using the built in functionality from torchbearer ([torchbearer](https://github.com/ecs-vlc/torchbearer) is a model fitting library for PyTorch)
  - [neptune.py](https://github.com/stared/livelossplot/blob/master/examples/neptune.py) and [neptune.ipynb](https://github.com/stared/livelossplot/blob/master/examples/neptune.ipynb) - a [Neptune.AI](https://neptune.ai/)
  - [matplotlib.ipynb](https://github.com/stared/livelossplot/blob/master/examples/matplotlib.ipynb) - a Matplotlib output example
  - [various_options.ipynb](https://github.com/stared/livelossplot/blob/master/examples/various_options.ipynb) - an extended API for metrics grouping and custom outputs

  You [run examples in Colab](https://colab.research.google.com/github/stared/livelossplot).



  Text logs are easy, but it's easy to miss the most crucial information: is it learning, doing nothing or overfitting?
  Visual feedback allows us to keep track of the training process. Now there is one for Jupyter.

  If you want to get serious - use [TensorBoard](https://www.tensorflow.org/programmers_guide/summaries_and_tensorboard), .
  But what if you just want to train a small model in Jupyter Notebook? Here is a way to do so, using `livelossplot` as a plug&play component



  `PlotLosses` for a generic API.

  ```{python}
  plotlosses = PlotLosses()
  plotlosses.update({'acc': 0.7, 'val_acc': 0.4, 'loss': 0.9, 'val_loss': 1.1})
  plot.send()  # draw, update logs, etc
  ```

  There are callbacks for common libraries and frameworks: `PlotLossesKeras`, `PlotLossesKerasTF`, `PlotLossesPoutyne`, `PlotLossesIgnite`.

  Feel invited to write, and contribute, your adapter.
  If you want to use a bare logger, there is `MainLogger`.



  Plots: `MatplotlibPlot`, `BokehPlot`.

  Loggers: `ExtremaPrinter` (to standard output), `TensorboardLogger`, `TensorboardTFLogger`, `NeptuneLogger`.

  To use them, initialize PlotLosses with some outputs:

  ```{python}
  plotlosses = PlotLosses(outputs=[MatplotlibPlot(), TensorboardLogger()])
  ```

  There are custom `matplotlib` plots in `livelossplot.outputs.matplotlib_subplots` you can pass in `MatplotlibPlot` arguments.

  If you like to plot with [Bokeh](https://docs.bokeh.org/en/latest/) instead of [matplotlib](https://matplotlib.org/), use

  ```{python}
  plotlosses = PlotLosses(outputs=[BokehPlot()])
  ```



  This project supported by [Jacek Migdał](http://jacek.migdal.pl/), [Marek Cichy](https://medium.com/@marekkcichy/), [Casper da Costa-Luis](https://cdcl.ml/), and [Piotr Zientara](https://twitter.com/piotr_zientara). [Join the sponsors - show your ❤️ and support, and appear on the list](https://github.com/sponsors/stared)! It will give me time and energy to work on this project.

  This project is also supported by a European program *Program Operacyjny Inteligentny Rozwój* for [GearShift - building the engine of behavior of wheeled motor vehicles and map’s generation based on artificial intelligence algorithms implemented on the Unreal Engine platform](https://mapadotacji.gov.pl/projekty/874596/?lang=en) lead by ECC Games (NCBR grant GameINN).



  It started as [this gist](https://gist.github.com/stared/dfb4dfaf6d9a8501cd1cc8b8cb806d2e). Since it went popular, I decided to rewrite it as a package.

  Oh, and I am in general interested in data vis, see [Simple diagrams of convoluted neural networks](https://medium.com/inbrowserai/simple-diagrams-of-convoluted-neural-networks-39c097d2925b) (and overview of deep learning architecture diagrams):

  > A good diagram is worth a thousand equations — let’s create more of these!

  ...or [my other data vis projects](https://p.migdal.pl/projects/).



  If you want more functionality - open an [Issue](https://github.com/stared/livelossplot/issues) or even better - prepare a [Pull Request](https://github.com/stared/livelossplot/pulls).


pkgId: 55a90910dffb992077c58d2d9e428f3da132bdcfff552880c762e5922c27e382
name: python-livereload
arch: src
version: 2.6.3
epoch: 0
release: 1
summary: Python LiveReload is an awesome tool for web developers
url: https://github.com/lepture/python-livereload
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fd6b32d6-a045-4fde-8489-29c60177ee10
location_href: 00004119-python-livereload/python-livereload-2.6.3-1.src.rpm
checksum_type: sha256
description:
  This is a brand new LiveReload in version 2.0.0.
  `Download on PyPi <https://pypi.python.org/pypi/livereload>`_


pkgId: 896f16684ff891631d267b4c6be24c65cd9032135abb15f19c868a9758953ae3
name: python-lizard
arch: src
version: 1.17.10
epoch: 0
release: 1
url: http://www.lizard.ws
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-85b1e837-4dbd-4bb9-8cce-a2e34ccad440
location_href: 00011905-python-lizard/python-lizard-1.17.10-1.src.rpm
checksum_type: sha256
summary:
  A code analyzer without caring the C/C++ header files. It works with Java, C/C++, JavaScript, Python, Ruby, Swift, Objective C. Metrics includes cyclomatic complexity number etc.

description:
  |
  Lizard is an extensible Cyclomatic Complexity Analyzer for many programming languages
  including C/C++ (doesn't require all the header files or Java imports). It also does
  copy-paste detection (code clone detection/code duplicate detection) and many other forms of static
  code analysis.
  A list of supported languages:
  -  C/C++ (works with C++14)
  -  Java
  -  C# (C Sharp)
  -  JavaScript (With ES6 and JSX)
  -  TypeScript
  -  Objective-C
  -  Swift
  -  Python
  -  Ruby
  -  TTCN-3
  -  PHP
  -  Scala
  -  GDScript
  -  Golang
  -  Lua
  -  Rust
  -  Fortran
  -  Kotlin
  By default lizard will search for any source code that it knows and mix
  all the results together. This might not be what you want. You can use
  the "-l" option to select language(s).
  It counts
  -  the nloc (lines of code without comments),
  -  CCN (cyclomatic complexity number),
  -  token count of functions.
  -  parameter count of functions.
  You can set limitation for CCN (-C), the number of parameters (-a).
  Functions that exceed these limitations will generate warnings. The exit
  code of lizard will be none-Zero if there are warnings.
  This tool actually calculates how complex the code 'looks' rather than
  how complex the code really 'is'. People will need this tool because it's
  often very hard to get all the included folders and files right when
  they are complicated. But we don't really need that kind of accuracy for
  cyclomatic complexity.
  It requires python2.7 or above (early versions are not verified).


pkgId: 319ac4f143fe02559086f0ed43d14f528d38c94879ffeb888ae3041ac2ae3324
name: python-lkml
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: A speedy LookML parser implemented in pure Python.
url: https://github.com/joshtemple/lkml
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-08ac9447-5e34-418a-b2fc-3d21b8ee78b9
location_href: 00010048-python-lkml/python-lkml-1.3.1-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://img.shields.io/circleci/build/github/joshtemple/lkml.svg)](https://circleci.com/gh/joshtemple/lkml)
  [![Codecov](https://img.shields.io/codecov/c/github/joshtemple/lkml.svg)](https://codecov.io/gh/joshtemple/lkml)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Read the Docs](https://img.shields.io/readthedocs/lkml)](https://lkml.readthedocs.io/en/latest/)



  A speedy LookML parser and serializer implemented in pure Python.

  **Read the documentation on [Read the Docs](https://lkml.readthedocs.io/en/latest/).**

  `lkml.load` parses LookML strings to Python objects or JSON strings. `lkml.dump` serializes (generates) LookML strings from Python objects.

  Why should you use `lkml`?
  - Tested on **over 160K lines of LookML** from public repositories on GitHub
  - Parses a typical view or model file in < **10 ms** (excludes I/O time)
  - Written in pure, modern Python 3.7 with **no external dependencies**
  - A **full unit test suite** with excellent coverage

  Interested in contributing to `lkml`? Check out the [contributor guidelines](CONTRIBUTING.md).



  `lkml` is available to install on [pip](https://pypi.org/project/lkml/) via the following command:

  ```
  pip install lkml
  ```


pkgId: 3b617c8a276409d52325ace845f9800da40770013058e36274ac5323cfc62918
name: python-llfuse
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: Python bindings for the low-level FUSE API
url: https://github.com/python-llfuse/python-llfuse/
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dc3a5747-ebab-46e3-8d97-2dd03fd8cbbf
location_href: 00004120-python-llfuse/python-llfuse-1.4.2-1.src.rpm
checksum_type: sha256
description:
  **Warning - no longer developed!**
  Python-LLFUSE is no longer actively developed and just receiving
  community-contributed maintenance to keep it alive for some time.
  Python-LLFUSE is a set of Python bindings for the low level FUSE_
  API. It requires at least FUSE 2.8.0 and supports both Python 2.x and
  3.x. Like FUSE itself, Python-LLFUSE is developed for Linux systems,
  but it should be compatible with OS-X, FreeBSD and NetBSD as well.
  Python-LLFUSE releases can be downloaded from PyPi_. The documentation
  can be `read online`__ and is also included in the ``doc/html``
  directory of the Python-LLFUSE tarball.


pkgId: 349fe5051c615c99f66c8dcb4356e535865eb1e22045802935077ffc084f3d55
name: python-lmdb-debuginfo
arch: aarch64
version: 1.4.0
epoch: 0
release: 1
summary: Debug information for package python-lmdb
url: http://github.com/jnwatson/py-lmdb/
rpm_license: OLDAP-2.8
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-d5b853d3-a4a6-41cc-9a0d-e80ed1a3d96a
rpm_sourcerpm: python-lmdb-1.4.0-1.src.rpm
location_href: 00004121-python-lmdb/python-lmdb-debuginfo-1.4.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-lmdb.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 72188d8ec44120487baebc34c2975c23c98e1e95efab7e32cb506ac29bf22f8b
name: python-lmdb-debugsource
arch: aarch64
version: 1.4.0
epoch: 0
release: 1
summary: Debug sources for package python-lmdb
url: http://github.com/jnwatson/py-lmdb/
rpm_license: OLDAP-2.8
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-d5b853d3-a4a6-41cc-9a0d-e80ed1a3d96a
rpm_sourcerpm: python-lmdb-1.4.0-1.src.rpm
location_href: 00004121-python-lmdb/python-lmdb-debugsource-1.4.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-lmdb.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 27f272fc89dc8f81562fb6286706d2f9e0dd5edc980f4e48e975eb0ce3165e03
name: python-localstack
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: LocalStack - A fully functional local Cloud stack
url: https://github.com/localstack/localstack
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b8270277-4f02-4009-96ff-4ab06fd126b1
location_href: 00013180-python-localstack/python-localstack-2.0.1-1.src.rpm
checksum_type: sha256
description:
  [LocalStack](https://localstack.cloud) is a cloud service emulator that runs in a single container on your laptop or in your CI environment. With LocalStack, you can run your AWS applications or Lambdas entirely on your local machine without connecting to a remote cloud provider! Whether you are testing complex CDK applications or Terraform configurations, or just beginning to learn about AWS services, LocalStack helps speed up and simplify your testing and development workflow.
  LocalStack supports a growing number of AWS services, like AWS Lambda, S3, Dynamodb, Kinesis, SQS, SNS, and many more! The [Pro version of LocalStack](https://localstack.cloud/pricing) supports additional APIs and advanced features. You can find a comprehensive list of supported APIs on our [☑️ Feature Coverage](https://docs.localstack.cloud/user-guide/aws/feature-coverage/) page.
  LocalStack also provides additional features to make your life as a cloud developer easier! Check out LocalStack's [Cloud Developer Tools](https://docs.localstack.cloud/user-guide/tools/) for more information.

  * `python` (Python 3.7 up to 3.11 supported)
  * `pip` (Python package manager)
  * `Docker`

  The easiest way to install LocalStack is via `pip`:
  ```
  pip install localstack
  ```
  This installs the `localstack-cli` which is used to run the Docker image that hosts the LocalStack runtime.
  > **Important**: Do not use `sudo` or run as `root` user. LocalStack must be installed and started entirely under a local non-root user. If you have problems with permissions in macOS High Sierra, install with `pip install --user localstack`

  Start LocalStack inside a Docker container by running:
  ```
   % localstack start -d
       __                     _______ __             __
      / /   ____  _________ _/ / ___// /_____ ______/ /__
     / /   / __ \/ ___/ __ `/ /\__ \/ __/ __ `/ ___/ //_/
    / /___/ /_/ / /__/ /_/ / /___/ / /_/ /_/ / /__/ ,<
   /_____/\____/\___/\__,_/_//____/\__/\__,_/\___/_/|_|
   💻 LocalStack CLI 2.0.0
  [20:22:20] starting LocalStack in Docker mode 🐳
  [20:22:21] detaching
  ```
  You can query the status of respective services on LocalStack by running:
  ```
  % localstack status services
  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┓
  ┃ Service                  ┃ Status      ┃
  ┡━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━┩
  │ acm                      │ ✔ available │
  │ apigateway               │ ✔ available │
  │ cloudformation           │ ✔ available │
  │ cloudwatch               │ ✔ available │
  │ config                   │ ✔ available │
  │ dynamodb                 │ ✔ available │
  ```
  To use SQS, a fully managed distributed message queuing service, on LocalStack, run:
  ```shell
  % awslocal sqs create-queue --queue-name sample-queue
  {
      "QueueUrl": "http://localhost:4566/000000000000/sample-queue"
  }
  ```
  Learn more about [LocalStack AWS services](https://docs.localstack.cloud/references/coverage/) and using them with LocalStack's `awslocal` CLI.

  You can run LocalStack through the following options:
  - [LocalStack CLI](https://docs.localstack.cloud/getting-started/installation/#localstack-cli)
  - [Docker](https://docs.localstack.cloud/getting-started/installation/#docker)
  - [Docker Compose](https://docs.localstack.cloud/getting-started/installation/#docker-compose)
  - [Helm](https://docs.localstack.cloud/getting-started/installation/#helm)

  To start using LocalStack, check out our documentation at <https://docs.localstack.cloud>.
  - [LocalStack Configuration](https://docs.localstack.cloud/references/configuration/)
  - [LocalStack in CI](https://docs.localstack.cloud/user-guide/ci/)
  - [LocalStack Integrations](https://docs.localstack.cloud/user-guide/integrations/)
  - [LocalStack Tools](https://docs.localstack.cloud/user-guide/tools/)
  - [Understanding LocalStack](https://docs.localstack.cloud/references/)
  - [Troubleshoot](doc/troubleshoot/README.md)
  To use LocalStack with a graphical user interface, you can use the following UI clients:
  * [Commandeer desktop app](https://getcommandeer.com)
  * [DynamoDB Admin Web UI](https://www.npmjs.com/package/dynamodb-admin)

  Please refer to [GitHub releases](https://github.com/localstack/localstack/releases) to see the complete list of changes for each release. For extended release notes, please refer to the [LocalStack Discuss](https://discuss.localstack.cloud/c/announcement/5).

  If you are interested in contributing to LocalStack:
  - Start by reading our [contributing guide](CONTRIBUTING.md).
  - Check out our [developer guide](https://docs.localstack.cloud/contributing/).
  - Navigate our codebase and [open issues](https://github.com/localstack/localstack/issues).
  We are thankful for all the contributions and feedback we receive.

  To get in touch with LocalStack team for bugs/feature requests, support questions or general discussions, please use:
  - [LocalStack Slack Community](https://localstack.cloud/contact/)
  - [LocalStack Discussion Page](https://discuss.localstack.cloud/)
  - [LocalStack GitHub Issue tracker](https://github.com/localstack/localstack/issues)

  We are thankful to all the people who have contributed to this project.
  <a href="https://github.com/localstack/localstack/graphs/contributors"><img src="https://opencollective.com/localstack/contributors.svg?width=890" /></a>

  We are also grateful to all our backers who have donated to the project. You can become a backer on [Open Collective](https://opencollective.com/localstack#backer).
  <a href="https://opencollective.com/localstack#backers" target="_blank"><img src="https://opencollective.com/localstack/backers.svg?width=890"></a>

  You can also support this project by becoming a sponsor on [Open Collective](https://opencollective.com/localstack#sponsor). Your logo will show up here along with a link to your website.
  <a href="https://opencollective.com/localstack/sponsor/0/website" target="_blank"><img src="https://opencollective.com/localstack/sponsor/0/avatar.svg"></a>
  <a href="https://opencollective.com/localstack/sponsor/1/website" target="_blank"><img src="https://opencollective.com/localstack/sponsor/1/avatar.svg"></a>
  <a href="https://opencollective.com/localstack/sponsor/2/website" target="_blank"><img src="https://opencollective.com/localstack/sponsor/2/avatar.svg"></a>
  <a href="https://opencollective.com/localstack/sponsor/3/website" target="_blank"><img src="https://opencollective.com/localstack/sponsor/3/avatar.svg"></a>
  <a href="https://opencollective.com/localstack/sponsor/4/website" target="_blank"><img src="https://opencollective.com/localstack/sponsor/4/avatar.svg"></a>
  <a href="https://opencollective.com/localstack/sponsor/5/website" target="_blank"><img src="https://opencollective.com/localstack/sponsor/5/avatar.svg"></a>
  <a href="https://opencollective.com/localstack/sponsor/6/website" target="_blank"><img src="https://opencollective.com/localstack/sponsor/6/avatar.svg"></a>
  <a href="https://opencollective.com/localstack/sponsor/7/website" target="_blank"><img src="https://opencollective.com/localstack/sponsor/7/avatar.svg"></a>
  <a href="https://opencollective.com/localstack/sponsor/8/website" target="_blank"><img src="https://opencollective.com/localstack/sponsor/8/avatar.svg"></a>
  <a href="https://opencollective.com/localstack/sponsor/9/website" target="_blank"><img src="https://opencollective.com/localstack/sponsor/9/avatar.svg"></a>

  Copyright (c) 2017-2023 LocalStack maintainers and contributors.
  Copyright (c) 2016 Atlassian and others.
  This version of LocalStack is released under the Apache License, Version 2.0 (see [LICENSE](LICENSE.txt)). By downloading and using this software you agree to the [End-User License Agreement (EULA)](doc/end_user_license_agreement). To know about the external software we use, look at our [third party software tools](doc/third-party-software-tools/README.md) page.


pkgId: a387f71a4cfce50a4a2c82653fb801313b5dd47b2c6d4fd3ac667edee9b09c84
name: python-localstack-plugin-loader
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: The dynamic code loading framework used in LocalStack
url: https://github.com/localstack/localstack-plugin-loader
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7b95a703-1d4b-4c96-b055-120ecd362ac0
location_href: 00013021-python-localstack-plugin-loader/python-localstack-plugin-loader-1.1.1-1.src.rpm
checksum_type: sha256
description:
  <p>
    <a href="https://github.com/localstack/localstack-plugin-loader/actions/workflows/build.yml"><img alt="CI badge" src="https://github.com/localstack/localstack-plugin-loader/actions/workflows/build.yml/badge.svg"></img></a>
    <a href="https://pypi.org/project/localstack-plugin-loader/"><img alt="PyPI Version" src="https://img.shields.io/pypi/v/localstack-plugin-loader?color=blue"></a>
    <a href="https://img.shields.io/pypi/l/localstack-plugin-loader.svg"><img alt="PyPI License" src="https://img.shields.io/pypi/l/localstack-plugin-loader.svg"></a>
    <a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>
  </p>
  localstack-plugin-loader is the dynamic code loading framework used in [LocalStack](https://github.com/localstack/localstack).


pkgId: eebf268a66337b23f58d4b63e0a19078977543f807a0b52caa7978c1084916f7
name: python-locket
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: File-based locks for Python on Linux and Windows
url: http://github.com/mwilliamson/locket.py
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d076f979-bba8-4614-9480-9c05a5f7fafe
location_href: 00004122-python-locket/python-locket-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Locket implements a file-based lock that can be used by multiple processes provided they use the same path.
      import locket
      
      with locket.lock_file("path/to/lock/file"):
          perform_action()
      
      with locket.lock_file("path/to/lock/file", timeout=0):
          perform_action()
      
      with locket.lock_file("path/to/lock/file", timeout=30):
          perform_action()
      
      lock = locket.lock_file("path/to/lock/file")
      try:
          lock.acquire()
          perform_action()
      finally:
          lock.release()
  Locks largely behave as (non-reentrant) ``Lock`` instances from the ``threading``
  module in the standard library. Specifically, their behaviour is:
  * Locks are uniquely identified by the file being locked,
    both in the same process and across different processes.
  * Locks are either in a locked or unlocked state.
  * When the lock is unlocked, calling ``acquire()`` returns immediately and changes
    the lock state to locked.
  * When the lock is locked, calling ``acquire()`` will block until the lock state
    changes to unlocked, or until the timeout expires.
  * If a process holds a lock, any thread in that process can call ``release()`` to
    change the state to unlocked.
  * Calling ``release()`` on an unlocked lock raises ``LockError``.
  * Behaviour of locks after ``fork`` is undefined.


pkgId: b04ec1668317c64be93f788198c3c88f24e1b7cbd84070264457c118b2b7de05
name: python-lockfile
arch: src
version: 0.12.2
epoch: 0
release: 1
summary: Platform-independent file locking module
url: http://launchpad.net/pylockfile
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ed93630e-3872-4069-8707-e2ab112a1e52
location_href: 00004123-python-lockfile/python-lockfile-0.12.2-1.src.rpm
checksum_type: sha256
description:
  Note: This package is **deprecated**. It is highly preferred that instead of
  using this code base that instead `fasteners`_ or `oslo.concurrency`_ is
  used instead. For any questions or comments or further help needed
  please email `openstack-dev`_ and prefix your email subject
  with ``[oslo][pylockfile]`` (for a faster response).

  .. _fasteners: https://pypi.python.org/pypi/fasteners
  .. _oslo.concurrency: http://docs.openstack.org/developer/oslo.concurrency/
  .. _openstack-dev: http://lists.openstack.org/cgi-bin/mailman/listinfo/openstack-dev

  The lockfile package exports a LockFile class which provides a simple API for
  locking files.  Unlike the Windows msvcrt.locking function, the fcntl.lockf
  and flock functions, and the deprecated posixfile module, the API is
  identical across both Unix (including Linux and Mac) and Windows platforms.
  The lock mechanism relies on the atomic nature of the link (on Unix) and
  mkdir (on Windows) system calls.  An implementation based on SQLite is also
  provided, more as a demonstration of the possibilities it provides than as
  production-quality code.

  Note: In version 0.9 the API changed in two significant ways:

   * It changed from a module defining several classes to a package containing
     several modules, each defining a single class.

   * Where classes had been named SomethingFileLock before the last two words
     have been reversed, so that class is now SomethingLockFile.

  The previous module-level definitions of LinkFileLock, MkdirFileLock and
  SQLiteFileLock will be retained until the 1.0 release.

  To install:

      python setup.py install

  * Documentation: http://docs.openstack.org/developer/pylockfile
  * Source: http://git.openstack.org/cgit/openstack/pylockfile
  * Bugs: http://bugs.launchpad.net/pylockfile


pkgId: 4bcd3508eea94001a313e36b4f973e9314ae5b871552e719fefa5ad5cd430ca8
name: python-logdna
arch: src
version: 1.18.6
epoch: 0
release: 1
summary: A Python Package for Sending Logs to LogDNA
url: https://github.com/logdna/python
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4e0c8e57-e62d-422c-b0d2-82e31f63b3aa
location_href: 00012564-python-logdna/python-logdna-1.18.6-1.src.rpm
checksum_type: sha256
description:
  * [Installation](#installation)
  * [Setup](#setup)
  * [Usage](#usage)
    * [Usage with fileConfig](#usage-with-fileconfig)
  * [API](#api)
    * [LogDNAHandler(key: string, [options: dict])](#logdnahandlerkey-string-options-dict)
      * [key](#key)
      * [options](#options)
    * [log(line, [options])](#logline-options)
      * [line](#line)
      * [options](#options-1)
  * [Development](#development)
    * [Scripts](#scripts)
  * [License](#license)

  ```bash
  $ pip install logdna
  ```

  ```python
  import logging
  from logdna import LogDNAHandler
  import os



  key=os.environ['INGESTION_KEY']
  log = logging.getLogger('logdna')
  log.setLevel(logging.INFO)
  options = {
    'hostname': 'pytest',
    'ip': '10.0.1.1',
    'mac': 'C0:FF:EE:C0:FF:EE'
  }

  options['index_meta'] = True
  options['custom_fields'] = 'meta'
  test = LogDNAHandler(key, options)
  log.addHandler(test)
  log.warning("Warning message", extra={'app': 'bloop'})
  log.info("Info message")
  ```
  _**Required**_
  * [LogDNA Ingestion Key](https://app.logdna.com/manage/profile)
  _**Optional**_
  * Hostname - ([string][])
  * MAC Address - ([string][])
  * IP Address - ([string][])
  * Index Meta - ([bool][]) - formatted as `options['index_meta']`

  After initial setup, logging is as easy as:
  ```python

  log.info('My Sample Log Line')

  log.info('My Sample Log Line', extra={ 'level': 'MyCustomLevel' })

  log.info('My Sample Log Line', extra={ 'level': 'Warn', 'app': 'myAppName'})

  meta = {
      'foo': 'bar',
      'nested': {
          'nest1': 'nested text'
      }
  }
  opts = {
      'level': 'warn',
      'meta': meta
  }
  log.info('My Sample Log Line', extra=opts)
  ```

  To use [LogDNAHandler](#logdnahandlerkey-string-options-dict) with [fileConfig][] (e.g., in a Django `settings.py` file):
  ```python
  import os
  import logging
  from logdna import LogDNAHandler #  required to register `logging.handlers.LogDNAHandler`
  LOGGING = {
      
      'handlers': {
          'logdna': {
              'level': logging.DEBUG,
              'class': 'logging.handlers.LogDNAHandler',
              'key': os.environ.get('LOGDNA_INGESTION_KEY'),
              'options': {
                  'app': '<app name>',
                  'env': os.environ.get('ENVIRONMENT'),
                  'index_meta': <True|False>,
              },
          },
      },
      'loggers': {
          '': {
              'handlers': ['logdna'],
              'level': logging.DEBUG
          },
      },
  }
  ```
  (This example assumes you have set environment variables for `ENVIRONMENT` and `LOGDNA_INGESTION_KEY`.)



  * _**Required**_
  * Type: [string][]
  * Values: `<your ingestion key>`
  The [LogDNA API Key](https://app.logdna.com/manage/profile) associated with your account.


  * _Optional_
  * Type: [string][]
  * Default: `''`
  * Values: `<your custom app>`
  The default app named that is included in every every log line sent through this instance.

  * _Optional_
  * Type: [string][]
  * Default: `''`
  * Values: `<your custom env>`
  The default env passed along with every log sent through this instance.

  * _Optional_
  * Type: [string][]
  * Default: `''`
  * Values: `<your custom hostname>`
  The default hostname passed along with every log sent through this instance.

  * _Optional_
  * Type: [bool][]
  * Default: `False`
  Python [LogRecord][] objects includes language-specific information that may be useful metadata in logs.
  Setting `include_standard_meta` to `True` automatically populates meta objects with `name`, `pathname`, and `lineno`
  from the [LogRecord][].
  *WARNING* This option is deprecated and will be removed in the upcoming major release.

  * _Optional_
  * Type: [bool][]
  * Default: `False`
  We allow meta objects to be passed with each line. By default these meta objects are stringified and not searchable, and are only displayed for informational purposes.
  If this option is set to True then meta objects are parsed and searchable up to three levels deep. Any fields deeper than three levels are stringified and cannot be searched.
  *WARNING* If this option is True, your metadata objects MUST have consistent types across all log messages or the metadata object might not be parsed properly.

  * _Optional_
  * Type: [string][]
  * Default: `Info`
  * Values: `Debug`, `Trace`, `Info`, `Warn`, `Error`, `Fatal`, `<your custom level>`
  The default level passed along with every log sent through this instance.

  * _Optional_
  * Type: [string][] or [bool][]
  * Default: `True`
  * Values: `False` or any level
  Sets the verbosity of log statements for failures.

  * _Optional_
  * Type: [int][]
  * Default: `30000`
  The amount of time (in ms) the request should wait for LogDNA to respond before timing out.

  * _Optional_
  * Type: [list][]&lt;[string][]&gt;
  * Default: `[]`
  List of tags used to dynamically group hosts.  More information on tags is available at [How Do I Use Host Tags?](https://docs.logdna.com/docs/logdna-agent#section-how-do-i-use-host-tags-)

  * _Optional_
  * Type: [string][]
  * Default: `'https://logs.logdna.com/logs/ingest'`
  A custom ingestion endpoint to stream log lines into.

  * _Optional_
  * Type: [list][]&lt;[string][]&gt;
  * Default: `['args', 'name', 'pathname', 'lineno']`
  List of fields out of `record` object to include in the `meta` object. By default, `args`, `name`, `pathname`, and `lineno` will be included.

  * _Optional_
  * Type: [bool][]
  * Default: `False`
  Enables logging of the API response when an HTTP error is encountered


  * _Required_
  * Type: [string][]
  * Default: `''`
  The log line to be sent to LogDNA.


  * _Optional_
  * Type: [string][]
  * Default: `Info`
  * Values: `Debug`, `Trace`, `Info`, `Warn`, `Error`, `Fatal`, `<your custom level>`
  The level passed along with this log line.

  * _Optional_
  * Type: [string][]
  * Default: `''`
  * Values: `<your custom app>`
  The app passed along with this log line.

  * _Optional_
  * Type: [string][]
  * Default: `''`
  * Values: `<your custom env>`
  The environment passed with this log line.

  * _Optional_
  * Type: [dict][]
  * Default: `None`
  A standard dictonary containing additional metadata about the log line that is passed. Please ensure values are JSON serializable.
  **NOTE**: Values that are not JSON serializable will be removed and the respective keys will be added to the `__errors` string.

  * _Optional_
  * Type: [bool][]
  * Default: `False`
  We allow meta objects to be passed with each line. By default these meta objects will be stringified and will not be
  searchable, but will be displayed for informational purposes.
  If this option is turned to true then meta objects will be parsed and will be searchable up to three levels deep. Any fields deeper than three levels will be stringified and cannot be searched.
  *WARNING* When this option is true, your metadata objects across all types of log messages MUST have consistent types or the metadata object may not be parsed properly!

  * _Optional_
  * Type: [float][]
  * Default: [time.time()][]
  The time in seconds since the epoch to use for the log timestamp. It must be within one day or current time - if it is not, it is ignored and time.time() is used in its place.

  This project makes use of the [poetry][] package manager for local development.
  ```shell
  $ poetry install
  ```

  **lint**
  Run linting rules w/o attempting to fix them
  ```shell
  $ poetry run task lint
  ```
  **lint:fix**
  Run lint rules against all local python files and attempt to fix where possible.
  ```shell
  $ poetry run task lint:fix
  ```
  **test**:
  Runs all unit tests and generates coverage reports
  ```shell
  poetry run task test
  ```

  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):
  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tr>
      <td align="center"><a href="https://github.com/respectus"><img src="https://avatars.githubusercontent.com/u/1046364?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Muaz Siddiqui</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=respectus" title="Code">💻</a> <a href="https://github.com/logdna/python/commits?author=respectus" title="Documentation">📖</a> <a href="https://github.com/logdna/python/commits?author=respectus" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://github.com/smusali"><img src="https://avatars.githubusercontent.com/u/34287490?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Samir Musali</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=smusali" title="Code">💻</a> <a href="https://github.com/logdna/python/commits?author=smusali" title="Documentation">📖</a> <a href="https://github.com/logdna/python/commits?author=smusali" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://github.com/vilyapilya"><img src="https://avatars.githubusercontent.com/u/17367511?v=4?s=100" width="100px;" alt=""/><br /><sub><b>vilyapilya</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=vilyapilya" title="Code">💻</a> <a href="#maintenance-vilyapilya" title="Maintenance">🚧</a> <a href="https://github.com/logdna/python/commits?author=vilyapilya" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://github.com/mikehu"><img src="https://avatars.githubusercontent.com/u/981800?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Mike Hu</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=mikehu" title="Documentation">📖</a></td>
      <td align="center"><a href="http://codedependant.net/"><img src="https://avatars.githubusercontent.com/u/148561?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Eric Satterwhite</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=esatterwhite" title="Code">💻</a> <a href="https://github.com/logdna/python/commits?author=esatterwhite" title="Documentation">📖</a> <a href="https://github.com/logdna/python/commits?author=esatterwhite" title="Tests">⚠️</a> <a href="#tool-esatterwhite" title="Tools">🔧</a></td>
      <td align="center"><a href="http://dev.utek.pl/"><img src="https://avatars.githubusercontent.com/u/128036?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Łukasz Bołdys (Lukasz Boldys)</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=utek" title="Code">💻</a> <a href="https://github.com/logdna/python/issues?q=author%3Autek" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/baronomasia"><img src="https://avatars.githubusercontent.com/u/4133158?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Ryan</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=baronomasia" title="Documentation">📖</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/LYHuang"><img src="https://avatars.githubusercontent.com/u/14082239?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Mike Huang</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=LYHuang" title="Code">💻</a> <a href="https://github.com/logdna/python/issues?q=author%3ALYHuang" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://www.medium.com/@dmaas"><img src="https://avatars.githubusercontent.com/u/9013104?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Dan Maas</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=danmaas" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/dchai76"><img src="https://avatars.githubusercontent.com/u/13873467?v=4?s=100" width="100px;" alt=""/><br /><sub><b>DChai</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=dchai76" title="Documentation">📖</a></td>
      <td align="center"><a href="https://naboa.de/"><img src="https://avatars.githubusercontent.com/u/10531844?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Jakob de Maeyer </b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=jdemaeyer" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/sataloger"><img src="https://avatars.githubusercontent.com/u/359111?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Andrey Babak</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=sataloger" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/mike-spainhower"><img src="https://avatars.githubusercontent.com/u/380032?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Mike S</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=SpainTrain" title="Code">💻</a> <a href="https://github.com/logdna/python/commits?author=SpainTrain" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/btashton"><img src="https://avatars.githubusercontent.com/u/173245?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Brennan Ashton</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=btashton" title="Code">💻</a></td>
    </tr>
    <tr>
      <td align="center"><a href="http://justrocketscience.com/"><img src="https://avatars.githubusercontent.com/u/604528?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Christian Hotz-Behofsits</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=inkrement" title="Code">💻</a> <a href="https://github.com/logdna/python/issues?q=author%3Ainkrement" title="Bug reports">🐛</a></td>
      <td align="center"><a href="http://www.kinoarts.com/blog/"><img src="https://avatars.githubusercontent.com/u/108118?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Kurtiss Hare</b></sub></a><br /><a href="https://github.com/logdna/python/issues?q=author%3Akurtiss" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://twitter.com/rudyryk"><img src="https://avatars.githubusercontent.com/u/4500?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Alexey Kinev</b></sub></a><br /><a href="https://github.com/logdna/python/issues?q=author%3Arudyryk" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/matthiasfru"><img src="https://avatars.githubusercontent.com/u/24245643?v=4?s=100" width="100px;" alt=""/><br /><sub><b>matthiasfru</b></sub></a><br /><a href="https://github.com/logdna/python/issues?q=author%3Amatthiasfru" title="Bug reports">🐛</a></td>
    </tr>
  </table>
  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->
  <!-- ALL-CONTRIBUTORS-LIST:END -->
  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!

  MIT © [LogDNA](https://logdna.com/)
  Copyright © 2017 [LogDNA][], released under an MIT license. See the [LICENSE](./LICENSE) file and [https://opensource.org/licenses/MIT](https://opensource.org/licenses/MIT)
  *Happy Logging!*
  [bool]: https://docs.python.org/3/library/stdtypes.html#boolean-values
  [dict]: https://docs.python.org/3/library/stdtypes.html#mapping-types-dict
  [int]: https://docs.python.org/3/library/functions.html#int
  [float]: https://docs.python.org/3/library/functions.html#float
  [string]: https://docs.python.org/3/library/string.html
  [list]: https://docs.python.org/3/library/stdtypes.html#list
  [time.time()]: https://docs.python.org/3/library/time.html?#time.time
  [poetry]: https://python-poetry.org
  [LogDNA]: https://logdna.com/
  [LogRecord]: https://docs.python.org/2/library/logging.html#logrecord-objects
  [fileConfig]: https://docs.python.org/2/library/logging.config.html#logging.config.fileConfig


pkgId: 55dea574cc3896b6beaaaaaafcc8c7936bf77434160a3b599a4c4d33c584d648
name: python-logging_tree
arch: src
version: 1.9
epoch: 0
release: 1
summary: Introspect and display the logger tree inside "logging"
url: https://github.com/brandon-rhodes/logging_tree
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b610d2f0-b166-49e1-828a-a44b2a2bb953
location_href: 00004126-python-logging-tree/python-logging_tree-1.9-1.src.rpm
checksum_type: sha256
description:
  **Version 1.9** - 2021 April 10
      Declare compatibility with Python 3.9.  Improve how the logging
      module's built-in ``Formatter`` class is displayed under old Python
      versions where the ``logging`` module uses old-style classes.
  **Version 1.8.1** - 2020 January 26
      Adjust one test to make it pass under Python 3.8, and update the
      distribution classifiers to declare compatibility with Python
      versions through 3.8.
  **Version 1.8** - 2018 August 5
      Improve the output to better explain what happens if a "parent"
      attribute has been set to None.
  **Version 1.7** - 2016 January 23
      Detect whether each logger has the correct "parent" attribute and,
      if not, print where its log messages are being sent instead.
  **Version 1.6** - 2015 January 8
      Fixed a crash that would occur if a custom logging Formatter was
      missing its format string attributes.
  **Version 1.5** - 2014 December 24
      Handlers now display their logging level if one has been set, and
      their custom logging formatter if one has been installed.
  **Version 1.4** - 2014 January 8
      Thanks to a contribution from Dave Brondsema, disabled loggers are
      now actually marked as "Disabled" to make it less of a surprise that
      they fail to log anything.
  **Version 1.3** - 2013 October 29
      Be explicit and display the logger level ``NOTSET`` along with the
      effective level inherited from the logger's ancestors; and display
      the list of ``.filters`` of a custom logging handler even though it
      might contain custom code that ignores them.
  **Version 1.2** - 2013 January 19
      Compatible with Python 3.3 thanks to @ralphbean.
  **Version 1.1** - 2012 February 17
      Now compatible with 2.3 <= Python <= 3.2.
  **Version 1.0** - 2012 February 13
      Can display the handler inside a MemoryHandler; entire public
      interface documented; 100% test coverage.
  **Version 0.6** - 2012 February 10
      Added a display format for every ``logging.handlers`` class.
  **Version 0.5** - 2012 February 8
      Initial release.


pkgId: 9b67ae79aa7027a2f9c92ff74db06889155aae2c49a5fc05db3ca9379b9e47e6
name: python-loggly-python-handler
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Python logging handler that sends messages to Loggly
url: https://github.com/loggly/loggly-python-handler/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-10220ae5-2232-45fa-b977-7119367af43c
location_href: 00012235-python-loggly-python-handler/python-loggly-python-handler-1.0.1-1.src.rpm
checksum_type: sha256
description:
  A simple Python logging Loggly handler that can be used to send to a Loggly Gen2 https endpoint. Borrowed the extra fields concept from the graypy logging library. Check out Loggly's [Python logging documentation](https://www.loggly.com/docs/python-http/) to learn more.

  Download the repository using pip
      sudo pip install loggly-python-handler


  Create a Configuration file python.conf and add HTTPSHandler to Configuration File.
      [handlers]
      keys=HTTPSHandler
      [handler_HTTPSHandler]
      class=loggly.handlers.HTTPSHandler
      formatter=jsonFormat
      args=('https://logs-01.loggly.com/inputs/TOKEN/tag/python','POST')
      [formatters]
      keys=jsonFormat
      [loggers]
      keys=root
      [logger_root]
      handlers=HTTPSHandler
      level=INFO
      [formatter_jsonFormat]
      format={ "loggerName":"s", "asciTime":"s", "fileName":"s", "logRecordCreationTime":"f", "functionName":"s", "levelNo":"s", "lineNo":"d", "time":"d", "levelName":"s", "message":"s"}
      datefmt=

      import logging
      import logging.config
      import loggly.handlers
      logging.config.fileConfig('python.conf')
      logger = logging.getLogger('myLogger')
      logger.info('Test log')


      LOGGING = {
          'version': 1,
          'disable_existing_loggers': False,
          'formatters': {
              'verbose': {
                  'format': 's s s d d s'
              },
              'simple': {
                  'format': 's s'
              },
              'json': {
                  'format': '{ "loggerName":"s", "asciTime":"s", "fileName":"s", "logRecordCreationTime":"f", "functionName":"s", "levelNo":"s", "lineNo":"d", "time":"d", "levelName":"s", "message":"s"}',
              },
          },
          'handlers': {
              'console': {
                  'class': 'logging.StreamHandler',
                  'level': 'DEBUG',
                  'formatter': 'verbose',
              },
              'loggly': {
                  'class': 'loggly.handlers.HTTPSHandler',
                  'level': 'INFO',
                  'formatter': 'json',
                  'url': 'https://logs-01.loggly.com/inputs/TOKEN/tag/python',
              },
          },
          'loggers': {
              'django': {
                  'handlers': ['console', ],
                  'level': os.getenv('DJANGO_LOG_LEVEL', 'INFO'),
              },
              'your_app_name': {
                  'handlers': ['console', 'loggly'],
                  'level': 'INFO',
              },
          },
      }

      import logging
      logger = logging.getLogger(__name__)
      def logging_example(request):
          """logging example
          """
          logger.debug('this is DEBUG message.')
          logger.info('this is INFO message.')
          logger.warning('this is WARNING message.')
          logger.error('this is ERROR message.')
          logger.critical('this is CRITICAL message.')
          return Response({}, status=status.HTTP_200_OK)
  Replace
  <ul>
  <li><strong>TOKEN: </strong>your Loggly Customer Token</li>
  </ul>


pkgId: 2269479b1eb5881678313710d7b39c7478acbf3fd256c3199fa5838d29226ff0
name: python-logstash_formatter
arch: src
version: 0.5.17
epoch: 0
release: 1
summary: JSON formatter meant for logstash
url: https://github.com/exoscale/python-logstash-formatter
rpm_license: MIT, see LICENSE file
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a6ce9eeb-2e79-4377-9fa2-78ba2a7a6586
location_href: 00011325-python-logstash-formatter/python-logstash_formatter-0.5.17-1.src.rpm
checksum_type: sha256
description:
  This library is provided to allow standard python logging to output log data
  as json objects ready to be shipped out to logstash.
  This project has been originally open sourced by `exoscale <https://www.exoscale.ch/>`_ (which is a great hosting service btw), thanks to them.


pkgId: b15991a7d8223b436a641a8061c566533a8ad1223526056710c7a33dcfea9776
name: python-loguru
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Python logging made (stupidly) simple
url: https://github.com/Delgan/loguru
rpm_license: MIT license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2389c1e9-0c14-4ae0-b3f5-1a42af325d17
location_href: 00009382-python-loguru/python-loguru-0.7.0-1.src.rpm
checksum_type: sha256
description:
  **Loguru** is a library which aims to bring enjoyable logging in Python.
  Did you ever feel lazy about configuring a logger and used ``print()`` instead?... I did, yet logging is fundamental to every application and eases the process of debugging. Using **Loguru** you have no excuse not to use logging from the start, this is as simple as ``from loguru import logger``.
  Also, this library is intended to make Python logging less painful by adding a bunch of useful functionalities that solve caveats of the standard loggers. Using logs in your application should be an automatism, **Loguru** tries to make it both pleasant and powerful.


pkgId: 540fe3b80445bd573ab9a49ca157f064fb3e71524df34599a8484c97de66326a
name: python-logutils
arch: src
version: 0.3.5
epoch: 0
release: 1
summary: Logging utilities
url: http://code.google.com/p/logutils/
rpm_license: Copyright (C) 2010-2017 by Vinay Sajip. All Rights Reserved. See LICENSE.txt for license.
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ea086f44-4f11-4cc7-9dbb-59c50ec03b0c
location_href: 00011705-python-logutils/python-logutils-0.3.5-1.src.rpm
checksum_type: sha256
description:
  The logutils package provides a set of handlers for the Python standard
  library's logging package.

  Some of these handlers are out-of-scope for the standard library, and
  so they are packaged here. Others are updated versions which have
  appeared in recent Python releases, but are usable with older versions
  of Python and so are packaged here.

  The source code repository is at:

  https://bitbucket.org/vinay.sajip/logutils/

  Documentation is available at:

  https://logutils.readthedocs.io/

  https://pythonhosted.org/logutils/


pkgId: 3013663b7a84d60370b01c851c3d7b0f99e4e98a5e778b7d33120fa0e1c7936d
name: python-logzero
arch: src
version: 1.7.0
epoch: 0
release: 1
summary: Robust and effective logging for Python 2 and 3
url: https://github.com/metachris/logzero
rpm_license: MIT license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cdec0b23-c01d-4866-9ab4-acfd0c591314
location_href: 00004127-python-logzero/python-logzero-1.7.0-1.src.rpm
checksum_type: sha256
description:
  * Easy logging to console and/or (rotating) file.
  * Provides a fully configured standard [Python logger object](https://docs.python.org/2/library/logging.html#module-level-functions>).
  * JSON logging (with integrated [python-json-logger](https://github.com/madzak/python-json-logger))
  * Pretty formatting, including level-specific colors in the console.
  * No dependencies
  * Windows color output supported by [colorama](https://github.com/tartley/colorama)
  * Robust against str/bytes encoding problems, works with all kinds of character encodings and special characters.
  * Multiple loggers can write to the same logfile (also across multiple Python files and processes).
  * Global default logger with [logzero.logger](https://logzero.readthedocs.io/en/latest/#i-logzero-logger) and custom loggers with [logzero.setup_logger(..)](https://logzero.readthedocs.io/en/latest/#i-logzero-setup-logger).
  * Compatible with Python 2 and 3.
  * All contained in a [single file](https://github.com/metachris/logzero/blob/master/logzero/__init__.py).
  * Licensed under the MIT license.
  * Heavily inspired by the [Tornado web framework](https://github.com/tornadoweb/tornado).
  Installation:
  ```shell
  python -m pip install logzero
  ```


pkgId: 3b9f2fa413bd17523c4b9a06f6973c91a382091405f8c64b5943d3829d923aab
name: python-lrparsing
arch: src
version: 1.0.13
epoch: 0
release: 1
summary: An LR(1) parser hiding behind a pythonic interface
url: http://lrparsing.sourceforge.net/
rpm_license: GNU Affero General Public License v3 or later (AGPLv3+)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dcce0193-8c2e-494c-b292-809ac9def5ff
location_href: 00004128-python-lrparsing/python-lrparsing-1.0.13-1.src.rpm
checksum_type: sha256
description:
  Lrparsing provides both an LR(1) parser and a
  tokeniser.  It differs from other Python LR(1) parsers in
  using Python expressions as grammars, and offers simple to use
  disambiguation tools.

  The result is something that is powerful yet concise.  For simple
  tasks this means it can be thought of as an extension to Python's
  existing re module, used when regular expressions become
  too cumbersome.   For complex tasks lrparsing offers a high speed
  parser (very roughly 25us per token from string to parse tree
  on a desktop CPU), pre-compilation of the grammar and error recovery
  hooks so parsing can continue after an error is found.

  In addition to extensive documentation it comes with a parser for
  Sqlite3 data manipulation statements and a Lua 5.2 to Python
  compiler as examples.  The documentation can be read online at
  http://lrparsing.sourceforge.net/doc/html/.


pkgId: be4eb16b7102a1772f03397d7c73f83e38d68ee5ba465cadcff375d38015e6d3
name: python-lru-dict
arch: src
version: 1.1.8
epoch: 0
release: 1
summary: An Dict like LRU container.
url: https://github.com/amitdev/lru-dict
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-08a6dc05-bc69-4590-8880-06dfca6cf2c7
location_href: 00010137-python-lru-dict/python-lru-dict-1.1.8-1.src.rpm
checksum_type: sha256
description:
  A fixed size dict like container which evicts Least Recently Used (LRU) items
  once size limit is exceeded. There are many python implementations available
  which does similar things. This is a fast and efficient C implementation.
  LRU maximum capacity can be modified at run-time.
  If you are looking for pure python version, look `else where <http://www.google.com/search?q=python+lru+dict>`_.


pkgId: e609478a5209cb3409399ad993e1fe372eb993a7c6c08db6225b8bc26a044d36
name: python-lru-dict-debuginfo
arch: aarch64
version: 1.1.8
epoch: 0
release: 1
summary: Debug information for package python-lru-dict
url: https://github.com/amitdev/lru-dict
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-08a6dc05-bc69-4590-8880-06dfca6cf2c7
rpm_sourcerpm: python-lru-dict-1.1.8-1.src.rpm
location_href: 00010137-python-lru-dict/python-lru-dict-debuginfo-1.1.8-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-lru-dict.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: eeff26d5f53a19ece38aaef1e61d2e87c2fdb8903443c176f1569809fc176959
name: python-lru-dict-debugsource
arch: aarch64
version: 1.1.8
epoch: 0
release: 1
summary: Debug sources for package python-lru-dict
url: https://github.com/amitdev/lru-dict
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-08a6dc05-bc69-4590-8880-06dfca6cf2c7
rpm_sourcerpm: python-lru-dict-1.1.8-1.src.rpm
location_href: 00010137-python-lru-dict/python-lru-dict-debugsource-1.1.8-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-lru-dict.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 03ec410418674a1b646c90740a2899cd57de546c44e5a66b29e6017a0d0dc7d9
name: python-luftdaten
arch: src
version: 0.7.4
epoch: 0
release: 1
summary: Python API for interacting with luftdaten.info
url: https://github.com/home-assistant-ecosystem/python-luftdaten
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-86401386-6f66-43f4-86c5-37108ab6c2c3
location_href: 00004131-python-luftdaten/python-luftdaten-0.7.4-1.src.rpm
checksum_type: sha256
description:
  Python client for interacting with `sensor.community <https://sensor.community/>`_ (previously known as `luftdaten.info <http://luftdaten.info/>`_.
  This module is not official, developed, supported or endorsed by sensor.community/luftdaten.info.


pkgId: 57bb1f65fd420acc6402bd02db8aed70fde3a6e489d5490810bad0357b57193a
name: python-luhn
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Generate and verify Luhn check digits
url: https://github.com/mmcloughlin/luhn
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b4ac80dc-5b85-462b-bda7-eb60fd4446ca
location_href: 00011959-python-luhn/python-luhn-0.2.0-1.src.rpm
checksum_type: sha256
description:
  |pypi| |buildstatus| |coverage|
  Generate and verify Luhn check digits
  Install with
      pip install luhn
  Use ``verify`` to check digit strings
      >>> from luhn import *
      >>> verify('356938035643809')
      True
      >>> verify('534618613411236')
      False
  and use ``generate`` to produce them
      >>> generate('53461861341123')
      4
  or ``append`` for convenience
      >>> append('53461861341123')
      '534618613411234'


pkgId: 4d87a05e8d3982a9e4b263631c964e1237b40a89e6b022b50fc9cb6155a08f3e
name: python-luigi
arch: src
version: 3.2.1
epoch: 0
release: 1
summary: Workflow mgmgt + task scheduling + dependency resolution.
url: https://github.com/spotify/luigi
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a7b7a388-bf2f-4da4-acd4-8a7d662292d8
location_href: 00009747-python-luigi/python-luigi-3.2.1-1.src.rpm
checksum_type: sha256
description:
  Run ``pip install luigi`` to install the latest stable version from `PyPI
  <https://pypi.python.org/pypi/luigi>`_. `Documentation for the latest release
  <https://luigi.readthedocs.io/en/stable/>`__ is hosted on readthedocs.
  Run ``pip install luigi[toml]`` to install Luigi with `TOML-based configs
  <https://luigi.readthedocs.io/en/stable/configuration.html>`__ support.
  For the bleeding edge code, ``pip install
  git+https://github.com/spotify/luigi.git``. `Bleeding edge documentation
  <https://luigi.readthedocs.io/en/latest/>`__ is also available.


pkgId: c6c4093d74fbfb6abc6384329a424f2de4d88fc35c1731e8a21d8ce408c98df0
name: python-lunr
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: A Python implementation of Lunr.js
url: https://github.com/yeraydiazdiaz/lunr.py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e1d3a0df-c183-4a66-a3f7-1c3b55fefc29
location_href: 00004132-python-lunr/python-lunr-0.6.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/yeraydiazdiaz/lunr.py/workflows/CI/badge.svg?branch=master)](https://github.com/yeraydiazdiaz/lunr.py/actions?workflow=CI)
  [![codecov](https://codecov.io/gh/yeraydiazdiaz/lunr.py/branch/master/graph/badge.svg)](https://codecov.io/gh/yeraydiazdiaz/lunr.py)
  [![Supported Python Versions](https://img.shields.io/pypi/pyversions/lunr.svg)](https://pypi.org/project/lunr/)
  [![PyPI](https://img.shields.io/pypi/v/lunr.svg)](https://pypi.org/project/lunr/)
  [![Read the Docs](https://img.shields.io/readthedocs/lunr.svg)](http://lunr.readthedocs.io/en/latest/)
  [![Downloads](http://pepy.tech/badge/lunr)](http://pepy.tech/project/lunr)
  [![shoutouts.dev](https://shoutouts.dev/projects/yeraydiazdiaz/lunr.py/badge)](https://shoutouts.dev/projects/yeraydiazdiaz/lunr.py)



  A Python implementation of [Lunr.js](https://lunrjs.com) by [Oliver Nightingale](https://github.com/olivernn).

  > A bit like Solr, but much smaller and not as bright.

  This Python version of Lunr.js aims to bring the simple and powerful full text search
  capabilities into Python guaranteeing results as close as the original
  implementation as possible.

  - [Documentation](http://lunr.readthedocs.io/en/latest/)



  Lunr is a simple full text search solution for situations where deploying a full
  scale solution like Elasticsearch isn't possible, viable or you're simply prototyping.
  Lunr parses a set of documents and creates an inverted index for quick full text
  searches in the same way other more complicated solution.

  The trade-off is that Lunr keeps the inverted index in memory and requires you
  to recreate or read the index at the start of your application.



  A core objective of Lunr.py is to provide
  [interoperability with the JavaScript version](https://lunr.readthedocs.io/en/latest/lunrjs-interop).

  An example can be found in the [MkDocs documentation library](http://www.mkdocs.org/).
  MkDocs produces a set of documents from the pages of the documentation and uses
  [Lunr.js](https://lunrjs.com) in the frontend to power its built-in searching
  engine. This set of documents is in the form of a JSON file which needs to be
  fetched and parsed by Lunr.js to create the inverted index at startup of your application.

  While this is not a problem for most sites, depending on the size of your document
  set, this can take some time.

  Lunr.py provides a backend solution, allowing you to parse the documents in Python
  of time and create a serialized Lunr.js index you can pass have the browser
  version read, minimizing start up time of your application.

  Each version of lunr.py
  [targets a specific version of lunr.js](https://github.com/yeraydiazdiaz/lunr.py/blob/master/lunr/__init__.py#L12)
  and produces the same results for a
  [non-trivial corpus of documents](https://github.com/yeraydiazdiaz/lunr.py/blob/master/tests/acceptance_tests/fixtures/mkdocs_index.json).



  `pip install lunr`

  An optional and experimental support for other languages thanks to the
  [Natural Language Toolkit](http://www.nltk.org/) stemmers is also available via
  `pip install lunr[languages]`. The usage of the language feature is subject to
  [NTLK corpus licensing clauses](https://github.com/nltk/nltk#redistributing).

  Please refer to the
  [documentation page on languages](https://lunr.readthedocs.io/en/latest/languages/)
  for more information.



  First, you'll need a list of dicts representing the documents you want to search on.
  These documents must have a unique field which will serve as a reference and a
  series of fields you'd like to search on.

  Lunr provides a convenience `lunr` function to quickly index this set of documents:

  ```python
  >>> from lunr import lunr
  >>>
  >>> documents = [{
  ...     'id': 'a',
  ...     'title': 'Mr. Green kills Colonel Mustard',
  ...     'body': 'Mr. Green killed Colonel Mustard in the study with the candlestick.',
  ... }, {
  ...     'id': 'b',
  ...     'title': 'Plumb waters plant',
  ...     'body': 'Professor Plumb has a green plant in his study',
  ... }]
  >>> idx = lunr(
  ...     ref='id', fields=('title', 'body'), documents=documents
  ... )
  >>> idx.search('kill')
  [{'ref': 'a', 'score': 0.6931722372559913, 'match_data': <MatchData "kill">}]
  >>> idx.search('study')
  [{'ref': 'b', 'score': 0.23576799568081389, 'match_data': <MatchData "studi">}, {'ref': 'a', 'score': 0.2236629211724517, 'match_data': <MatchData "studi">}]
  ```

  Please refer to the [documentation](http://lunr.readthedocs.io/en/latest/)
  for more usage examples.


pkgId: 176420d136d436be10a373ca13d0459b94aa70ef5b7d684b05f96db3f36957ba
name: python-lupa
arch: src
version: 1.14.1
epoch: 0
release: 1
summary: Python wrapper around Lua and LuaJIT
url: https://github.com/scoder/lupa
rpm_license: MIT style
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-61c3663c-3e0e-47b8-87ae-38ee526a46a2
location_href: 00004134-python-lupa/python-lupa-1.14.1-1.src.rpm
checksum_type: sha256
description:
  Lupa integrates the runtimes of Lua_ or LuaJIT2_ into CPython.
  It is a partial rewrite of LunaticPython_ in Cython_ with some
  additional features such as proper coroutine support.
  For questions not answered here, please contact the `Lupa mailing list`_.


pkgId: cdfcc688f6085a83fcd54bf47f9151b620715f9dcc4ed6fff0da92aac0176368
name: python-lupa-debuginfo
arch: aarch64
version: 1.14.1
epoch: 0
release: 1
summary: Debug information for package python-lupa
url: https://github.com/scoder/lupa
rpm_license: MIT style
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-61c3663c-3e0e-47b8-87ae-38ee526a46a2
rpm_sourcerpm: python-lupa-1.14.1-1.src.rpm
location_href: 00004134-python-lupa/python-lupa-debuginfo-1.14.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-lupa.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: be5b1d619fb4a6730272136ecee7ce376e6e0b5cdeda8f150bdd209f008d5ef8
name: python-lupa-debugsource
arch: aarch64
version: 1.14.1
epoch: 0
release: 1
summary: Debug sources for package python-lupa
url: https://github.com/scoder/lupa
rpm_license: MIT style
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-61c3663c-3e0e-47b8-87ae-38ee526a46a2
rpm_sourcerpm: python-lupa-1.14.1-1.src.rpm
location_href: 00004134-python-lupa/python-lupa-debugsource-1.14.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-lupa.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 5cd1b2ae763e6a2ca86396cddb4dcdf80025a0e0e4e5a04ef7f23b05d573bbef
name: python-lyricsgenius
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: Download lyrics and metadata from Genius.com
url: https://github.com/johnwmillr/lyricsgenius
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c6d801f0-c45b-4d1e-a10f-70bab045d839
location_href: 00010775-python-lyricsgenius/python-lyricsgenius-3.0.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/johnwmillr/LyricsGenius.svg?branch=master)](https://travis-ci.org/johnwmillr/LyricsGenius)
  [![Documentation Status](https://readthedocs.org/projects/lyricsgenius/badge/?version=master)](https://lyricsgenius.readthedocs.io/en/latest/?badge=master)
  [![PyPI version](https://badge.fury.io/py/lyricsgenius.svg)](https://pypi.org/project/lyricsgenius/)
  [![Python version](https://img.shields.io/badge/python-3.x-brightgreen.svg)](https://pypi.org/project/lyricsgenius/)

  `lyricsgenius` provides a simple interface to the song, artist, and lyrics data stored on [Genius.com](https://www.genius.com).

  The full documentation for `lyricsgenius` is available online at [Read the Docs](https://lyricsgenius.readthedocs.io/en/master/).


  Before using this package you'll need to sign up for a (free) account that authorizes access to [the Genius API](http://genius.com/api-clients). The Genius account provides a `access_token` that is required by the package. See the [Usage section](https://github.com/johnwmillr/LyricsGenius#usage) below for examples.


  `lyricsgenius` requires Python 3.

  Use `pip` to install the package from PyPI:

  ```bash
  pip install lyricsgenius
  ```

  Or, install the latest version of the package from GitHub:

  ```bash
  pip install git+https://github.com/johnwmillr/LyricsGenius.git
  ```


  Import the package and initiate Genius:

  ```python
  import lyricsgenius
  genius = lyricsgenius.Genius(token)
  ```

  If you don't pass a token to the `Genius` class, `lyricsgenus` will look for an environment variable called `GENIUS_ACCESS_TOKEN` and attempt to use that for authentication.

  ```python
  genius = Genius()
  ```

  Search for songs by a given artist:

  ```python
  artist = genius.search_artist("Andy Shauf", max_songs=3, sort="title")
  print(artist.songs)
  ```
  By default, the `search_artist()` only returns songs where the given artist is the primary artist.
  However, there may be instances where it is desirable to get all of the songs that the artist appears on.
  You can do this by setting the `include_features` argument to `True`.

  ```python
  artist = genius.search_artist("Andy Shauf", max_songs=3, sort="title", include_features=True)
  print(artist.songs)
  ```

  Search for a single song by the same artist:

  ```python
  song = artist.song("To You")


  print(song.lyrics)
  ```

  Add the song to the artist object:

  ```python
  artist.add_song(song)


  ```

  Save the artist's songs to a JSON file:

  ```python
  artist.save_lyrics()
  ```

  Searching for an album and saving it:

  ```python
  album = genius.search_album("The Party", "Andy Shauf")
  album.save_lyrics()
  ```

  There are various options configurable as parameters within the `Genius` class:

  ```python
  genius.verbose = False # Turn off status messages
  genius.remove_section_headers = True # Remove section headers (e.g. [Chorus]) from lyrics when searching
  genius.skip_non_songs = False # Include hits thought to be non-songs (e.g. track lists)
  genius.excluded_terms = ["(Remix)", "(Live)"] # Exclude songs with these words in their title
  ```

  You can also call the package from the command line:

  ```bash
  export GENIUS_ACCESS_TOKEN="my_access_token_here"
  python3 -m lyricsgenius --help
  ```

  Search for and save lyrics to a given song and album:

  ```bash
  python3 -m lyricsgenius song "Begin Again" "Andy Shauf" --save
  python3 -m lyricsgenius album "The Party" "Andy Shauf" --save
  ```

  Search for five songs by 'The Beatles' and save the lyrics:

  ```bash
  python3 -m lyricsgenius artist "The Beatles" --max-songs 5 --save
  ```



    - [Trucks and Beer: A textual analysis of popular country music](http://www.johnwmillr.com/trucks-and-beer/)
    - [Neural machine translation: Explaining the Meaning Behind Lyrics](https://github.com/tsandefer/dsi_capstone_3)
    - [What makes some blink-182 songs more popular than others?](http://jdaytn.com/posts/download-blink-182-data/)
    - [Sentiment analysis on hip-hop lyrics](https://github.com/Hugo-Nattagh/2017-Hip-Hop)
    - [Does Country Music Drink More Than Other Genres?](https://towardsdatascience.com/does-country-music-drink-more-than-other-genres-a21db901940b)
    - [49 Years of Lyrics: Why So Angry?](https://towardsdatascience.com/49-years-of-lyrics-why-so-angry-1adf0a3fa2b4)


  Please contribute! If you want to fix a bug, suggest improvements, or add new features to the project, just [open an issue](https://github.com/johnwmillr/LyricsGenius/issues) or send me a pull request.


