# packages

pkgId: 36021d3f4639d964e4d07e2f7c9fb7a00d2d641ae654bc9e9ed3575097e67aa4
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-fe2b5cec-b2c8-4804-9406-3ffb5f5ed9be
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: 2688626d1bdd01d14a68e1f53114a31887fd8dd37a1630302e647d50f38b131c
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-4130b209-078d-454f-ac26-a2fdb42e6dee
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: 831928268518d1bb1231e9a938257658efde744bd4ae758c4a74f0eb18a872c6
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-65f24fa2-539b-494c-821f-2271c6221421
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: 6e83474a2f3ff342d379f8710f2225d874f897dbf11115ebc2cca05ff148c2b4
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-1d35b2c0-5abc-4f04-8adf-f1d6c09a5045
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: 23f1f7b7bdc6a67f1fa97391900696cb984214677a9b568b534495b16f957d1d
name: python-jellyfish-debuginfo
arch: x86_64
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-1d35b2c0-5abc-4f04-8adf-f1d6c09a5045
rpm_sourcerpm: python-jellyfish-0.9.0-1.src.rpm
location_href: 00003957-python-jellyfish/python-jellyfish-debuginfo-0.9.0-1.x86_64.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: 9e3f2644016f067a18792eed1489fc24099529fbabaca8f0373ee5158b2a2a3b
name: python-jellyfish-debugsource
arch: x86_64
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-1d35b2c0-5abc-4f04-8adf-f1d6c09a5045
rpm_sourcerpm: python-jellyfish-0.9.0-1.src.rpm
location_href: 00003957-python-jellyfish/python-jellyfish-debugsource-0.9.0-1.x86_64.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: 0b28e69acf79e99211ea740c9ea6b5c754769d930c3d317e0b45c7c1864744ce
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-2695bd9e-edac-4753-a575-e08d229fa43c
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: 8dea858b28b8e808bf1e8ca0825c40945a33b643134c875126ed0cc1719b6a75
name: python-jenkspy
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Compute Natural Breaks (Fisher-Jenks algorithm)
url: http://github.com/mthh/jenkspy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bc22e969-5718-4a7a-96e8-aa8b5f1e0eb4
location_href: 00010509-python-jenkspy/python-jenkspy-0.3.2-1.src.rpm
checksum_type: sha256
description:
  Compute "natural breaks" (*Fisher-Jenks algorithm*) on list / tuple / array / numpy.ndarray of integers/floats.
  The algorithm implemented by this library is also sometimes referred to as *Fisher-Jenks algorithm*, *Jenks Optimisation Method* or *Fisher exact optimization method*. This is a deterministic method to calculate the optimal class boundaries.
  Intended compatibility: CPython 3.6+
  Wheels are provided via PyPI for Windows / MacOS / Linux users - Also available on conda-forge channel for Anaconda users.
  |Version| |Anaconda-Server Badge| |Build Status GH| |PyPI download month|


pkgId: 13045a200fef98a1f2735b37d1f442656f9bc098212848ee518684854d275bcd
name: python-jenkspy-debuginfo
arch: x86_64
version: 0.3.2
epoch: 0
release: 1
summary: Debug information for package python-jenkspy
url: http://github.com/mthh/jenkspy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-bc22e969-5718-4a7a-96e8-aa8b5f1e0eb4
rpm_sourcerpm: python-jenkspy-0.3.2-1.src.rpm
location_href: 00010509-python-jenkspy/python-jenkspy-debuginfo-0.3.2-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-jenkspy.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 8a8b92abb03a921a88e4a7d1086d6b3729e2db258489e8d44df025eaadc23c74
name: python-jenkspy-debugsource
arch: x86_64
version: 0.3.2
epoch: 0
release: 1
summary: Debug sources for package python-jenkspy
url: http://github.com/mthh/jenkspy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-bc22e969-5718-4a7a-96e8-aa8b5f1e0eb4
rpm_sourcerpm: python-jenkspy-0.3.2-1.src.rpm
location_href: 00010509-python-jenkspy/python-jenkspy-debugsource-0.3.2-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-jenkspy.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 292948367591bcb980bb7deec2de79830e562e1bea85563e49f1a430d44964a2
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-b0c1b41f-e410-49ef-974d-a6f5eb29ceee
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: c89b6d7ef22dd8937ceee1bb1aac2c281b94dcd8c4856b2d4baee166156054d3
name: python-jetplot
arch: src
version: 0.5.4
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/nirum/jetplot.git
rpm_license: LICENSE.md
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-12accf3c-9815-4b8c-803b-0de6b75ebab5
location_href: 00012754-python-jetplot/python-jetplot-0.5.4-1.src.rpm
checksum_type: sha256
description:
  ![build](https://github.com/nirum/jetplot/workflows/build/badge.svg)
  [![codecov](https://codecov.io/gh/nirum/jetplot/branch/master/graph/badge.svg)](https://codecov.io/gh/nirum/jetplot)



  `jetplot` is collection of miscellaneous utils for Matplotlib.




  ```bash
  pip install jetplot
  ```



  Coming soon.




  | Version | Release Date | Description                                                                                                                                                                                                     |
  | ------: | :----------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  | 0.5.3   | Aug 30 2022  | Stops jetplot from updating Matplotlib rcParams on import.                                                                                                                                                     |
  | 0.5.0   | Jul 15 2022  | Updates default color palettes, adds new Palette class, adds ridgeline plot.                                                                                                                                                     |
  | 0.4.0   | Oct 20 2021  | Name change! Renamed package from `jetpack` to `jetplot`.                                                                                                                                                       |
  | 0.3.0   | Oct 13 2021  | Drops animation module and the `moviepy` dependency                                                                                                                                                             |
  | 0.0.0   | Jan 19 2015  | Initial commit                                                                                                                                                                                                  |



  MIT. See [`LICENSE.md`](./LICENSE.md)


pkgId: 30292dea5c77044374a5addaee1123ea5735b5b9c8a072359d1ecf3c474fb863
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-58ecc407-ce0f-44e6-80b6-19eca69dc172
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: 3a7c0ca925f1d8652ec858a1f90e60f883a66af45720b9baba7b7b28a976bc97
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-b607aff0-57e8-4b1d-a5cb-872d554e9e1a
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: d70b766d947c3ed18b9b7c71558414f00df20a73cf73ea7d0c83c7e826be7f03
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-51309d05-0e5f-4218-a541-edccd8a6478a
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: 311031f52297d95b8e9cb46d4083e2ddba303a007ebfce8e4250a9c706f73ead
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-6b629463-caef-443a-9be5-d110880fb598
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: 678b8fd903e6636e6b24fbb27176c7e760fa974f0ffec9b325fc4b1e2562d571
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-642cc090-fb13-405a-aefd-8af9a3f14357
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: c7b37c49d8abfd0ffb27375375939f20ae04e245b322355ffd3aefdbe0d2aebd
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-cfa0d08e-b14d-4d63-b426-bb4c014f6e91
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: b5000a55edd5db4055f175d67e8d3b8ee754d24e69d7bec8c0d91fc913b7fc55
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-fdaac42c-7c99-4b1f-bcee-a79985327480
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: edce43171b533470d85e355534fd6443cfe21042f1be3bf1363101c649330b47
name: python-jmp
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: JMP is a Mixed Precision library for JAX.
url: https://github.com/deepmind/jmp
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a031a779-830a-4cac-ba17-957c50fcee42
location_href: 00012945-python-jmp/python-jmp-0.0.4-1.src.rpm
checksum_type: sha256
description:
  ![Test status](https://github.com/deepmind/jmp/workflows/pytest/badge.svg)
  ![PyPI version](https://img.shields.io/pypi/v/jmp)

  [**Installation**](#installation)
  | [**Examples**](#examples)
  | [**Policies**](#policies)
  | [**Loss scaling**](#loss-scaling)
  | [**Citing JMP**](#citing-jmp)
  | [**References**](#references)

  Mixed precision training [[0]] is a technique that mixes the use of full and
  half precision floating point numbers during training to reduce the memory
  bandwidth requirements and improve the computational efficiency of a given
  model.

  This library implements support for mixed precision training in [JAX] by providing
  two key abstractions (mixed precision "policies" and loss scaling). Neural
  network libraries (such as [Haiku]) can integrate with `jmp` and provide
  "Automatic Mixed Precision (AMP)" support (automating or simplifying applying
  policies to modules).

  All code examples below assume the following:

  ```python
  import jax
  import jax.numpy as jnp
  import jmp

  half = jnp.float16  # On TPU this should be jnp.bfloat16.
  full = jnp.float32
  ```



  JMP is written in pure Python, but depends on C++ code via JAX and NumPy.

  Because JAX installation is different depending on your CUDA version, JMP does
  not list JAX as a dependency in `requirements.txt`.

  First, follow [these instructions](https://github.com/google/jax#installation)
  to install JAX with the relevant accelerator support.

  Then, install JMP using pip:

  ```bash
  $ pip install git+https://github.com/deepmind/jmp
  ```



  You can find a
  [fully worked JMP example in Haiku](https://github.com/deepmind/dm-haiku/tree/master/examples/imagenet)
  which shows how to use mixed f32/f16 precision to halve training time on GPU and
  mixed f32/bf16 to reduce training time on TPU by a third.



  A mixed precision policy encapsulates the configuration in a mixed precision
  experiment.

  ```python


  my_policy = jmp.Policy(compute_dtype=half,
                         param_dtype=full,
                         output_dtype=half)
  ```

  The policy object can be used to cast pytrees:

  ```python
  def layer(params, x):
    params, x = my_policy.cast_to_compute((params, x))
    w, b = params
    y = x @ w + b
    return my_policy.cast_to_output(y)

  params = {"w": jnp.ones([], dtype=my_policy.param_dtype)}
  y = layer(params, x)
  assert y.dtype == half
  ```

  You can replace the output type of a given policy:

  ```python
  my_policy = my_policy.with_output_dtype(full)
  ```

  You can also define a policy via a string, which may be useful for specifying a
  policy as a command-line argument or as a hyperparameter to your experiment:

  ```python
  my_policy = jmp.get_policy("params=float32,compute=float16,output=float32")
  float16 = jmp.get_policy("float16")  # Everything in f16.
  half = jmp.get_policy("half")        # Everything in half (f16 or bf16).
  ```



  When training with reduced precision, consider whether gradients will need to be
  shifted into the representable range of the format that you are using. This is
  particularly important when training with `float16` and less important for
  `bfloat16`. See the NVIDIA mixed precision user guide [[1]] for more details.

  The easiest way to shift gradients is with loss scaling, which scales your loss
  and gradients by `S` and `1/S` respectively.

  ```python
  def my_loss_fn(params, loss_scale: jmp.LossScale, ...):
    loss = ...
    
    loss = loss_scale.scale(loss)
    return loss

  def train_step(params, loss_scale: jmp.LossScale, ...):
    grads = jax.grad(my_loss_fn)(...)
    grads = loss_scale.unscale(grads)
    
    params = apply_optimizer(params, grads)
    return params

  loss_scale = jmp.StaticLossScale(2 ** 15)
  for _ in range(num_steps):
    params = train_step(params, loss_scale, ...)
  ```

  The appropriate value for `S` depends on your model, loss, batch size and
  potentially other factors. You can determine this with trial and error. As a
  rule of thumb you want the largest value of `S` that does not introduce overflow
  during backprop. NVIDIA [[1]] recommend computing statistics about the gradients
  of your model (in full precision) and picking `S` such that its product with the
  maximum norm of your gradients is below `65,504`.

  We provide a dynamic loss scale, which adjusts the loss scale periodically
  during training to find the largest value for `S` that produces finite
  gradients. This is more convenient and robust compared with picking a static
  loss scale, but has a small performance impact (between 1 and 5%).

  ```python
  def my_loss_fn(params, loss_scale: jmp.LossScale, ...):
    loss = ...
    
    loss = loss_scale.scale(loss)
    return loss

  def train_step(params, loss_scale: jmp.LossScale, ...):
    grads = jax.grad(my_loss_fn)(...)
    grads = loss_scale.unscale(grads)
    

    
    
    
    skip_nonfinite_updates = isinstance(loss_scale, jmp.DynamicLossScale)

    if skip_nonfinite_updates:
      grads_finite = jmp.all_finite(grads)
      
      
      
      loss_scale = loss_scale.adjust(grads_finite)
      
      
      params = jmp.select_tree(grads_finite, apply_optimizer(params, grads), params)
    else:
      
      params = apply_optimizer(params, grads)

    
    
    return params, loss_scale

  loss_scale = jmp.DynamicLossScale(jmp.half_dtype()(2 ** 15))
  for _ in range(num_steps):
    params, loss_scale = train_step(params, loss_scale, ...)
  ```

  In general using a static loss scale should offer the best speed, but we have
  optimized dynamic loss scaling to make it competitive. We recommend you start
  with dynamic loss scaling and move to static loss scaling if performance is an
  issue.

  We finally offer a no-op loss scale which you can use as a drop in replacement.
  It does nothing (apart from implement the `jmp.LossScale` API):

  ```python
  loss_scale = jmp.NoOpLossScale()
  assert loss is loss_scale.scale(loss)
  assert grads is loss_scale.unscale(grads)
  assert loss_scale is loss_scale.adjust(grads_finite)
  assert loss_scale.loss_scale == 1
  ```



  This repository is part of the [DeepMind JAX Ecosystem](https://deepmind.com/blog/article/using-jax-to-accelerate-our-research),
  to cite JMP please use the [DeepMind JAX Ecosystem citation](https://github.com/deepmind/jax/blob/main/deepmind2020jax.txt).



  [[0]] Paulius Micikevicius, Sharan Narang, Jonah Alben, Gregory Diamos, Erich
  Elsen, David Garcia, Boris Ginsburg, Michael Houston, Oleksii Kuchaiev, Ganesh
  Venkatesh, Hao Wu: "Mixed Precision Training", 2017; arXiv:1710.03740
  https://arxiv.org/abs/1710.03740.

  [[1]] "Training With Mixed Precision :: NVIDIA Deep Learning Performance
  Documentation". Docs.Nvidia.Com, 2020,
  https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/.

  [0]: https://arxiv.org/abs/1710.03740
  [1]: https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/index.html
  [Haiku]: https://github.com/deepmind/dm-haiku
  [JAX]: https://github.com/google/jax


pkgId: 715d9651d698770cbebb76fb61888c9d5e199438aa7afa18b46ecca5a5518958
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-3c9b00c1-3051-441c-be55-c9b9d87a7b3f
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: 4b4f29a5f264841e646637cba796db2d23f2fb0a42ba57c1cdd265d1f789126f
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-edba49a3-1145-4101-a9ee-079c84264b48
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: d972c80d8573798781ad845854470899988fe32a41e3db0597157858e09ecd6d
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-eb49e06f-1872-4f7c-a113-f947f79345b9
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: 9e31c496f9138a3347d5a2fb9f1f890916690779a63b90dd03f1a283d21eae9b
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-e34246f8-3459-4b40-a507-b51aaa2312d7
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: 11566cb2a18c79e540424da79c3a68ff95a763245930ca87a2e2febe1fb70ad9
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-f70742a1-f820-41e3-8a14-48ea39e29d46
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: 7ff2becf64c7b9656256245b9f31c2b84df76d9659b29cbdd1aa865b7d999ca9
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-09533ecb-d97e-4302-81d7-393f235681a0
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: 04aa8235e8a642a0e2fca7576bacfd8a1a0a6b7c99ab0adc29ab270bc92307c4
name: python-json-logging
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: JSON Python Logging
url: https://github.com/thangbn/json-logging
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6877d1f7-7054-4be0-8db0-31d8911de92c
location_href: 00009817-python-json-logging/python-json-logging-1.3.0-1.src.rpm
checksum_type: sha256
description:
  Python logging library to emit JSON log that can be easily indexed and
  searchable by logging infrastructure such as
  `ELK <https://www.elastic.co/webinars/introduction-elk-stack>`_.
  Go here for full documentation: https://github.com/thangbn/json-logging-python


pkgId: b04da85600fed8ae572534a2499924012a55cf83cd01a99559f491943d863d9e
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-ad636e10-f2b8-475c-9444-5dc79404b250
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: c250fb7a9f490d51a490f41528150715579a3f90ea31557ee40bbd5f9f1a7c0d
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-efc6b4e3-01e3-4c39-b730-0b0a25f7357f
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: 3e1d1a3066baa5b0ea2d590ee82b8194fb9b33d8aac157e44ff72c3e83191076
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-1062627f-9de3-4072-904b-ece849d74da4
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: ef885a4551c86b78382549ab6875fead908be1845c2b1223057d594b121716cb
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-2b4083bd-ac9b-4d82-8cef-fd388ab317f8
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: 1ea82ba51ca2deb5cd6688d7dd4cf7f5f31118c9cb16176bf4400b305c52ed28
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-e5878a87-e21a-4e77-8823-c38632184b0a
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: 69e60485af631c30f083fa923a379223007ad9dce8bb6bca6c2b2fafd148aeec
name: python-jsonapi-requests
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Python client implementation for json api. http://jsonapi.org/
url: https://github.com/socialwifi/jsonapi-requests
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-45bf615e-ede1-4186-8b0d-867951712861
location_href: 00011999-python-jsonapi-requests/python-jsonapi-requests-0.7.0-1.src.rpm
checksum_type: sha256
description:
  ```python
  import jsonapi_requests
  api = jsonapi_requests.Api.config({
      'API_ROOT': 'https://localhost/api/2.0',
      'AUTH': ('basic_auth_login', 'basic_auth_password'),
      'VALIDATE_SSL': False,
      'TIMEOUT': 1,
  })
  endpoint = api.endpoint('networks/cd9c124a-acc3-4e20-8c02-3a37d460df22/available-profiles')
  response = endpoint.get()
  for profile in response.data:
      print(profile.attributes['name'])

  endpoint = api.endpoint('cookies')
  endpoint.post(object=jsonapi_requests.JsonApiObject(
      type='cookies',
      attributes={
          'uuid': '09d3a4fff8d64335a1ee9f1d9d054161',
          'domain': 'some.domain.pl'
      },
  ))

  ```

  Lets say we have api endpoint: `https://localhost/api/2.0/car/2`
  which returns
  ```json
  {
      "data":{
          "id": "2",
          "type": "car",
          "attributes": {
              "color": "red"
          },
          "relationships": {
              "driver": {
                  "data": {
                      "id": "3",
                      "type": "person"
                  }
              }
          }
      },
      "included": [
          {
              "id": "3",
              "type": "person",
              "attributes": {
                  "name": "Kowalski"
              },
              "relationships": {
                  "married-to": {
                      "data": {
                          "id": "4",
                          "type": "person"
                      }
                  }
              }
          },
          {
              "id": "4",
              "type": "person",
              "attributes": {
                  "name": "Kowalska"
              },
              "relationships": {
                  "married-to": {
                      "data": {
                          "id": "3",
                          "type": "person"
                      }
                  }
              }
          },
      ]
  }
  ```
  Then we can run:
  ```python
  import jsonapi_requests
  api = jsonapi_requests.orm.OrmApi.config({
      'API_ROOT': 'https://localhost/api/2.0',
      'AUTH': ('basic_auth_login', 'basic_auth_password'),
      'VALIDATE_SSL': False,
      'TIMEOUT': 1,
  })
  class Person(jsonapi_requests.orm.ApiModel):
      class Meta:
          type = 'person'
          api = api
      name = jsonapi_requests.orm.AttributeField('name')
      married_to = jsonapi_requests.orm.RelationField('married-to')
  class Car(jsonapi_requests.orm.ApiModel):
      class Meta:
          type = 'car'
          api = api
      color = jsonapi_requests.orm.AttributeField('color')
      driver = jsonapi_requests.orm.RelationField('driver')
  car = Car.from_id("2")
  car.color # request happens here

  car.driver.name

  car.driver.married_to.name

  car.driver.married_to.married_to.name

  ```

  When using jsonapi\_requests with Flask, we can set `jsonapi_requests.auth.FlaskForwardAuth()` as `AUTH` configuration option to copy authorization header from current request context.
  It can be useful when fetching resources from different microservices.
  Installation with flask support:
  ```bash
  pip install jsonapi-requests[flask]
  ```
  Example usage:
  ```python
  import jsonapi_requests
  api = jsonapi_requests.Api.config({
      'API_ROOT': 'https://localhost/api/2.0',
      'AUTH': jsonapi_requests.auth.FlaskForwardAuth(),
  })
  ```

  For more documentation check our [wiki](https://github.com/socialwifi/jsonapi-requests/wiki).


pkgId: 51663956d0395cf910afe026be79bbec9daa10b2619ed9d3c9eba72bd14bf253
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-6a5215fc-7b86-43f9-b6ac-2dc11b2450ec
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: 1e63964dcb3cf84a0f5bf4f28ddfb9cdd39f89add01bd639fc4b7a3250ec3560
name: python-jsonconversion
arch: src
version: 0.2.13
epoch: 0
release: 1
summary: This python module helps converting arbitrary Python objects into JSON strings and back.
url: https://github.com/DLR-RM/python-jsonconversion
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-52c56831-9b13-4895-882e-e73d79a45d5b
location_href: 00013854-python-jsonconversion/python-jsonconversion-0.2.13-1.src.rpm
checksum_type: sha256
description:
  This python module helps converting arbitrary Python objects into JSON strings and back. It extends the basic features
  of the ``JSONEncoder`` and ``JSONDecoder`` classes provided by the native ``json`` package. For this purpose,
  ``jsonconversion`` ships with these four classes:


pkgId: cf8e54a01c3f0dc871153cf2f7924c9b1893c69731f8fd2fe2ea9fe20c53bad2
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-bd0b0dc9-4a9e-47b9-b753-f55b0d5c0553
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: 48e027f86917454b7453da6be7a9d4c2ad1ec3b5f1c99fbece0f2175b53aa79c
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-43cf40d9-65a3-4782-99d0-68fd10710d02
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: e07d11ed3d9fac8635bee533bd9fbbbcd1b8b9bec150f1d0a7af4ea7db461009
name: python-jsonmerge
arch: src
version: 1.9.0
epoch: 0
release: 1
summary: Merge a series of JSON documents.
url: https://pypi.org/project/jsonmerge/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-998a4f8b-9298-443d-8d05-825e8ec6bcc3
location_href: 00010848-python-jsonmerge/python-jsonmerge-1.9.0-1.src.rpm
checksum_type: sha256
description:
  This Python module allows you to merge a series of JSON documents into a
  single one.
  This problem often occurs for example when different authors fill in
  different parts of a common document and you need to construct a document
  that includes contributions from all the authors. It also helps when
  dealing with consecutive versions of a document where different fields get
  updated over time.
  Consider a trivial example with two documents::
      >>> base = {
      >>> head = {
  We call the document we are merging changes into *base* and the changed
  document *head*. To merge these two documents using *jsonmerge*::
      >>> from pprint import pprint
      >>> from jsonmerge import merge
      >>> result = merge(base, head)
      >>> pprint(result, width=40)
      {'bar': ['two'],
       'baz': 'Hello, world!',
       'foo': 1}
  As you can see, when encountering an JSON object, *jsonmerge* by default
  returns fields that appear in either *base* or *head* document. For other
  JSON types, it simply replaces the older value. These principles are also
  applied in case of multiple nested JSON objects.
  In a more realistic use case however, you might want to apply different
  *merge strategies* to different parts of the document. You can tell
  *jsonmerge* how to do that using a syntax based on `JSON schema`_.
  If you already have schemas for your document, you can simply expand them
  with some additional keywords. Apart from the custom keywords described
  below, *jsonmerge* by default uses the schema syntax defined in the `Draft
  4`_ of the JSON schema specification.
  You use the *mergeStrategy* schema keyword to specify the strategy. The
  default two strategies mentioned above are called *objectMerge* for objects
  and *overwrite* for all other types.
  Let's say you want to specify that the merged *bar* field in the example
  document above should contain elements from all documents, not just the
  latest one. You can do this with a schema like this::
      >>> schema = {
      >>> from jsonmerge import Merger
      >>> merger = Merger(schema)
      >>> result = merger.merge(base, head)
      >>> pprint(result, width=40)
      {'bar': ['one', 'two'],
       'baz': 'Hello, world!',
       'foo': 1}
  Another common example is when you need to keep a versioned list of values
  that appeared in the series of documents::
      >>> schema = {
      >>> from jsonmerge import Merger
      >>> merger = Merger(schema)
      >>> rev1 = {
      >>> rev2 = {
      >>> base = None
      >>> base = merger.merge(base, rev1, merge_options={
      >>> base = merger.merge(base, rev2, merge_options={
      >>> pprint(base, width=55)
      {'foo': [{'revision': 1,
                'value': {'greeting': 'Hello, World!'}},
               {'revision': 2,
                'value': {'greeting': 'Howdy, World!'}}]}
  Note that we use the *mergeOptions* keyword in the schema to supply
  additional options to the merge strategy. In this case, we tell the
  *version* strategy to retain only 5 most recent versions of this field.
  We also used the *merge_options* argument to supply some options that are
  specific to each call of the *merge* method. Options specified this
  way are applied to all invocations of a specific strategy in a schema (in
  contrast to *mergeOptions*, which applies only to the strategy invocation
  in that specific location in the schema). Options specified in
  *mergeOptions* schema keyword override the options specified in the
  *merge_options* argument.
  The *metadata* option for the *version* strategy can contain some document
  meta-data that is included for each version of the field. *metadata* can
  contain an arbitrary JSON object.
  Example above also demonstrates how *jsonmerge* is typically used when
  merging more than two documents. Typically you start with an empty *base*
  and then consecutively merge different *heads* into it.
  A common source of problems are documents that do not match the schema used
  for merging. *jsonmerge* by itself does not validate input documents. It
  only uses the schema to obtain necessary information to apply appropriate merge
  strategies. Since the default strategies are used for parts of the
  document that are not covered by the schema it's easy to get unexpected
  output without any obvious errors raised by *jsonmerge*.
  In the following example, the property *Foo* (uppercase F) does not match
  *foo* (lowercase f) in the schema and hence the *version* strategy is not
  applied as with previous two revisions::
      >>> rev3 = {
      >>> base = merger.merge(base, rev3, merge_options={
      >>> pprint(base, width=55)
      {'Foo': {'greeting': 'Howdy, World!'},
       'foo': [{'revision': 1,
                'value': {'greeting': 'Hello, World!'}},
               {'revision': 2,
                'value': {'greeting': 'Howdy, World!'}}]}
  Hence it is recommended to validate the input documents against the schema
  before passing them to *jsonmerge*. This practice is even more effective if
  the schema is filled in with more information than strictly necessary for
  *jsonmerge* (e.g. adding information about types, restrict valid object
  properties with *additionalProperties*, etc.)::
      >>> from jsonschema import validate
      >>> validate(rev1, schema)
      >>> validate(rev2, schema)
      >>> validate(rev3, schema)
      Traceback (most recent call last):
      jsonschema.exceptions.ValidationError: Additional properties are not allowed ('Foo' was unexpected)
  If you care about well-formedness of your documents, you might also want to
  obtain a schema for the documents that the *merge* method creates.
  *jsonmerge* provides a way to automatically generate it from a schema for
  the input document::
      >>> result_schema = merger.get_schema()
      >>> pprint(result_schema, width=80)
      {'additionalProperties': False,
       'properties': {'foo': {'items': {'properties': {'value': {'type': 'object'}}},
                              'maxItems': 5,
                              'type': 'array'}}}
  Note that because of the *version* strategy, the type of the *foo* field
  changed from *object* to *array*.


pkgId: ea48ab62bbe8e272dedd3be580ecd103bd5737d0bc1710ef98a1d5246773a0d2
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-98624997-2da9-451f-a6f7-6fb57fd9cf6f
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: 161e97623d7043e80faf314333b470d777ee882781f1715746f4b648ba25c19e
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-1abb8e7b-1d2c-4437-b1d3-15052cc594d9
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: 6d37317ce1c82e6ebf46321e64376e88e02acebca64cc52a9ede30a084b2a188
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-02b59333-7f28-4f81-a256-26fea10e120f
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: d39d37e4f927b700426ca3610d89d9c6a219bbc72e2b303fa431e8931a1d39de
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-1da62f16-32a1-4a44-8f1f-8314d27e34b6
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: ec7e8f50c13ad3a759423dbcfbfbf063d7cf829b766df405b5a9f978714dfe83
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-75ece034-977b-48c8-a48f-cadb395f3d3e
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: 534655fe1d3276f64faf97caa1f82d61a144f5f566142029277d9c7386824fe0
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-8aa77bd0-98d4-47a6-927d-e37b19f5fb43
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: 5a59171ce8d95161823f0250f2967b4a65182a48dfba90ae6d61d4cd71f3d11a
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-156d4821-522f-44b9-a69e-f7267555907e
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: f0e6e8742965d616e0d858df63c854c23a66504e3ab467a958d5721b789e473c
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-5753c3e8-53aa-4aee-96ad-f85c97f44de0
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: 772e06d3a817ef3f2f710f893c993c52f38637870e9e43ac5d88bc77fff25688
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-31f646f9-4ce9-48f2-8167-c00f36b01020
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: 24a0910ea4007e45beaaefd77ce5400b01aefc045b47e9ec004798ff0ac1986f
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-cb4311d5-160a-4379-87a3-3bf527605c63
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: eb92ef204c8a6a5bf14688f4baeef5b6bf7426f1f27f1235e74b811e4096cb22
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-cb4311d5-160a-4379-87a3-3bf527605c63
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: 5299c0f54f201fb547e104a329fd50b984b5e7fc2841971b65e85e1e8442aa5e
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-44b583e3-ada4-4ffb-955b-d6d7d027ff41
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: 6589be38bf2a1d166a0cb0578b2b795feb01d2965ce92d1e82b1958517b2629b
name: python-jupyterhub-idle-culler
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://jupyter.org
rpm_license: 3-BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-62e68924-3d76-4a3a-a4c7-bed37bdc083b
location_href: 00011317-python-jupyterhub-idle-culler/python-jupyterhub-idle-culler-1.2.1-1.src.rpm
checksum_type: sha256
description:
  [![GitHub Workflow Status - Test](https://img.shields.io/github/workflow/status/jupyterhub/jupyterhub-idle-culler/Test?logo=github&label=tests)](https://github.com/jupyterhub/jupyterhub-idle-culler/actions)
  [![Latest PyPI version](https://img.shields.io/pypi/v/jupyterhub-idle-culler?logo=pypi&logoColor=white)](https://pypi.python.org/pypi/jupyterhub-idle-culler)
  [![GitHub](https://img.shields.io/badge/issue_tracking-github-blue?logo=github)](https://github.com/jupyterhub/jupyterhub-idle-culler/issues)
  [![Discourse](https://img.shields.io/badge/help_forum-discourse-blue?logo=discourse)](https://discourse.jupyter.org/c/jupyterhub)
  [![Gitter](https://img.shields.io/badge/social_chat-gitter-blue?logo=gitter)](https://gitter.im/jupyterhub/jupyterhub)

  `jupyterhub-idle-culler` provides a JupyterHub service to identify and shut down idle or long-running Jupyter Notebook servers.
  The exact actions performed are dependent on the used spawner for the Jupyter Notebook server (e.g. the default [LocalProcessSpawner](https://jupyterhub.readthedocs.io/en/stable/api/spawner.html#localprocessspawner>), [kubespawner](https://github.com/jupyterhub/kubespawner), or [dockerspawner](https://github.com/jupyterhub/dockerspawner)).
  In addition, if explicitly requested, all users whose Jupyter Notebook servers have been shut down this way are deleted as JupyterHub users from the internal database. This neither affects the authentication method which continues to allow those users to log in nor does it delete persisted user data (e.g. stored in docker volumes for dockerspawner or in persisted volumes for kubespawner).





  ```bash
  pip install jupyterhub-idle-culler
  ```



  Prior to JupyterHub 2.0, the `jupyterhub-idle-culler` required full administrative privileges,
  in order to have sufficient permissions to stop servers on behalf of users.

  JupyterHub 2.0 introduces [scopes][] to allow for more fine-grained permission control.
  This means that the configured culler service does not need full administrative privileges anymore.
  It can be assigned only the permissions it needs.

  [scopes]: https://jupyterhub.readthedocs.io/en/latest/rbac/scopes.html#available-scopes

  `jupyterhub-idle-culler` requires the following scopes to function:

  - `list:users` - access to the user list API, our source of information about who to cull
  - `read:users:activity` - read the last_activity field of the user
  - `delete:servers` - management of servers (this includes stopping servers)
  - `admin:users` (**optional**) - only needed if using `--cull-users`

  To assign the service the appropriate permissions, declare a role in your `jupyterhub_config.py`:

  ```python
  c.JupyterHub.load_roles = [
      {
          "name": "jupyterhub-idle-culler-role",
          "scopes": [
              "list:users",
              "read:users:activity",
              "delete:servers",
              
          ],
          
          "services": ["jupyterhub-idle-culler-service"],
      }
  ]
  ```



  In `jupyterhub_config.py`, add the following dictionary for the idle-culler
  Service to the `c.JupyterHub.services` list:

  ```python
  c.JupyterHub.services = [
      {
          "name": "jupyterhub-idle-culler-service",
          "command": [
              sys.executable,
              "-m", "jupyterhub_idle_culler",
              "--timeout=3600",
          ],
          
      }
  ]
  ```

  where:

  - `"command"` indicates that the Service will be managed by the Hub, and
  - `"admin": True` grants admin permissions to this Service and is only meant for
    use with jupyterhub < 2.0; see [above][permissions].



  `jupyterhub-idle-culler` can also be run as a standalone script. It can
  access the hub's api with a service token.

  Register the service token with JupyterHub in `jupyterhub_config.py`:

  ```python
  c.JupyterHub.services = [
      {
          "name": "jupyterhub-idle-culler-service",
          "api_token": "...",
          
      }
  ]
  ```

  where:

  - `"api_token"` contains a secret token, e.g. generated by `openssl rand -hex 32`, and
  - `"admin": True` grants admin permissions to this Service and is only meant for
    use with jupyterhub < 2.0; see [above][permissions].

  and store the same token in a `JUPYTERHUB_API_TOKEN` environment variable.
  Then start `jupyterhub-idle-culler` manually.

  ```bash
  export JUPYTERHUB_API_TOKEN=api_token_above...
  python3 -m jupyterhub-idle-culler [--timeout=900] [--url=http://localhost:8081/hub/api]
  ```



  ```
    --api-page-size                  Number of users to request per page, when
                                     using JupyterHub 2.0's paginated user list
                                     API. Default: user the server-side default
                                     configured page size. (default 0)
    --concurrency                    Limit the number of concurrent requests made
                                     to the Hub.  Deleting a lot of users at the
                                     same time can slow down the Hub, so limit
                                     the number of API requests we have
                                     outstanding at any given time. (default 10)
    --cull-admin-users               Whether admin users should be culled (only
                                     if --cull-users=true). (default True)
    --cull-every                     The interval (in seconds) for checking for
                                     idle servers to cull. (default 0)
    --cull-users                     Cull users in addition to servers.  This is
                                     for use in temporary-user cases such as
                                     tmpnb. (default False)
    --internal-certs-location        The location of generated internal-ssl
                                     certificates (only needed with --ssl-
                                     enabled=true). (default internal-ssl)
    --max-age                        The maximum age (in seconds) of servers that
                                     should be culled even if they are active.
                                     (default 0)
    --remove-named-servers           Remove named servers in addition to stopping
                                     them.  This is useful for a BinderHub that
                                     uses authentication and named servers.
                                     (default False)
    --ssl-enabled                    Whether the Jupyter API endpoint has TLS
                                     enabled. (default False)
    --timeout                        The idle timeout (in seconds). (default 600)
    --url                            The JupyterHub API URL.
  ```



  1. last_activity is not updated with high frequency, so cull timeout should be
     greater than the sum of:

     - single-user websocket ping interval (default: 30 seconds)
     - `JupyterHub.last_activity_interval` (default: 5 minutes)

  2. The same `--timeout` and `--max-age` values are used to cull
     users and users' servers. If you want a different value for users and servers,
     you should add this script to the services list twice, just with different
     `name`s, different values, and one with the `--cull-users` option.

  3. By default HTTP requests to the hub timeout after 60 seconds. This can be
     changed by setting the `JUPYTERHUB_REQUEST_TIMEOUT` environment variable.



  jupytehrub-idle-culler lists available users via JupyterHub's [/users][users-api] REST API.

  [users-api]: https://jupyterhub.readthedocs.io/en/stable/_static/rest-api/index.html#path--users

  jupyterhub-idle-culler culls user servers using JupyterHub's REST API
  ([/users/{name}/server](https://jupyterhub.readthedocs.io/en/stable/_static/rest-api/index.html#operation--users--name--server-delete)
  or
  [/users/{name}/servers/{server_name}](https://jupyterhub.readthedocs.io/en/stable/_static/rest-api/index.html#operation--users--name--servers--server_name--delete)),
  and makes the culling decisions based on its configuration and what JupyterHub
  reports about the user servers via its REST API
  [(/users)][users-api]
  where user servers' `last_activity` is reported back.

  The `last_activity` that JupyterHub reports is the most recent summary of
  information updated at a regular interval via the [`update_last_activity`
  function](https://github.com/jupyterhub/jupyterhub/blob/1.4.2/jupyterhub/app.py#L2646)
  that combines two sources of information.

  1. **The proxy's routes data**

     The `update_last_activity` function will [ask the
     proxy](https://jupyterhub.readthedocs.io/en/stable/reference/proxy.html#retrieving-routes)
     for the active routes like `/user/user1` and collects associated
     `last_activity` data if it is available. This activity represents
     successfully proxies network traffic.

     `last_activity` data for routes will be available when using
     [configurable-http-proxy](https://github.com/jupyterhub/configurable-http-proxy#readme)
     as JupyterHub does by default, but if for example
     [traefik-proxy](https://github.com/jupyterhub/traefik-proxy#readme) is used
     as it is in the [TLJH distribution](https://tljh.jupyter.org), no such data
     will be available.

  2. **The user server's activity reports**

     The `update_last_activity` function also reads JupyterHub's database that
     keeps state about servers `last_activity`. These database records are updated
     whenever a server notifies JupyterHub about activity, as they are
     responsible to do.

     Servers notify JupyterHub about activity by being started by the
     [`jupyterhub-singleuser`](https://github.com/jupyterhub/jupyterhub/blob/1.4.2/setup.py#L115)
     script that is made available by installing jupyterhub (or `jupyterhub-base`
     on conda-forge).

     The `jupyterhub-singleuser` script launches a modified server application
     that keeps JupyterHub updated with the server activity via the
     [`notify_activity`](https://github.com/jupyterhub/jupyterhub/blob/1.4.2/jupyterhub/singleuser/mixins.py#L497)
     function.

     The `notify_activity` function in turn make use of the server applications
     `last_activity` function (see implementation in
     [NotebookApp](https://github.com/jupyter/notebook/blob/v6.4.0/notebook/notebookapp.py#L392-L397)
     and
     [ServerApp](https://github.com/jupyter-server/jupyter_server/blob/v1.9.0/jupyter_server/serverapp.py#L375)
     respectively) that that combines information from API activity, kernel
     activity, kernel shutdown, and terminal activity. This activity also covers
     activity of applications like RStudio running via `jupyter-server-proxy`.

  Here is a summary of what's described so far:

  1. jupyterhub-idle-culler culls servers via JupyterHub's REST API.
  2. jupyterhub-idle-culler makes decisions based on information retrieved by
     JupyterHub REST API.
  3. JupyterHub REST API reports information regularly updated by summarizing
     information gained by: asking the proxy about routes' activity, and by
     retaining activity information reported by the servers.

  Now, as the server's kernel activity influence the activity that servers will
  notify JupyterHub about, the kernel activity in turn influences
  jupyterhub-idle-culler. Due to this, it can be relevant to also learn a little
  about a mechanism to _cull idle kernels_ as well even though
  jupyterhub-idle-culler isn't involved in that.

  The default kernel manager, the MappingKernelManager, can be configured to cull
  idle kernels. Its configuration is documented in
  [NotebookApp's](https://jupyter-notebook.readthedocs.io/en/stable/config.html#options)
  and
  [ServerApp's](https://jupyter-server.readthedocs.io/en/latest/full-config.html)
  respective documentation, and here are some relevant kernel culling
  configuration options:

  - `MappingKernelManager.cull_busy`
  - `MappingKernelManager.cull_idle_timeout`
  - `MappingKernelManager.cull_interval`
  - `MappingKernelManager.cull_connected`

    Note that `cull_connected` can be tricky to understand for JupyterLab as a
    browser having a web-socket connection to a kernel or not isn't as obvious as
    it was in the classical Jupyter notebook UI. See [this issue for more
    details](https://github.com/jupyterlab/jupyterlab/issues/6893).

    Also note that configuration of MappingKernelManager should be made on the
    user server itself, for example via a `jupyter_notebook_config.py` file in
    `/etc/jupyter` or `/usr/local/etc/jupyter` rather than where JupyterHub is
    running.

  Finally, note that a Jupyter Notebook server can shut itself down without
  without intervention by jupyterhub-idle-culler if
  `NotebookApp.shutdown_no_activity_timeout` is configured.





  JupyterHub 2.0 introduces pagination to the [/users][users-api] API endpoint.
  This pagination does not guarantee a consistent snapshot
  for consecutive requests spread over time,
  so it is possible for a highly active hub to occasionally miss culling users crossing page boundaries between requests.
  This is expected to be an infrequent occurrence and only result in delaying a server being culled by one cull interval
  in realistic scenarios, so of minor consequence in JupyterHub.

  The issue can be mitigated by requesting a larger page size,
  via e.g. `--api-page-size=200`,
  but feel free to open an issue if this is causing a problem for you.


pkgId: 2d349642024a61c7d80de710c5595777f70c40461a21c5dba5a9f36942c70605
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-c7394e62-959c-4913-9c68-099e11d1fc35
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: eadb3fe156416b149d1af8f8cf53036da9027c9b482b6643591b3e3404e82a48
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-95fac6de-dd0a-48a0-97c5-4275fc8ebade
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: 411f6d78ecaf09f43416c890872e324b7d8d965f00289ed736d46e6038a6aaf6
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-910caa03-2b44-4f8b-a384-fdb590578263
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: ad27ac30bf3ea970ae1d13ef5b48ebba1a684b94201cd29caeaf47d1e529b5ce
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-d362de2a-a7cf-403c-af1c-3990b0c3ea78
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: 10f51ad782991c94df0efbe94433f4e42229e4a1f65e52fffb42f27213081e87
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-bdc4ca44-075e-41ad-b64f-36837da9b5e4
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: 7f4f9faa502686f6f6a69abe1832b4d61d2912e030b41df6dd4820bb86726ea8
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-03788440-8497-4ba3-88d2-93ad9db62fb2
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: 3715ab1f1b4642fe76b5f86ab726e8da8a607d72a3792b88f6250d307af82a18
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-f4b8e726-9eda-4728-8724-d56a3bd76b8d
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: 1d292cfc592acd8e8530c4779c0184bbc9fc1969b7549382606182c88236d7d6
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-20f0ab8e-e1ab-46f4-89f5-7b2025875757
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: 63b53df83ae33157cb5cce7afa884fbbc827ab91c7f4fd6513d5cdda2b385e2b
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-dbe32ca7-c913-4474-9b88-8ca44366a407
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: 4bd8cd36dcb3c3b3956d50cc16ced078e69c5e2ccea9a3779c1d5af1953fa784
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-930cce7b-cd9e-4af6-87e8-6753bc1ca86a
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: f6533d307152ab20da6c7899dc092f3e79b772e32dc51a1b2d10643cf6ace1d1
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-e17ed809-8aab-4e8c-b85d-39ec5a46ab5c
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: d987dae992683e4891f43e4e57f29cd48a27e504f5195e9255c6934eb0cc08d7
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-99e74b93-0bf3-4eeb-952e-bad156653ba3
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: 929ad6dda3df7760f1852196596ebaa1c8f88b49e717a254995ae9d36d17e9f0
name: python-kconfiglib
arch: src
version: 14.1.0
epoch: 0
release: 1
summary: A flexible Python Kconfig implementation
url: https://github.com/ulfalizer/Kconfiglib
rpm_license: ISC
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f82bf554-e4da-4b76-82b7-bf57f02cae19
location_href: 00009882-python-kconfiglib/python-kconfiglib-14.1.0-1.src.rpm
checksum_type: sha256
description:
  Dependency loop with recent linux-next kernels
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  To fix issues with dependency loops on recent linux-next kernels, apply `this
  patch <https://www.spinics.net/lists/linux-kbuild/msg23455.html>`_. Hopefully,
  it will be in ``linux-next`` soon.
  ``windows-curses`` is no longer automatically installed on Windows
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  Starting with Kconfiglib 13.0.0, the `windows-curses
  <https://github.com/zephyrproject-rtos/windows-curses>`__ package is no longer
  automatically installed on Windows, and needs to be installed manually for the
  terminal ``menuconfig`` to work.
  This fixes installation of Kconfiglib on MSYS2, which is not compatible with
  ``windows-curses``. See `this issue
  <https://github.com/ulfalizer/Kconfiglib/issues/77>`__.
  The ``menuconfig`` now shows a hint re. installing ``windows-curses`` when the
  ``curses`` module can't be imported on Windows.
  Sorry if this change caused problems!


pkgId: 1c5f487d5d32af47c9b91d38e36de9029a43ed7bec2181d2e9d32bae0f28a386
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-a0382371-0c43-4561-9716-24c08e0dc643
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: 9864662f7f9eac91136bd51a690ef26b6fcff53d9e51a07118439236bba5724d
name: python-keras-bert
arch: src
version: 0.89.0
epoch: 0
release: 1
summary: BERT implemented in Keras
url: https://github.com/CyberZHG/keras-bert
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d5631f66-2e66-4ebd-8e9a-bae112daf755
location_href: 00013884-python-keras-bert/python-keras-bert-0.89.0-1.src.rpm
checksum_type: sha256
description:
  [![Version](https://img.shields.io/pypi/v/keras-bert.svg)](https://pypi.org/project/keras-bert/)
  ![License](https://img.shields.io/pypi/l/keras-bert.svg)

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

  Implementation of the [BERT](https://arxiv.org/pdf/1810.04805.pdf). Official pre-trained models could be loaded for feature extraction and prediction.



  ```bash
  pip install keras-bert
  ```



  * [Load Official Pre-trained Models](#Load-Official-Pre-trained-Models)
  * [Tokenizer](#Tokenizer)
  * [Train & Use](#Train-&-Use)
  * [Use Warmup](#Use-Warmup)
  * [Download Pretrained Checkpoints](#Download-Pretrained-Checkpoints)
  * [Extract Features](#Extract-Features)



  * [Kashgari is a Production-ready NLP Transfer learning framework for text-labeling and text-classification](https://github.com/BrikerMan/Kashgari)
  * [Keras ALBERT](https://github.com/TinkerMob/keras_albert_model)



  In [feature extraction demo](./demo/load_model/load_and_extract.py), you should be able to get the same extraction results as the official model `chinese_L-12_H-768_A-12`. And in [prediction demo](./demo/load_model/load_and_predict.py), the missing word in the sentence could be predicted.




  The [extraction demo](https://colab.research.google.com/github/CyberZHG/keras-bert/blob/master/demo/load_model/keras_bert_load_and_extract_tpu.ipynb) shows how to convert to a model that runs on TPU.

  The [classification demo](https://colab.research.google.com/github/CyberZHG/keras-bert/blob/master/demo/tune/keras_bert_classification_tpu.ipynb) shows how to apply the model to simple classification tasks.



  The `Tokenizer` class is used for splitting texts and generating indices:

  ```python
  from keras_bert import Tokenizer

  token_dict = {
      '[CLS]': 0,
      '[SEP]': 1,
      'un': 2,
      '##aff': 3,
      '##able': 4,
      '[UNK]': 5,
  }
  tokenizer = Tokenizer(token_dict)
  print(tokenizer.tokenize('unaffable'))  # The result should be `['[CLS]', 'un', '##aff', '##able', '[SEP]']`
  indices, segments = tokenizer.encode('unaffable')
  print(indices)  # Should be `[0, 2, 3, 4, 1]`
  print(segments)  # Should be `[0, 0, 0, 0, 0]`

  print(tokenizer.tokenize(first='unaffable', second='钢'))

  indices, segments = tokenizer.encode(first='unaffable', second='钢', max_len=10)
  print(indices)  # Should be `[0, 2, 3, 4, 1, 5, 1, 0, 0, 0]`
  print(segments)  # Should be `[0, 0, 0, 0, 0, 1, 1, 0, 0, 0]`
  ```



  ```python
  from tensorflow import keras
  from keras_bert import get_base_dict, get_model, compile_model, gen_batch_inputs



  sentence_pairs = [
      [['all', 'work', 'and', 'no', 'play'], ['makes', 'jack', 'a', 'dull', 'boy']],
      [['from', 'the', 'day', 'forth'], ['my', 'arm', 'changed']],
      [['and', 'a', 'voice', 'echoed'], ['power', 'give', 'me', 'more', 'power']],
  ]



  token_dict = get_base_dict()  # A dict that contains some special tokens
  for pairs in sentence_pairs:
      for token in pairs[0] + pairs[1]:
          if token not in token_dict:
              token_dict[token] = len(token_dict)
  token_list = list(token_dict.keys())  # Used for selecting a random word



  model = get_model(
      token_num=len(token_dict),
      head_num=5,
      transformer_num=12,
      embed_dim=25,
      feed_forward_dim=100,
      seq_len=20,
      pos_num=20,
      dropout_rate=0.05,
  )
  compile_model(model)
  model.summary()

  def _generator():
      while True:
          yield gen_batch_inputs(
              sentence_pairs,
              token_dict,
              token_list,
              seq_len=20,
              mask_rate=0.3,
              swap_sentence_rate=1.0,
          )

  model.fit_generator(
      generator=_generator(),
      steps_per_epoch=1000,
      epochs=100,
      validation_data=_generator(),
      validation_steps=100,
      callbacks=[
          keras.callbacks.EarlyStopping(monitor='val_loss', patience=5)
      ],
  )



  inputs, output_layer = get_model(
      token_num=len(token_dict),
      head_num=5,
      transformer_num=12,
      embed_dim=25,
      feed_forward_dim=100,
      seq_len=20,
      pos_num=20,
      dropout_rate=0.05,
      training=False,      # The input layers and output layer will be returned if `training` is `False`
      trainable=False,     # Whether the model is trainable. The default value is the same with `training`
      output_layer_num=4,  # The number of layers whose outputs will be concatenated as a single output.
                           
  )
  ```



  `AdamWarmup` optimizer is provided for warmup and decay. The learning rate will reach `lr` in `warmpup_steps` steps, and decay to `min_lr` in `decay_steps` steps. There is a helper function `calc_train_steps` for calculating the two steps:

  ```python
  import numpy as np
  from keras_bert import AdamWarmup, calc_train_steps

  train_x = np.random.standard_normal((1024, 100))

  total_steps, warmup_steps = calc_train_steps(
      num_example=train_x.shape[0],
      batch_size=32,
      epochs=10,
      warmup_proportion=0.1,
  )

  optimizer = AdamWarmup(total_steps, warmup_steps, lr=1e-3, min_lr=1e-5)
  ```



  Several download urls has been added. You can get the downloaded and uncompressed path of a checkpoint by:

  ```python
  from keras_bert import get_pretrained, PretrainedList, get_checkpoint_paths

  model_path = get_pretrained(PretrainedList.multi_cased_base)
  paths = get_checkpoint_paths(model_path)
  print(paths.config, paths.checkpoint, paths.vocab)
  ```



  You can use helper function `extract_embeddings` if the features of tokens or sentences (without further tuning) are what you need. To extract the features of all tokens:

  ```python
  from keras_bert import extract_embeddings

  model_path = 'xxx/yyy/uncased_L-12_H-768_A-12'
  texts = ['all work and no play', 'makes jack a dull boy~']

  embeddings = extract_embeddings(model_path, texts)
  ```

  The returned result is a list with the same length as texts. Each item in the list is a numpy array truncated by the length of the input. The shapes of outputs in this example are `(7, 768)` and `(8, 768)`.

  When the inputs are paired-sentences, and you need the outputs of `NSP` and max-pooling of the last 4 layers:

  ```python
  from keras_bert import extract_embeddings, POOL_NSP, POOL_MAX

  model_path = 'xxx/yyy/uncased_L-12_H-768_A-12'
  texts = [
      ('all work and no play', 'makes jack a dull boy'),
      ('makes jack a dull boy', 'all work and no play'),
  ]

  embeddings = extract_embeddings(model_path, texts, output_layer_num=4, poolings=[POOL_NSP, POOL_MAX])
  ```

  There are no token features in the results. The outputs of `NSP` and max-pooling will be concatenated with the final shape `(768 x 4 x 2,)`.

  The second argument in the helper function is a generator. To extract features from file:

  ```python
  import codecs
  from keras_bert import extract_embeddings

  model_path = 'xxx/yyy/uncased_L-12_H-768_A-12'

  with codecs.open('xxx.txt', 'r', 'utf8') as reader:
      texts = map(lambda x: x.strip(), reader)
      embeddings = extract_embeddings(model_path, texts)
  ```



  Add `TF_KERAS=1` to environment variables to use `tensorflow.python.keras`.


pkgId: d8279b0e4f511f225f20e5c866170728514c9fc3e3486ad3605004acc3eb7894
name: python-keras-layer-normalization
arch: src
version: 0.16.0
epoch: 0
release: 1
summary: Layer normalization implemented in Keras
url: https://github.com/CyberZHG/keras-layer-normalization
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-61e7656b-e8f8-4e6a-bea0-432ea52e124b
location_href: 00013831-python-keras-layer-normalization/python-keras-layer-normalization-0.16.0-1.src.rpm
checksum_type: sha256
description:
  [![Version](https://img.shields.io/pypi/v/keras-layer-normalization.svg)](https://pypi.org/project/keras-layer-normalization/)
  ![License](https://img.shields.io/pypi/l/keras-layer-normalization.svg)

  Implementation of the paper: [Layer Normalization](https://arxiv.org/pdf/1607.06450.pdf)



  ```bash
  pip install keras-layer-normalization
  ```



  ```python
  from tensorflow import keras
  from keras_layer_normalization import LayerNormalization


  input_layer = keras.layers.Input(shape=(2, 3))
  norm_layer = LayerNormalization()(input_layer)
  model = keras.models.Model(inputs=input_layer, outputs=norm_layer)
  model.compile(optimizer='adam', loss='mse', metrics={},)
  model.summary()
  ```


pkgId: 1626bf344cbafff118d56240489df7437b5986ec6ce4351f8abefabd569293c1
name: python-keras-nightly
arch: src
version: 2.13.0.dev2023041007
epoch: 0
release: 1
summary: Deep learning for humans.
url: https://keras.io/
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5d0e6eab-7c68-4f96-99dd-96c9717c0e07
location_href: 00009911-python-keras-nightly/python-keras-nightly-2.13.0.dev2023041007-1.src.rpm
checksum_type: sha256
description:
  Keras is a deep learning API written in Python,
  running on top of the machine learning platform TensorFlow.

  It was developed with a focus on enabling fast experimentation and
  providing a delightful developer experience.
  The purpose of Keras is to give an *unfair advantage* to any developer
  looking to ship ML-powered apps.

  Keras is:

  -   **Simple** -- but not simplistic. Keras reduces developer *cognitive load*
      to free you to focus on the parts of the problem that really matter.
      Keras focuses on ease of use, debugging speed, code elegance & conciseness,
      maintainability, and deployability (via TFServing, TFLite, TF.js).
  -   **Flexible** -- Keras adopts the principle of *progressive disclosure of
      complexity*: simple workflows should be quick and easy, while arbitrarily
      advanced workflows should be *possible* via a clear path that builds upon
      what you've already learned.
  -   **Powerful** -- Keras provides industry-strength performance and
      scalability: it is used by organizations and companies including NASA,
      YouTube, and Waymo. That's right -- your YouTube recommendations are
      powered by Keras, and so is the world's most advanced driverless vehicle.


pkgId: 6a50aeffa46d2be8987e4a66e1b2a50265e0bb3536d636658b21f031eab67f1a
name: python-keras-pos-embd
arch: src
version: 0.13.0
epoch: 0
release: 1
summary: Position embedding layers in Keras
url: https://github.com/CyberZHG/keras-pos-embd
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c1313747-8b2d-4bd7-9f56-925a632159c7
location_href: 00013928-python-keras-pos-embd/python-keras-pos-embd-0.13.0-1.src.rpm
checksum_type: sha256
description:
  [![Version](https://img.shields.io/pypi/v/keras-pos-embd.svg)](https://pypi.org/project/keras-pos-embd/)

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

  Position embedding layers in Keras.



  ```bash
  pip install keras-pos-embd
  ```





  ```python
  from tensorflow import keras
  from keras_pos_embd import PositionEmbedding

  model = keras.models.Sequential()
  model.add(PositionEmbedding(
      input_shape=(None,),
      input_dim=10,     # The maximum absolute value of positions.
      output_dim=2,     # The dimension of embeddings.
      mask_zero=10000,  # The index that presents padding (because `0` will be used in relative positioning).
      mode=PositionEmbedding.MODE_EXPAND,
  ))
  model.compile('adam', 'mse')
  model.summary()
  ```

  Note that you don't need to enable `mask_zero` if you want to add/concatenate other layers like word embeddings with masks:

  ```python
  from tensorflow import keras
  from keras_pos_embd import PositionEmbedding

  model = keras.models.Sequential()
  model.add(keras.layers.Embedding(
      input_shape=(None,),
      input_dim=10,
      output_dim=5,
      mask_zero=True,
  ))
  model.add(PositionEmbedding(
      input_dim=100,
      output_dim=5,
      mode=PositionEmbedding.MODE_ADD,
  ))
  model.compile('adam', 'mse')
  model.summary()
  ```



  The [sine and cosine embedding](https://arxiv.org/pdf/1706.03762) has no trainable weights. The layer has three modes, it works just like `PositionEmbedding` in `expand` mode:

  ```python
  from tensorflow import keras
  from keras_pos_embd import TrigPosEmbedding

  model = keras.models.Sequential()
  model.add(TrigPosEmbedding(
      input_shape=(None,),
      output_dim=30,                      # The dimension of embeddings.
      mode=TrigPosEmbedding.MODE_EXPAND,  # Use `expand` mode
  ))
  model.compile('adam', 'mse')
  model.summary()
  ```

  If you want to add this embedding to existed embedding, then there is no need to add a position input in `add` mode:

  ```python
  from tensorflow import keras
  from keras_pos_embd import TrigPosEmbedding

  model = keras.models.Sequential()
  model.add(keras.layers.Embedding(
      input_shape=(None,),
      input_dim=10,
      output_dim=5,
      mask_zero=True,
  ))
  model.add(TrigPosEmbedding(
      output_dim=5,
      mode=TrigPosEmbedding.MODE_ADD,
  ))
  model.compile('adam', 'mse')
  model.summary()
  ```


pkgId: dec69f944713031eb071a32f82254f516bdf5e25b7ff2dfad470067d3f593939
name: python-keras-position-wise-feed-forward
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Feed forward layer implemented in Keras
url: https://github.com/CyberZHG/keras-position-wise-feed-forward
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-209e3bbe-bbb7-4abf-8062-310e49e502a0
checksum_type: sha256
description:
  [![Version](https://img.shields.io/pypi/v/keras-position-wise-feed-forward.svg)](https://pypi.org/project/keras-position-wise-feed-forward/)
  ![License](https://img.shields.io/pypi/l/keras-position-wise-feed-forward.svg)

  Implementation of position-wise feed forward layer in the paper: [Attention is All You Need](https://arxiv.org/pdf/1706.03762.pdf)



  ```bash
  pip install keras-position-wise-feed-forward
  ```



  ```python
  from tensorflow import keras
  from keras_position_wise_feed_forward import FeedForward

  input_layer = keras.layers.Input(shape=(None, 32))
  feed_forward_layer = FeedForward(units=128)(input_layer)
  model = keras.models.Model(inputs=input_layer, outputs=feed_forward_layer)
  model.compile(optimizer='adam', loss='mse')
  model.summary()
  ```

location_href:
  00013940-python-keras-position-wise-feed-forward/python-keras-position-wise-feed-forward-0.8.0-1.src.rpm


pkgId: c544f047caaca9260f4a45a9a010ab8054a8117adfab5e5673ac753c60eaa2c6
name: python-keras-position-wise-feed-forward-help
arch: noarch
version: 0.8.0
epoch: 0
release: 1
summary: Development documents and examples for keras-position-wise-feed-forward
url: https://github.com/CyberZHG/keras-position-wise-feed-forward
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-209e3bbe-bbb7-4abf-8062-310e49e502a0
rpm_sourcerpm: python-keras-position-wise-feed-forward-0.8.0-1.src.rpm
checksum_type: sha256
description:
  [![Version](https://img.shields.io/pypi/v/keras-position-wise-feed-forward.svg)](https://pypi.org/project/keras-position-wise-feed-forward/)
  ![License](https://img.shields.io/pypi/l/keras-position-wise-feed-forward.svg)

  Implementation of position-wise feed forward layer in the paper: [Attention is All You Need](https://arxiv.org/pdf/1706.03762.pdf)



  ```bash
  pip install keras-position-wise-feed-forward
  ```



  ```python
  from tensorflow import keras
  from keras_position_wise_feed_forward import FeedForward

  input_layer = keras.layers.Input(shape=(None, 32))
  feed_forward_layer = FeedForward(units=128)(input_layer)
  model = keras.models.Model(inputs=input_layer, outputs=feed_forward_layer)
  model.compile(optimizer='adam', loss='mse')
  model.summary()
  ```

location_href:
  00013940-python-keras-position-wise-feed-forward/python-keras-position-wise-feed-forward-help-0.8.0-1.noarch.rpm


pkgId: 00c698227288f1dbf7a9c79f7a3e8eff6970fc58b01619cec91f2ff830d5f41a
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-420847ad-94b3-4bf5-aac6-736b6ce63d75
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: c461485d54f1c3c6d0999c3d1662bf43dc62489033c9c37581a04b358214cf44
name: python-keras-transformer
arch: src
version: 0.40.0
epoch: 0
release: 1
summary: Transformer implemented in Keras
url: https://github.com/CyberZHG/keras-transformer
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-aa3a8f73-dbce-4622-845c-5017e8b528fd
location_href: 00013517-python-keras-transformer/python-keras-transformer-0.40.0-1.src.rpm
checksum_type: sha256
description:
  [![Version](https://img.shields.io/pypi/v/keras-transformer.svg)](https://pypi.org/project/keras-transformer/)
  ![License](https://img.shields.io/pypi/l/keras-transformer.svg)

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

  Implementation of [transformer](https://arxiv.org/pdf/1706.03762.pdf) for seq2seq tasks.



  ```bash
  pip install keras-transformer
  ```





  ```python
  import numpy as np
  from keras_transformer import get_model


  tokens = 'all work and no play makes jack a dull boy'.split(' ')
  token_dict = {
      '<PAD>': 0,
      '<START>': 1,
      '<END>': 2,
  }
  for token in tokens:
      if token not in token_dict:
          token_dict[token] = len(token_dict)


  encoder_inputs_no_padding = []
  encoder_inputs, decoder_inputs, decoder_outputs = [], [], []
  for i in range(1, len(tokens) - 1):
      encode_tokens, decode_tokens = tokens[:i], tokens[i:]
      encode_tokens = ['<START>'] + encode_tokens + ['<END>'] + ['<PAD>'] * (len(tokens) - len(encode_tokens))
      output_tokens = decode_tokens + ['<END>', '<PAD>'] + ['<PAD>'] * (len(tokens) - len(decode_tokens))
      decode_tokens = ['<START>'] + decode_tokens + ['<END>'] + ['<PAD>'] * (len(tokens) - len(decode_tokens))
      encode_tokens = list(map(lambda x: token_dict[x], encode_tokens))
      decode_tokens = list(map(lambda x: token_dict[x], decode_tokens))
      output_tokens = list(map(lambda x: [token_dict[x]], output_tokens))
      encoder_inputs_no_padding.append(encode_tokens[:i + 2])
      encoder_inputs.append(encode_tokens)
      decoder_inputs.append(decode_tokens)
      decoder_outputs.append(output_tokens)


  model = get_model(
      token_num=len(token_dict),
      embed_dim=30,
      encoder_num=3,
      decoder_num=2,
      head_num=3,
      hidden_dim=120,
      attention_activation='relu',
      feed_forward_activation='relu',
      dropout_rate=0.05,
      embed_weights=np.random.random((13, 30)),
  )
  model.compile(
      optimizer='adam',
      loss='sparse_categorical_crossentropy',
  )
  model.summary()


  model.fit(
      x=[np.asarray(encoder_inputs * 1000), np.asarray(decoder_inputs * 1000)],
      y=np.asarray(decoder_outputs * 1000),
      epochs=5,
  )
  ```



  ```python
  from keras_transformer import decode

  decoded = decode(
      model,
      encoder_inputs_no_padding,
      start_token=token_dict['<START>'],
      end_token=token_dict['<END>'],
      pad_token=token_dict['<PAD>'],
      max_len=100,
  )
  token_dict_rev = {v: k for k, v in token_dict.items()}
  for i in range(len(decoded)):
      print(' '.join(map(lambda x: token_dict_rev[x], decoded[i][1:-1])))
  ```



  ```python
  import numpy as np
  from keras_transformer import get_model, decode

  source_tokens = [
      'i need more power'.split(' '),
      'eat jujube and pill'.split(' '),
  ]
  target_tokens = [
      list('我要更多的抛瓦'),
      list('吃枣💊'),
  ]


  def build_token_dict(token_list):
      token_dict = {
          '<PAD>': 0,
          '<START>': 1,
          '<END>': 2,
      }
      for tokens in token_list:
          for token in tokens:
              if token not in token_dict:
                  token_dict[token] = len(token_dict)
      return token_dict

  source_token_dict = build_token_dict(source_tokens)
  target_token_dict = build_token_dict(target_tokens)
  target_token_dict_inv = {v: k for k, v in target_token_dict.items()}


  encode_tokens = [['<START>'] + tokens + ['<END>'] for tokens in source_tokens]
  decode_tokens = [['<START>'] + tokens + ['<END>'] for tokens in target_tokens]
  output_tokens = [tokens + ['<END>', '<PAD>'] for tokens in target_tokens]


  source_max_len = max(map(len, encode_tokens))
  target_max_len = max(map(len, decode_tokens))

  encode_tokens = [tokens + ['<PAD>'] * (source_max_len - len(tokens)) for tokens in encode_tokens]
  decode_tokens = [tokens + ['<PAD>'] * (target_max_len - len(tokens)) for tokens in decode_tokens]
  output_tokens = [tokens + ['<PAD>'] * (target_max_len - len(tokens)) for tokens in output_tokens]

  encode_input = [list(map(lambda x: source_token_dict[x], tokens)) for tokens in encode_tokens]
  decode_input = [list(map(lambda x: target_token_dict[x], tokens)) for tokens in decode_tokens]
  decode_output = [list(map(lambda x: [target_token_dict[x]], tokens)) for tokens in output_tokens]


  model = get_model(
      token_num=max(len(source_token_dict), len(target_token_dict)),
      embed_dim=32,
      encoder_num=2,
      decoder_num=2,
      head_num=4,
      hidden_dim=128,
      dropout_rate=0.05,
      use_same_embed=False,  # Use different embeddings for different languages
  )
  model.compile('adam', 'sparse_categorical_crossentropy')
  model.summary()

  model.fit(
      x=[np.array(encode_input * 1024), np.array(decode_input * 1024)],
      y=np.array(decode_output * 1024),
      epochs=10,
      batch_size=32,
  )


  decoded = decode(
      model,
      encode_input,
      start_token=target_token_dict['<START>'],
      end_token=target_token_dict['<END>'],
      pad_token=target_token_dict['<PAD>'],
  )
  print(''.join(map(lambda x: target_token_dict_inv[x], decoded[0][1:-1])))
  print(''.join(map(lambda x: target_token_dict_inv[x], decoded[1][1:-1])))
  ```



  In `decode`, the word with top probability is selected as the predicted token by default. You can add randomness by setting `top_k` and `temperature`:

  ```python
  decoded = decode(
      model,
      encode_input,
      start_token=target_token_dict['<START>'],
      end_token=target_token_dict['<END>'],
      pad_token=target_token_dict['<PAD>'],
      top_k=10,
      temperature=1.0,
  )
  print(''.join(map(lambda x: target_token_dict_inv[x], decoded[0][1:-1])))
  print(''.join(map(lambda x: target_token_dict_inv[x], decoded[1][1:-1])))
  ```


pkgId: 53afc8afafb237300b34fa2114b57dd54bae8bccca4183847df5831947cebb58
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-a90a3d9b-cebb-4f33-97ae-f194ced9a483
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: da90493200b193109dfebf5234e9691093068bfd9b562e6496216f98da6dc510
name: python-keycloak-client
arch: src
version: 0.15.4
epoch: 0
release: 1
url: https://github.com/ly798/python-keycloak.git
rpm_license: The MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-16de9b27-61cc-449f-80e2-ef0ce022f800
location_href: 00012992-python-keycloak-client/python-keycloak-client-0.15.4-1.src.rpm
checksum_type: sha256
summary:
  keycloak-client(fork from python-keycloak) is a Python package providing access to the Keycloak API.

description:
  For review- see https://bitbucket.org/agriness/python-keycloak
  **python-keycloak** is a Python package providing access to the Keycloak API.


  ``` $ pip install keycloak-client ```

  ``` $ python setup.py install ```

  python-keycloak depends on:
  * Python 3
  * [requests](http://docs.python-requests.org/en/master/)
  * [python-jose](http://python-jose.readthedocs.io/en/latest/)

  * unittest
  * [httmock](https://github.com/patrys/httmock)

  Please report bugs and feature requests at
  https://bitbucket.org/agriness/python-keycloak/issues

  The documentation for python-keycloak is available on [readthedocs](http://python-keycloak.readthedocs.io).

  * [Agriness Team](http://www.agriness.com/pt/)
  * [Marcos Pereira](marcospereira.mpj@gmail.com)
  * [Martin Devlin](https://bitbucket.org/devlinmpearson/)
  * [Shon T. Urbas](https://bitbucket.org/surbas/)
  * [Markus Spanier](https://bitbucket.org/spanierm/)
  * [Remco Kranenburg](https://bitbucket.org/Remco47/)
  * [Armin](https://bitbucket.org/arminfelder/)
  * [njordr](https://bitbucket.org/njordr/)
  * [Josha Inglis](https://bitbucket.org/joshainglis/)
  * [Alex](https://bitbucket.org/alex_zel/)
  * [Ewan Jone](https://bitbucket.org/kisamoto/)

  ```python
  from keycloak import KeycloakOpenID

  keycloak_openid = KeycloakOpenID(server_url="http://localhost:8080/auth/",
                      client_id="example_client",
                      realm_name="example_realm",
                      client_secret_key="secret")

  config_well_know = keycloak_openid.well_know()

  token = keycloak_openid.token("user", "password")
  token = keycloak_openid.token("user", "password", totp="012345")

  userinfo = keycloak_openid.userinfo(token['access_token'])

  token = keycloak_openid.refresh_token(token['refresh_token'])

  keycloak_openid.logout(token['refresh_token'])

  certs = keycloak_openid.certs()

  token = keycloak_openid.token("user", "password")
  rpt = keycloak_openid.entitlement(token['access_token'], "resource_id")

  token_rpt_info = keycloak_openid.introspect(keycloak_openid.introspect(token['access_token'], rpt=rpt['rpt'],
                                       token_type_hint="requesting_party_token"))

  token_info = keycloak_openid.introspect(token['access_token']))

  KEYCLOAK_PUBLIC_KEY = "secret"
  options = {"verify_signature": True, "verify_aud": True, "exp": True}
  token_info = keycloak_openid.decode_token(token['access_token'], key=KEYCLOAK_PUBLIC_KEY, options=options)

  token = keycloak_openid.token("user", "password")
  keycloak_openid.load_authorization_config("example-authz-config.json")
  policies = keycloak_openid.get_policies(token['access_token'], method_token_info='decode', key=KEYCLOAK_PUBLIC_KEY)
  permissions = keycloak_openid.get_permissions(token['access_token'], method_token_info='introspect')

  from keycloak import KeycloakAdmin
  keycloak_admin = KeycloakAdmin(server_url="http://localhost:8080/auth/",
                                 username='example-admin',
                                 password='secret',
                                 realm_name="example_realm",
                                 verify=True)

  new_user = keycloak_admin.create_user({"email": "example@example.com",
                      "username": "example@example.com",
                      "enabled": True,
                      "firstName": "Example",
                      "lastName": "Example"})

  new_user = keycloak_admin.create_user({"email": "example@example.com",
                      "username": "example@example.com",
                      "enabled": True,
                      "firstName": "Example",
                      "lastName": "Example",
                      "credentials": [{"value": "secret","type": "password",}]})

  count_users = keycloak_admin.users_count()

  users = keycloak_admin.get_users({})

  user-id-keycloak = keycloak_admin.get_user_id("example@example.com")

  user = keycloak_admin.get_user("user-id-keycloak")

  response = keycloak_admin.update_user(user_id="user-id-keycloak",
                                        payload={'firstName': 'Example Update'})

  response = set_user_password(user_id="user-id-keycloak", password="secret", temporary=True)

  response = keycloak_admin.delete_user(user_id="user-id-keycloak")

  consents = keycloak_admin.consents_user(user_id="user-id-keycloak")

  response = keycloak_admin.send_update_account(user_id="user-id-keycloak",
                                                payload=json.dumps(['UPDATE_PASSWORD']))

  response = keycloak_admin.send_verify_email(user_id="user-id-keycloak")

  sessions = keycloak_admin.get_sessions(user_id="user-id-keycloak")

  server_info = keycloak_admin.get_server_info()

  clients = keycloak_admin.get_clients()

  client_id=keycloak_admin.get_client_id("my-client")

  client = keycloak_admin.get_client(client_id="client_id")

  realm_roles = keycloak_admin.get_realm_roles()

  client_roles = keycloak_admin.get_client_roles(client_id="client_id")

  role = keycloak_admin.get_client_role(client_id="client_id", role_name="role_name")


  role_id = keycloak_admin.get_client_role_id(client_id="client_id", role_name="test")

  keycloak_admin.create_client_role(client_id='client_id', {'name': 'roleName', 'clientRole': True})

  keycloak_admin.assign_client_role(client_id="client_id", user_id="user_id", role_id="role_id", role_name="test")

  keycloak_admin.get_client_roles_of_user(user_id="user_id", client_id="client_id")

  keycloak_admin.get_available_client_roles_of_user(user_id="user_id", client_id="client_id")

  keycloak_admin.get_composite_client_roles_of_user(user_id="user_id", client_id="client_id")

  keycloak_admin.delete_client_roles_of_user(client_id="client_id", user_id="user_id", roles={"id": "role-id"})
  keycloak_admin.delete_client_roles_of_user(client_id="client_id", user_id="user_id", roles=[{"id": "role-id_1"}, {"id": "role-id_2"}])

  group = keycloak_admin.create_group(name="Example Group")

  groups = keycloak_admin.get_groups()

  group = keycloak_admin.get_group(group_id='group_id')

  group = keycloak_admin.get_group_by_path(path='/group/subgroup', search_in_subgroups=True)

  sync_users(storage_id="storage_di", action="action")

  role_id = keycloak_admin.get_client_role_id(client_id=client_id, role_name="test")

  realm_roles = keycloak_admin.get_roles()

  keycloak_admin.assign_client_role(client_id=client_id, user_id=user_id, role_id=role_id, role_name="test")

  idps = keycloak_admin.get_idps()
  ```


pkgId: f16d78f2c211f3ea9339f2ee5f7ce7709137d576ef515e952c02d405f4fe45f3
name: python-keymaker
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Lightweight SSH key management on AWS EC2
url: https://github.com/kislyuk/keymaker
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0ee7daa9-0842-4fd0-989a-2ef10bc32598
location_href: 00014190-python-keymaker/python-keymaker-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Keymaker is **the missing link between SSH and IAM accounts on Amazon AWS**. It's a stateless synchronization engine
  that securely manages the process of SSH public key sharing and verification, user and group synchronization, and home
  directory sharing (via optional `EFS <https://aws.amazon.com/efs/>`_ integration). You, the AWS account administrator,
  define or import user and group identities in IAM, and instances in your account dynamically retrieve and use those
  identities to authenticate your users. Keymaker is the modern, minimalistic alternative to **LDAP** or **Active
  Directory** authentication.


pkgId: 2ef3672d637cea0690031b1308bebb912017e12c6f20466f9c17c7e25498c84e
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-ff355552-4b9a-433e-98cc-4068e7a04943
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: 0fcaa2755660cfa6b7ead6b197af6102a9e0ef8068069631d6b6765b2cc60914
name: python-kinesis-python
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Low level, multiprocessing based AWS Kinesis producer & consumer library
url: https://github.com/NerdWalletOSS/kinesis-python
rpm_license: Apache License Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-02443f20-b927-4d1e-b149-37d9bb4b680c
location_href: 00013988-python-kinesis-python/python-kinesis-python-0.2.1-1.src.rpm
checksum_type: sha256
description:
  The `official Kinesis python library`_ requires the use of Amazon's "MultiLangDaemon", which is a Java executable that
  operates by piping messages over STDIN/STDOUT.
      ಠ_ಠ
  While the desire to have a single implementation of the client library from a maintenance standpoint makes sense for
  the team responsible for the KPL, requiring the JRE to be installed and having to account for the overhead of the
  stream being consumed by Java and Python is not desireable for teams working in environments without Java.
  This is a pure-Python implementation of Kinesis producer and consumer classes that leverages Python's multiprocessing
  module to spawn a process per shard and then sends the messages back to the main process via a Queue.  It only depends
  on `boto3`_ (AWS SDK), `offspring`_ (Subprocess implementation) and `six`_ (py2/py3 compatibility).
  It also includes a DynamoDB state back-end that allows for multi-instance consumption of multiple shards, and stores the
  checkpoint data so that you can resume where you left off in a stream following restarts or crashes.


pkgId: 2a51b94b1c5e844152bbf7b3aa4b07018b848db5fc61acc7abe3d385785c24ce
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-f4ce9afc-e721-4f5c-9853-acfb542780b3
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: 9894187d93ddb4d68cbc0dc4b74abf697511c7383e6665e0c68ae57cde34e534
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-c9ce1c12-fc27-40e3-9ff9-f79cf49b7491
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: 379456caed42ba20f8caef13115f12320b39aadc65eff26f5dec55d761719b4f
name: python-klio-core
arch: src
version: 22.3.0
epoch: 0
release: 1
summary: Core klio library for common functionality
url: https://github.com/spotify/klio
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-db8efbfc-f3ea-4d1f-a9e2-a9c5b5e88336
location_href: 00014024-python-klio-core/python-klio-core-22.3.0-1.src.rpm
checksum_type: sha256
description:
  A library of common utilities, including the Klio `protobuf definitions <https://docs.klio.io/en/latest/userguide/pipeline/message.html>`_ and configuration parsing.
  As the ``klio-core`` package is **not** meant to be installed directly, check out the `installation guide <https://docs.klio.io/en/latest/quickstart/installation.html>`_ for how to setup installation.
  There is also the `user guide <https://docs.klio.io/en/latest/userguide/index.html>`_ and the `API documentation <https://docs.klio.io/en/latest/reference/core/index.html>`_ for more information.


pkgId: fffbf3ac85b0f83d615626729580f936ad30233b4ecb7c664a59e4802424dbc4
name: python-klio-exec
arch: src
version: 22.3.0
epoch: 0
release: 1
summary: Klio pipeline executor within a job
url: https://github.com/spotify/klio
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9a131a03-4a5e-426c-84cd-1c8dac80d706
location_href: 00013918-python-klio-exec/python-klio-exec-22.3.0-1.src.rpm
checksum_type: sha256
description:
  The executor – **not** meant to be used directly by the user – is a CLI that launches a pipeline from within a job's Docker container (a.k.a. an Apache Beam's `"driver"`_).
  Many commands from the ``klio-cli`` directly wrap to commands in the executor: a ``klio-cli`` command will set up the Docker context needed to correctly run the pipeline via the associated command with ``klio-exec``.
  The Docker context includes mounting the job directory, sets up environment variables, mounting credentials, etc.
  As the ``klio-exec`` package is **not** meant to be installed directly, check out the `installation guide <https://docs.klio.io/en/latest/quickstart/installation.html>`_ for how to setup installation.
  There is also the `user guide <https://docs.klio.io/en/latest/userguide/index.html>`_ and the `API documentation <https://docs.klio.io/en/latest/reference/executor/index.html>`_ for more information.


pkgId: cc8e8fecfd3b3d7d8e8e8f35888ff385bac83b50b11e237f82d6578f59b9cd17
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-1206a904-892b-41d2-838b-2e9719317aef
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: c9a8c59cc0991e4c4e2ec4be5076cca666c52177292112847d6467c8d4f0f8fa
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-c7096821-a611-4ca7-ad88-074dff3d14f2
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: 576ad919446ec7a499ccea48f330bb2ccf0ee9c941449dbf1d09fa12bd63fc42
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-745b6cb5-3773-4326-9918-648e0ad7b897
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: 5e041a2a7c72a4b3ebf2276b213e2197a47fc5058b8e412a2a642d8af999c9ed
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-f5edf1f7-6bcd-4476-85bb-4adc02fc6968
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: 785e465bb516b04d6c691d7b1f59266c91b0bad5994f53bf622fc195fe5c7480
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-53befc5d-249d-40f3-ac02-109a78f783db
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: 0c889cd792cd51bdb6b070d76d7c3e2cd1657c7d8a9aaf5c291a48130359c3dd
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-76234e20-178a-403b-9657-2be179319665
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: 12bb72afdb5694207b1313c665df105eda89fbdbfd479e3a037e4fca52f65523
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-a0ae72ae-886c-479d-bf11-793e971a9d8c
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: 30301e5fdf5ac73cb1034ee7ecaa877ff54cc06ed10e1ba074f620e436e82378
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-6e8667dd-e14c-434f-a8ce-e9db83aed586
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: 90b1817aaf15c918cd6fc040d9f802559ae5548f7e1d59a074e11eadffd98dfd
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-4ef50f51-e802-41f3-ba43-46b918ba0870
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: 3d73fa0137e0cbc43abc262ea3473f473fb7d51f17f192929ef0f6f2dad27937
name: python-ktrain
arch: src
version: 0.35.1
epoch: 0
release: 1
url: https://github.com/amaiya/ktrain
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f716b692-ef78-49af-bf3a-199bf5f62e6a
location_href: 00014243-python-ktrain/python-ktrain-0.35.1-1.src.rpm
checksum_type: sha256
summary:
  ktrain is a wrapper for TensorFlow Keras that makes deep learning and AI more accessible and easier to apply

description:
  **ktrain** is a lightweight wrapper for the deep learning library [TensorFlow Keras](https://www.tensorflow.org/guide/keras/overview) (and other libraries) to help build, train, and deploy neural networks and other machine learning models.  Inspired by ML framework extensions like *fastai* and *ludwig*, **ktrain** is designed to make deep learning and AI more accessible and easier to apply for both newcomers and experienced practitioners. With only a few lines of code, **ktrain** allows you to easily and quickly:
  - employ fast, accurate, and easy-to-use pre-canned models for  `text`, `vision`, `graph`, and `tabular` data:
    - `text` data:
       - **Text Classification**: [BERT](https://arxiv.org/abs/1810.04805), [DistilBERT](https://arxiv.org/abs/1910.01108), [NBSVM](https://www.aclweb.org/anthology/P12-2018), [fastText](https://arxiv.org/abs/1607.01759), and other models <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/text/IMDb-BERT.ipynb)]</sup></sub>
       - **Text Regression**: [BERT](https://arxiv.org/abs/1810.04805), [DistilBERT](https://arxiv.org/abs/1910.01108), Embedding-based linear text regression, [fastText](https://arxiv.org/abs/1607.01759), and other models <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/text/text_regression_example.ipynb)]</sup></sub>
       - **Sequence Labeling (NER)**:  Bidirectional LSTM with optional [CRF layer](https://arxiv.org/abs/1603.01360) and various embedding schemes such as pretrained [BERT](https://huggingface.co/transformers/pretrained_models.html) and [fasttext](https://fasttext.cc/docs/en/crawl-vectors.html) word embeddings and character embeddings <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/text/CoNLL2002_Dutch-BiLSTM.ipynb)]</sup></sub>
       - **Ready-to-Use NER models for English, Chinese, and Russian** with no training required <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/text/shallownlp-examples.ipynb)]</sup></sub>
       - **Sentence Pair Classification**  for tasks like paraphrase detection <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/text/MRPC-BERT.ipynb)]</sup></sub>
       - **Unsupervised Topic Modeling** with [LDA](http://www.jmlr.org/papers/volume3/blei03a/blei03a.pdf)  <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/text/20newsgroups-topic_modeling.ipynb)]</sup></sub>
       - **Document Similarity with One-Class Learning**:  given some documents of interest, find and score new documents that are thematically similar to them using [One-Class Text Classification](https://en.wikipedia.org/wiki/One-class_classification) <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/text/20newsgroups-document_similarity_scorer.ipynb)]</sup></sub>
       - **Document Recommendation Engines and Semantic Searches**:  given a text snippet from a sample document, recommend documents that are semantically-related from a larger corpus  <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/text/20newsgroups-recommendation_engine.ipynb)]</sup></sub>
       - **Text Summarization**:  summarize long documents - no training required <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/text/text_summarization.ipynb)]</sup></sub>
       - **End-to-End Question-Answering**:  ask a large text corpus questions and receive exact answers <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/text/question_answering_with_bert.ipynb)]</sup></sub>
       - **Easy-to-Use Built-In Search Engine**:  perform keyword searches on large collections of documents <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/text/question_answering_with_bert.ipynb)]</sup></sub>
       - **Zero-Shot Learning**:  classify documents into user-provided topics **without** training examples <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/text/zero_shot_learning_with_nli.ipynb)]</sup></sub>
       - **Language Translation**:  translate text from one language to another <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/text/language_translation_example.ipynb)]</sup></sub>
       - **Text Extraction**: Extract text from PDFs, Word documents, etc. <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/text/text_extraction_example.ipynb)]</sup></sub>
       - **Speech Transcription**: Extract text from audio files <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/develop/examples/text/speech_transcription_example.ipynb)]</sup></sub>
       - **Universal Information Extraction**:  extract any kind of information from documents by simply phrasing it in the form of a question <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/text/qa_information_extraction.ipynb)]</sup></sub>
       - **Keyphrase Extraction**:  extract keywords from documents <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/develop/examples/text/keyword_extraction_example.ipynb)]</sup></sub>
       - **Generative AI with GPT**: Provide instructions to a lightweight ChatGPT-like model running on your own own machine to solve various tasks. Model was fine-tuned on the [Alpaca](https://github.com/tatsu-lab/stanford_alpaca) instruction dataset ([CC By NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/deed.en_GB)) <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/develop/examples/text/generative_ai_example.ipynb)]</sup>
    - `vision` data:
      - **image classification** (e.g., [ResNet](https://arxiv.org/abs/1512.03385), [Wide ResNet](https://arxiv.org/abs/1605.07146), [Inception](https://www.cs.unc.edu/~wliu/papers/GoogLeNet.pdf)) <sub><sup>[[example notebook](https://colab.research.google.com/drive/1WipQJUPL7zqyvLT10yekxf_HNMXDDtyR)]</sup></sub>
      - **image regression** for predicting numerical targets from photos (e.g., age prediction) <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/vision/utk_faces_age_prediction-resnet50.ipynb)]</sup></sub>
      - **image captioning** with a pretrained model <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/develop/examples/vision/image_captioning_example.ipynb)]</sup></sub>
      - **object detection** with a pretrained model <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/develop/examples/vision/object_detection_example.ipynb)]</sup></sub>
    - `graph` data:
      - **node classification** with graph neural networks ([GraphSAGE](https://cs.stanford.edu/people/jure/pubs/graphsage-nips17.pdf)) <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/graphs/pubmed_node_classification-GraphSAGE.ipynb)]</sup></sub>
      - **link prediction** with graph neural networks ([GraphSAGE](https://cs.stanford.edu/people/jure/pubs/graphsage-nips17.pdf)) <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/graphs/cora_link_prediction-GraphSAGE.ipynb)]</sup></sub>
    - `tabular` data:
      - **tabular classification** (e.g., Titanic survival prediction) <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/tutorials/tutorial-08-tabular_classification_and_regression.ipynb)]</sup></sub>
      - **tabular regression** (e.g., predicting house prices) <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/tabular/HousePricePrediction-MLP.ipynb)]</sup></sub>
      - **causal inference** using meta-learners <sub><sup>[[example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/develop/examples/tabular/causal_inference_example.ipynb)]</sup></sub>
  - estimate an optimal learning rate for your model given your data using a Learning Rate Finder
  - utilize learning rate schedules such as the [triangular policy](https://arxiv.org/abs/1506.01186), the [1cycle policy](https://arxiv.org/abs/1803.09820), and [SGDR](https://arxiv.org/abs/1608.03983) to effectively minimize loss and improve generalization
  - build text classifiers for any language (e.g., [Arabic Sentiment Analysis with BERT](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/text/ArabicHotelReviews-AraBERT.ipynb), [Chinese Sentiment Analysis with NBSVM](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/text/ChineseHotelReviews-nbsvm.ipynb))
  - easily train NER models for any language (e.g., [Dutch NER](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/text/CoNLL2002_Dutch-BiLSTM.ipynb) )
  - load and preprocess text and image data from a variety of formats
  - inspect data points that were misclassified and [provide explanations](https://eli5.readthedocs.io/en/latest/) to help improve your model
  - leverage a simple prediction API for saving and deploying both models and data-preprocessing steps to make predictions on new raw data
  - built-in support for exporting models to [ONNX](https://onnx.ai/) and  [TensorFlow Lite](https://www.tensorflow.org/lite) (see [example notebook](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/develop/examples/text/ktrain-ONNX-TFLite-examples.ipynb) for more information)

  Please see the following tutorial notebooks for a guide on how to use **ktrain** on your projects:
  * Tutorial 1:  [Introduction](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/tutorials/tutorial-01-introduction.ipynb)
  * Tutorial 2:  [Tuning Learning Rates](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/tutorials/tutorial-02-tuning-learning-rates.ipynb)
  * Tutorial 3: [Image Classification](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/tutorials/tutorial-03-image-classification.ipynb)
  * Tutorial 4: [Text Classification](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/tutorials/tutorial-04-text-classification.ipynb)
  * Tutorial 5: [Learning from Unlabeled Text Data](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/tutorials/tutorial-05-learning_from_unlabeled_text_data.ipynb)
  * Tutorial 6: [Text Sequence Tagging](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/tutorials/tutorial-06-sequence-tagging.ipynb) for Named Entity Recognition
  * Tutorial 7: [Graph Node Classification](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/tutorials/tutorial-07-graph-node_classification.ipynb) with Graph Neural Networks
  * Tutorial 8: [Tabular Classification and Regression](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/tutorials/tutorial-08-tabular_classification_and_regression.ipynb)
  * Tutorial A1: [Additional tricks](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/tutorials/tutorial-A1-additional-tricks.ipynb), which covers topics such as previewing data augmentation schemes, inspecting intermediate output of Keras models for debugging, setting global weight decay, and use of built-in and custom callbacks.
  * Tutorial A2: [Explaining Predictions and Misclassifications](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/tutorials/tutorial-A2-explaining-predictions.ipynb)
  * Tutorial A3: [Text Classification with Hugging Face Transformers](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/develop/tutorials/tutorial-A3-hugging_face_transformers.ipynb)
  * Tutorial A4: [Using Custom Data Formats and Models: Text Regression with Extra Regressors](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/tutorials/tutorial-A4-customdata-text_regression_with_extra_regressors.ipynb)
  Some blog tutorials and other guides about **ktrain** are shown below:
  > [**ktrain: A Lightweight Wrapper for Keras to Help Train Neural Networks**](https://towardsdatascience.com/ktrain-a-lightweight-wrapper-for-keras-to-help-train-neural-networks-82851ba889c)
  > [**BERT Text Classification in 3 Lines of Code**](https://towardsdatascience.com/bert-text-classification-in-3-lines-of-code-using-keras-264db7e7a358)
  > [**Text Classification with Hugging Face Transformers in  TensorFlow 2 (Without Tears)**](https://medium.com/@asmaiya/text-classification-with-hugging-face-transformers-in-tensorflow-2-without-tears-ee50e4f3e7ed)
  > [**Build an Open-Domain Question-Answering System With BERT in 3 Lines of Code**](https://towardsdatascience.com/build-an-open-domain-question-answering-system-with-bert-in-3-lines-of-code-da0131bc516b)
  > [**Finetuning BERT using ktrain for Disaster Tweets Classification**](https://medium.com/analytics-vidhya/finetuning-bert-using-ktrain-for-disaster-tweets-classification-18f64a50910b) by Hamiz Ahmed
  > [**Indonesian NLP Examples with ktrain**](https://github.com/ilos-vigil/ktrain-assessment-study) by Sandy Khosasi

  Using **ktrain** on **Google Colab**?  See these Colab examples:
  -  **text classification:** [a simple demo of Multiclass Text Classification with BERT](https://colab.research.google.com/drive/1AH3fkKiEqBpVpO5ua00scp7zcHs5IDLK)
  -  **text classification:** [a simple demo of Multiclass Text Classification with Hugging Face Transformers](https://colab.research.google.com/drive/1YxcceZxsNlvK35pRURgbwvkgejXwFxUt)
  - **sequence-tagging (NER):** [NER example using `transformer` word embeddings](https://colab.research.google.com/drive/1whrnmM7ElqbaEhXf760eiOMiYk5MNO-Z?usp=sharing)
  - **question-answering:** [End-to-End Question-Answering](https://colab.research.google.com/drive/1tcsEQ7igx7lw_R0Pfpmsg9Wf3DEXyOvk?usp=sharing) using the 20newsgroups dataset.
  -  **image classification:** [image classification with Cats vs. Dogs](https://colab.research.google.com/drive/1WipQJUPL7zqyvLT10yekxf_HNMXDDtyR)
  Tasks such as text classification and image classification can be accomplished easily with
  only a few lines of code.

  ```python
  import ktrain
  from ktrain import text as txt

  (x_train, y_train), (x_test, y_test), preproc = txt.texts_from_folder('data/aclImdb', maxlen=500,
                                                                       preprocess_mode='bert',
                                                                       train_test_names=['train', 'test'],
                                                                       classes=['pos', 'neg'])

  model = txt.text_classifier('bert', (x_train, y_train), preproc=preproc)

  learner = ktrain.get_learner(model,
                               train_data=(x_train, y_train),
                               val_data=(x_test, y_test),
                               batch_size=6)

  learner.lr_find()             # briefly simulate training to find good learning rate
  learner.lr_plot()             # visually identify best learning rate

  learner.fit_onecycle(2e-5, 3)
  ```

  ```python
  import ktrain
  from ktrain import vision as vis

  (train_data, val_data, preproc) = vis.images_from_folder(
                                                datadir='data/dogscats',
                                                data_aug = vis.get_data_aug(horizontal_flip=True),
                                                train_test_names=['train', 'valid'],
                                                target_size=(224,224), color_mode='rgb')

  model = vis.image_classifier('pretrained_resnet50', train_data, val_data, freeze_layers=80)

  learner = ktrain.get_learner(model=model, train_data=train_data, val_data=val_data,
                               workers=8, use_multiprocessing=False, batch_size=64)

  learner.lr_find()             # briefly simulate training to find good learning rate
  learner.lr_plot()             # visually identify best learning rate

  learner.autofit(1e-4, checkpoint_folder='/tmp/saved_weights')
  ```

  ```python
  import ktrain
  from ktrain import text as txt

  (trn, val, preproc) = txt.entities_from_txt('data/ner_dataset.csv',
                                              sentence_column='Sentence #',
                                              word_column='Word',
                                              tag_column='Tag',
                                              data_format='gmb',
                                              use_char=True) # enable character embeddings

  model = txt.sequence_tagger('bilstm-crf', preproc)

  learner = ktrain.get_learner(model, train_data=trn, val_data=val)

  learner.fit(1e-3, 1)
  ```

  ```python
  import ktrain
  from ktrain import graph as gr

  (trn, val, preproc)  = gr.graph_nodes_from_csv(
                                                 'cora.content', # node attributes/labels
                                                 'cora.cites',   # edge list
                                                 sample_size=20,
                                                 holdout_pct=None,
                                                 holdout_for_inductive=False,
                                                train_pct=0.1, sep='\t')

  model=gr.graph_node_classifier('graphsage', trn)

  learner = ktrain.get_learner(model, train_data=trn, val_data=val, batch_size=64)

  learner.lr_find(max_epochs=100) # briefly simulate training to find good learning rate
  learner.lr_plot()               # visually identify best learning rate

  learner.autofit(0.01, checkpoint_folder='/tmp/saved_weights')
  ```

  ```python

  categories = ['alt.atheism', 'soc.religion.christian','comp.graphics', 'sci.med']
  from sklearn.datasets import fetch_20newsgroups
  train_b = fetch_20newsgroups(subset='train', categories=categories, shuffle=True)
  test_b = fetch_20newsgroups(subset='test',categories=categories, shuffle=True)
  (x_train, y_train) = (train_b.data, train_b.target)
  (x_test, y_test) = (test_b.data, test_b.target)

  import ktrain
  from ktrain import text
  MODEL_NAME = 'distilbert-base-uncased'
  t = text.Transformer(MODEL_NAME, maxlen=500, class_names=train_b.target_names)
  trn = t.preprocess_train(x_train, y_train)
  val = t.preprocess_test(x_test, y_test)
  model = t.get_classifier()
  learner = ktrain.get_learner(model, train_data=trn, val_data=val, batch_size=6)
  learner.fit_onecycle(5e-5, 4)
  learner.validate(class_names=t.get_classes()) # class_names must be string values











  ```
  <!--

  ```python

  import ktrain
  from ktrain import text as txt
  x_train= [['IL-2', 'responsiveness', 'requires', 'three', 'distinct', 'elements', 'within', 'the', 'enhancer', '.'], ...]
  y_train=[['B-protein', 'O', 'O', 'O', 'O', 'B-DNA', 'O', 'O', 'B-DNA', 'O'], ...]
  (trn, val, preproc) = txt.entities_from_array(x_train, y_train)
  model = txt.sequence_tagger('bilstm-bert', preproc, bert_model='monologg/biobert_v1.1_pubmed')
  learner = ktrain.get_learner(model, train_data=trn, val_data=val, batch_size=128)
  learner.fit(0.01, 1, cycle_len=5)
  ```
  -->

  ```python
  import ktrain
  from ktrain import tabular
  import pandas as pd
  train_df = pd.read_csv('train.csv', index_col=0)
  train_df = train_df.drop(['Name', 'Ticket', 'Cabin'], 1)
  trn, val, preproc = tabular.tabular_from_df(train_df, label_columns=['Survived'], random_state=42)
  learner = ktrain.get_learner(tabular.tabular_classifier('mlp', trn), train_data=trn, val_data=val)
  learner.lr_find(show_plot=True, max_epochs=5) # estimate learning rate
  learner.fit_onecycle(5e-3, 10)

  tst = preproc.preprocess_test(pd.read_csv('heldout.csv', index_col=0))
  learner.evaluate(tst, class_names=preproc.get_classes())
  ```


  1. Make sure pip is up-to-date with: `pip install -U pip`
  2. [Install TensorFlow 2](https://www.tensorflow.org/install) if it is not already installed (e.g., `pip install tensorflow`)
  3. Install *ktrain*: `pip install ktrain`
  The above should be all you need on Linux systems and cloud computing environments like Google Colab and AWS EC2.  If you are using **ktrain** on a **Windows computer**, you can follow these
  [more detailed instructions](https://github.com/amaiya/ktrain/blob/master/FAQ.md#how-do-i-install-ktrain-on-a-windows-machine) that include some extra steps.
  **Supported TensorFlow Versions**:  *ktrain* should currently support any version of TensorFlow at or above to v2.3: i.e., `pip install tensorflow>=2.3`.  However, if using `tensorflow>=2.11`, then you must only use legacy optimizers such as `tf.keras.optimizers.legacy.Adam`.  The newer `tf.keras.optimizers.Optimizer` base class is not supported at this time.  For instance, when using TensorFlow 2.11 and above, please use `tf.keras.optimzers.legacy.Adam()` instead of the string `"adam"` in `model.compile`. **ktrain** does this automatically when using out-of-the-box models (e.g., models from the `transformers` library).

  - Some optional, extra libraries used for some operations can be installed as needed. (Notice that **ktrain** is using forked versions of the `eli5` and `stellargraph` libraries in order to support TensorFlow2.)
  ```python

  pip install https://github.com/amaiya/stellargraph/archive/refs/heads/no_tf_dep_082.zip

  pip install https://github.com/amaiya/eli5-tf/archive/refs/heads/master.zip

  pip install shap

  pip install torch

  pip install librosa

  pip install causalnlp

  pip install sumy

  pip install textblob
  ```
  - **ktrain** purposely pins to a lower version of **transformers** to include support for older versions of TensorFlow.  If you need a newer version of `transformers`, it is usually safe for you to upgrade `transformers`, as long as you do it **after** installing **ktrain**.
  - As of v0.30.x, TensorFlow installation is optional and only required if training neural networks.  Although **ktrain** uses TensorFlow for neural network training, it also includes a variety of useful pretrained PyTorch models and sklearn models, which
  can be used out-of-the-box **without** having TensorFlow installed, as summarized in this table:
  | Feature  | TensorFlow |  PyTorch | Sklearn
  | --- | :-: | :-: | :-: |
  | [training](https://towardsdatascience.com/ktrain-a-lightweight-wrapper-for-keras-to-help-train-neural-networks-82851ba889c) any neural network (e.g., text or image classification)  |  ✅  | ❌  | ❌  |
  | [End-to-End Question-Answering](https://nbviewer.org/github/amaiya/ktrain/blob/master/examples/text/question_answering_with_bert.ipynb) (pretrained)             |  ✅  | ✅  | ❌  |
  | [QA-Based Information Extraction](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/text/qa_information_extraction.ipynb) (pretrained)      |  ✅  | ✅  | ❌  |
  | [Zero-Shot Classification](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/text/zero_shot_learning_with_nli.ipynb) (pretrained)   |  ❌  | ✅  | ❌  |
  | [Language Translation](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/text/language_translation_example.ipynb) (pretrained)      |  ❌  | ✅  | ❌  |
  | [Summarization](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/examples/text/text_summarization_with_bart.ipynb) (pretrained)             |  ❌  | ✅  | ❌  |
  | [Speech Transcription](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/develop/examples/text/speech_transcription_example.ipynb) (pretrained)     |  ❌  | ✅  |❌   |
  | [Image Captioning](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/develop/examples/vision/image_captioning_example.ipynb) (pretrained)     |  ❌  | ✅  |❌   |
  | [Object Detection](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/develop/examples/vision/object_detection_example.ipynb) (pretrained)     |  ❌  | ✅  |❌   |
  | [Topic Modeling](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/master/tutorials/tutorial-05-learning_from_unlabeled_text_data.ipynb) (sklearn)  |  ❌  | ❌  | ✅  |
  | [Keyphrase Extraction](https://nbviewer.jupyter.org/github/amaiya/ktrain/blob/develop/examples/text/keyword_extraction_example.ipynb) (textblob/nltk/sklearn)   |  ❌  | ❌  | ✅  |
  As noted above, end-to-end question-answering and information extraction in **ktrain** can be used with either TensorFlow (using `framework='tf'`) or PyTorch (using `framework='pt'`).
  <!--
  pip install pdoc3==0.9.2
  pdoc3 --html -o docs ktrain
  diff -qr docs/ktrain/ /path/to/repo/ktrain/docs
  -->

  Please cite the [following paper](https://arxiv.org/abs/2004.10703) when using **ktrain**:
  ```
  @article{maiya2020ktrain,
      title={ktrain: A Low-Code Library for Augmented Machine Learning},
      author={Arun S. Maiya},
      year={2020},
      eprint={2004.10703},
      archivePrefix={arXiv},
      primaryClass={cs.LG},
      journal={arXiv preprint arXiv:2004.10703},
  }
  ```
  <!--

  The following software/libraries should be installed:
  - [Python 3.6+](https://www.python.org/) (tested on 3.6.7)
  - [Keras](https://keras.io/)  (tested on 2.2.4)
  - [TensorFlow](https://www.tensorflow.org/)  (tested on 1.10.1)
  - [scikit-learn](https://scikit-learn.org/stable/) (tested on 0.20.0)
  - [matplotlib](https://matplotlib.org/) (tested on 3.0.0)
  - [pandas](https://pandas.pydata.org/) (tested on 0.24.2)
  - [keras_bert](https://github.com/CyberZHG/keras-bert/tree/master/keras_bert)
  - [fastprogress](https://github.com/fastai/fastprogress)


pkgId: 320d9f4d9bb444a885edf6c8fdb46680dc1f86da7bbc5e591185232a797abd12
name: python-kwconfig
arch: src
version: 1.1.7
epoch: 0
release: 1
summary: A Python module for managing config files in keyword style json format.
url: https://github.com/rrwen/kwconfig
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f39f9e66-a50a-461b-9b11-646f96e3bbd1
location_href: 00014129-python-kwconfig/python-kwconfig-1.1.7-1.src.rpm
checksum_type: sha256
description:
  1. Install `Python <https://www.python.org/downloads/>`_
  2. Install `kwconfig <https://pypi.python.org/pypi/kwconfig>`_ via ``pip``
    pip install kwconfig
  For the latest developer version, see `Developer Install`_.


pkgId: ff0231bb5757a2956c35714f1c0039216a46fb8abb824ac23888d8fbeace8497
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-6221744b-f811-4d39-881e-cef6f7afd711
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: 4ada058b137a4d21e20b8a94521b16067514097b4fe5b35d9098870b74e73869
name: python-langcodes
arch: src
version: 3.3.0
epoch: 0
release: 1
summary: Tools for labeling human languages with IETF language tags
url: https://github.com/rspeer/langcodes
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f5770a03-7ef0-40da-8154-33b68dba51d1
location_href: 00009814-python-langcodes/python-langcodes-3.3.0-1.src.rpm
checksum_type: sha256
description:
  **langcodes** knows what languages are. It knows the standardized codes that
  refer to them, such as `en` for English, `es` for Spanish and `hi` for Hindi.

  These are [IETF language tags][]. You may know them by their old name, ISO 639
  language codes. IETF has done some important things for backward compatibility
  and supporting language variations that you won't find in the ISO standard.

  [IETF language tags]: https://www.w3.org/International/articles/language-tags/

  It may sound to you like langcodes solves a pretty boring problem. At one
  level, that's right. Sometimes you have a boring problem, and it's great when a
  library solves it for you.

  But there's an interesting problem hiding in here. How do you work with
  language codes? How do you know when two different codes represent the same
  thing? How should your code represent relationships between codes, like the
  following?

  * `eng` is equivalent to `en`.
  * `fra` and `fre` are both equivalent to `fr`.
  * `en-GB` might be written as `en-gb` or `en_GB`. Or as 'en-UK', which is
    erroneous, but should be treated as the same.
  * `en-CA` is not exactly equivalent to `en-US`, but it's really, really close.
  * `en-Latn-US` is equivalent to `en-US`, because written English must be written
    in the Latin alphabet to be understood.
  * The difference between `ar` and `arb` is the difference between "Arabic" and
    "Modern Standard Arabic", a difference that may not be relevant to you.
  * You'll find Mandarin Chinese tagged as `cmn` on Wiktionary, but many other
    resources would call the same language `zh`.
  * Chinese is written in different scripts in different territories. Some
    software distinguishes the script. Other software distinguishes the territory.
    The result is that `zh-CN` and `zh-Hans` are used interchangeably, as are
    `zh-TW` and `zh-Hant`, even though occasionally you'll need something
    different such as `zh-HK` or `zh-Latn-pinyin`.
  * The Indonesian (`id`) and Malaysian (`ms` or `zsm`) languages are mutually
    intelligible.
  * `jp` is not a language code. (The language code for Japanese is `ja`, but
    people confuse it with the country code for Japan.)

  One way to know is to read IETF standards and Unicode technical reports.
  Another way is to use a library that implements those standards and guidelines
  for you, which langcodes does.

  When you're working with these short language codes, you may want to see the
  name that the language is called _in_ a language: `fr` is called "French" in
  English. That language doesn't have to be English: `fr` is called "français" in
  French. A supplement to langcodes, [`language_data`][language-data], provides
  this information.

  [language-data]: https://github.com/rspeer/language_data

  langcodes is maintained by Elia Robyn Lake a.k.a. Robyn Speer, and is released
  as free software under the MIT license.




  Although this is not the only reason to use it, langcodes will make you more
  acronym-compliant.

  langcodes implements [BCP 47](http://tools.ietf.org/html/bcp47), the IETF Best
  Current Practices on Tags for Identifying Languages. BCP 47 is also known as
  RFC 5646. It subsumes ISO 639 and is backward compatible with it, and it also
  implements recommendations from the [Unicode CLDR](http://cldr.unicode.org).

  langcodes can also refer to a database of language properties and names, built
  from Unicode CLDR and the IANA subtag registry, if you install `language_data`.

  In summary, langcodes takes language codes and does the Right Thing with them,
  and if you want to know exactly what the Right Thing is, there are some
  documents you can go read.






  This function standardizes tags, as strings, in several ways.

  It replaces overlong tags with their shortest version, and also formats them
  according to the conventions of BCP 47:

      >>> from langcodes import *
      >>> standardize_tag('eng_US')
      'en-US'

  It removes script subtags that are redundant with the language:

      >>> standardize_tag('en-Latn')
      'en'

  It replaces deprecated values with their correct versions, if possible:

      >>> standardize_tag('en-uk')
      'en-GB'

  Sometimes this involves complex substitutions, such as replacing Serbo-Croatian
  (`sh`) with Serbian in Latin script (`sr-Latn`), or the entire tag `sgn-US`
  with `ase` (American Sign Language).

      >>> standardize_tag('sh-QU')
      'sr-Latn-EU'

      >>> standardize_tag('sgn-US')
      'ase'

  If *macro* is True, it uses macrolanguage codes as a replacement for the most
  common standardized language within that macrolanguage.

      >>> standardize_tag('arb-Arab', macro=True)
      'ar'

  Even when *macro* is False, it shortens tags that contain both the
  macrolanguage and the language:

      >>> standardize_tag('zh-cmn-hans-cn')
      'zh-Hans-CN'

  If the tag can't be parsed according to BCP 47, this will raise a
  LanguageTagError (a subclass of ValueError):

      >>> standardize_tag('spa-latn-mx')
      'es-MX'

      >>> standardize_tag('spa-mx-latn')
      Traceback (most recent call last):
          ...
      langcodes.tag_parser.LanguageTagError: This script subtag, 'latn', is out of place. Expected variant, extension, or end of string.




  This package defines one class, named Language, which contains the results
  of parsing a language tag. Language objects have the following fields,
  any of which may be unspecified:

  - *language*: the code for the language itself.
  - *script*: the 4-letter code for the writing system being used.
  - *territory*: the 2-letter or 3-digit code for the country or similar region
    whose usage of the language appears in this text.
  - *extlangs*: a list of more specific language codes that follow the language
    code. (This is allowed by the language code syntax, but deprecated.)
  - *variants*: codes for specific variations of language usage that aren't
    covered by the *script* or *territory* codes.
  - *extensions*: information that's attached to the language code for use in
    some specific system, such as Unicode collation orders.
  - *private*: a code starting with `x-` that has no defined meaning.

  The `Language.get` method converts a string to a Language instance, and the
  `Language.make` method makes a Language instance from its fields.  These values
  are cached so that calling `Language.get` or `Language.make` again with the
  same values returns the same object, for efficiency.

  By default, it will replace non-standard and overlong tags as it interprets
  them. To disable this feature and get the codes that literally appear in the
  language tag, use the *normalize=False* option.

      >>> Language.get('en-Latn-US')
      Language.make(language='en', script='Latn', territory='US')

      >>> Language.get('sgn-US', normalize=False)
      Language.make(language='sgn', territory='US')

      >>> Language.get('und')
      Language.make()

  Here are some examples of replacing non-standard tags:

      >>> Language.get('sh-QU')
      Language.make(language='sr', script='Latn', territory='EU')

      >>> Language.get('sgn-US')
      Language.make(language='ase')

      >>> Language.get('zh-cmn-Hant')
      Language.make(language='zh', script='Hant')

  Use the `str()` function on a Language object to convert it back to its
  standard string form:

      >>> str(Language.get('sh-QU'))
      'sr-Latn-EU'

      >>> str(Language.make(territory='IN'))
      'und-IN'




  A language code is _valid_ when every part of it is assigned a meaning by IANA.
  That meaning could be "private use".

  In langcodes, we check the language subtag, script, territory, and variants for
  validity. We don't check other parts such as extlangs or Unicode extensions.

  For example, `ja` is a valid language code, and `jp` is not:

      >>> Language.get('ja').is_valid()
      True

      >>> Language.get('jp').is_valid()
      False

  The top-level function `tag_is_valid(tag)` is possibly more convenient to use,
  because it can return False even for tags that don't parse:

      >>> tag_is_valid('C')
      False

  If one subtag is invalid, the entire code is invalid:

      >>> tag_is_valid('en-000')
      False

  `iw` is valid, though it's a deprecated alias for `he`:

      >>> tag_is_valid('iw')
      True

  The empty language tag (`und`) is valid:

      >>> tag_is_valid('und')
      True

  Private use codes are valid:

      >>> tag_is_valid('x-other')
      True

      >>> tag_is_valid('qaa-Qaai-AA-x-what-even-is-this')
      True

  Language tags that are very unlikely are still valid:

      >>> tag_is_valid('fr-Cyrl')
      True

  Tags with non-ASCII characters are invalid, because they don't parse:

     >>> tag_is_valid('zh-普通话')
     False




  Before there was BCP 47, there was ISO 639-2. The ISO tried to make room for the
  variety of human languages by assigning every language a 3-letter code,
  including the ones that already had 2-letter codes.

  Unfortunately, this just led to more confusion. Some languages ended up with two
  different 3-letter codes for legacy reasons, such as French, which is `fra` as a
  "terminology" code, and `fre` as a "biblographic" code. And meanwhile, `fr` was
  still a code that you'd be using if you followed ISO 639-1.

  In BCP 47, you should use 2-letter codes whenever they're available, and that's
  what langcodes does. Fortunately, all the languages that have two different
  3-letter codes also have a 2-letter code, so if you prefer the 2-letter code,
  you don't have to worry about the distinction.

  But some applications want the 3-letter code in particular, so langcodes
  provides a method for getting those, `Language.to_alpha3()`. It returns the
  'terminology' code by default, and passing `variant='B'` returns the
  bibliographic code.

  When this method returns, it always returns a 3-letter string.

      >>> Language.get('fr').to_alpha3()
      'fra'
      >>> Language.get('fr-CA').to_alpha3()
      'fra'
      >>> Language.get('fr-CA').to_alpha3(variant='B')
      'fre'
      >>> Language.get('de').to_alpha3()
      'deu'
      >>> Language.get('no').to_alpha3()
      'nor'
      >>> Language.get('un').to_alpha3()
      Traceback (most recent call last):
          ...
      LookupError: 'un' is not a known language code, and has no alpha3 code.

  For many languages, the terminology and bibliographic alpha3 codes are the same.

      >>> Language.get('en').to_alpha3(variant='T')
      'eng'
      >>> Language.get('en').to_alpha3(variant='B')
      'eng'

  When you use any of these "overlong" alpha3 codes in langcodes, they normalize
  back to the alpha2 code:

      >>> Language.get('zho')
      Language.make(language='zh')




  The methods in this section require an optional package called `language_data`.
  You can install it with `pip install language_data`, or request the optional
  "data" feature of langcodes with `pip install langcodes[data]`.

  The dependency that you put in setup.py should be `langcodes[data]`.



  It's often helpful to be able to describe a language code in a way that a user
  (or you) can understand, instead of in inscrutable short codes. The
  `display_name` method lets you describe a Language object *in a language*.

  The `.display_name(language, min_score)` method will look up the name of the
  language. The names come from the IANA language tag registry, which is only in
  English, plus CLDR, which names languages in many commonly-used languages.

  The default language for naming things is English:

      >>> Language.make(language='fr').display_name()
      'French'

      >>> Language.make().display_name()
      'Unknown language'

      >>> Language.get('zh-Hans').display_name()
      'Chinese (Simplified)'

      >>> Language.get('en-US').display_name()
      'English (United States)'

  But you can ask for language names in numerous other languages:

      >>> Language.get('fr').display_name('fr')
      'français'

      >>> Language.get('fr').display_name('es')
      'francés'

      >>> Language.make().display_name('es')
      'lengua desconocida'

      >>> Language.get('zh-Hans').display_name('de')
      'Chinesisch (Vereinfacht)'

      >>> Language.get('en-US').display_name('zh-Hans')
      '英语（美国）'

  Why does everyone get Slovak and Slovenian confused? Let's ask them.

      >>> Language.get('sl').display_name('sl')
      'slovenščina'
      >>> Language.get('sk').display_name('sk')
      'slovenčina'
      >>> Language.get('sl').display_name('sk')
      'slovinčina'
      >>> Language.get('sk').display_name('sl')
      'slovaščina'

  If the language has a script or territory code attached to it, these will be
  described in parentheses:

      >>> Language.get('en-US').display_name()
      'English (United States)'

  Sometimes these can be the result of tag normalization, such as in this case
  where the legacy tag 'sh' becomes 'sr-Latn':

      >>> Language.get('sh').display_name()
      'Serbian (Latin)'

      >>> Language.get('sh', normalize=False).display_name()
      'Serbo-Croatian'

  Naming a language in itself is sometimes a useful thing to do, so the
  `.autonym()` method makes this easy, providing the display name of a language
  in the language itself:

      >>> Language.get('fr').autonym()
      'français'
      >>> Language.get('es').autonym()
      'español'
      >>> Language.get('ja').autonym()
      '日本語'
      >>> Language.get('en-AU').autonym()
      'English (Australia)'
      >>> Language.get('sr-Latn').autonym()
      'srpski (latinica)'
      >>> Language.get('sr-Cyrl').autonym()
      'српски (ћирилица)'

  The names come from the Unicode CLDR data files, and in English they can
  also come from the IANA language subtag registry. Together, they can give
  you language names in the 196 languages that CLDR supports.




  You can get the parts of the name separately with the methods `.language_name()`,
  `.script_name()`, and `.territory_name()`, or get a dictionary of all the parts
  that are present using the `.describe()` method. These methods also accept a
  language code for what language they should be described in.

      >>> shaw = Language.get('en-Shaw-GB')
      >>> shaw.describe('en')
      {'language': 'English', 'script': 'Shavian', 'territory': 'United Kingdom'}

      >>> shaw.describe('es')
      {'language': 'inglés', 'script': 'shaviano', 'territory': 'Reino Unido'}




  As the reverse of the above operations, you may want to look up a language by
  its name, converting a natural language name such as "French" to a code such as
  'fr'.

  The name can be in any language that CLDR supports (see "Ambiguity" below).

      >>> import langcodes
      >>> langcodes.find('french')
      Language.make(language='fr')

      >>> langcodes.find('francés')
      Language.make(language='fr')

  However, this method currently ignores the parenthetical expressions that come from
  `.display_name()`:

      >>> langcodes.find('English (Canada)')
      Language.make(language='en')

  There is still room to improve the way that language names are matched, because
  some languages are not consistently named the same way. The method currently
  works with hundreds of language names that are used on Wiktionary.



  For the sake of usability, `langcodes.find()` doesn't require you to specify what
  language you're looking up a language in by name. This could potentially lead to
  a conflict: what if name "X" is language A's name for language B, and language C's
  name for language D?

  We can collect the language codes from CLDR and see how many times this
  happens. In the majority of cases like that, B and D are codes whose names are
  also overlapping in the _same_ language and can be resolved by some general
  principle.

  For example, no matter whether you decide "Tagalog" refers to the language code
  `tl` or the largely overlapping code `fil`, that distinction doesn't depend on
  the language you're saying "Tagalog" in. We can just return `tl` consistently.

      >>> langcodes.find('tagalog')
      Language.make(language='tl')

  In the few cases of actual interlingual ambiguity, langcodes won't match a result.
  You can pass in a `language=` parameter to say what language the name is in.

  For example, there are two distinct languages called "Tonga" in various languages.
  They are `to`, the language of Tonga which is called "Tongan" in English; and `tog`,
  a language of Malawi that can be called "Nyasa Tonga" in English.

      >>> langcodes.find('tongan')
      Language.make(language='to')

      >>> langcodes.find('nyasa tonga')
      Language.make(language='tog')

      >>> langcodes.find('tonga')
      Traceback (most recent call last):
      ...
      LookupError: Can't find any language named 'tonga'

      >>> langcodes.find('tonga', language='id')
      Language.make(language='to')

      >>> langcodes.find('tonga', language='ca')
      Language.make(language='tog')

  Other ambiguous names written in Latin letters are "Kiga", "Mbundu", "Roman", and "Ruanda".




  The `Language.speaking_population()` and `Language.writing_population()`
  methods get Unicode's estimates of how many people in the world use a
  language.

  As with the language name data, this requires the optional `language_data`
  package to be installed.

  `.speaking_population()` estimates how many people speak a language. It can
  be limited to a particular territory with a territory code (such as a country
  code).

      >>> Language.get('es').speaking_population()
      487664083

      >>> Language.get('pt').speaking_population()
      237135429

      >>> Language.get('es-BR').speaking_population()
      76218

      >>> Language.get('pt-BR').speaking_population()
      192661560

      >>> Language.get('vo').speaking_population()
      0

  Script codes will be ignored, because the script is not involved in speaking:

      >>> Language.get('es-Hant').speaking_population() ==\
      ... Language.get('es').speaking_population()
      True

  `.writing_population()` estimates how many people write a language.

      >>> all = Language.get('zh').writing_population()
      >>> all
      1240326057

      >>> traditional = Language.get('zh-Hant').writing_population()
      >>> traditional
      37019589

      >>> simplified = Language.get('zh-Hans').writing_population()
      >>> all == traditional + simplified
      True

  The estimates for "writing population" are often overestimates, as described
  in the [CLDR documentation on territory data][overestimates]. In most cases,
  they are derived from published data about literacy rates in the places where
  those languages are spoken. This doesn't take into account that many literate
  people around the world speak a language that isn't typically written, and
  write in a _different_ language.

  [overestimates]: https://unicode-org.github.io/cldr-staging/charts/39/supplemental/territory_language_information.html

  Like `.speaking_population()`, this can be limited to a particular territory:

      >>> Language.get('zh-Hant-HK').writing_population()
      6439733
      >>> Language.get('zh-Hans-HK').writing_population()
      338933




  The `tag_distance` function returns a number from 0 to 134 indicating the
  distance between the language the user desires and a supported language.

  The distance data comes from CLDR v38.1 and involves a lot of judgment calls
  made by the Unicode consortium.




  This table summarizes the language distance values:

  | Value | Meaning                                                                                                       | Example
  | ----: | :------                                                                                                       | :------
  |     0 | These codes represent the same language, possibly after filling in values and normalizing.                    | Norwegian Bokmål → Norwegian
  |   1-3 | These codes indicate a minor regional difference.                                                             | Australian English → British English
  |   4-9 | These codes indicate a significant but unproblematic regional difference.                                     | American English → British English
  | 10-24 | A gray area that depends on your use case. There may be problems with understanding or usability.             | Afrikaans → Dutch, Wu Chinese → Mandarin Chinese
  | 25-50 | These languages aren't similar, but there are demographic reasons to expect some intelligibility.             | Tamil → English, Marathi → Hindi
  | 51-79 | There are large barriers to understanding.                                                                    | Japanese → Japanese in Hepburn romanization
  | 80-99 | These are different languages written in the same script.                                                     | English → French, Arabic → Urdu
  |  100+ | These languages have nothing particularly in common.                                                          | English → Japanese, English → Tamil

  See the docstring of `tag_distance` for more explanation and examples.




  Suppose you have software that supports any of the `supported_languages`. The
  user wants to use `desired_language`.

  The function `closest_supported_match(desired_language, supported_languages)`
  lets you choose the right language, even if there isn't an exact match.
  It returns the language tag of the best-supported language, even if there
  isn't an exact match.

  The `max_distance` parameter lets you set a cutoff on what counts as language
  support. It has a default of 25, a value that is probably okay for simple
  cases of i18n, but you might want to set it lower to require more precision.

      >>> closest_supported_match('fr', ['de', 'en', 'fr'])
      'fr'

      >>> closest_supported_match('pt', ['pt-BR', 'pt-PT'])
      'pt-BR'

      >>> closest_supported_match('en-AU', ['en-GB', 'en-US'])
      'en-GB'

      >>> closest_supported_match('af', ['en', 'nl', 'zu'])
      'nl'

      >>> closest_supported_match('und', ['en', 'und'])
      'und'

      >>> print(closest_supported_match('af', ['en', 'nl', 'zu'], max_distance=10))
      None

  A similar function is `closest_match(desired_language, supported_language)`,
  which returns both the best matching language tag and the distance. If there is
  no match, it returns ('und', 1000).

      >>> closest_match('fr', ['de', 'en', 'fr'])
      ('fr', 0)

      >>> closest_match('sh', ['hr', 'bs', 'sr-Latn', 'sr-Cyrl'])
      ('sr-Latn', 0)

      >>> closest_match('id', ['zsm', 'mhp'])
      ('zsm', 14)

      >>> closest_match('ja', ['ja-Latn-hepburn', 'en'])
      ('und', 1000)

      >>> closest_match('ja', ['ja-Latn-hepburn', 'en'], max_distance=60)
      ('ja-Latn-hepburn', 50)



  There are many more methods for manipulating and comparing language codes,
  and you will find them documented thoroughly in [the code itself][code].

  The interesting functions all live in this one file, with extensive docstrings
  and annotations. Making a separate Sphinx page out of the docstrings would be
  the traditional thing to do, but here it just seems redundant. You can go read
  the docstrings in context, in their native habitat, and they'll always be up to
  date.

  [Code with documentation][code]

  [code]: https://github.com/rspeer/langcodes/blob/master/langcodes/__init__.py





  - Updated to CLDR v40.

  - Updated the IANA subtag registry to version 2021-08-06.

  - Bug fix: recognize script codes that appear in the IANA registry even if
    they're missing from CLDR for some reason. 'cu-Cyrs' is valid, for example.

  - Switched the build system from `setuptools` to `poetry`.

  To install the package in editable mode before PEP 660 is better supported, use
  `poetry install` instead of `pip install -e .`.



  - Supports Python 3.6 through 3.10.

  - Added the top-level function `tag_is_valid(tag)`, for determining if a string
    is a valid language tag without having to parse it first.

  - Added the top-level function `closest_supported_match(desired, supported)`,
    which is similar to `closest_match` but with a simpler return value. It
    returns the language tag of the closest match, or None if no match is close
    enough.

  - Bug fix: a lot of well-formed but invalid language codes appeared to be
    valid, such as 'aaj' or 'en-Latnx', because the regex could match a prefix of
    a subtag. The validity regex is now required to match completely.

  - Bug fixes that address some edge cases of validity:

    - A language tag that is entirely private use, like 'x-private', is valid
    - A language tag that uses the same extension twice, like 'en-a-bbb-a-ccc',
      is invalid
    - A language tag that uses the same variant twice, like 'de-1901-1901', is
      invalid
    - A language tag with two extlangs, like 'sgn-ase-bfi', is invalid

  - Updated dependencies so they are compatible with Python 3.10, including
    switching back from `marisa-trie-m` to `marisa-trie` in `language_data`.

  - In bugfix release 3.2.1, corrected cases where the parser accepted
    ill-formed language tags:

    - All subtags must be made of between 1 and 8 alphanumeric ASCII characters
    - Tags with two extension 'singletons' in a row (`en-a-b-ccc`) should be
      rejected



  - Added the `Language.to_alpha3()` method, for getting a three-letter code for a
    language according to ISO 639-2.

  - Updated the type annotations from obiwan-style to mypy-style.




  - Moved bulky data, particularly language names, into a separate
    `language_data` package. In situations where the data isn't needed,
    `langcodes` becomes a smaller, pure-Python package with no dependencies.

  - Language codes where the language segment is more than 4 letters no longer
    parse: Language.get('nonsense') now returns an error.

    (This is technically stricter than the parse rules of BCP 47, but there are
    no valid language codes of this form and there should never be any. An
    attempt to parse a language code with 5-8 letters is most likely a mistake or
    an attempt to make up a code.)

  - Added a method for checking the validity of a language code.

  - Added methods for estimating language population.

  - Updated to CLDR 38.1, which includes differences in language matching.

  - Tested on Python 3.6 through 3.9; no longer tested on Python 3.5.




  - Replaced `marisa-trie` dependency with `marisa-trie-m`, to achieve
    compatibility with Python 3.9.




  - Added the `display_name` method to be a more intuitive way to get a string
    describing a language code, and made the `autonym` method use it instead of
    `language_name`.

  - Updated to CLDR v37.

  - Previously, some attempts to get the name of a language would return its
    language code instead, perhaps because the name was being requested in a
    language for which CLDR doesn't have name data. This is unfortunate because
    names and codes should not be interchangeable.

    Now we fall back on English names instead, which exists for all IANA codes.
    If the code is unknown, we return a string such as "Unknown language [xx]".




  Version 2.0 involves some significant changes that may break compatibility with 1.4,
  in addition to updating to version 36.1 of the Unicode CLDR data and the April 2020
  version of the IANA subtag registry.

  This version requires Python 3.5 or later.



  Originally, the goodness of a match between two different language codes was defined
  in terms of a "match score" with a maximum of 100. Around 2016, Unicode started
  replacing this with a different measure, the "match distance", which was defined
  much more clearly, but we had to keep using the "match score".

  As of langcodes version 2.0, the "score" functions (such as
  `Language.match_score`, `tag_match_score`, and `best_match`) are deprecated.
  They'll keep using the deprecated language match tables from around CLDR 27.

  For a better measure of the closeness of two language codes, use `Language.distance`,
  `tag_distance`, and `closest_match`.



  We were always out of step with CLDR here. Following the example of the IANA
  database, we referred to things like the 'US' in 'en-US' as a "region code",
  but the Unicode standards consistently call it a "territory code".

  In langcodes 2.0, parameters, dictionary keys, and attributes named `region`
  have been renamed to `territory`.  We try to support a few common cases with
  deprecation warnings, such as looking up the `region` property of a Language
  object.

  A nice benefit of this is that when a dictionary is displayed with 'language',
  'script', and 'territory' keys in alphabetical order, they are in the same
  order as they are in a language code.


pkgId: d0d16c3c01519c77a4e99da3a90773603dfaba388d6502d15baa6e4df8c7c549
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-7703646a-b974-44c9-a1ee-0d9dc035dbc4
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: ced701ef8a97048437c3d4df2fa9c39febcece22565c83247dba59c5d6f64016
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-36ee0f25-0472-4a45-b1ba-93f2e8f0f0b6
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: 132ca5f3105eff2b8a16494f6af5f473de55ca380a92b679cc12f84979dac802
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-1efdbba1-02e2-44b0-94a4-067aba6dbf68
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: 7992f07f16e252649579481290a10169968e2821b0618a64bb7f25a3fc5ed934
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-152b0fe0-d805-4f24-9eaa-0108754eefc9
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: 8b70010e8a1a1b62c292e02a2593379df13726c8d1bdd85c0edb3792a5ee5439
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-79002690-f24d-4bbb-a60e-ea4d95c406db
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: 80cb18efa494bceb8ce8298fe36074baa2f4ee7faa313479b00dda53b2a429c4
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-8ec5fa20-3bbc-46fe-9b15-16a5dbda19fd
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: 242fe17d888bfb24c45f309c9bc7d6368440b3b128e5435ef23ce2db99b15696
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-b3e2173d-ab75-4705-b6f0-498843221313
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: c12965d83720713e5c8a80b27cfabc14b4bf5bdee7b734847d44b66bac008649
name: python-lazy-object-proxy-debuginfo
arch: x86_64
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-83122f08-da11-4644-9cbc-f9dbf645d685
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.x86_64.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: 820f01a8bf65f545ac7ec5045a4ea67fc675db8b923f26473287e0aa2e52b336
name: python-lazy-object-proxy-debugsource
arch: x86_64
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-83122f08-da11-4644-9cbc-f9dbf645d685
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.x86_64.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: 12da8a7b130d0f0ded2c7865c41d16a830b82bccd290299ab283ca5608fb71ae
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-80ed891d-8256-40ab-ae4f-0c525355050e
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: acdb54c51fe1a7bff1a1a2ee1a604487663707aea6ca078a4741068811da5baf
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-0c1fc809-bb46-4365-aa4d-fe6ecf6b931c
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: 1fbc2c29db67b4121579491f91546f0b97f8ccf05192508acc269cccb9edc58d
name: python-lbt-grasshopper
arch: src
version: 1.6.27
epoch: 0
release: 1
summary: Collection of all Ladybug Tools plugins for Grasshopper
url: https://github.com/ladybug-tools/lbt-grasshopper
rpm_license: AGPL-3.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5d2a0597-b475-49d8-9f6c-3d341a20389e
location_href: 00014185-python-lbt-grasshopper/python-lbt-grasshopper-1.6.27-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/ladybug-tools/lbt-grasshopper.svg?branch=master)](https://travis-ci.com/ladybug-tools/lbt-grasshopper)

  [![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 Ladybug Tools plugins for Grasshopper.

  Note that this repository and corresponding Python package does not contain any
  code and it simply exists to provide a shortcut for installing all of the grasshopper
  plugin packages together. The repository CI also manages the assignment of version
  numbers to the totality of the grasshopper plugins together.



  Running `pip install lbt-grasshopper` will result in the installation of the
  following Grasshopper plugin packages:

  * [ladybug-grasshopper](https://github.com/ladybug-tools/ladybug-grasshopper)
  * [honeybee-grasshopper-core](https://github.com/ladybug-tools/honeybee-grasshopper-core)
  * [honeybee-grasshopper-radiance](https://github.com/ladybug-tools/honeybee-grasshopper-radiance)
  * [honeybee-grasshopper-energy](https://github.com/ladybug-tools/honeybee-grasshopper-energy)
  * [dragonfly-grasshopper](https://github.com/ladybug-tools/dragonfly-grasshopper)

  All of the repositories above contain only Grasshopper components and their
  source code.



  See [the wiki of this repository](https://github.com/ladybug-tools/lbt-grasshopper/wiki)
  for a list of instructions to install the Grasshopper plugin for free.

  Alternatively, you can use the [Pollination Grasshopper single-click installer ](https://www.pollination.cloud/grasshopper-plugin) to install the Ladybug Tools plugin for free.


pkgId: 565e12ef072b9100b94b252396df31b13eaa3026b685371755cc217911a1ebd3
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-efff9657-033a-4e81-91d2-03b39545568b
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: e33f97a452704bdacda76e0c079b3370500a27125f7b1e785ff59ab918f97ce0
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-f406d558-dadf-44fa-aadc-8cdd6998f8c9
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: f42bd7e3cd6d27e30118ac427d6a78a7a5fcf4b47432faec9581aef14177a641
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-0b36c23f-98b5-460e-befe-063f6ea9c3b4
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: ad7dc81314b71ef7fedf1ac2f576ed466c4e491e7efbbd52b76de27eac461144
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-ad28f57e-db63-4f16-b786-0a010f6df2d0
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: b0fdeab77cd3240a802a0e3e638a0428256f1f3470e65f03aacc5e64f3d3fbd7
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-5efe7850-c292-4b1c-993f-5eb689babd3a
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: 2727032fa380822c0d69c2a994ef9d13399deb4cc4d134f75de07a1e8fee91e2
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-e6e4c101-fadd-4c81-a53b-abe55bbff60a
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: 54c7d9e693d51385b2b9a5f7dd531c8ce17e2bdd1947608a9543ea4ff68ec14b
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-82da3c4f-83eb-4333-b3d5-4991503b3fb7
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: ad182ca2616e9691bdd6935a846424ac3130c16bf7a3e9d17a9d6d3c4b365840
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-bb6ea20d-b209-443a-bb47-025c803814da
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: 3c54eb7767765a482a0b0dc75b3d3e96190c6ce52ec75f8b4baea723a20bc345
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-1ff1857f-b8ce-4279-b799-6d5e0527dc9c
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: 1e77ff517362165cf1a863acf8cba49921b5f50f996a1750e800cd438bba8be2
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-ccc188be-ecd9-4bee-ab69-140208489ae7
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: eb8694a53413ec6bd44a88f248abb9c944e72d739a97987237a3b13324ba0f00
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-21e417f2-9c32-4397-99bc-4135db223c82
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: 0972c0de9f03495f798945c15f9a817853da27c1a3ca5d6d74b90435ac19ad91
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-e0e6278f-66d2-411d-ade3-cbc775db108b
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: 28a2466037261d5527c5bcb524834722eac696c97f4e9f211147afac3787ae03
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-d16d13eb-fabf-42cc-88ee-acbbc0f894bc
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: 78e2d40486411e6a4fa283f71fb45aa92124637656077f59412e1ce1fa92efe7
name: python-libsass-debuginfo
arch: x86_64
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-d16d13eb-fabf-42cc-88ee-acbbc0f894bc
rpm_sourcerpm: python-libsass-0.22.0-1.src.rpm
location_href: 00004099-python-libsass/python-libsass-debuginfo-0.22.0-1.x86_64.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: 44c0f2b3e767495c96bffb6fdeb05e16d12e10e726cd4c37e712d6d8d1e0305c
name: python-libsass-debugsource
arch: x86_64
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-d16d13eb-fabf-42cc-88ee-acbbc0f894bc
rpm_sourcerpm: python-libsass-0.22.0-1.src.rpm
location_href: 00004099-python-libsass/python-libsass-debugsource-0.22.0-1.x86_64.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: 015ce42c8203aad1b7ae87400d27d9de294192a2f28e9e3878eeaf7b1a2b4865
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-108c2eea-d9f9-4b0c-a9cd-d09f647cee02
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: 1c7179bafb792ab42290f83adb6bef88c5cc1050fad631cb69755e80d427f643
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-b0b07c83-c993-4380-b361-b74f8fa77bb3
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: f88d8b8957a5e21b426a6d86bc272df7f148f94160c90216c2050b7e2905edc0
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-a9cd2547-0643-4575-a77b-f52c9ef071ea
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: e225201171bf69e698c7b403e5779747efcf73b9e1d522d67e24a9eda0fa65c6
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-98c7255f-ca9b-4f86-bbfb-e7d00303def1
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: 305ee43cc52d9e4d49861c9f247a20f15dc8124a2cd24abd80a0df03e281e367
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-b59aeece-fc12-4fba-873b-a247109fda1d
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: a7a22f0fe847190e055958990f5fb5ff77c14e34dd494d514d75e9361fa202e2
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-38879446-0b0a-4fdd-b62f-a8eaf6d1f3e0
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: 6ff824c15516b3fb0fc5ea4db7c7c5c0c177ec34a2ce553b1d0057b486d3c11d
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-5947462a-84b1-4dc9-9ddb-1e1cb2b8b671
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: 072cc08a8f7a2cf4fd0a2555b731c5484e9c53ae0b82087438e542df3322dc33
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-32e41dbd-ac82-4a56-8b43-200e4365b92d
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: cd5f2ee96300144d7fbddd883873b8acfa78738b197b5d4c8a4109807d5a5db7
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-f1f223b6-adf9-4642-b0ff-8df5f1fe4ff1
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: 7dcb95af2df399a91c4e385ffbbabd3fc43b0a43b18477d29fd49fd69a3fbf14
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-46634978-f875-46ac-b749-c14a61d67cab
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: bdd75f5266992ca3cab6d25c4dcbe3cb6a6fe556a12c73c097bae405fb9a5618
name: python-lmdb-debuginfo
arch: x86_64
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-562e9b64-ab23-45f5-abd6-0beccef70213
rpm_sourcerpm: python-lmdb-1.4.0-1.src.rpm
location_href: 00004121-python-lmdb/python-lmdb-debuginfo-1.4.0-1.x86_64.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: 4f853e49f38388dc72b56a864e6e1ae9835db4d589de4ba5eeec5ae0b30029a3
name: python-lmdb-debugsource
arch: x86_64
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-562e9b64-ab23-45f5-abd6-0beccef70213
rpm_sourcerpm: python-lmdb-1.4.0-1.src.rpm
location_href: 00004121-python-lmdb/python-lmdb-debugsource-1.4.0-1.x86_64.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: 592f0a009a3794085bddab69f8674c717b19329cbbea38a6a108e260e2a6a022
name: python-lob
arch: src
version: 4.5.4
epoch: 0
release: 1
summary: Lob Python Bindings
url: https://github.com/lob/lob-python
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d12e23f6-9d1b-4095-9a5c-b143871308d6
location_href: 00011452-python-lob/python-lob-4.5.4-1.src.rpm
checksum_type: sha256
description:
  Copyright &copy; 2013-2019 Lob.com
  Released under the MIT License, which can be found in the repository in `LICENSE.txt`.


pkgId: ac9d5216aa821b5e2c4798629786e01d0a5bc8351d5a4223e6677b500ad35f17
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-84b7301c-89e5-4234-bbb0-52318e5162cc
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: ce097f7492bea37efdc101c65cd502c8f991ff096b672e66d64d0fdc44dacd3f
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-e80e06bc-ade3-4fb2-9dac-394cb5d5ac3e
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: 4dc2b938a22487c5b1c5383cc6d8a1eb49b49b1e6164647fd17d917d6efb3a50
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-803f094c-68ad-4d19-a792-3a6d972dac15
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: 64e5f69974609621cb37d124e38dbff4fd902b7a7505d971533869844d382b6c
name: python-locust
arch: src
version: 2.15.1
epoch: 0
release: 1
summary: Developer friendly load testing framework
url: https://locust.io/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-778bdb43-4874-4478-b6a6-eb9d56b731fc
location_href: 00010009-python-locust/python-locust-2.15.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/locust.svg)](https://pypi.org/project/locust/)
  [![PyPI](https://img.shields.io/pypi/pyversions/locust.svg)](https://pypi.org/project/locust/)
  [![Build Status](https://github.com/locustio/locust/workflows/Tests/badge.svg)](https://github.com/locustio/locust/actions?query=workflow%3ATests)
  [![codecov](https://codecov.io/gh/locustio/locust/branch/master/graph/badge.svg)](https://codecov.io/gh/locustio/locust)
  [![license](https://img.shields.io/github/license/locustio/locust.svg)](https://github.com/locustio/locust/blob/master/LICENSE)
  [![GitHub contributors](https://img.shields.io/github/contributors/locustio/locust.svg)](https://github.com/locustio/locust/graphs/contributors)
  [![Support Ukraine Badge](https://bit.ly/support-ukraine-now)](https://github.com/support-ukraine/support-ukraine)

  Locust is an easy to use, scriptable and scalable performance testing tool. You define the behaviour of your users in regular Python code, instead of being constrained by a UI or domain specific language that only pretends to be real code. This makes Locust infinitely expandable and very developer friendly.

  To get started right away, head over to the [documentation](http://docs.locust.io/en/stable/installation.html).





  If you want your users to loop, perform some conditional behaviour or do some calculations, you just use the regular programming constructs provided by Python. Locust runs every user inside its own greenlet (a lightweight process/coroutine). This enables you to write your tests like normal (blocking) Python code instead of having to use callbacks or some other mechanism. Because your scenarios are “just python” you can use your regular IDE, and version control your tests as regular code (as opposed to some other tools that use XML or binary formats)

  ```python
  from locust import HttpUser, task, between

  class QuickstartUser(HttpUser):
      wait_time = between(1, 2)

      def on_start(self):
          self.client.post("/login", json={"username":"foo", "password":"bar"})

      @task
      def hello_world(self):
          self.client.get("/hello")
          self.client.get("/world")

      @task(3)
      def view_item(self):
          for item_id in range(10):
              self.client.get(f"/item?id={item_id}", name="/item")
  ```



  Locust makes it easy to run load tests distributed over multiple machines. It is event-based (using [gevent](http://www.gevent.org/)), which makes it possible for a single process to handle many thousands concurrent users. While there may be other tools that are capable of doing more requests per second on a given hardware, the low overhead of each Locust user makes it very suitable for testing highly concurrent workloads.



  Locust has a user friendly web interface that shows the progress of your test in real-time. You can even change the load while the test is running. It can also be run without the UI, making it easy to use for CI/CD testing.

  <img src="https://raw.githubusercontent.com/locustio/locust/master/locust/static/img/ui-screenshot-charts.png" alt="Locust UI charts" width="200"/> <img src="https://raw.githubusercontent.com/locustio/locust/master/locust/static/img/ui-screenshot-stats.png" alt="Locust UI stats" width="200"/> <img src="https://raw.githubusercontent.com/locustio/locust/master/locust/static/img/ui-screenshot-workers.png" alt="Locust UI workers" width="200"/> <img src="https://raw.githubusercontent.com/locustio/locust/master/locust/static/img/ui-screenshot-start-test.png" alt="Locust UI start test" width="200"/>



  Even though Locust primarily works with web sites/services, it can be used to test almost any system or protocol. Just [write a client](https://docs.locust.io/en/latest/testing-other-systems.html#testing-other-systems) for what you want to test, or [explore some created by the community](https://github.com/SvenskaSpel/locust-plugins#users).



  Locust's code base is intentionally kept small and doesn't solve everything out of the box. Instead, we try to make it easy to adapt to any situation you may come across, using regular Python code. There is nothing stopping you from:

  * [Send real time reporting data to TimescaleDB and visualize it in Grafana](https://github.com/SvenskaSpel/locust-plugins/blob/master/locust_plugins/dashboards/README.md)
  * [Wrap calls to handle the peculiarities of your REST API](https://github.com/SvenskaSpel/locust-plugins/blob/8af21862d8129a5c3b17559677fe92192e312d8f/examples/rest_ex.py#L87)
  * [Use a totally custom load shape/profile](https://docs.locust.io/en/latest/custom-load-shape.html#custom-load-shape)
  * ...



  * Website: [locust.io](https://locust.io)
  * Documentation: [docs.locust.io](https://docs.locust.io)
  * Support/Questions: [StackOverflow](https://stackoverflow.com/questions/tagged/locust)
  * Code/issues: [GitHub](https://github.com/locustio/locust)
  * Chat/discussion: [Slack signup](https://slack.locust.io/)



  * [Carl Byström](http://cgbystrom.com) ([@cgbystrom](https://twitter.com/cgbystrom) on Twitter)
  * [Jonatan Heyman](http://heyman.info) ([@jonatanheyman](https://twitter.com/jonatanheyman) on Twitter)
  * [Joakim Hamrén](https://github.com/Jahaja) ([@Jahaaja](https://twitter.com/Jahaaja) on Twitter)
  * [Hugo Heyman](https://github.com/HeyHugo) ([@hugoheyman](https://twitter.com/hugoheyman) on Twitter)
  * [Lars Holmberg](https://github.com/cyberw)



  Open source licensed under the MIT license (see _LICENSE_ file for details).


pkgId: 8f7e055698468339afef18badc238b81804a988910cf96321f4477b11d247a20
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-4dca5806-c797-41bf-84fa-4611705ed4b5
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


