# packages

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

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

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


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


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

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

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


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


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


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


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


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


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

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

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

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

  Originally developed as part of the ACME_ protocol implementation.

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


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

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


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


pkgId: 5a618c92c953184ca15e20d20feb5de5e6c0dd1eb39002c0d80ecf74d11cb84b
name: python-json-lines
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Reading JSON lines (jl) files, recover broken files
url: https://github.com/TeamHG-Memex/json-lines
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-af9de295-e47c-47c7-8da5-787ce8232d7b
location_href: 00014156-python-json-lines/python-json-lines-0.5.0-1.src.rpm
checksum_type: sha256
description:
  This is a tiny library for reading JSON lines (.jl) files,
  including gzipped and broken files.
  `JSON lines <http://jsonlines.org/>`_ is a text file format
  where each line is a single json encoded item.


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


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


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

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


  ```

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

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

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

  Templates control the style of the generated documentation.

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

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

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

  [See CONTRIBUTING.md](CONTRIBUTING.md)


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


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

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

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

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

  * Objects and arrays may end with trailing commas.

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

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

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

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

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

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



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

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

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

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


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




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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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


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


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





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

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



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





  jsonformatter is available on PyPI.
  Use pip to install:

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

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






  ```python
  import logging

  from jsonformatter import basicConfig


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

  output:

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





  ```python
  import logging

  from jsonformatter import JsonFormatter





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

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

  formatter = JsonFormatter(STRING_FORMAT)

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

  root.addHandler(sh)

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

  output:

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





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

  [logger_root]
  level=INFO
  handlers=infohandler




  [handlers]
  keys=infohandler

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



  [formatters]
  keys=form01

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

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

  ```

  output:

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





  flask_demo.py

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

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

  app = Flask(__name__)



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

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


  formatter = JsonFormatter(
      RECORD_CUSTOM_FORMAT,
      record_custom_attrs=RECORD_CUSTOM_ATTRS
  )

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

  output:

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





  settings.py

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







  ```python
  import logging

  from jsonformatter import JsonFormatter

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

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

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

  output:

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




  ```python
  import logging

  from jsonformatter import JsonFormatter

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


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

  formatter = JsonFormatter(MULTI_ATTRIBUTES_FORMAT)

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

  sh.setLevel(logging.INFO)

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





  ```python
  import logging

  from jsonformatter import JsonFormatter

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

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


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

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

  sh.setLevel(logging.INFO)

  root.addHandler(sh)

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





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

  from jsonformatter import JsonFormatter



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

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



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


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

          return json.JSONEncoder.default(self, o)

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

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

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

  sh.setLevel(logging.INFO)

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





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

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


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

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

  Python3 compatibily by Per J. Sandstrom


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

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


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

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


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


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

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

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

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

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



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

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

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


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

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

  Process incoming JSON-RPC requests in Python.

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

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

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

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

  ```

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

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

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


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


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

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

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

  Example of a model to serialize:

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

  Example of using jsons to serialize:

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

  Example of using jsons to deserialize:

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



      pip install jsons



  ```python
  import jsons

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

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

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


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

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



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







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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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




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

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


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


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


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

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

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


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

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


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

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


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

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

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



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

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

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

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

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

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

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

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

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





  Everything should work from Kubernetes v1.6+.

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

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



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



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

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





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



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


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

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



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

  ![pygments screencast](pygments.gif)



  `jupyterlab_pygments` can be installed with the conda package manager

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

  or from pypi

  ```
  pip install jupyterlab_pygments
  ```



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



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

  This includes the ability to differentiate properties from general names.



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


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


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


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


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


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


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



  ```python
  from kaggle_environments import make


  env = make("tictactoe")


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


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


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



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

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



  ```python

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



  > A function which given an observation generates an action.



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

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

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


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


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



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

  ```python

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


  agent2 = "random"


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


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


  agent5 = 3


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



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

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


  print(*env.agents)


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



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

  ```python
  from kaggle_environments import make

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


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

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



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

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

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

  ```python
  from kaggle_environments import make

  def agent():
    return "Something Bad"

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

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

  ```



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

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



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

  ```python
  from kaggle_environments import make


  env = make(
    
    "connectx",

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

    
    steps=[],

    
    debug=True
  )
  ```



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

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

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



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

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



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

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



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

  ```python
  from kaggle_environments import evaluate


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


  agents = ["random", agent1]


  num_episodes = 10

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



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

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



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

  ```python
  from kaggle_environments import make

  env = make("connectx")

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



  The following rendering modes are supported:

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

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



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



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



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



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



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

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



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



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



  ```python

  import requests
  import json

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

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

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


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


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

  This library implements Kaitai Struct API for Python.

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

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

  Further reading:

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


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


pkgId: 1f8edc2437fc3edb3200263aa8e2bf1f7c838a7ce3ed597439c404d3468c1d0f
name: python-kats
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: kats: kit to analyze time series
url: https://github.com/facebookresearch/Kats
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-617e1ef2-a514-4b39-bd37-6c9ffd6b65fa
location_href: 00013823-python-kats/python-kats-0.2.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
  <img src="kats_logo.svg" width="40%"/>
  </div>

  <div align="center">
    <a href="https://github.com/facebookresearch/Kats/actions">
    <img alt="Github Actions" src="https://github.com/facebookresearch/Kats/actions/workflows/build_and_test.yml/badge.svg"/>
    </a>
    <a href="https://pypi.python.org/pypi/kats">
    <img alt="PyPI Version" src="https://img.shields.io/pypi/v/kats.svg"/>
    </a>
    <a href="https://github.com/facebookresearch/Kats/blob/master/CONTRIBUTING.md">
    <img alt="PRs Welcome" src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg"/>
    </a>
  </div>



  Kats is a toolkit to analyze time series data, a lightweight, easy-to-use, and generalizable framework to perform time series analysis. Time series analysis is an essential component of Data Science and Engineering work at industry, from understanding the key statistics and characteristics, detecting regressions and anomalies, to forecasting future trends. Kats aims to provide the one-stop shop for time series analysis, including detection, forecasting, feature extraction/embedding, multivariate analysis, etc.

  Kats is released by Facebook's *Infrastructure Data Science* team. It is available for download on [PyPI](https://pypi.python.org/pypi/kats/).



  - Homepage: https://facebookresearch.github.io/Kats/
  - Kats Python package: https://pypi.org/project/kats/0.1.0/
  - Facebook Engineering Blog Post: https://engineering.fb.com/2021/06/21/open-source/kats/
  - Source code repository: https://github.com/facebookresearch/kats
  - Contributing: https://github.com/facebookresearch/Kats/blob/master/CONTRIBUTING.md
  - Tutorials: https://github.com/facebookresearch/Kats/tree/master/tutorials



  Kats is on PyPI, so you can use `pip` to install it.

  ```bash
  pip install --upgrade pip
  pip install kats
  ```

  If you need only a small subset of Kats, you can install a minimal version of Kats with
  ```bash
  MINIMAL_KATS=1 pip install kats
  ```
  which omits many dependencies (everything in `test_requirements.txt`).
  However, this will disable many functionalities and cause `import kats` to log
  warnings. See `setup.py` for full details and options.



  Here are a few sample snippets from a subset of Kats offerings:



  Using `Prophet` model to forecast the `air_passengers` data set.

  ```python
  import pandas as pd

  from kats.consts import TimeSeriesData
  from kats.models.prophet import ProphetModel, ProphetParams


  air_passengers_df = pd.read_csv(
      "../kats/data/air_passengers.csv",
      header=0,
      names=["time", "passengers"],
  )


  air_passengers_ts = TimeSeriesData(air_passengers_df)


  params = ProphetParams(seasonality_mode='multiplicative') # additive mode gives worse results


  m = ProphetModel(air_passengers_ts, params)


  m.fit()


  fcst = m.predict(steps=30, freq="MS")
  ```



  Using `CUSUM` detection algorithm on simulated data set.

  ```python

  import numpy as np
  import pandas as pd

  from kats.consts import TimeSeriesData
  from kats.detectors.cusum_detection import CUSUMDetector


  np.random.seed(10)
  df_increase = pd.DataFrame(
      {
          'time': pd.date_range('2019-01-01', '2019-03-01'),
          'increase':np.concatenate([np.random.normal(1,0.2,30), np.random.normal(2,0.2,30)]),
      }
  )


  timeseries = TimeSeriesData(df_increase)


  change_points = CUSUMDetector(timeseries).detector()
  ```



  We can extract meaningful features from the given time series data

  ```python

  import pandas as pd
  from kats.consts import TimeSeriesData
  from kats.tsfeatures.tsfeatures import TsFeatures


  air_passengers_df = pd.read_csv(
      "../kats/data/air_passengers.csv",
      header=0,
      names=["time", "passengers"],
  )


  air_passengers_ts = TimeSeriesData(air_passengers_df)


  features = TsFeatures().transform(air_passengers_ts)
  ```




  * Forecasting
      * Added global model, a neural network forecasting model
      * Added [global model tutorial](https://github.com/facebookresearch/Kats/blob/main/tutorials/kats_205_globalmodel.ipynb)
      * Consolidated backtesting APIs and some minor bug fixes
  * Detection
      * Added model optimizer for anomaly/ changepoint detection
      * Added evaluators for anomaly/changepoint detection
      * Improved simulators, to build synthetic data and inject anomalies
      * Added new detectors: ProphetTrendDetector, Dynamic Time Warping based detectors
      * Support for meta-learning, to recommend anomaly detection algorithms and parameters for your dataset
      * Standardized API for some of our legacy detectors: OutlierDetector, MKDetector
      * Support for Seasonality Removal in StatSigDetector
  * TsFeatures
      * Added time-based features
  * Others
      * Bug fixes, code coverage improvement, etc.



  * Initial release



  Kats is a project with several skillful researchers and engineers contributing to it.

  Kats is currently maintained by [Xiaodong Jiang](https://www.linkedin.com/in/xdjiang/) with major contributions coming
  from many talented individuals in various forms and means. A non-exhaustive but growing list needs to mention: [Sudeep Srivastava](https://www.linkedin.com/in/sudeep-srivastava-2129484/), [Sourav Chatterjee](https://www.linkedin.com/in/souravc83/), [Jeff Handler](https://www.linkedin.com/in/jeffhandl/), [Rohan Bopardikar](https://www.linkedin.com/in/rohan-bopardikar-30a99638), [Dawei Li](https://www.linkedin.com/in/lidawei/), [Yanjun Lin](https://www.linkedin.com/in/yanjun-lin/), [Yang Yu](https://www.linkedin.com/in/yangyu2720/), [Michael Brundage](https://www.linkedin.com/in/michaelb), [Caner Komurlu](https://www.linkedin.com/in/ckomurlu/), [Rakshita Nagalla](https://www.linkedin.com/in/rakshita-nagalla/), [Zhichao Wang](https://www.linkedin.com/in/zhichaowang/), [Hechao Sun](https://www.linkedin.com/in/hechao-sun-83b9ba4b/), [Peng Gao](https://www.linkedin.com/in/peng-gao-9137a24b/), [Wei Cheung](https://www.linkedin.com/in/weizhicheung/), [Jun Gao](https://www.linkedin.com/in/jun-gao-71352b64/), [Qi Wang](https://www.linkedin.com/in/qi-wang-9231a783/), [Morteza Kazemi](https://www.linkedin.com/in/morteza-kazemi-pmp-csm/), [Tihamér Levendovszky](https://www.linkedin.com/in/tiham%C3%A9r-levendovszky-29639b5/), [Jian Zhang](https://www.linkedin.com/in/jian-zhang-73718917/), [Ahmet Koylan](https://www.linkedin.com/in/ahmetburhan/), [Kun Jiang](https://www.linkedin.com/in/kunqiang-jiang-ph-d-0988aa1b/), [Aida Shoydokova](https://www.linkedin.com/in/ashoydok/), [Ploy Temiyasathit](https://www.linkedin.com/in/nutcha-temiyasathit/), Sean Lee, [Nikolay Pavlovich Laptev](http://www.nikolaylaptev.com/), [Peiyi Zhang](https://www.linkedin.com/in/pyzhang/), [Emre Yurtbay](https://www.linkedin.com/in/emre-yurtbay-27516313a/), [Daniel Dequech](https://www.linkedin.com/in/daniel-dequech/), [Rui Yan](https://www.linkedin.com/in/rui-yan/), [William Luo](https://www.linkedin.com/in/wqcluo/), [Marius Guerard](https://www.linkedin.com/in/mariusguerard/), and [Pietari Pulkkinen](https://www.linkedin.com/in/pietaripulkkinen/).



  Kats is licensed under the [MIT license](LICENSE).


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


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


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

  Install with: pip install keep-alive.


pkgId: e33f1f5fb00ce4032c7a02ad8c007f2e2a10dcfea7747a97f77d58bbe3afc818
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-e9e05d68-6b82-4e2c-a653-60b666e65b75
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: 020300eecb7160bd0f377e3abe2ded17feb4604e66fbccf215010fc680a1072b
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-5c842e2b-285f-4d28-ba6f-5800568d5d0c
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: 4487cfa1d48db94ce9a297f7c78f06b8a647bc11bed6d4fc6edff35da9b4737f
name: python-keras-multi-head
arch: src
version: 0.29.0
epoch: 0
release: 1
summary: A wrapper layer for stacking layers horizontally
url: https://github.com/CyberZHG/keras-multi-head
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-058acf3b-9304-4960-aa7b-48b9e9f5ef00
location_href: 00013897-python-keras-multi-head/python-keras-multi-head-0.29.0-1.src.rpm
checksum_type: sha256
description:
  [![Version](https://img.shields.io/pypi/v/keras-multi-head.svg)](https://pypi.org/project/keras-multi-head/)
  ![License](https://img.shields.io/pypi/l/keras-multi-head.svg)

  A wrapper layer for stacking layers horizontally.

  ![](https://user-images.githubusercontent.com/853842/45797517-867b8580-bcd8-11e8-9ec6-39d6508cf438.png)



  ```bash
  pip install keras-multi-head
  ```





  The layer will be duplicated if only a single layer is provided. The `layer_num` argument controls how many layers will be duplicated eventually.

  ```python
  from tensorflow import keras
  from keras_multi_head import MultiHead


  model = keras.models.Sequential()
  model.add(keras.layers.Embedding(input_dim=100, output_dim=20, name='Embedding'))
  model.add(MultiHead(keras.layers.LSTM(units=32), layer_num=5, name='Multi-LSTMs'))
  model.add(keras.layers.Flatten(name='Flatten'))
  model.add(keras.layers.Dense(units=4, activation='softmax', name='Dense'))
  model.build()
  model.summary()
  ```



  The first argument could also be a list of layers with different configurations, however, they must have the same output shapes.

  ```python
  from tensorflow import keras
  from keras_multi_head import MultiHead


  model = keras.models.Sequential()
  model.add(keras.layers.Embedding(input_dim=100, output_dim=20, name='Embedding'))
  model.add(MultiHead([
      keras.layers.Conv1D(filters=32, kernel_size=3, padding='same'),
      keras.layers.Conv1D(filters=32, kernel_size=5, padding='same'),
      keras.layers.Conv1D(filters=32, kernel_size=7, padding='same'),
  ], name='Multi-CNNs'))
  model.build()
  model.summary()
  ```



  The input data will be mapped to different values of the same shape for each layer when `hidden_dim` is given.



  ![](https://user-images.githubusercontent.com/853842/45857922-8b4e4100-bd8d-11e8-905a-4eb07da31418.png)

  The regularization is used when you expect to extract different features from the parallel layers. You can customize the indices of weights in the layers, the intervals represent the parts of the weights and the factor of the regularization.

  For example, the bidirectional LSTM layer has 6 weights by default, and the first 3s belong to the forward layer. The 2nd weight (recurrent kernel) in the forward layer controls the computation of gates for recurrent connections. The kernel for computing cell states lays in units x 2 to units x 3 of the recurrent kernel. We can used the regularization for the kernels:

  ```python
  from tensorflow import keras
  from keras_multi_head import MultiHead


  model = keras.models.Sequential()
  model.add(keras.layers.Embedding(input_dim=5, output_dim=3, name='Embed'))
  model.add(MultiHead(
      layer=keras.layers.Bidirectional(keras.layers.LSTM(units=16), name='LSTM'),
      layer_num=5,
      reg_index=[1, 4],
      reg_slice=(slice(None, None), slice(32, 48)),
      reg_factor=0.1,
      name='Multi-Head-Attention',
  ))
  model.add(keras.layers.Flatten(name='Flatten'))
  model.add(keras.layers.Dense(units=2, activation='softmax', name='Dense'))
  model.build()
  ```

  * `reg_index`: The indices of `layer.get_weights()`, a single integer or a list of integers.
  * `reg_slice`: `slice`s or a tuple of `slice`s or a list of the previous choices. If multiple indices are provided in `reg_index` and `reg_slice` is not a list, then `reg_slice` is assumed to be equal for all the indices. The whole array will be used if you leave this argument to `None`.
  * `reg_factor`: The factor of the regularization, a float or a list of floats.



  A more specific multi-head layer is provided (since the general one is harder to use). The layer uses scaled dot product attention layers as its sub-layers and only `head_num` is required:

  ```python
  from tensorflow import keras
  from keras_multi_head import MultiHeadAttention

  input_layer = keras.layers.Input(
      shape=(2, 3),
      name='Input',
  )
  att_layer = MultiHeadAttention(
      head_num=3,
      name='Multi-Head',
  )(input_layer)
  model = keras.models.Model(inputs=input_layer, outputs=att_layer)
  model.compile(
      optimizer='adam',
      loss='mse',
      metrics={},
  )
  model.summary()
  ```

  The shapes of input and output tensors would be the same if only one layer is presented as input. The input layers will be considered as query, key and value when a list is given:

  ```python
  from tensorflow import keras
  from keras_multi_head import MultiHeadAttention

  input_query = keras.layers.Input(
      shape=(2, 3),
      name='Input-Q',
  )
  input_key = keras.layers.Input(
      shape=(4, 5),
      name='Input-K',
  )
  input_value = keras.layers.Input(
      shape=(4, 6),
      name='Input-V',
  )
  att_layer = MultiHeadAttention(
      head_num=3,
      name='Multi-Head',
  )([input_query, input_key, input_value])
  model = keras.models.Model(inputs=[input_query, input_key, input_value], outputs=att_layer)
  model.compile(
      optimizer='adam',
      loss='mse',
      metrics={},
  )
  model.summary()
  ```


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

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

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

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



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





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

  ```python
  import keras
  from keras_self_attention import SeqSelfAttention


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



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

  ```python
  from keras_self_attention import SeqSelfAttention

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



  You can use multiplicative attention by setting `attention_type`:

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

  ```python
  from keras_self_attention import SeqSelfAttention

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



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

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

  ```python
  import keras
  from keras_self_attention import SeqSelfAttention

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



  Make sure to add `SeqSelfAttention` to custom objects:

  ```python
  import keras

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



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

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



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


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

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

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

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

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

  keyboard.wait('esc')

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

  keyboard.play(recorded, speed_factor=3)

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

  keyboard.wait()
  ```

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


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


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


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

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


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


pkgId: 54ca8cb99f2c4067e34f4eafd85d6f9684178ab395b3e3b9720d7291146c0197
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-bfb6d43c-0d39-4db3-911f-03743798526c
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: e0f04ac636d62b248fb5ef6af31350d76a4476402af7438486534e45499e02d4
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-c11b2b61-700f-41ba-a10b-ead6b0cb84d6
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: ac74c537545f65ce7e3c2c80d3afc1bfe61ebe0d1d3b2be3de52aea969b06bed
name: python-klusta
arch: src
version: 3.0.16
epoch: 0
release: 1
summary: Spike detection and automatic clustering for spike sorting
url: https://klusta.cortexlab.net
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e3ebf27e-b22a-4466-acd8-da09a276d8f3
location_href: 00004017-python-klusta/python-klusta-3.0.16-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://img.shields.io/travis/kwikteam/klusta.svg)](https://travis-ci.org/kwikteam/klusta)
  [![codecov.io](https://img.shields.io/codecov/c/github/kwikteam/klusta.svg)](http://codecov.io/github/kwikteam/klusta?branch=master)
  [![Documentation Status](https://readthedocs.org/projects/klusta/badge/?version=latest)](http://klusta.readthedocs.org/en/latest/)
  [![PyPI release](https://img.shields.io/pypi/v/klusta.svg)](https://pypi.python.org/pypi/klusta)
  [![GitHub release](https://img.shields.io/github/release/kwikteam/klusta.svg)](https://github.com/kwikteam/klusta/releases/latest)

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

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



  **klusta** implements the following features:

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




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

  We have developed two GUI programs with the same features:

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

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




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

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

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

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

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

      See the documentation for more details.




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

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




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




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




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


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


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

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

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

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

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

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

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

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




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

  ```bash

  conda install koalas -c conda-forge
  ```

  ```bash

  pip install koalas
  ```

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

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

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

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

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

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


  df = ks.from_pandas(pdf)


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


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

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




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




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




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




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


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


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

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

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

  It is built on a set of core principles:

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

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

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

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



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



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



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

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



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

      poetry install

  You can then run the tests with:

      poetry run pytest



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



  Apache 2.0


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

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


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

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

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

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

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



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

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




  Simply run followings on your computer:

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

  Or you can build image on your machine:

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

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

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

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

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

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





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

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

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






  ```python
  from konoha import WordTokenizer

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

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


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

  ```

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



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

  ```python

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


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


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



  ```python
  from konoha import SentenceTokenizer

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

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

  ```

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

  1. sentence splitter

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

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

  ```

  2. bracket expression

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

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

  ```




  ```
  python -m pytest
  ```



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



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


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

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

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

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




  * https://kopf.readthedocs.io/




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

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




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

  A minimalistic operator can look like this:

  ```python
  import kopf

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

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

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

  ```python
  import time
  import kopf

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

  Or the same with the timers:

  ```python
  import kopf

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

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




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

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

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

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

  See `kopf run --help` for other ways of attaching the handlers.




  Please read [CONTRIBUTING.md](https://github.com/nolar/kopf/blob/main/CONTRIBUTING.md)
  for details on our process for submitting pull requests to us, and please ensure
  you follow the [CODE_OF_CONDUCT.md](https://github.com/nolar/kopf/blob/main/CODE_OF_CONDUCT.md).

  To install the environment for the local development,
  read [DEVELOPMENT.md](https://github.com/nolar/kopf/blob/main/DEVELOPMENT.md).




  We use [SemVer](http://semver.org/) for versioning. For the versions available,
  see the [releases on this repository](https://github.com/nolar/kopf/releases).




  This project is licensed under the MIT License —
  see the [LICENSE](https://github.com/nolar/kopf/blob/main/LICENSE) file for details.




  * Thanks to Zalando for starting this project in Zalando's Open-Source Incubator
    in the first place.
  * Thanks to [@side8](https://github.com/side8) and their [k8s-operator](https://github.com/side8/k8s-operator)
    for inspiration.


pkgId: b45671cc2f1fe84dcc311db4a768cd31dacf4023a0422eabfc34182d4c8c76ab
name: python-korean-lunar-calendar
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Korean Lunar Calendar
url: https://github.com/usingsky/korean_lunar_calendar_py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e5b645bb-d507-4e15-8b9a-338fe33d9069
location_href: 00004034-python-korean-lunar-calendar/python-korean-lunar-calendar-0.3.1-1.src.rpm
checksum_type: sha256
description:
  한국 양음력 변환
  Overview
  ^^^^^^^^
  Here is a library to convert Korean lunar-calendar to Gregorian
  calendar.
  Korean calendar and Chinese calendar is same lunar calendar but have
  different date.
  This follow the KARI(Korea Astronomy and Space Science Institute)
  한국 양음력 변환 (한국천문연구원 기준) - 네트워크 연결 불필요
  음력 변환은 1000년 01월 01일 부터 2050년 11월 18일까지 지원
  양력 변환은 1000년 02월 13일 부터 2050년 12월 31일까지 지원
      Gregorian calendar (1000-02-13 ~ 2050-12-31) <--> Korean lunar-calendar (1000-01-01 ~ 2050-11-18)
  Install
  ^^^^^^^
  pip install korean\_lunar\_calendar
  To use
  ^^^^^^
  (0) import module
          from korean_lunar_calendar import KoreanLunarCalendar
  (1) Korean Solar Date -> Korean Lunar Date (양력 -> 음력)
          calendar = KoreanLunarCalendar()
          
          calendar.setSolarDate(2017, 6, 24)
          
          print(calendar.LunarIsoFormat())
          
          print(calendar.getGapJaString())
          
          print(calendar.getChineseGapJaString())
      [Result]
      2017-05-01 Intercalation
      정유년 병오월 임오일 (윤월)
      丁酉年 丙午月 壬午日 (閏月)
  (2) Korean Lunar Date -> Korean Solar Date (음력 -> 양력)
          
          calendar.setLunarDate(1956, 1, 21, False)
          
          print(calendar.SolarIsoFormat())
          
          print(calendar.getGapJaString())
          
          print(calendar.getChineseGapJaString())
      [Result]
      1956-03-03
      병신년 경인월 기사일
      丙申年 庚寅月 己巳日


pkgId: ec8044f858ea1b08a418ae2ad2517c4001d853d0d4f0331ac8b3253a9c74b884
name: python-krbcontext
arch: src
version: 0.10
epoch: 0
release: 1
summary: A Kerberos context manager
url: https://github.com/krbcontext/python-krbcontext
rpm_license: GPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3eaf9409-8184-4763-865e-77729bbf5d0b
location_href: 00004035-python-krbcontext/python-krbcontext-0.10-1.src.rpm
checksum_type: sha256
description:
  ``krbcontext`` provides a Kerberos context that you can put code inside, which
  requires a valid ticket in credential cache.


pkgId: 2be3171ec1859f743f52e1157ec2c7835a18f7308411135f700fc7825f71f272
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-4a9d7666-545d-464e-bad6-50ac2d73be3d
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: 9adf4cf198aa65f93177299457185d69a36a2ef4855eabdebe61115b2a7240c4
name: python-landslide
arch: src
version: 1.1.9
epoch: 0
release: 1
summary: HTML5 slideshow generator for Markdown, ReST, and Textile
url: http://github.com/adamzap/landslide
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e6f7c945-ce6a-40ac-8419-bf81e0db57e2
location_href: 00004041-python-landslide/python-landslide-1.1.9-1.src.rpm
checksum_type: sha256
description:
  Landslide takes your Markdown, ReST, or Textile file(s) and generates fancy
  HTML5 slideshow like `this <http://landslide.adamzap.com/>`_.

  Read the `README <http://github.com/adamzap/landslide/blob/master/README.md>`_
  for formatting instructions and more information.


pkgId: b36943e8a3833ec40d3e2f1206c81b4e6b2628da02165f92b614e11c252faf41
name: python-langdetect
arch: src
version: 1.0.9
epoch: 0
release: 1
summary: Language detection library ported from Google's language-detection.
url: https://github.com/Mimino666/langdetect
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0f7066f0-7b4c-4ed4-a077-877aef3a6597
location_href: 00009422-python-langdetect/python-langdetect-1.0.9-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/Mimino666/langdetect.svg?branch=master)](https://travis-ci.org/Mimino666/langdetect)
  Port of Nakatani Shuyo's [language-detection](https://github.com/shuyo/language-detection) library (version from 03/03/2014) to Python.


pkgId: 14170b2bea599e88f5f54f1b28b18ab2f914f83eab430aa79f9af110f86f0aa8
name: python-langua
arch: src
version: 1.0.12
epoch: 0
release: 1
summary: Faster port of Language detection built by Shuyo in Python
description:
  $ pip install langua
  Supported Python versions 2.7, 3.4+.

url: https://github.com/whiletruelearn/langua
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-25918adb-6a0e-4593-b297-257b215db0d3
location_href: 00010286-python-langua/python-langua-1.0.12-1.src.rpm
checksum_type: sha256
rpm_license:
  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at


pkgId: 61ac49bf22453e337e4342c02da39376196bd7583a445e914219fd4e2a6e73a1
name: python-lark
arch: src
version: 1.1.5
epoch: 0
release: 1
summary: a modern parsing library
url: https://github.com/lark-parser/lark
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-add09afa-77a9-4fa1-8802-e42f3692cd0c
location_href: 00011549-python-lark/python-lark-1.1.5-1.src.rpm
checksum_type: sha256
description:
  Lark is a modern general-purpose parsing library for Python.

  With Lark, you can parse any context-free grammar, efficiently, with very little code.

  Main Features:
   - Builds a parse-tree (AST) automagically, based on the structure of the grammar
   - Earley parser
      - Can parse all context-free grammars
      - Full support for ambiguous grammars
   - LALR(1) parser
      - Fast and light, competitive with PLY
      - Can generate a stand-alone parser
   - CYK parser, for highly ambiguous grammars
   - EBNF grammar
   - Unicode fully supported
   - Automatic line & column tracking
   - Standard library of terminals (strings, numbers, names, etc.)
   - Import grammars from Nearley.js
   - Extensive test suite
   - And much more!

  Since version 1.0, only Python versions 3.6 and up are supported.


pkgId: b569931e0e7b80a8f985b9d4705f4569eed626fe2ef1d185e248d94416aaab99
name: python-lark-parser
arch: src
version: 0.12.0
epoch: 0
release: 1
summary: a modern parsing library
url: https://github.com/lark-parser/lark
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7e0b2cf3-f593-457b-bfaf-c8b68906bc60
location_href: 00004043-python-lark-parser/python-lark-parser-0.12.0-1.src.rpm
checksum_type: sha256
description:
  Lark is a modern general-purpose parsing library for Python.

  With Lark, you can parse any context-free grammar, efficiently, with very little code.

  Main Features:
   - Builds a parse-tree (AST) automagically, based on the structure of the grammar
   - Earley parser
      - Can parse all context-free grammars
      - Full support for ambiguous grammars
   - LALR(1) parser
      - Fast and light, competitive with PLY
      - Can generate a stand-alone parser
   - CYK parser, for highly ambiguous grammars
   - EBNF grammar
   - Unicode fully supported
   - Python 2 & 3 compatible
   - Automatic line & column tracking
   - Standard library of terminals (strings, numbers, names, etc.)
   - Import grammars from Nearley.js
   - Extensive test suite
   - And much more!


pkgId: d06becd7b8691a8c8317ca8bed363d57c9def56f56d2fa484b7ad49043856114
name: python-lazr.config
arch: src
version: 2.2.3
epoch: 0
release: 1
summary: Create configuration schemas, and process and validate configurations.
url: https://launchpad.net/lazr.config
rpm_license: LGPL v3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-20091a14-a240-4246-adda-ea980c86bbf3
location_href: 00004047-python-lazr-config/python-lazr.config-2.2.3-1.src.rpm
checksum_type: sha256
description:
  The LAZR config system is typically used to manage process configuration.
  Process configuration is for saying how things change when we run systems on
  different machines, or under different circumstances.

  This system uses ini-like file format of section, keys, and values.  The
  config file supports inheritance to minimize duplication of information across
  files. The format supports schema validation.


pkgId: 429e7a8a824fd9814af2a47f23ad891d7aeadc1ec2eb9488d019bb62aa7b473e
name: python-lazr.delegates
arch: src
version: 2.0.4
epoch: 0
release: 1
summary: Easily write objects that delegate behavior
url: https://launchpad.net/lazr.delegates
rpm_license: LGPL v3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5226f8d3-bb32-4ec7-8427-562c70c19941
location_href: 00004048-python-lazr-delegates/python-lazr.delegates-2.0.4-1.src.rpm
checksum_type: sha256
description:
  The ``lazr.delegates`` package makes it easy to write objects that delegate
  behavior to another object. The new object adds some property or behavior on
  to the other object, while still providing the underlying interface, and
  delegating behavior.


pkgId: 91a1f7e2560010c0d5c646a3df280542bde600fe525a49cfd38240244ac19722
name: python-lazr.smtptest
arch: src
version: 2.0.4
epoch: 0
release: 1
summary: A test framework for SMTP based applications
url: https://launchpad.net/lazr.smtptest
rpm_license: LGPL v3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cbd3d5a4-6814-44d5-82d9-fdafdbbd45e3
location_href: 00004050-python-lazr-smtptest/python-lazr.smtptest-2.0.4-1.src.rpm
checksum_type: sha256
description:
  This is LAZR smtptest, a framework for testing SMTP-based applications and
  libraries.  It provides a real, live SMTP server that you can send messages
  to, and from which you can read those test messages.  This can be used to
  ensure proper operation of your applications which send email.


pkgId: 20be56941cca977f5bcd8a1753b3e2b68fd8d9e820adac8a96489fe86c480ce5
name: python-lazy-object-proxy-debuginfo
arch: aarch64
version: 1.9.0
epoch: 0
release: 1
summary: Debug information for package python-lazy-object-proxy
url: https://github.com/ionelmc/python-lazy-object-proxy
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-4b12d867-2199-45d0-9b9e-55e70d5852d8
rpm_sourcerpm: python-lazy-object-proxy-1.9.0-1.src.rpm
location_href: 00009064-python-lazy-object-proxy/python-lazy-object-proxy-debuginfo-1.9.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-lazy-object-proxy.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 63a66f76a2f2e7fdd160ead262b8731efb8619eb928f522dae047cdf58052490
name: python-lazy-object-proxy-debugsource
arch: aarch64
version: 1.9.0
epoch: 0
release: 1
summary: Debug sources for package python-lazy-object-proxy
url: https://github.com/ionelmc/python-lazy-object-proxy
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-4b12d867-2199-45d0-9b9e-55e70d5852d8
rpm_sourcerpm: python-lazy-object-proxy-1.9.0-1.src.rpm
location_href: 00009064-python-lazy-object-proxy/python-lazy-object-proxy-debugsource-1.9.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-lazy-object-proxy.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 2584caafe5746f9cfe03217ecee978ecd6e48ed4806009e16a0b0f0e0e322e3d
name: python-lazyarray
arch: src
version: 0.5.2
epoch: 0
release: 1
url: http://github.com/NeuralEnsemble/lazyarray/
rpm_license: Modified BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-12334cfe-02bc-4c23-84ec-12dc4c303102
location_href: 00004052-python-lazyarray/python-lazyarray-0.5.2-1.src.rpm
checksum_type: sha256
summary:
  a Python package that provides a lazily-evaluated numerical array class, larray, based on and compatible with NumPy arrays.


pkgId: 344bf6500873960b9f9a37b2d03ca86ede1b2bf7875cb23483d9bc1f48c45552
name: python-lbt-dragonfly
arch: src
version: 0.10.75
epoch: 0
release: 1
summary: Collection of all Dragonfly core Python libraries
url: https://github.com/ladybug-tools/lbt-dragonfly
rpm_license: AGPL-3.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-07e6511e-b1f8-4b92-a0da-fd31724084b9
location_href: 00011979-python-lbt-dragonfly/python-lbt-dragonfly-0.10.75-1.src.rpm
checksum_type: sha256
description:
  ![Dragonfly](http://www.ladybug.tools/assets/img/dragonfly.png)

  [![Build Status](https://github.com/ladybug-tools/lbt-dragonfly/workflows/CI/badge.svg)](https://github.com/ladybug-tools/lbt-dragonfly/actions)

  [![Python 2.7](https://img.shields.io/badge/python-2.7-green.svg)](https://www.python.org/downloads/release/python-270/) [![Python 3.6](https://img.shields.io/badge/python-3.6-blue.svg)](https://www.python.org/downloads/release/python-360/) [![IronPython](https://img.shields.io/badge/ironpython-2.7-red.svg)](https://github.com/IronLanguages/ironpython2/releases/tag/ipy-2.7.8/)



  Collection of all Dragonfly core Python libraries.

  Note that this repository and corresponding Python package does not contain any source
  code and it simply exists to provide a shortcut for installing all of the dragonfly
  core libraries and extensions together.



  Running `pip install lbt-dragonfly` will result in the installation of the following
  dragonfly Python packages:

  * [dragonfly-energy](https://github.com/ladybug-tools/dragonfly-energy)
  * [dragonfly-uwg](https://github.com/ladybug-tools/dragonfly-uwg)
  * [dragonfly-doe2](https://github.com/ladybug-tools/dragonfly-doe2)



  Since both dragonfly extensions use the dragonfly core libraries, the following
  dependencies are also included:

  * [dragonfly-core](https://github.com/ladybug-tools/dragonfly-core)
  * [dragonfly-schema](https://github.com/ladybug-tools/dragonfly-schema)



  Since dragonfly uses ladybug and honeybee, the following dependencies are also included:

  * [lbt-ladybug](https://github.com/ladybug-tools/lbt-ladybug)
  * [lbt-honeybee](https://github.com/ladybug-tools/lbt-honeybee)


pkgId: 029e184289133945542ab8088a8e7ff91bc2384e67b22c31ec903b7ea7bfbd1b
name: python-lbt-honeybee
arch: src
version: 0.7.188
epoch: 0
release: 1
summary: Installs a collection of all Honeybee core Python libraries.
url: https://github.com/ladybug-tools/lbt-honeybee
rpm_license: AGPL-3.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-68ff5af1-b0b8-4cbf-a0af-8fe387a32bb8
location_href: 00012668-python-lbt-honeybee/python-lbt-honeybee-0.7.188-1.src.rpm
checksum_type: sha256
description:
  ![Honeybee](http://www.ladybug.tools/assets/img/honeybee.png)

  [![Build Status](https://github.com/ladybug-tools/lbt-honeybee/workflows/CI/badge.svg)](https://github.com/ladybug-tools/lbt-honeybee/actions)

  [![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/)



  A collection of Honeybee core Python libraries and extensions.

  Note that this Python package and corresponding repository does not contain any source
  code and it simply exists to provide a shortcut for installing all of the honeybee
  extension packages together.



  ```console
  pip install -U lbt-honeybee
  ```



  Running `pip install lbt-honeybee -U` will result in the installation of the following
  honeybee Python packages:

  * [honeybee-radiance](https://github.com/ladybug-tools/honeybee-radiance)
  * [honeybee-radiance-postprocess](https://github.com/ladybug-tools/honeybee-radiance-postprocess)
  * [honeybee-radiance-folder](https://github.com/ladybug-tools/honeybee-radiance-folder)
  * [honeybee-radiance-command](https://github.com/ladybug-tools/honeybee-radiance-command)
  * [honeybee-energy](https://github.com/ladybug-tools/honeybee-energy)
  * [honeybee-energy-standards](https://github.com/ladybug-tools/honeybee-energy-standards)
  * [honeybee-display](https://github.com/ladybug-tools/honeybee-display)



  Since both honeybee extensions use the honeybee core libraries, the following
  dependencies are also included:

  * [honeybee-core](https://github.com/ladybug-tools/honeybee-core)
  * [honeybee-schema](https://github.com/ladybug-tools/honeybee-schema)



  Since honeybee uses ladybug, the following is also included:

  * [ladybug-geometry](https://github.com/ladybug-tools/ladybug-geometry)
  * [ladybug-core](https://github.com/ladybug-tools/ladybug)
  * [ladybug-comfort](https://github.com/ladybug-tools/ladybug-comfort)
  * [ladybug-display](https://github.com/ladybug-tools/ladybug-display)


pkgId: ffb68a2ff251ae1fbbeea59ac542b4adcbf14f52ca8ba37ee9d868674a27c475
name: python-ldap3
arch: src
version: 2.9.1
epoch: 0
release: 1
summary: A strictly RFC 4510 conforming LDAP V3 pure Python client library
url: https://github.com/cannatag/ldap3
rpm_license: LGPL v3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4ef89906-423c-414e-bed1-8ac3ec6cd666
location_href: 00004055-python-ldap3/python-ldap3-2.9.1-1.src.rpm
checksum_type: sha256
description:
  ldap3 is a strictly RFC 4510 conforming **LDAP V3 pure Python client** library. The same codebase runs in Python 2, Python 3, PyPy and PyPy3.


pkgId: b29a0dcbf42584309f1c703f34b83cb0e5522a9fdbac5b4e503d36b429bff526
name: python-ldappool
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: A simple connector pool for python-ldap.
url: https://opendev.org/openstack/ldappool
rpm_license: Mozilla Public License 2.0 (MPL 2.0)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-192a65e2-9052-45c4-ac5a-9a08bf2781c3
location_href: 00004057-python-ldappool/python-ldappool-3.0.0-1.src.rpm
checksum_type: sha256
description:
  A simple connector pool for python-ldap.
  The pool keeps LDAP connectors alive and let you reuse them,
  drastically reducing the time spent to initiate a ldap connection.
  The pool has useful features like:
  - transparent reconnection on failures or server restarts
  - configurable pool size and connectors timeouts
  - configurable max lifetime for connectors
  - a context manager to simplify acquiring and releasing a connector
  **You need python-ldap in order to use this library**
  Quickstart
  To work with the pool, you just need to create it, then use it as a
  context manager with the *connection* method::
      from ldappool import ConnectionManager
      cm = ConnectionManager('ldap://localhost')
      with cm.connection('uid=adminuser,ou=logins,dc=mozilla', 'password') as conn:
  The connector returned by *connection* is a LDAPObject, that's binded to the
  server. See https://pypi.org/project/python-ldap/ for details on how to use a connector.
  It is possible to check the state of the pool by representing the pool as a string::
      from ldappool import ConnectionManager
      cm = ConnectionManager('ldap://localhost', size=2)
      print(cm)
  This will result in output similar to this table::
      +--------------+-----------+----------+------------------+--------------------+------------------------------+
      | Slot (2 max) | Connected |  Active  |       URI        | Lifetime (600 max) |           Bind DN            |
      +--------------+-----------+----------+------------------+--------------------+------------------------------+
      |      1       | connected | inactive | ldap://localhost |  0.00496101379395  | uid=tuser,dc=example,dc=test |
      |      2       | connected | inactive | ldap://localhost |  0.00532603263855  | uid=tuser,dc=example,dc=test |
      +--------------+-----------+----------+------------------+--------------------+------------------------------+
  ConnectionManager options
  Here are the options you can use when instanciating the pool:
  - **uri**: ldap server uri **[mandatory]**
  - **bind**: default bind that will be used to bind a connector.
    **default: None**
  - **passwd**: default password that will be used to bind a connector.
    **default: None**
  - **size**: pool size. **default: 10**
  - **retry_max**: number of attempts when a server is down. **default: 3**
  - **retry_delay**: delay in seconds before a retry. **default: .1**
  - **use_tls**: activate TLS when connecting. **default: False**
  - **timeout**: connector timeout. **default: -1**
  - **use_pool**: activates the pool. If False, will recreate a connector
    each time. **default: True**
  The **uri** option will accept a comma or whitespace separated list of LDAP
  server URIs to allow for failover behavior when connection errors are
  encountered.  Connections will be attempted against the servers in order,
  with **retry_max** attempts per URI before failing over to the next server.
  The **connection** method takes two options:
  - **bind**: bind used to connect. If None, uses the pool default's.
    **default: None**
  - **passwd**: password used to connect. If None, uses the pool default's.
    **default: None**


pkgId: c687fe330b132ef5bb7a771ab940a08ade8e6e4f2858bd7772cc3f06a1092295
name: python-leather
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: Python charting for 80% of humans.
url: http://leather.readthedocs.io/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-abe220b0-394c-4642-8161-32eca8e6f403
location_href: 00004061-python-leather/python-leather-0.3.4-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://travis-ci.org/wireservice/leather.png
      :target: https://travis-ci.org/wireservice/leather
      :alt: Build status

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

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

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

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

  Leather is the Python charting library for those who need charts *now* and don't care if they're perfect.

  Leather isn't picky. It's rough. It gets dirty. It looks sexy just hanging on the back of a chair. Leather doesn't need your accessories. Leather is how Snake Plissken would make charts.

  Get it?

  Important links:

  * Documentation:    http://leather.rtfd.io
  * Repository:       https://github.com/wireservice/leather
  * Issues:           https://github.com/wireservice/leather/issues


pkgId: 35376189b469f39dca3cbe89d0ea3168dc70d0ef13aed50431bbd2a1004c0ad1
name: python-lenses
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: A lens library for python
url: https://github.com/ingolemo/python-lenses
rpm_license: GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5f6055c2-b291-4bae-953b-2144c7d71269
location_href: 00010908-python-lenses/python-lenses-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Lenses is a python library that helps you to manipulate large
  data-structures without mutating them. It is inspired by the lenses in
  Haskell, although it's much less principled and the api is more suitable
  for python.


pkgId: 038225f44cef58a3b519d36354228d11e8f351e20d3c6a99f92d61b4b508c58a
name: python-lesscpy
arch: src
version: 0.15.1
epoch: 0
release: 1
summary: Python LESS compiler
url: https://github.com/lesscpy/lesscpy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5aea7502-6977-4752-9f63-a968afd233c5
location_href: 00004062-python-lesscpy/python-lesscpy-0.15.1-1.src.rpm
checksum_type: sha256
description:
  Python LESS Compiler.
  A compiler written in Python for the LESS language. For those of us not willing
  or able to have node.js installed in our environment. Not all features of LESS
  are supported (yet). Some features wil probably never be supported (JavaScript
  evaluation). This program uses PLY (Python Lex-Yacc) to tokenize / parse the
  input and is considerably slower than the NodeJS compiler. The plan is to
  utilize this to build in proper syntax checking and perhaps YUI compressing.
  This is an early version, so you are likely to find bugs.
  For more information on LESS:
    http://lesscss.org/ or https://github.com/cloudhead/less.js
  Development files:
    https://github.com/lesscpy/lesscpy


pkgId: bb5d583ed3d4e9394ab384c0bdd514288486af9cc46b615abc1429ec455a7b6e
name: python-lexicon
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Powerful dict subclass(es) with aliasing & attribute access
url: https://github.com/bitprophet/lexicon#what
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4aa228d1-5b0e-464f-abc4-4b0f3a921240
location_href: 00004064-python-lexicon/python-lexicon-2.0.1-1.src.rpm
checksum_type: sha256
description:
  Lexicon is a simple collection of Python ``dict`` subclasses providing extra
  power:
  - ``AliasDict``, a dictionary supporting both simple and complex key aliasing:
      - Alias a single key to another key, so that e.g. ``mydict['bar']`` points
        to ``mydict['foo']``, for both reads and writes.
      - Alias a single key to a list of other keys, for writing only, e.g. with
        ``active_groups = AliasDict({'ops': True, 'biz': True, 'dev': True,
        'product': True})`` one can make an alias ``'tech'`` mapping to ``('ops',
        'dev')`` and then e.g. ``active_groups['tech'] = False``.
      - Aliasing is recursive: an alias pointing to another alias will behave as
        if it points to the other alias' target.
  - ``AttributeDict``, supporting attribute read & write access, e.g. ``mydict =
    AttributeDict({'foo': 'bar'})`` exhibits ``mydict.foo`` and ``mydict.foo =
    'new value'``.
  - ``Lexicon``, a subclass of both of the above which exhibits both sets of
    behavior.


pkgId: ae78b517847db81a1ce22fde1c3b71d45b124502ddcfdba7b02535b91ccc90de
name: python-libNeuroML
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: A Python library for working with NeuroML descriptions of neuronal models
url: http://libneuroml.readthedocs.org/en/latest/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-09cb4344-e350-4600-9342-7c8aae0557a2
location_href: 00004068-python-libNeuroML/python-libNeuroML-0.4.1-1.src.rpm
checksum_type: sha256
description:
  [![GH Build](https://github.com/NeuralEnsemble/libNeuroML/actions/workflows/ci.yml/badge.svg)](https://github.com/NeuralEnsemble/libNeuroML/actions/workflows/ci.yml)
  [![Documentation Status](https://readthedocs.org/projects/libneuroml/badge/?version=latest)](https://libneuroml.readthedocs.io/en/latest/?badge=latest)
  [![PyPI](https://img.shields.io/pypi/v/libNeuroML)](https://pypi.org/project/libNeuroML/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/libNeuroML)](https://pypi.org/project/libNeuroML/)
  [![GitHub](https://img.shields.io/github/license/NeuralEnsemble/libNeuroML)](https://github.com/NeuralEnsemble/libNeuroML/blob/master/LICENSE)
  [![GitHub pull requests](https://img.shields.io/github/issues-pr/NeuralEnsemble/libNeuroML)](https://github.com/NeuralEnsemble/libNeuroML/pulls)
  [![GitHub issues](https://img.shields.io/github/issues/NeuralEnsemble/libNeuroML)](https://github.com/NeuralEnsemble/libNeuroML/issues)
  [![GitHub Org's stars](https://img.shields.io/github/stars/NeuralEnsemble?style=social)](https://github.com/NeuralEnsemble)
  [![Twitter Follow](https://img.shields.io/twitter/follow/NeuroML?style=social)](https://twitter.com/NeuroML)
  [![Gitter](https://badges.gitter.im/NeuroML/community.svg)](https://gitter.im/NeuroML/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)

  This package provides Python libNeuroML, for working with neuronal models specified in [NeuroML 2](http://neuroml.org/neuromlv2).

  For more about libNeuroML see:

  Michael Vella, Robert C. Cannon, Sharon Crook, Andrew P. Davison, Gautham Ganapathy, Hugh P. C. Robinson, R. Angus Silver and Padraig Gleeson,
  **libNeuroML and PyLEMS: using Python to combine procedural and declarative modeling approaches in computational neuroscience**
  [Frontiers in Neuroinformatics 2014](http://journal.frontiersin.org/Journal/10.3389/fninf.2014.00038/abstract), doi: 10.3389/fninf.2014.00038

  _**PLEASE CITE THE PAPER ABOVE IF YOU USE libNeuroML!**_

  Documentation is available at http://readthedocs.org/docs/libneuroml/en/latest/

  For installation instructions, see http://readthedocs.org/docs/libneuroml/en/latest/install.html

  For an overview of all NeuroML related libraries/documentation/publications see https://docs.neuroml.org



  A related package, **[pyNeuroML](https://github.com/NeuroML/pyNeuroML)** builds on this and provides functionality, scripts and modules for reading, writing, **simulating** and analysing NeuroML2/LEMS models.

  pyNeuroML builds on: [libNeuroML](https://github.com/NeuralEnsemble/libNeuroML) & [PyLEMS](https://github.com/LEMS/pylems) and wraps functionality from [jNeuroML](https://github.com/NeuroML/jNeuroML).




  Most of the work happens in the [development branch](https://github.com/NeuralEnsemble/libNeuroML/tree/development).
  That branch is kept up to date with the development branches for [NeuroML 2](https://github.com/NeuroML/NeuroML2/tree/development) and related libraries.
  See https://docs.neuroml.org/ for an overview of the various NeuroML libraries.




  - Enable Python 3.10 support
  - Regenerate nml.py with generateDS using Python 3
  - Add generic `add` method to all NeuroML ComponentType classes that allows users to easily construct their NeuroML documents.
  - Improve unit tests
  - DEPRECATION notice: `append_to_element` will be deprecated in future releases, please use the `add` method instead



  - Documentation updates for RTD and other minor fixes.



  - Patch release with minor changes under the hood.
  - Use PyTest for testing.
  - Enable CI on GitHub Actions



  - Using Schema for NeuroML v2.1. Better compatibility with Python 3



  - Updated to use the final stable Schema for NeuroML v2.0



  - Updated to use the final stable Schema for NeuroML v2beta5



  - Updated to use the final stable Schema for NeuroML v2beta4
  - Tested with Python 3



  - Updated to use the Schema for NeuroML v2beta4



  - Updated to use the Schema for NeuroML v2beta3
  - Ensures numpy & pytables are only required when using non-XML loaders/writers



  - Updated to use the Schema for NeuroML v2beta2



  - Minor release: Update to latest schema



  - Several Bug fixes and small enhamcements
  - Support for latest NeuroML schema (see change outline)
  - JSON serialization
  - MongoDB backend
  - HDF5 serialization
  - Improved installation process
  - All usage examples are now run on the Travis-CI continuous integration server to confirm that that they do not error.
  - Schema validation utility
  - Improved documentation and documentation new look


  :copyright: Copyright 2021 by the libNeuroML team, see [AUTHORS](AUTHORS). Modified BSD License, see [LICENSE](LICENSE) for details.


  [![Build Status](https://api.travis-ci.org/NeuralEnsemble/libNeuroML.png)](https://travis-ci.org/NeuralEnsemble/libNeuroML)


pkgId: 023efcb88696a89fcc1109eaddf44536bf7957bf5c016aeb190c5c5fdf37a897
name: python-libevdev
arch: src
version: 0.11
epoch: 0
release: 1
summary: Python wrapper for libevdev
url: https://gitlab.freedesktop.org/libevdev/python-libevdev
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-aa9aa675-fffd-4dab-adba-a94f44f343ca
location_href: 00004075-python-libevdev/python-libevdev-0.11-1.src.rpm
checksum_type: sha256
description:
  python-libevdev is a Python wrapper around the libevdev C library. It
  provides a Pythonic API to read events from the Linux kernel's input device
  nodes and to read and/or modify the device's state and capabilities.

  The documentation is available here:
  https://python-libevdev.readthedocs.io/en/latest/


pkgId: ecf3c9b15147d2bed3d13e9275a414bad668c1f07f273295ac121bcbeb352609
name: python-libhoney
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: Python library for sending data to Honeycomb
url: https://github.com/honeycombio/libhoney-py
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ae35291a-2dc5-4a96-9c45-5c16f6d6e6bf
location_href: 00011652-python-libhoney/python-libhoney-2.3.0-1.src.rpm
checksum_type: sha256
description:
  [![OSS Lifecycle](https://img.shields.io/osslifecycle/honeycombio/libhoney-py?color=success)](https://github.com/honeycombio/home/blob/main/honeycomb-oss-lifecycle-and-practices.md)
  [![Build Status](https://circleci.com/gh/honeycombio/libhoney-py.svg?style=svg)](https://app.circleci.com/pipelines/github/honeycombio/libhoney-py)

  Python library for sending events to [Honeycomb](https://honeycomb.io), a service for debugging your software in production.

  - [Usage and Examples](https://docs.honeycomb.io/sdk/python/)

  For tracing support and automatic instrumentation of Django, Flask, AWS Lambda, and other frameworks, check out our [Beeline for Python](https://github.com/honeycombio/beeline-python).



  Features, bug fixes and other changes to libhoney are gladly accepted. Please
  open issues or a pull request with your change. Remember to add your name to the
  CONTRIBUTORS file!

  All contributions will be released under the Apache License 2.0.



  You may need to install the `bump2version` utility by running `pip install bump2version`.

  To update the version number, do

  ```
  bump2version [major|minor|patch|release|build]
  ```

  If you want to release the version publicly, you will need to manually create a tag `v<x.y.z>` and push it in order to
  cause CircleCI to automatically push builds to github releases and PyPI.


pkgId: 62104d7f6496376dabed38d6f12d571f7019bf9419d605f5afd3de77299c1629
name: python-libify
arch: src
version: 0.78
epoch: 0
release: 1
summary: Import Databricks notebooks as libraries/modules
url: https://github.com/vagrantism/libify
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a46f28d3-9d1e-4156-92d6-446041687d8e
location_href: 00010130-python-libify/python-libify-0.78-1.src.rpm
checksum_type: sha256
description:
  ![Build/Push Pipeline](https://github.com/vagrantism/libify/workflows/Build%20and%20Publish%20to%20PyPI%20and%20TestPyPI/badge.svg) ![GitHub issues](https://img.shields.io/github/issues/vagrantism/libify) ![PyPI - Format](https://img.shields.io/pypi/format/libify) ![PyPI version](https://badge.fury.io/py/libify.svg) ![GitHub last commit](https://img.shields.io/github/last-commit/vagrantism/libify) ![GitHub tag (latest by date)](https://img.shields.io/github/v/tag/vagrantism/libify) ![visitors](https://visitor-badge.laobi.icu/badge?page_id=libify_main_ctr) ![Downloads](https://pepy.tech/badge/libify)


pkgId: 3d84e0889556fb3235efa566c616109a4573d4d71574f5b549db54759a187781
name: python-libpysal
arch: src
version: 4.7.0
epoch: 0
release: 1
summary: Core components of PySAL A library of spatial analysis functions.
url: http://pysal.org/libpysal
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8632763e-0657-44bf-b19d-de5c4076d679
location_href: 00004092-python-libpysal/python-libpysal-4.7.0-1.src.rpm
checksum_type: sha256
description:
  ****************
  libpysal modules
  ****************
  - libpysal.cg  Computational geometry
  - libpysal.io  Input and output
  - libpysal.weights  Spatial weights
  - libpysal.examples  Built-in example datasets
  *****************
  Example Notebooks
  *****************
  - `Spatial Weights  <notebooks/weights.ipynb>`_
  - `Voronoi  <notebooks/voronoi.ipynb>`_
  - `Input and Output <notebooks/io.ipynb>`_
  ***********
  Development
  ***********
  libpysal development is hosted on github_.
  Discussions of development occurs on the
  `developer list <http://groups.google.com/group/pysal-dev>`_
  as well as gitter_.
  ************
  Contributing
  ************
  PySAL-libpysal is under active development and contributors are welcome.
  If you have any suggestions, feature requests, or bug reports,
  please open new `issues <https://github.com/pysal/libpysal/issues>`_ on GitHub.
  To submit patches, please review `PySAL's documentation for developers <https://pysal.org/docs/devs/>`_,
  the PySAL `development guidelines <https://github.com/pysal/pysal/wiki>`_,
  the `libpysal contributing guidelines <https://github.com/pysal/libpysal/blob/master/.github/CONTRIBUTING.md>`_
  before  opening a `pull request <https://github.com/pysal/libpysal/pulls>`_.
  Once your changes get merged, you’ll automatically be added to
  the `Contributors List <https://github.com/pysal/libpysal/graphs/contributors>`_.
  ***********
  Bug reports
  ***********
  To search for or report bugs, please see `libpysal's issues <https://github.com/pysal/libpysal/issues>`_.
  *******************
  License information
  *******************
  See the `LICENSE <https://github.com/pysal/libpysal/blob/master/LICENSE.txt>`_
  for information on the history of this software, terms & conditions for usage,
  and a DISCLAIMER OF ALL WARRANTIES.


pkgId: 4610984f10332dc2b765868f096f4243cd530433fa7d20a119e8da376d6939ba
name: python-libs
arch: src
version: 0.0.10
epoch: 0
release: 1
summary: Packages of tools
url: https://github.com/phyng/libs
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c34a0c1d-55e1-4a8e-b83b-6a293ebff862
location_href: 00004097-python-libs/python-libs-0.0.10-1.src.rpm
checksum_type: sha256
description:
  Some library to extend Python Standard Library

  [![Github](https://github.com/phyng/libs/workflows/test/badge.svg)](https://github.com/phyng/libs/actions) [![Pypi](https://img.shields.io/pypi/v/libs.svg?style=flat&label=PyPI)](https://pypi.org/project/libs/)



  https://phyng.com/libs/



  ```bash

  pip install libs


  poetry add libs
  ```



  ```bash
  npm test
  npm test_coverage
  ```


pkgId: 2f625c5b187dc5d2dcf00ca604016024d0bc2cc2f4d33c4ef04883bc476bac0c
name: python-libsass
arch: src
version: 0.22.0
epoch: 0
release: 1
summary: Sass for Python: A straightforward binding of libsass for Python.
url: https://sass.github.io/libsass-python/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d4349636-a906-4a61-a25d-5244a6fae0f7
location_href: 00004099-python-libsass/python-libsass-0.22.0-1.src.rpm
checksum_type: sha256
description:
  This package provides a simple Python extension module ``sass`` which is
  binding LibSass_ (written in C/C++ by Hampton Catlin and Aaron Leung).
  It's very straightforward and there isn't any headache related Python
  distribution/deployment.  That means you can add just ``libsass`` into
  your ``setup.py``'s ``install_requires`` list or ``requirements.txt`` file.
  No need for Ruby nor Node.js.
  It currently supports CPython 3.6+, and PyPy 3!


pkgId: 061a7b8227add5570f950552b3753001b2709426d9d729f035a993c875c319fa
name: python-libsass-debuginfo
arch: aarch64
version: 0.22.0
epoch: 0
release: 1
summary: Debug information for package python-libsass
url: https://sass.github.io/libsass-python/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-d4349636-a906-4a61-a25d-5244a6fae0f7
rpm_sourcerpm: python-libsass-0.22.0-1.src.rpm
location_href: 00004099-python-libsass/python-libsass-debuginfo-0.22.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-libsass.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: e5b8d7575c95410b4117c5035dcd27e4792674cb728d4a78f03cc7e91c09d32a
name: python-libsass-debugsource
arch: aarch64
version: 0.22.0
epoch: 0
release: 1
summary: Debug sources for package python-libsass
url: https://sass.github.io/libsass-python/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-d4349636-a906-4a61-a25d-5244a6fae0f7
rpm_sourcerpm: python-libsass-0.22.0-1.src.rpm
location_href: 00004099-python-libsass/python-libsass-debugsource-0.22.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-libsass.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 673063200d138af3e674f370daffd29d3af46d34573e53eb7e9e43e74910ff35
name: python-libtmux
arch: src
version: 0.21.0
epoch: 0
release: 1
summary: Typed scripting library / ORM / API wrapper for tmux
url: http://github.com/tmux-python/libtmux/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dc998806-bd1f-4622-87ef-412f7a284495
location_href: 00004106-python-libtmux/python-libtmux-0.21.0-1.src.rpm
checksum_type: sha256
description:
          \   ^__^
           \  (oo)\_______
              (__)\       )\/\
                  ||----w |
                  ||     ||
  ```
  Traverse and navigate:
  ```python
  >>> pane.window
  Window(@1 1:..., Session($1 ...))
  >>> pane.window.session
  Session($1 ...)
  ```

  Unsupported / no security releases or bug fixes:
  - Python 2.x: The backports branch is
    [`v0.8.x`](https://github.com/tmux-python/libtmux/tree/v0.8.x).

  Your donations fund development of new features, testing and support.
  Your money will go directly to maintenance and development of the
  project. If you are an individual, feel free to give whatever feels
  right for the value you get out of the project.
  See donation options at <https://git-pull.com/support.html>.

  - tmux support: 1.8+
  - python support: >= 3.7, pypy, pypy3
  - Source: <https://github.com/tmux-python/libtmux>
  - Docs: <https://libtmux.git-pull.com>
  - API: <https://libtmux.git-pull.com/api.html>
  - Changelog: <https://libtmux.git-pull.com/history.html>
  - Issues: <https://github.com/tmux-python/libtmux/issues>
  - Test Coverage: <https://codecov.io/gh/tmux-python/libtmux>
  - pypi: <https://pypi.python.org/pypi/libtmux>
  - Open Hub: <https://www.openhub.net/p/libtmux-python>
  - Repology: <https://repology.org/project/python:libtmux/versions>
  - License: [MIT](http://opensource.org/licenses/MIT).


pkgId: df8568e9e5fdcfe1807f4859c95008f9cbe8427f9e1226dae390e676d7685953
name: python-libusb1
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Pure-python wrapper for libusb-1.0
url: https://github.com/vpelletier/python-libusb1
rpm_license: LGPLv2.1+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-811d8bd8-050b-43f9-8615-2b6d6e23451e
location_href: 00004108-python-libusb1/python-libusb1-3.0.0-1.src.rpm
checksum_type: sha256
description:
  - CPython_ 3.6+, pypy_ 2.0+. Older versions may work, but are not
    recommended as there is no automated regression testing set up for them.
  - libusb-1.0_


pkgId: bae32d275c169c74a55c7dab66f5e9f1776fb464d4495d12cfb28e638c672def
name: python-lifelines
arch: src
version: 0.27.4
epoch: 0
release: 1
summary: Survival analysis in Python, including Kaplan Meier, Nelson Aalen and regression
url: https://github.com/CamDavidsonPilon/lifelines
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cc519ccf-c7c5-471d-ae52-1611755bc129
location_href: 00010344-python-lifelines/python-lifelines-0.27.4-1.src.rpm
checksum_type: sha256
description:
  ![](http://i.imgur.com/EOowdSD.png)

  [![PyPI version](https://badge.fury.io/py/lifelines.svg)](https://badge.fury.io/py/lifelines)
  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/lifelines/badges/version.svg
  )](https://conda.anaconda.org/conda-forge)
  [![DOI](https://zenodo.org/badge/12420595.svg)](https://zenodo.org/badge/latestdoi/12420595)


  [What is survival analysis and why should I learn it?](http://lifelines.readthedocs.org/en/latest/Survival%20Analysis%20intro.html)
   Survival analysis was originally developed and applied heavily by the actuarial and medical community. Its purpose was to answer *why do events occur now versus later* under uncertainty (where *events* might refer to deaths, disease remission, etc.). This is great for researchers who are interested in measuring lifetimes: they can answer questions like *what factors might influence deaths?*

  But outside of medicine and actuarial science, there are many other interesting and exciting applications of survival analysis. For example:
  - SaaS providers are interested in measuring subscriber lifetimes, or time to some first action
  - inventory stock out is a censoring event for true "demand" of a good.
  - sociologists are interested in measuring political parties' lifetimes, or relationships, or marriages
  - A/B tests to determine how long it takes different groups to perform an action.

  *lifelines* is a pure Python implementation of the best parts of survival analysis.




  If you are new to survival analysis, wondering why it is useful, or are interested in *lifelines* examples, API, and syntax, please read the [Documentation and Tutorials page](http://lifelines.readthedocs.org/en/latest/index.html)


   - Start a conversation in our [Discussions room](https://github.com/CamDavidsonPilon/lifelines/discussions).
   - Some users have posted common questions at [stats.stackexchange.com](https://stats.stackexchange.com/search?tab=votes&q=%22lifelines%22%20is%3aquestion)
   - creating an issue in the [Github repository](https://github.com/camdavidsonpilon/lifelines).



  See our [Contributing](https://github.com/CamDavidsonPilon/lifelines/blob/master/.github/CONTRIBUTING.md) guidelines.


pkgId: a9c0171e46268042fe16657166b7e914e34a9dc9884c935ee78b068aaf74edd8
name: python-linkify-it-py
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Links recognition library with FULL unicode support.
url: https://github.com/tsutsu3/linkify-it-py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-76eb86de-b9cb-4b10-bfbb-321c784bc2f0
location_href: 00012928-python-linkify-it-py/python-linkify-it-py-2.0.0-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/tsutsu3/linkify-it-py/workflows/CI/badge.svg?branch=main)](https://github.com/tsutsu3/linkify-it-py/actions)
  [![pypi](https://img.shields.io/pypi/v/linkify-it-py)](https://pypi.org/project/linkify-it-py/)
  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/linkify-it-py/badges/version.svg)](https://anaconda.org/conda-forge/linkify-it-py)
  [![codecov](https://codecov.io/gh/tsutsu3/linkify-it-py/branch/main/graph/badge.svg)](https://codecov.io/gh/tsutsu3/linkify-it-py)
  [![Maintainability](https://api.codeclimate.com/v1/badges/6341fd3ec5f05fde392f/maintainability)](https://codeclimate.com/github/tsutsu3/linkify-it-py/maintainability)

  This is Python port of [linkify-it](https://github.com/markdown-it/linkify-it).

  > Links recognition library with FULL unicode support.
  > Focused on high quality link patterns detection in plain text.

  __[Javascript Demo](http://markdown-it.github.io/linkify-it/)__

  Why it's awesome:

  - Full unicode support, _with astral characters_!
  - International domains support.
  - Allows rules extension & custom normalizers.




  ```bash
  pip install linkify-it-py
  ```

  or

  ```bash
  conda install -c conda-forge linkify-it-py
  ```





  ```python
  from linkify_it import LinkifyIt


  linkify = LinkifyIt()

  print(linkify.test("Site github.com!"))


  print(linkify.match("Site github.com!"))








  ```



  ```python
  from linkify_it import LinkifyIt
  from linkify_it.tlds import TLDS



  linkify = (
      LinkifyIt()
      .tlds(TLDS)               # Reload with full tlds list
      .tlds("onion", True)      # Add unofficial `.onion` domain
      .add("git:", "http:")     # Add `git:` protocol as "alias"
      .add("ftp:", None)        # Disable `ftp:` protocol
      .set({"fuzzy_ip": True})  # Enable IPs in fuzzy links (without schema)
  )
  print(linkify.test("Site tamanegi.onion!"))


  print(linkify.match("Site tamanegi.onion!"))








  ```



  ```python
  from linkify_it import LinkifyIt


  linkify = LinkifyIt()

  def validate(obj, text, pos):
      tail = text[pos:]

      if not obj.re.get("twitter"):
          obj.re["twitter"] = re.compile(
              "^([a-zA-Z0-9_]){1,15}(?!_)(?=$|" + obj.re["src_ZPCc"] + ")"
          )
      if obj.re["twitter"].search(tail):
          if pos > 2 and tail[pos - 2] == "@":
              return False
          return len(obj.re["twitter"].search(tail).group())
      return 0

  def normalize(obj, match):
      match.url = "https://twitter.com/" + re.sub(r"^@", "", match.url)

  linkify.add("@", {"validate": validate, "normalize": normalize})
  ```




  [API documentation](https://linkify-it-py.readthedocs.io/en/latest/)



  Creates new linkifier instance with optional additional schemas.

  By default understands:

  - `http(s)://...` , `ftp://...`, `mailto:...` & `//...` links
  - "fuzzy" links and emails (google.com, foo@bar.com).

  `schemas` is an dict, where each key/value describes protocol/rule:

  - __key__ - link prefix (usually, protocol name with `:` at the end, `skype:`
    for example). `linkify-it-py` makes sure that prefix is not preceded with
    alphanumeric char.
  - __value__ - rule to check tail after link prefix
    - _str_
      - just alias to existing rule
    - _dict_
      - _validate_ - either a `re.Pattern` (start with `^`, and don't include the
        link prefix itself), or a validator `function` which, given arguments
        _self_, _text_ and _pos_, returns the length of a match in _text_
        starting at index _pos_.  _pos_ is the index right after the link prefix.
        _self_ can be used to access the linkify object to cache data.
      - _normalize_ - optional function to normalize text & url of matched result
        (for example, for twitter mentions).

  `options`:

  - __fuzzy_link__ - recognize URL-s without `http(s)://` head. Default `True`.
  - __fuzzy_ip__ - allow IPs in fuzzy links above. Can conflict with some texts
    like version numbers. Default `False`.
  - __fuzzy_email__ - recognize emails without `mailto:` prefix. Default `True`.
  - __---__ - set `True` to terminate link with `---` (if it's considered as long dash).




  Searches linkifiable pattern and returns `True` on success or `False` on fail.




  Quick check if link MAY BE can exist. Can be used to optimize more expensive
  `.test()` calls. Return `False` if link can not be found, `True` - if `.test()`
  call needed to know exactly.




  Similar to `.test()` but checks only specific protocol tail exactly at given
  position. Returns length of found pattern (0 on fail).




  Returns `list` of found link matches or null if nothing found.

  Each match has:

  - __schema__ - link schema, can be empty for fuzzy links, or `//` for
    protocol-neutral links.
  - __index__ - offset of matched text
  - __last_index__ - index of next char after mathch end
  - __raw__ - matched text
  - __text__ - normalized text
  - __url__ - link, generated from matched text



  Checks if a match exists at the start of the string. Returns `Match`
  (see docs for `match(text)`) or null if no URL is at the start.
  Doesn't work with fuzzy links.



  Load (or merge) new tlds list. Those are needed for fuzzy links (without schema)
  to avoid false positives. By default:

  - 2-letter root zones are ok.
  - biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф are ok.
  - encoded (`xn--...`) root zones are ok.

  If that's not enough, you can reload defaults with more detailed zones list.



  Add a new schema to the schemas object. As described in the constructor
  definition, `key` is a link prefix (`skype:`, for example), and `value`
  is a `str` to alias to another schema, or an `dict` with `validate` and
  optionally `normalize` definitions.  To disable an existing rule, use
  `.add(key, None)`.




  Override default options. Missed properties will not be changed.




  [MIT](https://github.com/tsutsu3/linkify-it-py/blob/master/LICENSE)


pkgId: caef403e960f5fe2d7b1e875498fecdf6dfece59099c4979986497ef27d83283
name: python-liquidctl
arch: src
version: 1.12.1
epoch: 0
release: 1
summary: Cross-platform tool and drivers for liquid coolers and other devices
url: https://github.com/liquidctl/liquidctl
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-da2dc455-8492-4ce5-9f8d-a37e2c506160
location_href: 00004115-python-liquidctl/python-liquidctl-1.12.1-1.src.rpm
checksum_type: sha256
description:
  Cross-platform tool and drivers for liquid coolers and other devices.

  Go to the [project homepage] for more information.

  ```
  $ liquidctl list
  Device #0: Corsair Vengeance RGB DIMM2
  Device #1: Corsair Vengeance RGB DIMM4
  Device #2: NZXT Smart Device (V1)
  Device #3: NZXT Kraken X (X42, X52, X62 or X72)


  NZXT Smart Device (V1)
  ├── Firmware version             1.7
  ├── LED accessories                2
  ├── LED accessory type    HUE+ Strip
  └── LED count (total)             20

  NZXT Kraken X (X42, X52, X62 or X72)
  └── Firmware version    6.2


  NZXT Smart Device (V1)
  ├── Fan 1 speed            1499  rpm
  ├── Fan 1 voltage         11.91  V
  ├── Fan 1 current          0.05  A
  ├── Fan 1 control mode      PWM
  ├── Fan 2 [...]
  ├── Fan 3 [...]
  └── Noise level              61  dB

  NZXT Kraken X (X42, X52, X62 or X72)
  ├── Liquid temperature    34.7  °C
  ├── Fan speed              798  rpm
  └── Pump speed            2268  rpm


  Corsair Vengeance RGB DIMM2
  └── Temperature    37.5  °C

  Corsair Vengeance RGB DIMM4
  └── Temperature    37.8  °C





  ```

  [project homepage]: https://github.com/liquidctl/liquidctl


pkgId: b83b67f249e0e601b9235f6ae315992fab9dcc7572c1235a9f114b44dc185056
name: python-litecli
arch: src
version: 1.9.0
epoch: 0
release: 1
summary: CLI for SQLite Databases with auto-completion and syntax highlighting.
url: https://github.com/dbcli/litecli
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-704a8227-58f3-4774-8a4a-af86bb8e5dc7
location_href: 00004117-python-litecli/python-litecli-1.9.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/dbcli/litecli.svg?branch=master)](https://travis-ci.org/dbcli/litecli)

  [Docs](https://litecli.com)

  A command-line client for SQLite databases that has auto-completion and syntax highlighting.

  ![Completion](screenshots/litecli.png)
  ![CompletionGif](screenshots/litecli.gif)



  If you already know how to install python packages, then you can install it via pip:

  You might need sudo on linux.

  ```
  $ pip install -U litecli
  ```

  The package is also available on Arch Linux through AUR in two versions: [litecli](https://aur.archlinux.org/packages/litecli/) is based the latest release (git tag) and [litecli-git](https://aur.archlinux.org/packages/litecli-git/) is based on the master branch of the git repo. You can install them manually or with an AUR helper such as `yay`:

  ```
  $ yay -S litecli
  ```
  or

  ```
  $ yay -S litecli-git
  ```

  For MacOS users, you can also use Homebrew to install it:

  ```
  $ brew install litecli
  ```



  ```
  $ litecli --help

  Usage: litecli [OPTIONS] [DATABASE]

  Examples:
    - litecli sqlite_db_name
  ```

  A config file is automatically created at `~/.config/litecli/config` at first launch. For Windows machines a config file is created at `~\AppData\Local\dbcli\litecli\config` at first launch. See the file itself for a description of all available options.



  Visit: [litecli.com/features](https://litecli.com/features)


pkgId: a9122b2913574e18728d7c33df713ad715a24d380cc803d07de1f5e025d82410
name: python-lithium-reducer
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: Lithium is an automated testcase reduction tool
url: https://github.com/MozillaSecurity/lithium
rpm_license: MPL 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7169f681-24d5-494e-9bfd-9c0fa3a567cd
location_href: 00012603-python-lithium-reducer/python-lithium-reducer-0.6.2-1.src.rpm
checksum_type: sha256
description:
  [![Task Status](https://community-tc.services.mozilla.com/api/github/v1/repository/MozillaSecurity/lithium/master/badge.svg)](https://community-tc.services.mozilla.com/api/github/v1/repository/MozillaSecurity/lithium/master/latest)
  [![codecov](https://codecov.io/gh/MozillaSecurity/lithium/branch/master/graph/badge.svg)](https://codecov.io/gh/MozillaSecurity/lithium)
  [![Matrix](https://img.shields.io/badge/dynamic/json?color=green&label=chat&query=%24.chunk[%3F(%40.canonical_alias%3D%3D%22%23fuzzing%3Amozilla.org%22)].num_joined_members&suffix=%20users&url=https%3A%2F%2Fmozilla.modular.im%2F_matrix%2Fclient%2Fr0%2FpublicRooms&style=flat&logo=matrix)](https://riot.im/app/#/room/#fuzzing:mozilla.org)
  [![PyPI](https://img.shields.io/pypi/v/lithium-reducer)](https://pypi.org/project/lithium-reducer)



  Lithium is an automated testcase reduction tool developed by [Jesse Ruderman](http://www.squarefree.com/).

  Most of what you need to know to use Lithium is in one of these pages:

  - [How to use Lithium to reduce Firefox bugs](src/lithium/docs/using-for-firefox.md).  Lithium has been used it to make reduced testcases for hundreds of Firefox crashes and assertions.
  - [How to create your own "interestingness tests"](src/lithium/docs/creating-tests.md).  Lithium is flexible enough to reduce files for complicated properties such as "parsed differently by Opera and Firefox".  Just supply a small program that determines when a given file has the property.




  By default, Lithium uses a clever algorithm that's efficient at reducing most large testcases.  For a testcase with 2048 lines, it will try removing each chunk of size 1024, permanently removing it if it is still 'interesting'.  It then does the same for each chunk of size 512, then 256, all the way down to chunks of size 1.  It then does as many additional rounds at chunk size 1 as necessary until it completes a round without removing anything, at which point the file is 1-minimal (removing any single line from the file makes it 'uninteresting').

  If *n* is the size of the testcase and *m* is the size of the 1-minimal testcase found by Lithium, then Lithium usually performs O(m &sdot; lg(n)) tests with a total test size of O(m &sdot; n).  See the [analysis of Lithium's algorithm](src/lithium/docs/algorithm.md) for more information and proofs.

  To keep *m* small, make sure Lithium's smallest removals won't introduce fatal syntax errors into the file it is trying to reduce.  For example, don't use --char when trying to reduce a long sequence of JavaScript statements, and don't feed XHTML to Lithium.  (Convert it to HTML first and let Firefox's tag-soup parser sort out the invalidity, or use serializeDOMAsScript.)




      pip install lithium-reducer
      python -m lithium [options] interestingness-test.py [arguments for interestingness test]




  <dl>

  <dt>--testcase=filename</dt>
  <dd>Tells Lithium which file to reduce.  By default, it will assume the last argument to the interestingness test is the file to reduce.</dd>

  <dt>--char (-c)<dt>
  <dd>By default, Lithium treats lines as atomic units.  This is great if each line is a JavaScript statement, but sometimes you want to go further.  Use this option to tell Lithium to treat the file as a sequence of characters instead of a sequence of lines.</dd>

  <dt>--strategy=[check-only,minimize,minimize-balanced,replace-properties-by-globals,replace-arguments-by-globals,minimize-around]</dt>
  <dd>"minimize" is the default, the algorithm described above. "check-only" tries to run Lithium to determine interestingness, without reduction. For the other strategies, check out <a href="https://github.com/MozillaSecurity/lithium/pull/2">this GitHub PR</a>.</dd>

  <dt>--repeat=[always, last, never].</dt>
  <dd>By default, Lithium only repeats at the same chunk size if it just finished the last round (e.g. chunk size 1).  You can use --repeat=always to tell it to repeat any chunk size if something was removed during the round, which can be useful for non-deterministic testcases or non-monotonic situations.  You can use --repeat=never to tell it to exit immediately after a single round at the last chunk size, which can save a little time at the risk of leaving a little bit extra in the file.</dd>

  <dt>--max=n. default: about half of the file.</dt>
  <dt>--min=n. default: 1.</dt>
  <dd>What chunk sizes to test.  Must be powers of two.  --max is useful if you're restarting Lithium after it has already gone through a few rounds.  --min is useful if you're reducing HTML and want to do the final by hand.</dd>

  <dt>--chunk-size=n</dt>
  <dd>Shortcut for "repeat=never, min=n, max=n".  --chunk-size=1 is a quick way to determine whether a file is 1-minimal, for example after making a change that you think might make some lines unnecessary.</dd>

  </dl>




  If you find a non-deterministic bug, don't despair.  Lithium will do fine as long as you make the bug happen at least 70% of the time.  You can repeat the test either within the application, by adding a loop or reload in the testcase (outside of the DDBEGIN/DDEND markers!), or outside of the application, by adding a loop to the "interestingness test" script.




  Lithium is written in [Python](https://www.python.org/) and requires Python 3.5+.



  - [Lithium's testcase reduction algorithm](src/lithium/docs/algorithm.md) is a modified version of the "ddmin" algorithm in Andreas Zeller's paper, [Simplifying and Isolating Failure-Inducing Input](https://www.st.cs.uni-saarland.de/papers/tse2002/).
  - The idea of using an external "interestingness test" program came from [Delta](http://delta.tigris.org/), a similar tool that's [used in clever ways by the GCC project](https://gcc.gnu.org/wiki/A_guide_to_testcase_reduction).
  - [timed_run](src/lithium/interestingness/timed_run.py), used by many of the "interestingness test" scripts that come with Lithium, is based on [timed_run.py](https://web.archive.org/web/20071107032840/http://bclary.com/log/2007/03/07/timed_run), which was written by [Chris Cooper](http://coop.deadsquid.com/) and [Bob Clary](https://bclary.com/).
  - The code was significantly cleaned up and modernized by Jesse Schwartzentruber and Gary Kwong in mid-2017.


pkgId: 8bcf00cbdf00e533997dc34d0a1fa8e8f764624e2fa65746321f711f77c15000
name: python-livelossplot
arch: src
version: 0.5.5
epoch: 0
release: 1
summary: Live training loss plot in Jupyter Notebook for Keras, PyTorch and others.
url: https://github.com/stared/livelossplot
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e78e333a-6513-40db-b274-ae525de759c6
location_href: 00012167-python-livelossplot/python-livelossplot-0.5.5-1.src.rpm
checksum_type: sha256
description:
  [![livelossplot version - PyPI](https://img.shields.io/pypi/v/livelossplot)](https://pypi.org/project/livelossplot/)
  ![PyPI status](https://img.shields.io/pypi/status/livelossplot.svg)
  ![MIT license - PyPI](https://img.shields.io/pypi/l/livelossplot.svg)
  ![Python version - PyPI](https://img.shields.io/pypi/pyversions/livelossplot.svg)
  [![GitHub Workflow Status](https://img.shields.io/github/workflow/status/stared/livelossplot/Python%20package)](https://github.com/stared/livelossplot/actions)
  [![Downloads](http://pepy.tech/badge/livelossplot)](https://pepy.tech/project/livelossplot)
  [![Twitter @pmigdal](https://img.shields.io/twitter/follow/pmigdal)](https://twitter.com/pmigdal)

  Don't train deep learning models blindfolded! Be impatient and look at each epoch of your training!

  ([RECENT CHANGES](CHANGELOG.md), [EXAMPLES IN COLAB](https://colab.research.google.com/github/stared/livelossplot), [API LOOKUP](http://p.migdal.pl/livelossplot/), [CODE](https://github.com/stared/livelossplot))

  A live training loss plot in [Jupyter Notebook](http://jupyter.org/) for [Keras](https://keras.io/), [PyTorch](http://pytorch.org/) and other frameworks. An open-source Python package by [Piotr Migdał](https://p.migdal.pl/), [Bartłomiej Olechno](https://github.com/Bartolo1024/) and [others](https://github.com/stared/livelossplot/graphs/contributors). **Open for collaboration!** (Some tasks are as simple as writing code docstrings, so - no excuses! :))

  ```python
  from livelossplot import PlotLossesKeras

  model.fit(X_train, Y_train,
            epochs=10,
            validation_data=(X_test, Y_test),
            callbacks=[PlotLossesKeras()],
            verbose=0)
  ```

  ![Animated fig for livelossplot tracking log-loss and accuracy](https://raw.githubusercontent.com/stared/livelossplot/master/livelossplot.gif)

  - (The most FA)Q: Why not TensorBoard?
  - A: Jupyter Notebook compatibility (for exploration and teaching). The simplicity of use.



  To install [this version from PyPI](https://pypi.org/project/livelossplot/), type:

  ```bash
  pip install livelossplot
  ```

  To get the newest one from this repo (note that we are in the alpha stage, so there may be frequent updates), type:

  ```bash
  pip install git+git://github.com/stared/livelossplot.git
  ```



  Look at notebook files with full working [examples](https://github.com/stared/livelossplot/blob/master/examples/):

  - [keras.ipynb](https://github.com/stared/livelossplot/blob/master/examples/keras.ipynb) - a Keras callback
  - [minimal.ipynb](https://github.com/stared/livelossplot/blob/master/examples/minimal.ipynb) - a bare API, to use anywhere
  - [bokeh.ipynb](https://github.com/stared/livelossplot/blob/master/examples/bokeh.ipynb) - a bare API, plots with Bokeh ([open it in Colab to see the plots](https://colab.research.google.com/github/stared/livelossplot/blob/master/examples/bokeh.ipynb))
  - [pytorch.ipynb](https://github.com/stared/livelossplot/blob/master/examples/pytorch.ipynb) - a bare API, as applied to PyTorch
  - [2d_prediction_maps.ipynb](https://github.com/stared/livelossplot/blob/master/examples/2d_prediction_maps.ipynb) - example of custom plots - 2d prediction maps (0.4.1+)
  - [poutyne.ipynb](https://github.com/stared/livelossplot/blob/master/examples/poutyne.ipynb) - a Poutyne callback ([Poutyne](https://poutyne.org/) is a Keras-like framework for PyTorch)
  - [torchbearer.ipynb](https://github.com/stared/livelossplot/blob/master/examples/torchbearer.ipynb) - an example using the built in functionality from torchbearer ([torchbearer](https://github.com/ecs-vlc/torchbearer) is a model fitting library for PyTorch)
  - [neptune.py](https://github.com/stared/livelossplot/blob/master/examples/neptune.py) and [neptune.ipynb](https://github.com/stared/livelossplot/blob/master/examples/neptune.ipynb) - a [Neptune.AI](https://neptune.ai/)
  - [matplotlib.ipynb](https://github.com/stared/livelossplot/blob/master/examples/matplotlib.ipynb) - a Matplotlib output example
  - [various_options.ipynb](https://github.com/stared/livelossplot/blob/master/examples/various_options.ipynb) - an extended API for metrics grouping and custom outputs

  You [run examples in Colab](https://colab.research.google.com/github/stared/livelossplot).



  Text logs are easy, but it's easy to miss the most crucial information: is it learning, doing nothing or overfitting?
  Visual feedback allows us to keep track of the training process. Now there is one for Jupyter.

  If you want to get serious - use [TensorBoard](https://www.tensorflow.org/programmers_guide/summaries_and_tensorboard), .
  But what if you just want to train a small model in Jupyter Notebook? Here is a way to do so, using `livelossplot` as a plug&play component



  `PlotLosses` for a generic API.

  ```{python}
  plotlosses = PlotLosses()
  plotlosses.update({'acc': 0.7, 'val_acc': 0.4, 'loss': 0.9, 'val_loss': 1.1})
  plot.send()  # draw, update logs, etc
  ```

  There are callbacks for common libraries and frameworks: `PlotLossesKeras`, `PlotLossesKerasTF`, `PlotLossesPoutyne`, `PlotLossesIgnite`.

  Feel invited to write, and contribute, your adapter.
  If you want to use a bare logger, there is `MainLogger`.



  Plots: `MatplotlibPlot`, `BokehPlot`.

  Loggers: `ExtremaPrinter` (to standard output), `TensorboardLogger`, `TensorboardTFLogger`, `NeptuneLogger`.

  To use them, initialize PlotLosses with some outputs:

  ```{python}
  plotlosses = PlotLosses(outputs=[MatplotlibPlot(), TensorboardLogger()])
  ```

  There are custom `matplotlib` plots in `livelossplot.outputs.matplotlib_subplots` you can pass in `MatplotlibPlot` arguments.

  If you like to plot with [Bokeh](https://docs.bokeh.org/en/latest/) instead of [matplotlib](https://matplotlib.org/), use

  ```{python}
  plotlosses = PlotLosses(outputs=[BokehPlot()])
  ```



  This project supported by [Jacek Migdał](http://jacek.migdal.pl/), [Marek Cichy](https://medium.com/@marekkcichy/), [Casper da Costa-Luis](https://cdcl.ml/), and [Piotr Zientara](https://twitter.com/piotr_zientara). [Join the sponsors - show your ❤️ and support, and appear on the list](https://github.com/sponsors/stared)! It will give me time and energy to work on this project.

  This project is also supported by a European program *Program Operacyjny Inteligentny Rozwój* for [GearShift - building the engine of behavior of wheeled motor vehicles and map’s generation based on artificial intelligence algorithms implemented on the Unreal Engine platform](https://mapadotacji.gov.pl/projekty/874596/?lang=en) lead by ECC Games (NCBR grant GameINN).



  It started as [this gist](https://gist.github.com/stared/dfb4dfaf6d9a8501cd1cc8b8cb806d2e). Since it went popular, I decided to rewrite it as a package.

  Oh, and I am in general interested in data vis, see [Simple diagrams of convoluted neural networks](https://medium.com/inbrowserai/simple-diagrams-of-convoluted-neural-networks-39c097d2925b) (and overview of deep learning architecture diagrams):

  > A good diagram is worth a thousand equations — let’s create more of these!

  ...or [my other data vis projects](https://p.migdal.pl/projects/).



  If you want more functionality - open an [Issue](https://github.com/stared/livelossplot/issues) or even better - prepare a [Pull Request](https://github.com/stared/livelossplot/pulls).


pkgId: 55a90910dffb992077c58d2d9e428f3da132bdcfff552880c762e5922c27e382
name: python-livereload
arch: src
version: 2.6.3
epoch: 0
release: 1
summary: Python LiveReload is an awesome tool for web developers
url: https://github.com/lepture/python-livereload
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fd6b32d6-a045-4fde-8489-29c60177ee10
location_href: 00004119-python-livereload/python-livereload-2.6.3-1.src.rpm
checksum_type: sha256
description:
  This is a brand new LiveReload in version 2.0.0.
  `Download on PyPi <https://pypi.python.org/pypi/livereload>`_


pkgId: 896f16684ff891631d267b4c6be24c65cd9032135abb15f19c868a9758953ae3
name: python-lizard
arch: src
version: 1.17.10
epoch: 0
release: 1
url: http://www.lizard.ws
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-85b1e837-4dbd-4bb9-8cce-a2e34ccad440
location_href: 00011905-python-lizard/python-lizard-1.17.10-1.src.rpm
checksum_type: sha256
summary:
  A code analyzer without caring the C/C++ header files. It works with Java, C/C++, JavaScript, Python, Ruby, Swift, Objective C. Metrics includes cyclomatic complexity number etc.

description:
  |
  Lizard is an extensible Cyclomatic Complexity Analyzer for many programming languages
  including C/C++ (doesn't require all the header files or Java imports). It also does
  copy-paste detection (code clone detection/code duplicate detection) and many other forms of static
  code analysis.
  A list of supported languages:
  -  C/C++ (works with C++14)
  -  Java
  -  C# (C Sharp)
  -  JavaScript (With ES6 and JSX)
  -  TypeScript
  -  Objective-C
  -  Swift
  -  Python
  -  Ruby
  -  TTCN-3
  -  PHP
  -  Scala
  -  GDScript
  -  Golang
  -  Lua
  -  Rust
  -  Fortran
  -  Kotlin
  By default lizard will search for any source code that it knows and mix
  all the results together. This might not be what you want. You can use
  the "-l" option to select language(s).
  It counts
  -  the nloc (lines of code without comments),
  -  CCN (cyclomatic complexity number),
  -  token count of functions.
  -  parameter count of functions.
  You can set limitation for CCN (-C), the number of parameters (-a).
  Functions that exceed these limitations will generate warnings. The exit
  code of lizard will be none-Zero if there are warnings.
  This tool actually calculates how complex the code 'looks' rather than
  how complex the code really 'is'. People will need this tool because it's
  often very hard to get all the included folders and files right when
  they are complicated. But we don't really need that kind of accuracy for
  cyclomatic complexity.
  It requires python2.7 or above (early versions are not verified).


pkgId: 319ac4f143fe02559086f0ed43d14f528d38c94879ffeb888ae3041ac2ae3324
name: python-lkml
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: A speedy LookML parser implemented in pure Python.
url: https://github.com/joshtemple/lkml
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-08ac9447-5e34-418a-b2fc-3d21b8ee78b9
location_href: 00010048-python-lkml/python-lkml-1.3.1-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://img.shields.io/circleci/build/github/joshtemple/lkml.svg)](https://circleci.com/gh/joshtemple/lkml)
  [![Codecov](https://img.shields.io/codecov/c/github/joshtemple/lkml.svg)](https://codecov.io/gh/joshtemple/lkml)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Read the Docs](https://img.shields.io/readthedocs/lkml)](https://lkml.readthedocs.io/en/latest/)



  A speedy LookML parser and serializer implemented in pure Python.

  **Read the documentation on [Read the Docs](https://lkml.readthedocs.io/en/latest/).**

  `lkml.load` parses LookML strings to Python objects or JSON strings. `lkml.dump` serializes (generates) LookML strings from Python objects.

  Why should you use `lkml`?
  - Tested on **over 160K lines of LookML** from public repositories on GitHub
  - Parses a typical view or model file in < **10 ms** (excludes I/O time)
  - Written in pure, modern Python 3.7 with **no external dependencies**
  - A **full unit test suite** with excellent coverage

  Interested in contributing to `lkml`? Check out the [contributor guidelines](CONTRIBUTING.md).



  `lkml` is available to install on [pip](https://pypi.org/project/lkml/) via the following command:

  ```
  pip install lkml
  ```


pkgId: 3b617c8a276409d52325ace845f9800da40770013058e36274ac5323cfc62918
name: python-llfuse
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: Python bindings for the low-level FUSE API
url: https://github.com/python-llfuse/python-llfuse/
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dc3a5747-ebab-46e3-8d97-2dd03fd8cbbf
location_href: 00004120-python-llfuse/python-llfuse-1.4.2-1.src.rpm
checksum_type: sha256
description:
  **Warning - no longer developed!**
  Python-LLFUSE is no longer actively developed and just receiving
  community-contributed maintenance to keep it alive for some time.
  Python-LLFUSE is a set of Python bindings for the low level FUSE_
  API. It requires at least FUSE 2.8.0 and supports both Python 2.x and
  3.x. Like FUSE itself, Python-LLFUSE is developed for Linux systems,
  but it should be compatible with OS-X, FreeBSD and NetBSD as well.
  Python-LLFUSE releases can be downloaded from PyPi_. The documentation
  can be `read online`__ and is also included in the ``doc/html``
  directory of the Python-LLFUSE tarball.


pkgId: 349fe5051c615c99f66c8dcb4356e535865eb1e22045802935077ffc084f3d55
name: python-lmdb-debuginfo
arch: aarch64
version: 1.4.0
epoch: 0
release: 1
summary: Debug information for package python-lmdb
url: http://github.com/jnwatson/py-lmdb/
rpm_license: OLDAP-2.8
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-d5b853d3-a4a6-41cc-9a0d-e80ed1a3d96a
rpm_sourcerpm: python-lmdb-1.4.0-1.src.rpm
location_href: 00004121-python-lmdb/python-lmdb-debuginfo-1.4.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-lmdb.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 72188d8ec44120487baebc34c2975c23c98e1e95efab7e32cb506ac29bf22f8b
name: python-lmdb-debugsource
arch: aarch64
version: 1.4.0
epoch: 0
release: 1
summary: Debug sources for package python-lmdb
url: http://github.com/jnwatson/py-lmdb/
rpm_license: OLDAP-2.8
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-d5b853d3-a4a6-41cc-9a0d-e80ed1a3d96a
rpm_sourcerpm: python-lmdb-1.4.0-1.src.rpm
location_href: 00004121-python-lmdb/python-lmdb-debugsource-1.4.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-lmdb.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 27f272fc89dc8f81562fb6286706d2f9e0dd5edc980f4e48e975eb0ce3165e03
name: python-localstack
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: LocalStack - A fully functional local Cloud stack
url: https://github.com/localstack/localstack
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b8270277-4f02-4009-96ff-4ab06fd126b1
location_href: 00013180-python-localstack/python-localstack-2.0.1-1.src.rpm
checksum_type: sha256
description:
  [LocalStack](https://localstack.cloud) is a cloud service emulator that runs in a single container on your laptop or in your CI environment. With LocalStack, you can run your AWS applications or Lambdas entirely on your local machine without connecting to a remote cloud provider! Whether you are testing complex CDK applications or Terraform configurations, or just beginning to learn about AWS services, LocalStack helps speed up and simplify your testing and development workflow.
  LocalStack supports a growing number of AWS services, like AWS Lambda, S3, Dynamodb, Kinesis, SQS, SNS, and many more! The [Pro version of LocalStack](https://localstack.cloud/pricing) supports additional APIs and advanced features. You can find a comprehensive list of supported APIs on our [☑️ Feature Coverage](https://docs.localstack.cloud/user-guide/aws/feature-coverage/) page.
  LocalStack also provides additional features to make your life as a cloud developer easier! Check out LocalStack's [Cloud Developer Tools](https://docs.localstack.cloud/user-guide/tools/) for more information.

  * `python` (Python 3.7 up to 3.11 supported)
  * `pip` (Python package manager)
  * `Docker`

  The easiest way to install LocalStack is via `pip`:
  ```
  pip install localstack
  ```
  This installs the `localstack-cli` which is used to run the Docker image that hosts the LocalStack runtime.
  > **Important**: Do not use `sudo` or run as `root` user. LocalStack must be installed and started entirely under a local non-root user. If you have problems with permissions in macOS High Sierra, install with `pip install --user localstack`

  Start LocalStack inside a Docker container by running:
  ```
   % localstack start -d
       __                     _______ __             __
      / /   ____  _________ _/ / ___// /_____ ______/ /__
     / /   / __ \/ ___/ __ `/ /\__ \/ __/ __ `/ ___/ //_/
    / /___/ /_/ / /__/ /_/ / /___/ / /_/ /_/ / /__/ ,<
   /_____/\____/\___/\__,_/_//____/\__/\__,_/\___/_/|_|
   💻 LocalStack CLI 2.0.0
  [20:22:20] starting LocalStack in Docker mode 🐳
  [20:22:21] detaching
  ```
  You can query the status of respective services on LocalStack by running:
  ```
  % localstack status services
  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┓
  ┃ Service                  ┃ Status      ┃
  ┡━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━┩
  │ acm                      │ ✔ available │
  │ apigateway               │ ✔ available │
  │ cloudformation           │ ✔ available │
  │ cloudwatch               │ ✔ available │
  │ config                   │ ✔ available │
  │ dynamodb                 │ ✔ available │
  ```
  To use SQS, a fully managed distributed message queuing service, on LocalStack, run:
  ```shell
  % awslocal sqs create-queue --queue-name sample-queue
  {
      "QueueUrl": "http://localhost:4566/000000000000/sample-queue"
  }
  ```
  Learn more about [LocalStack AWS services](https://docs.localstack.cloud/references/coverage/) and using them with LocalStack's `awslocal` CLI.

  You can run LocalStack through the following options:
  - [LocalStack CLI](https://docs.localstack.cloud/getting-started/installation/#localstack-cli)
  - [Docker](https://docs.localstack.cloud/getting-started/installation/#docker)
  - [Docker Compose](https://docs.localstack.cloud/getting-started/installation/#docker-compose)
  - [Helm](https://docs.localstack.cloud/getting-started/installation/#helm)

  To start using LocalStack, check out our documentation at <https://docs.localstack.cloud>.
  - [LocalStack Configuration](https://docs.localstack.cloud/references/configuration/)
  - [LocalStack in CI](https://docs.localstack.cloud/user-guide/ci/)
  - [LocalStack Integrations](https://docs.localstack.cloud/user-guide/integrations/)
  - [LocalStack Tools](https://docs.localstack.cloud/user-guide/tools/)
  - [Understanding LocalStack](https://docs.localstack.cloud/references/)
  - [Troubleshoot](doc/troubleshoot/README.md)
  To use LocalStack with a graphical user interface, you can use the following UI clients:
  * [Commandeer desktop app](https://getcommandeer.com)
  * [DynamoDB Admin Web UI](https://www.npmjs.com/package/dynamodb-admin)

  Please refer to [GitHub releases](https://github.com/localstack/localstack/releases) to see the complete list of changes for each release. For extended release notes, please refer to the [LocalStack Discuss](https://discuss.localstack.cloud/c/announcement/5).

  If you are interested in contributing to LocalStack:
  - Start by reading our [contributing guide](CONTRIBUTING.md).
  - Check out our [developer guide](https://docs.localstack.cloud/contributing/).
  - Navigate our codebase and [open issues](https://github.com/localstack/localstack/issues).
  We are thankful for all the contributions and feedback we receive.

  To get in touch with LocalStack team for bugs/feature requests, support questions or general discussions, please use:
  - [LocalStack Slack Community](https://localstack.cloud/contact/)
  - [LocalStack Discussion Page](https://discuss.localstack.cloud/)
  - [LocalStack GitHub Issue tracker](https://github.com/localstack/localstack/issues)

  We are thankful to all the people who have contributed to this project.
  <a href="https://github.com/localstack/localstack/graphs/contributors"><img src="https://opencollective.com/localstack/contributors.svg?width=890" /></a>

  We are also grateful to all our backers who have donated to the project. You can become a backer on [Open Collective](https://opencollective.com/localstack#backer).
  <a href="https://opencollective.com/localstack#backers" target="_blank"><img src="https://opencollective.com/localstack/backers.svg?width=890"></a>

  You can also support this project by becoming a sponsor on [Open Collective](https://opencollective.com/localstack#sponsor). Your logo will show up here along with a link to your website.
  <a href="https://opencollective.com/localstack/sponsor/0/website" target="_blank"><img src="https://opencollective.com/localstack/sponsor/0/avatar.svg"></a>
  <a href="https://opencollective.com/localstack/sponsor/1/website" target="_blank"><img src="https://opencollective.com/localstack/sponsor/1/avatar.svg"></a>
  <a href="https://opencollective.com/localstack/sponsor/2/website" target="_blank"><img src="https://opencollective.com/localstack/sponsor/2/avatar.svg"></a>
  <a href="https://opencollective.com/localstack/sponsor/3/website" target="_blank"><img src="https://opencollective.com/localstack/sponsor/3/avatar.svg"></a>
  <a href="https://opencollective.com/localstack/sponsor/4/website" target="_blank"><img src="https://opencollective.com/localstack/sponsor/4/avatar.svg"></a>
  <a href="https://opencollective.com/localstack/sponsor/5/website" target="_blank"><img src="https://opencollective.com/localstack/sponsor/5/avatar.svg"></a>
  <a href="https://opencollective.com/localstack/sponsor/6/website" target="_blank"><img src="https://opencollective.com/localstack/sponsor/6/avatar.svg"></a>
  <a href="https://opencollective.com/localstack/sponsor/7/website" target="_blank"><img src="https://opencollective.com/localstack/sponsor/7/avatar.svg"></a>
  <a href="https://opencollective.com/localstack/sponsor/8/website" target="_blank"><img src="https://opencollective.com/localstack/sponsor/8/avatar.svg"></a>
  <a href="https://opencollective.com/localstack/sponsor/9/website" target="_blank"><img src="https://opencollective.com/localstack/sponsor/9/avatar.svg"></a>

  Copyright (c) 2017-2023 LocalStack maintainers and contributors.
  Copyright (c) 2016 Atlassian and others.
  This version of LocalStack is released under the Apache License, Version 2.0 (see [LICENSE](LICENSE.txt)). By downloading and using this software you agree to the [End-User License Agreement (EULA)](doc/end_user_license_agreement). To know about the external software we use, look at our [third party software tools](doc/third-party-software-tools/README.md) page.


pkgId: a387f71a4cfce50a4a2c82653fb801313b5dd47b2c6d4fd3ac667edee9b09c84
name: python-localstack-plugin-loader
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: The dynamic code loading framework used in LocalStack
url: https://github.com/localstack/localstack-plugin-loader
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7b95a703-1d4b-4c96-b055-120ecd362ac0
location_href: 00013021-python-localstack-plugin-loader/python-localstack-plugin-loader-1.1.1-1.src.rpm
checksum_type: sha256
description:
  <p>
    <a href="https://github.com/localstack/localstack-plugin-loader/actions/workflows/build.yml"><img alt="CI badge" src="https://github.com/localstack/localstack-plugin-loader/actions/workflows/build.yml/badge.svg"></img></a>
    <a href="https://pypi.org/project/localstack-plugin-loader/"><img alt="PyPI Version" src="https://img.shields.io/pypi/v/localstack-plugin-loader?color=blue"></a>
    <a href="https://img.shields.io/pypi/l/localstack-plugin-loader.svg"><img alt="PyPI License" src="https://img.shields.io/pypi/l/localstack-plugin-loader.svg"></a>
    <a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>
  </p>
  localstack-plugin-loader is the dynamic code loading framework used in [LocalStack](https://github.com/localstack/localstack).


pkgId: eebf268a66337b23f58d4b63e0a19078977543f807a0b52caa7978c1084916f7
name: python-locket
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: File-based locks for Python on Linux and Windows
url: http://github.com/mwilliamson/locket.py
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d076f979-bba8-4614-9480-9c05a5f7fafe
location_href: 00004122-python-locket/python-locket-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Locket implements a file-based lock that can be used by multiple processes provided they use the same path.
      import locket
      
      with locket.lock_file("path/to/lock/file"):
          perform_action()
      
      with locket.lock_file("path/to/lock/file", timeout=0):
          perform_action()
      
      with locket.lock_file("path/to/lock/file", timeout=30):
          perform_action()
      
      lock = locket.lock_file("path/to/lock/file")
      try:
          lock.acquire()
          perform_action()
      finally:
          lock.release()
  Locks largely behave as (non-reentrant) ``Lock`` instances from the ``threading``
  module in the standard library. Specifically, their behaviour is:
  * Locks are uniquely identified by the file being locked,
    both in the same process and across different processes.
  * Locks are either in a locked or unlocked state.
  * When the lock is unlocked, calling ``acquire()`` returns immediately and changes
    the lock state to locked.
  * When the lock is locked, calling ``acquire()`` will block until the lock state
    changes to unlocked, or until the timeout expires.
  * If a process holds a lock, any thread in that process can call ``release()`` to
    change the state to unlocked.
  * Calling ``release()`` on an unlocked lock raises ``LockError``.
  * Behaviour of locks after ``fork`` is undefined.


pkgId: b04ec1668317c64be93f788198c3c88f24e1b7cbd84070264457c118b2b7de05
name: python-lockfile
arch: src
version: 0.12.2
epoch: 0
release: 1
summary: Platform-independent file locking module
url: http://launchpad.net/pylockfile
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ed93630e-3872-4069-8707-e2ab112a1e52
location_href: 00004123-python-lockfile/python-lockfile-0.12.2-1.src.rpm
checksum_type: sha256
description:
  Note: This package is **deprecated**. It is highly preferred that instead of
  using this code base that instead `fasteners`_ or `oslo.concurrency`_ is
  used instead. For any questions or comments or further help needed
  please email `openstack-dev`_ and prefix your email subject
  with ``[oslo][pylockfile]`` (for a faster response).

  .. _fasteners: https://pypi.python.org/pypi/fasteners
  .. _oslo.concurrency: http://docs.openstack.org/developer/oslo.concurrency/
  .. _openstack-dev: http://lists.openstack.org/cgi-bin/mailman/listinfo/openstack-dev

  The lockfile package exports a LockFile class which provides a simple API for
  locking files.  Unlike the Windows msvcrt.locking function, the fcntl.lockf
  and flock functions, and the deprecated posixfile module, the API is
  identical across both Unix (including Linux and Mac) and Windows platforms.
  The lock mechanism relies on the atomic nature of the link (on Unix) and
  mkdir (on Windows) system calls.  An implementation based on SQLite is also
  provided, more as a demonstration of the possibilities it provides than as
  production-quality code.

  Note: In version 0.9 the API changed in two significant ways:

   * It changed from a module defining several classes to a package containing
     several modules, each defining a single class.

   * Where classes had been named SomethingFileLock before the last two words
     have been reversed, so that class is now SomethingLockFile.

  The previous module-level definitions of LinkFileLock, MkdirFileLock and
  SQLiteFileLock will be retained until the 1.0 release.

  To install:

      python setup.py install

  * Documentation: http://docs.openstack.org/developer/pylockfile
  * Source: http://git.openstack.org/cgit/openstack/pylockfile
  * Bugs: http://bugs.launchpad.net/pylockfile


pkgId: 4bcd3508eea94001a313e36b4f973e9314ae5b871552e719fefa5ad5cd430ca8
name: python-logdna
arch: src
version: 1.18.6
epoch: 0
release: 1
summary: A Python Package for Sending Logs to LogDNA
url: https://github.com/logdna/python
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4e0c8e57-e62d-422c-b0d2-82e31f63b3aa
location_href: 00012564-python-logdna/python-logdna-1.18.6-1.src.rpm
checksum_type: sha256
description:
  * [Installation](#installation)
  * [Setup](#setup)
  * [Usage](#usage)
    * [Usage with fileConfig](#usage-with-fileconfig)
  * [API](#api)
    * [LogDNAHandler(key: string, [options: dict])](#logdnahandlerkey-string-options-dict)
      * [key](#key)
      * [options](#options)
    * [log(line, [options])](#logline-options)
      * [line](#line)
      * [options](#options-1)
  * [Development](#development)
    * [Scripts](#scripts)
  * [License](#license)

  ```bash
  $ pip install logdna
  ```

  ```python
  import logging
  from logdna import LogDNAHandler
  import os



  key=os.environ['INGESTION_KEY']
  log = logging.getLogger('logdna')
  log.setLevel(logging.INFO)
  options = {
    'hostname': 'pytest',
    'ip': '10.0.1.1',
    'mac': 'C0:FF:EE:C0:FF:EE'
  }

  options['index_meta'] = True
  options['custom_fields'] = 'meta'
  test = LogDNAHandler(key, options)
  log.addHandler(test)
  log.warning("Warning message", extra={'app': 'bloop'})
  log.info("Info message")
  ```
  _**Required**_
  * [LogDNA Ingestion Key](https://app.logdna.com/manage/profile)
  _**Optional**_
  * Hostname - ([string][])
  * MAC Address - ([string][])
  * IP Address - ([string][])
  * Index Meta - ([bool][]) - formatted as `options['index_meta']`

  After initial setup, logging is as easy as:
  ```python

  log.info('My Sample Log Line')

  log.info('My Sample Log Line', extra={ 'level': 'MyCustomLevel' })

  log.info('My Sample Log Line', extra={ 'level': 'Warn', 'app': 'myAppName'})

  meta = {
      'foo': 'bar',
      'nested': {
          'nest1': 'nested text'
      }
  }
  opts = {
      'level': 'warn',
      'meta': meta
  }
  log.info('My Sample Log Line', extra=opts)
  ```

  To use [LogDNAHandler](#logdnahandlerkey-string-options-dict) with [fileConfig][] (e.g., in a Django `settings.py` file):
  ```python
  import os
  import logging
  from logdna import LogDNAHandler #  required to register `logging.handlers.LogDNAHandler`
  LOGGING = {
      
      'handlers': {
          'logdna': {
              'level': logging.DEBUG,
              'class': 'logging.handlers.LogDNAHandler',
              'key': os.environ.get('LOGDNA_INGESTION_KEY'),
              'options': {
                  'app': '<app name>',
                  'env': os.environ.get('ENVIRONMENT'),
                  'index_meta': <True|False>,
              },
          },
      },
      'loggers': {
          '': {
              'handlers': ['logdna'],
              'level': logging.DEBUG
          },
      },
  }
  ```
  (This example assumes you have set environment variables for `ENVIRONMENT` and `LOGDNA_INGESTION_KEY`.)



  * _**Required**_
  * Type: [string][]
  * Values: `<your ingestion key>`
  The [LogDNA API Key](https://app.logdna.com/manage/profile) associated with your account.


  * _Optional_
  * Type: [string][]
  * Default: `''`
  * Values: `<your custom app>`
  The default app named that is included in every every log line sent through this instance.

  * _Optional_
  * Type: [string][]
  * Default: `''`
  * Values: `<your custom env>`
  The default env passed along with every log sent through this instance.

  * _Optional_
  * Type: [string][]
  * Default: `''`
  * Values: `<your custom hostname>`
  The default hostname passed along with every log sent through this instance.

  * _Optional_
  * Type: [bool][]
  * Default: `False`
  Python [LogRecord][] objects includes language-specific information that may be useful metadata in logs.
  Setting `include_standard_meta` to `True` automatically populates meta objects with `name`, `pathname`, and `lineno`
  from the [LogRecord][].
  *WARNING* This option is deprecated and will be removed in the upcoming major release.

  * _Optional_
  * Type: [bool][]
  * Default: `False`
  We allow meta objects to be passed with each line. By default these meta objects are stringified and not searchable, and are only displayed for informational purposes.
  If this option is set to True then meta objects are parsed and searchable up to three levels deep. Any fields deeper than three levels are stringified and cannot be searched.
  *WARNING* If this option is True, your metadata objects MUST have consistent types across all log messages or the metadata object might not be parsed properly.

  * _Optional_
  * Type: [string][]
  * Default: `Info`
  * Values: `Debug`, `Trace`, `Info`, `Warn`, `Error`, `Fatal`, `<your custom level>`
  The default level passed along with every log sent through this instance.

  * _Optional_
  * Type: [string][] or [bool][]
  * Default: `True`
  * Values: `False` or any level
  Sets the verbosity of log statements for failures.

  * _Optional_
  * Type: [int][]
  * Default: `30000`
  The amount of time (in ms) the request should wait for LogDNA to respond before timing out.

  * _Optional_
  * Type: [list][]&lt;[string][]&gt;
  * Default: `[]`
  List of tags used to dynamically group hosts.  More information on tags is available at [How Do I Use Host Tags?](https://docs.logdna.com/docs/logdna-agent#section-how-do-i-use-host-tags-)

  * _Optional_
  * Type: [string][]
  * Default: `'https://logs.logdna.com/logs/ingest'`
  A custom ingestion endpoint to stream log lines into.

  * _Optional_
  * Type: [list][]&lt;[string][]&gt;
  * Default: `['args', 'name', 'pathname', 'lineno']`
  List of fields out of `record` object to include in the `meta` object. By default, `args`, `name`, `pathname`, and `lineno` will be included.

  * _Optional_
  * Type: [bool][]
  * Default: `False`
  Enables logging of the API response when an HTTP error is encountered


  * _Required_
  * Type: [string][]
  * Default: `''`
  The log line to be sent to LogDNA.


  * _Optional_
  * Type: [string][]
  * Default: `Info`
  * Values: `Debug`, `Trace`, `Info`, `Warn`, `Error`, `Fatal`, `<your custom level>`
  The level passed along with this log line.

  * _Optional_
  * Type: [string][]
  * Default: `''`
  * Values: `<your custom app>`
  The app passed along with this log line.

  * _Optional_
  * Type: [string][]
  * Default: `''`
  * Values: `<your custom env>`
  The environment passed with this log line.

  * _Optional_
  * Type: [dict][]
  * Default: `None`
  A standard dictonary containing additional metadata about the log line that is passed. Please ensure values are JSON serializable.
  **NOTE**: Values that are not JSON serializable will be removed and the respective keys will be added to the `__errors` string.

  * _Optional_
  * Type: [bool][]
  * Default: `False`
  We allow meta objects to be passed with each line. By default these meta objects will be stringified and will not be
  searchable, but will be displayed for informational purposes.
  If this option is turned to true then meta objects will be parsed and will be searchable up to three levels deep. Any fields deeper than three levels will be stringified and cannot be searched.
  *WARNING* When this option is true, your metadata objects across all types of log messages MUST have consistent types or the metadata object may not be parsed properly!

  * _Optional_
  * Type: [float][]
  * Default: [time.time()][]
  The time in seconds since the epoch to use for the log timestamp. It must be within one day or current time - if it is not, it is ignored and time.time() is used in its place.

  This project makes use of the [poetry][] package manager for local development.
  ```shell
  $ poetry install
  ```

  **lint**
  Run linting rules w/o attempting to fix them
  ```shell
  $ poetry run task lint
  ```
  **lint:fix**
  Run lint rules against all local python files and attempt to fix where possible.
  ```shell
  $ poetry run task lint:fix
  ```
  **test**:
  Runs all unit tests and generates coverage reports
  ```shell
  poetry run task test
  ```

  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):
  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tr>
      <td align="center"><a href="https://github.com/respectus"><img src="https://avatars.githubusercontent.com/u/1046364?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Muaz Siddiqui</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=respectus" title="Code">💻</a> <a href="https://github.com/logdna/python/commits?author=respectus" title="Documentation">📖</a> <a href="https://github.com/logdna/python/commits?author=respectus" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://github.com/smusali"><img src="https://avatars.githubusercontent.com/u/34287490?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Samir Musali</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=smusali" title="Code">💻</a> <a href="https://github.com/logdna/python/commits?author=smusali" title="Documentation">📖</a> <a href="https://github.com/logdna/python/commits?author=smusali" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://github.com/vilyapilya"><img src="https://avatars.githubusercontent.com/u/17367511?v=4?s=100" width="100px;" alt=""/><br /><sub><b>vilyapilya</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=vilyapilya" title="Code">💻</a> <a href="#maintenance-vilyapilya" title="Maintenance">🚧</a> <a href="https://github.com/logdna/python/commits?author=vilyapilya" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://github.com/mikehu"><img src="https://avatars.githubusercontent.com/u/981800?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Mike Hu</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=mikehu" title="Documentation">📖</a></td>
      <td align="center"><a href="http://codedependant.net/"><img src="https://avatars.githubusercontent.com/u/148561?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Eric Satterwhite</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=esatterwhite" title="Code">💻</a> <a href="https://github.com/logdna/python/commits?author=esatterwhite" title="Documentation">📖</a> <a href="https://github.com/logdna/python/commits?author=esatterwhite" title="Tests">⚠️</a> <a href="#tool-esatterwhite" title="Tools">🔧</a></td>
      <td align="center"><a href="http://dev.utek.pl/"><img src="https://avatars.githubusercontent.com/u/128036?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Łukasz Bołdys (Lukasz Boldys)</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=utek" title="Code">💻</a> <a href="https://github.com/logdna/python/issues?q=author%3Autek" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/baronomasia"><img src="https://avatars.githubusercontent.com/u/4133158?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Ryan</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=baronomasia" title="Documentation">📖</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/LYHuang"><img src="https://avatars.githubusercontent.com/u/14082239?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Mike Huang</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=LYHuang" title="Code">💻</a> <a href="https://github.com/logdna/python/issues?q=author%3ALYHuang" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://www.medium.com/@dmaas"><img src="https://avatars.githubusercontent.com/u/9013104?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Dan Maas</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=danmaas" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/dchai76"><img src="https://avatars.githubusercontent.com/u/13873467?v=4?s=100" width="100px;" alt=""/><br /><sub><b>DChai</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=dchai76" title="Documentation">📖</a></td>
      <td align="center"><a href="https://naboa.de/"><img src="https://avatars.githubusercontent.com/u/10531844?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Jakob de Maeyer </b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=jdemaeyer" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/sataloger"><img src="https://avatars.githubusercontent.com/u/359111?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Andrey Babak</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=sataloger" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/mike-spainhower"><img src="https://avatars.githubusercontent.com/u/380032?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Mike S</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=SpainTrain" title="Code">💻</a> <a href="https://github.com/logdna/python/commits?author=SpainTrain" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/btashton"><img src="https://avatars.githubusercontent.com/u/173245?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Brennan Ashton</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=btashton" title="Code">💻</a></td>
    </tr>
    <tr>
      <td align="center"><a href="http://justrocketscience.com/"><img src="https://avatars.githubusercontent.com/u/604528?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Christian Hotz-Behofsits</b></sub></a><br /><a href="https://github.com/logdna/python/commits?author=inkrement" title="Code">💻</a> <a href="https://github.com/logdna/python/issues?q=author%3Ainkrement" title="Bug reports">🐛</a></td>
      <td align="center"><a href="http://www.kinoarts.com/blog/"><img src="https://avatars.githubusercontent.com/u/108118?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Kurtiss Hare</b></sub></a><br /><a href="https://github.com/logdna/python/issues?q=author%3Akurtiss" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://twitter.com/rudyryk"><img src="https://avatars.githubusercontent.com/u/4500?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Alexey Kinev</b></sub></a><br /><a href="https://github.com/logdna/python/issues?q=author%3Arudyryk" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/matthiasfru"><img src="https://avatars.githubusercontent.com/u/24245643?v=4?s=100" width="100px;" alt=""/><br /><sub><b>matthiasfru</b></sub></a><br /><a href="https://github.com/logdna/python/issues?q=author%3Amatthiasfru" title="Bug reports">🐛</a></td>
    </tr>
  </table>
  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->
  <!-- ALL-CONTRIBUTORS-LIST:END -->
  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!

  MIT © [LogDNA](https://logdna.com/)
  Copyright © 2017 [LogDNA][], released under an MIT license. See the [LICENSE](./LICENSE) file and [https://opensource.org/licenses/MIT](https://opensource.org/licenses/MIT)
  *Happy Logging!*
  [bool]: https://docs.python.org/3/library/stdtypes.html#boolean-values
  [dict]: https://docs.python.org/3/library/stdtypes.html#mapping-types-dict
  [int]: https://docs.python.org/3/library/functions.html#int
  [float]: https://docs.python.org/3/library/functions.html#float
  [string]: https://docs.python.org/3/library/string.html
  [list]: https://docs.python.org/3/library/stdtypes.html#list
  [time.time()]: https://docs.python.org/3/library/time.html?#time.time
  [poetry]: https://python-poetry.org
  [LogDNA]: https://logdna.com/
  [LogRecord]: https://docs.python.org/2/library/logging.html#logrecord-objects
  [fileConfig]: https://docs.python.org/2/library/logging.config.html#logging.config.fileConfig


pkgId: 55dea574cc3896b6beaaaaaafcc8c7936bf77434160a3b599a4c4d33c584d648
name: python-logging_tree
arch: src
version: 1.9
epoch: 0
release: 1
summary: Introspect and display the logger tree inside "logging"
url: https://github.com/brandon-rhodes/logging_tree
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b610d2f0-b166-49e1-828a-a44b2a2bb953
location_href: 00004126-python-logging-tree/python-logging_tree-1.9-1.src.rpm
checksum_type: sha256
description:
  **Version 1.9** - 2021 April 10
      Declare compatibility with Python 3.9.  Improve how the logging
      module's built-in ``Formatter`` class is displayed under old Python
      versions where the ``logging`` module uses old-style classes.
  **Version 1.8.1** - 2020 January 26
      Adjust one test to make it pass under Python 3.8, and update the
      distribution classifiers to declare compatibility with Python
      versions through 3.8.
  **Version 1.8** - 2018 August 5
      Improve the output to better explain what happens if a "parent"
      attribute has been set to None.
  **Version 1.7** - 2016 January 23
      Detect whether each logger has the correct "parent" attribute and,
      if not, print where its log messages are being sent instead.
  **Version 1.6** - 2015 January 8
      Fixed a crash that would occur if a custom logging Formatter was
      missing its format string attributes.
  **Version 1.5** - 2014 December 24
      Handlers now display their logging level if one has been set, and
      their custom logging formatter if one has been installed.
  **Version 1.4** - 2014 January 8
      Thanks to a contribution from Dave Brondsema, disabled loggers are
      now actually marked as "Disabled" to make it less of a surprise that
      they fail to log anything.
  **Version 1.3** - 2013 October 29
      Be explicit and display the logger level ``NOTSET`` along with the
      effective level inherited from the logger's ancestors; and display
      the list of ``.filters`` of a custom logging handler even though it
      might contain custom code that ignores them.
  **Version 1.2** - 2013 January 19
      Compatible with Python 3.3 thanks to @ralphbean.
  **Version 1.1** - 2012 February 17
      Now compatible with 2.3 <= Python <= 3.2.
  **Version 1.0** - 2012 February 13
      Can display the handler inside a MemoryHandler; entire public
      interface documented; 100% test coverage.
  **Version 0.6** - 2012 February 10
      Added a display format for every ``logging.handlers`` class.
  **Version 0.5** - 2012 February 8
      Initial release.


pkgId: 9b67ae79aa7027a2f9c92ff74db06889155aae2c49a5fc05db3ca9379b9e47e6
name: python-loggly-python-handler
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Python logging handler that sends messages to Loggly
url: https://github.com/loggly/loggly-python-handler/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-10220ae5-2232-45fa-b977-7119367af43c
location_href: 00012235-python-loggly-python-handler/python-loggly-python-handler-1.0.1-1.src.rpm
checksum_type: sha256
description:
  A simple Python logging Loggly handler that can be used to send to a Loggly Gen2 https endpoint. Borrowed the extra fields concept from the graypy logging library. Check out Loggly's [Python logging documentation](https://www.loggly.com/docs/python-http/) to learn more.

  Download the repository using pip
      sudo pip install loggly-python-handler


  Create a Configuration file python.conf and add HTTPSHandler to Configuration File.
      [handlers]
      keys=HTTPSHandler
      [handler_HTTPSHandler]
      class=loggly.handlers.HTTPSHandler
      formatter=jsonFormat
      args=('https://logs-01.loggly.com/inputs/TOKEN/tag/python','POST')
      [formatters]
      keys=jsonFormat
      [loggers]
      keys=root
      [logger_root]
      handlers=HTTPSHandler
      level=INFO
      [formatter_jsonFormat]
      format={ "loggerName":"s", "asciTime":"s", "fileName":"s", "logRecordCreationTime":"f", "functionName":"s", "levelNo":"s", "lineNo":"d", "time":"d", "levelName":"s", "message":"s"}
      datefmt=

      import logging
      import logging.config
      import loggly.handlers
      logging.config.fileConfig('python.conf')
      logger = logging.getLogger('myLogger')
      logger.info('Test log')


      LOGGING = {
          'version': 1,
          'disable_existing_loggers': False,
          'formatters': {
              'verbose': {
                  'format': 's s s d d s'
              },
              'simple': {
                  'format': 's s'
              },
              'json': {
                  'format': '{ "loggerName":"s", "asciTime":"s", "fileName":"s", "logRecordCreationTime":"f", "functionName":"s", "levelNo":"s", "lineNo":"d", "time":"d", "levelName":"s", "message":"s"}',
              },
          },
          'handlers': {
              'console': {
                  'class': 'logging.StreamHandler',
                  'level': 'DEBUG',
                  'formatter': 'verbose',
              },
              'loggly': {
                  'class': 'loggly.handlers.HTTPSHandler',
                  'level': 'INFO',
                  'formatter': 'json',
                  'url': 'https://logs-01.loggly.com/inputs/TOKEN/tag/python',
              },
          },
          'loggers': {
              'django': {
                  'handlers': ['console', ],
                  'level': os.getenv('DJANGO_LOG_LEVEL', 'INFO'),
              },
              'your_app_name': {
                  'handlers': ['console', 'loggly'],
                  'level': 'INFO',
              },
          },
      }

      import logging
      logger = logging.getLogger(__name__)
      def logging_example(request):
          """logging example
          """
          logger.debug('this is DEBUG message.')
          logger.info('this is INFO message.')
          logger.warning('this is WARNING message.')
          logger.error('this is ERROR message.')
          logger.critical('this is CRITICAL message.')
          return Response({}, status=status.HTTP_200_OK)
  Replace
  <ul>
  <li><strong>TOKEN: </strong>your Loggly Customer Token</li>
  </ul>


pkgId: 2269479b1eb5881678313710d7b39c7478acbf3fd256c3199fa5838d29226ff0
name: python-logstash_formatter
arch: src
version: 0.5.17
epoch: 0
release: 1
summary: JSON formatter meant for logstash
url: https://github.com/exoscale/python-logstash-formatter
rpm_license: MIT, see LICENSE file
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a6ce9eeb-2e79-4377-9fa2-78ba2a7a6586
location_href: 00011325-python-logstash-formatter/python-logstash_formatter-0.5.17-1.src.rpm
checksum_type: sha256
description:
  This library is provided to allow standard python logging to output log data
  as json objects ready to be shipped out to logstash.
  This project has been originally open sourced by `exoscale <https://www.exoscale.ch/>`_ (which is a great hosting service btw), thanks to them.


pkgId: b15991a7d8223b436a641a8061c566533a8ad1223526056710c7a33dcfea9776
name: python-loguru
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Python logging made (stupidly) simple
url: https://github.com/Delgan/loguru
rpm_license: MIT license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2389c1e9-0c14-4ae0-b3f5-1a42af325d17
location_href: 00009382-python-loguru/python-loguru-0.7.0-1.src.rpm
checksum_type: sha256
description:
  **Loguru** is a library which aims to bring enjoyable logging in Python.
  Did you ever feel lazy about configuring a logger and used ``print()`` instead?... I did, yet logging is fundamental to every application and eases the process of debugging. Using **Loguru** you have no excuse not to use logging from the start, this is as simple as ``from loguru import logger``.
  Also, this library is intended to make Python logging less painful by adding a bunch of useful functionalities that solve caveats of the standard loggers. Using logs in your application should be an automatism, **Loguru** tries to make it both pleasant and powerful.


pkgId: 540fe3b80445bd573ab9a49ca157f064fb3e71524df34599a8484c97de66326a
name: python-logutils
arch: src
version: 0.3.5
epoch: 0
release: 1
summary: Logging utilities
url: http://code.google.com/p/logutils/
rpm_license: Copyright (C) 2010-2017 by Vinay Sajip. All Rights Reserved. See LICENSE.txt for license.
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ea086f44-4f11-4cc7-9dbb-59c50ec03b0c
location_href: 00011705-python-logutils/python-logutils-0.3.5-1.src.rpm
checksum_type: sha256
description:
  The logutils package provides a set of handlers for the Python standard
  library's logging package.

  Some of these handlers are out-of-scope for the standard library, and
  so they are packaged here. Others are updated versions which have
  appeared in recent Python releases, but are usable with older versions
  of Python and so are packaged here.

  The source code repository is at:

  https://bitbucket.org/vinay.sajip/logutils/

  Documentation is available at:

  https://logutils.readthedocs.io/

  https://pythonhosted.org/logutils/


pkgId: 3013663b7a84d60370b01c851c3d7b0f99e4e98a5e778b7d33120fa0e1c7936d
name: python-logzero
arch: src
version: 1.7.0
epoch: 0
release: 1
summary: Robust and effective logging for Python 2 and 3
url: https://github.com/metachris/logzero
rpm_license: MIT license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cdec0b23-c01d-4866-9ab4-acfd0c591314
location_href: 00004127-python-logzero/python-logzero-1.7.0-1.src.rpm
checksum_type: sha256
description:
  * Easy logging to console and/or (rotating) file.
  * Provides a fully configured standard [Python logger object](https://docs.python.org/2/library/logging.html#module-level-functions>).
  * JSON logging (with integrated [python-json-logger](https://github.com/madzak/python-json-logger))
  * Pretty formatting, including level-specific colors in the console.
  * No dependencies
  * Windows color output supported by [colorama](https://github.com/tartley/colorama)
  * Robust against str/bytes encoding problems, works with all kinds of character encodings and special characters.
  * Multiple loggers can write to the same logfile (also across multiple Python files and processes).
  * Global default logger with [logzero.logger](https://logzero.readthedocs.io/en/latest/#i-logzero-logger) and custom loggers with [logzero.setup_logger(..)](https://logzero.readthedocs.io/en/latest/#i-logzero-setup-logger).
  * Compatible with Python 2 and 3.
  * All contained in a [single file](https://github.com/metachris/logzero/blob/master/logzero/__init__.py).
  * Licensed under the MIT license.
  * Heavily inspired by the [Tornado web framework](https://github.com/tornadoweb/tornado).
  Installation:
  ```shell
  python -m pip install logzero
  ```


pkgId: 6a53fb72937223ea11d16dd8ffb1feb07be8f70ed00fe5d3c3f09f7c00c8aa78
name: python-lpips
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: LPIPS Similarity metric
url: https://github.com/richzhang/PerceptualSimilarity
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c0607674-8d39-4f1d-a99d-57cccde64255
location_href: 00013809-python-lpips/python-lpips-0.1.4-1.src.rpm
checksum_type: sha256
description:
  **The Unreasonable Effectiveness of Deep Features as a Perceptual Metric**
  [Richard Zhang](https://richzhang.github.io/), [Phillip Isola](http://web.mit.edu/phillipi/), [Alexei A. Efros](http://www.eecs.berkeley.edu/~efros/), [Eli Shechtman](https://research.adobe.com/person/eli-shechtman/), [Oliver Wang](http://www.oliverwang.info/). In [CVPR](https://arxiv.org/abs/1801.03924), 2018.

  <img src='https://richzhang.github.io/PerceptualSimilarity/index_files/fig1_v2.jpg' width=1200>



  Run `pip install lpips`. The following Python code is all you need.

  ```python
  import lpips
  loss_fn_alex = lpips.LPIPS(net='alex') # best forward scores
  loss_fn_vgg = lpips.LPIPS(net='vgg') # closer to "traditional" perceptual loss, when used for optimization

  import torch
  img0 = torch.zeros(1,3,64,64) # image should be RGB, IMPORTANT: normalized to [-1,1]
  img1 = torch.zeros(1,3,64,64)
  d = loss_fn_alex(img0, img1)
  ```

  More thorough information about variants is below. This repository contains our **perceptual metric (LPIPS)** and **dataset (BAPPS)**. It can also be used as a "perceptual loss". This uses PyTorch; a Tensorflow alternative is [here](https://github.com/alexlee-gk/lpips-tensorflow).


  **Table of Contents**<br>
  1. [Learned Perceptual Image Patch Similarity (LPIPS) metric](#1-learned-perceptual-image-patch-similarity-lpips-metric)<br>
     a. [Basic Usage](#a-basic-usage) If you just want to run the metric through command line, this is all you need.<br>
     b. ["Perceptual Loss" usage](#b-backpropping-through-the-metric)<br>
     c. [About the metric](#c-about-the-metric)<br>
  2. [Berkeley-Adobe Perceptual Patch Similarity (BAPPS) dataset](#2-berkeley-adobe-perceptual-patch-similarity-bapps-dataset)<br>
     a. [Download](#a-downloading-the-dataset)<br>
     b. [Evaluation](#b-evaluating-a-perceptual-similarity-metric-on-a-dataset)<br>
     c. [About the dataset](#c-about-the-dataset)<br>
     d. [Train the metric using the dataset](#d-using-the-dataset-to-train-the-metric)<br>




  - Install PyTorch 1.0+ and torchvision fom http://pytorch.org

  ```bash
  pip install -r requirements.txt
  ```
  - Clone this repo:
  ```bash
  git clone https://github.com/richzhang/PerceptualSimilarity
  cd PerceptualSimilarity
  ```



  Evaluate the distance between image patches. **Higher means further/more different. Lower means more similar.**





  Example scripts to take the distance between 2 specific images, all corresponding pairs of images in 2 directories, or all pairs of images within a directory:

  ```
  python lpips_2imgs.py -p0 imgs/ex_ref.png -p1 imgs/ex_p0.png --use_gpu
  python lpips_2dirs.py -d0 imgs/ex_dir0 -d1 imgs/ex_dir1 -o imgs/example_dists.txt --use_gpu
  python lpips_1dir_allpairs.py -d imgs/ex_dir_pair -o imgs/example_dists_pair.txt --use_gpu
  ```



  File [test_network.py](test_network.py) shows example usage. This snippet is all you really need.

  ```python
  import lpips
  loss_fn = lpips.LPIPS(net='alex')
  d = loss_fn.forward(im0,im1)
  ```

  Variables ```im0, im1``` is a PyTorch Tensor/Variable with shape ```Nx3xHxW``` (```N``` patches of size ```HxW```, RGB images scaled in `[-1,+1]`). This returns `d`, a length `N` Tensor/Variable.

  Run `python test_network.py` to take the distance between example reference image [`ex_ref.png`](imgs/ex_ref.png) to distorted images [`ex_p0.png`](./imgs/ex_p0.png) and [`ex_p1.png`](imgs/ex_p1.png). Before running it - which do you think *should* be closer?

  **Some Options** By default in `model.initialize`:
  - By default, `net='alex'`. Network `alex` is fastest, performs the best (as a forward metric), and is the default. For backpropping, `net='vgg'` loss is closer to the traditional "perceptual loss".
  - By default, `lpips=True`. This adds a linear calibration on top of intermediate features in the net. Set this to `lpips=False` to equally weight all the features.



  File [`lpips_loss.py`](lpips_loss.py) shows how to iteratively optimize using the metric. Run `python lpips_loss.py` for a demo. The code can also be used to implement vanilla VGG loss, without our learned weights.



  **Higher means further/more different. Lower means more similar.**

  We found that deep network activations work surprisingly well as a perceptual similarity metric. This was true across network architectures (SqueezeNet [2.8 MB], AlexNet [9.1 MB], and VGG [58.9 MB] provided similar scores) and supervisory signals (unsupervised, self-supervised, and supervised all perform strongly). We slightly improved scores by linearly "calibrating" networks - adding a linear layer on top of off-the-shelf classification networks. We provide 3 variants, using linear layers on top of the SqueezeNet, AlexNet (default), and VGG networks.

  If you use LPIPS in your publication, please specify which version you are using. The current version is 0.1. You can set `version='0.0'` for the initial release.





  Run `bash ./scripts/download_dataset.sh` to download and unzip the dataset into directory `./dataset`. It takes [6.6 GB] total. Alternatively, run `bash ./scripts/download_dataset_valonly.sh` to only download the validation set [1.3 GB].
  - 2AFC train [5.3 GB]
  - 2AFC val [1.1 GB]
  - JND val [0.2 GB]



  Script `test_dataset_model.py` evaluates a perceptual model on a subset of the dataset.

  **Dataset flags**
  - `--dataset_mode`: `2afc` or `jnd`, which type of perceptual judgment to evaluate
  - `--datasets`: list the datasets to evaluate
      - if `--dataset_mode 2afc`: choices are [`train/traditional`, `train/cnn`, `val/traditional`, `val/cnn`, `val/superres`, `val/deblur`, `val/color`, `val/frameinterp`]
      - if `--dataset_mode jnd`: choices are [`val/traditional`, `val/cnn`]

  **Perceptual similarity model flags**
  - `--model`: perceptual similarity model to use
      - `lpips` for our LPIPS learned similarity model (linear network on top of internal activations of pretrained network)
      - `baseline` for a classification network (uncalibrated with all layers averaged)
      - `l2` for Euclidean distance
      - `ssim` for Structured Similarity Image Metric
  - `--net`: [`squeeze`,`alex`,`vgg`] for the `net-lin` and `net` models; ignored for `l2` and `ssim` models
  - `--colorspace`: choices are [`Lab`,`RGB`], used for the `l2` and `ssim` models; ignored for `net-lin` and `net` models

  **Misc flags**
  - `--batch_size`: evaluation batch size (will default to 1)
  - `--use_gpu`: turn on this flag for GPU usage

  An example usage is as follows: `python ./test_dataset_model.py --dataset_mode 2afc --datasets val/traditional val/cnn --model lpips --net alex --use_gpu --batch_size 50`. This would evaluate our model on the "traditional" and "cnn" validation datasets.



  The dataset contains two types of perceptual judgements: **Two Alternative Forced Choice (2AFC)** and **Just Noticeable Differences (JND)**.

  **(1) 2AFC** Evaluators were given a patch triplet (1 reference + 2 distorted). They were asked to select which of the distorted was "closer" to the reference.

  Training sets contain 2 judgments/triplet.
  - `train/traditional` [56.6k triplets]
  - `train/cnn` [38.1k triplets]
  - `train/mix` [56.6k triplets]

  Validation sets contain 5 judgments/triplet.
  - `val/traditional` [4.7k triplets]
  - `val/cnn` [4.7k triplets]
  - `val/superres` [10.9k triplets]
  - `val/deblur` [9.4k triplets]
  - `val/color` [4.7k triplets]
  - `val/frameinterp` [1.9k triplets]

  Each 2AFC subdirectory contains the following folders:
  - `ref`: original reference patches
  - `p0,p1`: two distorted patches
  - `judge`: human judgments - 0 if all preferred p0, 1 if all humans preferred p1

  **(2) JND** Evaluators were presented with two patches - a reference and a distorted - for a limited time. They were asked if the patches were the same (identically) or different.

  Each set contains 3 human evaluations/example.
  - `val/traditional` [4.8k pairs]
  - `val/cnn` [4.8k pairs]

  Each JND subdirectory contains the following folders:
  - `p0,p1`: two patches
  - `same`: human judgments: 0 if all humans thought patches were different, 1 if all humans thought patches were same



  See script `train_test_metric.sh` for an example of training and testing the metric. The script will train a model on the full training set for 10 epochs, and then test the learned metric on all of the validation sets. The numbers should roughly match the **Alex - lin** row in Table 5 in the [paper](https://arxiv.org/abs/1801.03924). The code supports training a linear layer on top of an existing representation. Training will add a subdirectory in the `checkpoints` directory.

  You can also train "scratch" and "tune" versions by running `train_test_metric_scratch.sh` and `train_test_metric_tune.sh`, respectively.



  If you find this repository useful for your research, please use the following.

  ```
  @inproceedings{zhang2018perceptual,
    title={The Unreasonable Effectiveness of Deep Features as a Perceptual Metric},
    author={Zhang, Richard and Isola, Phillip and Efros, Alexei A and Shechtman, Eli and Wang, Oliver},
    booktitle={CVPR},
    year={2018}
  }
  ```



  This repository borrows partially from the [pytorch-CycleGAN-and-pix2pix](https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix) repository. The average precision (AP) code is borrowed from the [py-faster-rcnn](https://github.com/rbgirshick/py-faster-rcnn/blob/master/lib/datasets/voc_eval.py) repository. [Angjoo Kanazawa](https://github.com/akanazawa), [Connelly Barnes](http://www.connellybarnes.com/work/), [Gaurav Mittal](https://github.com/g1910), [wilhelmhb](https://github.com/wilhelmhb), [Filippo Mameli](https://github.com/mameli), [SuperShinyEyes](https://github.com/SuperShinyEyes), [Minyoung Huh](http://people.csail.mit.edu/minhuh/) helped to improve the codebase.


pkgId: 3b9f2fa413bd17523c4b9a06f6973c91a382091405f8c64b5943d3829d923aab
name: python-lrparsing
arch: src
version: 1.0.13
epoch: 0
release: 1
summary: An LR(1) parser hiding behind a pythonic interface
url: http://lrparsing.sourceforge.net/
rpm_license: GNU Affero General Public License v3 or later (AGPLv3+)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dcce0193-8c2e-494c-b292-809ac9def5ff
location_href: 00004128-python-lrparsing/python-lrparsing-1.0.13-1.src.rpm
checksum_type: sha256
description:
  Lrparsing provides both an LR(1) parser and a
  tokeniser.  It differs from other Python LR(1) parsers in
  using Python expressions as grammars, and offers simple to use
  disambiguation tools.

  The result is something that is powerful yet concise.  For simple
  tasks this means it can be thought of as an extension to Python's
  existing re module, used when regular expressions become
  too cumbersome.   For complex tasks lrparsing offers a high speed
  parser (very roughly 25us per token from string to parse tree
  on a desktop CPU), pre-compilation of the grammar and error recovery
  hooks so parsing can continue after an error is found.

  In addition to extensive documentation it comes with a parser for
  Sqlite3 data manipulation statements and a Lua 5.2 to Python
  compiler as examples.  The documentation can be read online at
  http://lrparsing.sourceforge.net/doc/html/.


pkgId: be4eb16b7102a1772f03397d7c73f83e38d68ee5ba465cadcff375d38015e6d3
name: python-lru-dict
arch: src
version: 1.1.8
epoch: 0
release: 1
summary: An Dict like LRU container.
url: https://github.com/amitdev/lru-dict
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-08a6dc05-bc69-4590-8880-06dfca6cf2c7
location_href: 00010137-python-lru-dict/python-lru-dict-1.1.8-1.src.rpm
checksum_type: sha256
description:
  A fixed size dict like container which evicts Least Recently Used (LRU) items
  once size limit is exceeded. There are many python implementations available
  which does similar things. This is a fast and efficient C implementation.
  LRU maximum capacity can be modified at run-time.
  If you are looking for pure python version, look `else where <http://www.google.com/search?q=python+lru+dict>`_.


pkgId: e609478a5209cb3409399ad993e1fe372eb993a7c6c08db6225b8bc26a044d36
name: python-lru-dict-debuginfo
arch: aarch64
version: 1.1.8
epoch: 0
release: 1
summary: Debug information for package python-lru-dict
url: https://github.com/amitdev/lru-dict
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-08a6dc05-bc69-4590-8880-06dfca6cf2c7
rpm_sourcerpm: python-lru-dict-1.1.8-1.src.rpm
location_href: 00010137-python-lru-dict/python-lru-dict-debuginfo-1.1.8-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-lru-dict.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: eeff26d5f53a19ece38aaef1e61d2e87c2fdb8903443c176f1569809fc176959
name: python-lru-dict-debugsource
arch: aarch64
version: 1.1.8
epoch: 0
release: 1
summary: Debug sources for package python-lru-dict
url: https://github.com/amitdev/lru-dict
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-08a6dc05-bc69-4590-8880-06dfca6cf2c7
rpm_sourcerpm: python-lru-dict-1.1.8-1.src.rpm
location_href: 00010137-python-lru-dict/python-lru-dict-debugsource-1.1.8-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-lru-dict.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: c88dc74db079921f7cc390a293557831ac59f9d79405711ed875ad381d160f21
name: python-lti-consumer-xblock
arch: src
version: 9.0.0
epoch: 0
release: 1
summary: This XBlock implements the consumer side of the LTI specification.
url: https://github.com/openedx/xblock-lti-consumer
rpm_license: GNU Affero General Public License v3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-446355a4-e897-40a3-abf6-e30540b10283
location_href: 00013859-python-lti-consumer-xblock/python-lti-consumer-xblock-9.0.0-1.src.rpm
checksum_type: sha256
description:
  For details regarding how to deploy this or any other XBlock in the lms instance, see the `installing-the-xblock`_ documentation.


pkgId: 03ec410418674a1b646c90740a2899cd57de546c44e5a66b29e6017a0d0dc7d9
name: python-luftdaten
arch: src
version: 0.7.4
epoch: 0
release: 1
summary: Python API for interacting with luftdaten.info
url: https://github.com/home-assistant-ecosystem/python-luftdaten
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-86401386-6f66-43f4-86c5-37108ab6c2c3
location_href: 00004131-python-luftdaten/python-luftdaten-0.7.4-1.src.rpm
checksum_type: sha256
description:
  Python client for interacting with `sensor.community <https://sensor.community/>`_ (previously known as `luftdaten.info <http://luftdaten.info/>`_.
  This module is not official, developed, supported or endorsed by sensor.community/luftdaten.info.


pkgId: 57bb1f65fd420acc6402bd02db8aed70fde3a6e489d5490810bad0357b57193a
name: python-luhn
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Generate and verify Luhn check digits
url: https://github.com/mmcloughlin/luhn
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b4ac80dc-5b85-462b-bda7-eb60fd4446ca
location_href: 00011959-python-luhn/python-luhn-0.2.0-1.src.rpm
checksum_type: sha256
description:
  |pypi| |buildstatus| |coverage|
  Generate and verify Luhn check digits
  Install with
      pip install luhn
  Use ``verify`` to check digit strings
      >>> from luhn import *
      >>> verify('356938035643809')
      True
      >>> verify('534618613411236')
      False
  and use ``generate`` to produce them
      >>> generate('53461861341123')
      4
  or ``append`` for convenience
      >>> append('53461861341123')
      '534618613411234'


pkgId: 4d87a05e8d3982a9e4b263631c964e1237b40a89e6b022b50fc9cb6155a08f3e
name: python-luigi
arch: src
version: 3.2.1
epoch: 0
release: 1
summary: Workflow mgmgt + task scheduling + dependency resolution.
url: https://github.com/spotify/luigi
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a7b7a388-bf2f-4da4-acd4-8a7d662292d8
location_href: 00009747-python-luigi/python-luigi-3.2.1-1.src.rpm
checksum_type: sha256
description:
  Run ``pip install luigi`` to install the latest stable version from `PyPI
  <https://pypi.python.org/pypi/luigi>`_. `Documentation for the latest release
  <https://luigi.readthedocs.io/en/stable/>`__ is hosted on readthedocs.
  Run ``pip install luigi[toml]`` to install Luigi with `TOML-based configs
  <https://luigi.readthedocs.io/en/stable/configuration.html>`__ support.
  For the bleeding edge code, ``pip install
  git+https://github.com/spotify/luigi.git``. `Bleeding edge documentation
  <https://luigi.readthedocs.io/en/latest/>`__ is also available.


pkgId: c6c4093d74fbfb6abc6384329a424f2de4d88fc35c1731e8a21d8ce408c98df0
name: python-lunr
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: A Python implementation of Lunr.js
url: https://github.com/yeraydiazdiaz/lunr.py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e1d3a0df-c183-4a66-a3f7-1c3b55fefc29
location_href: 00004132-python-lunr/python-lunr-0.6.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/yeraydiazdiaz/lunr.py/workflows/CI/badge.svg?branch=master)](https://github.com/yeraydiazdiaz/lunr.py/actions?workflow=CI)
  [![codecov](https://codecov.io/gh/yeraydiazdiaz/lunr.py/branch/master/graph/badge.svg)](https://codecov.io/gh/yeraydiazdiaz/lunr.py)
  [![Supported Python Versions](https://img.shields.io/pypi/pyversions/lunr.svg)](https://pypi.org/project/lunr/)
  [![PyPI](https://img.shields.io/pypi/v/lunr.svg)](https://pypi.org/project/lunr/)
  [![Read the Docs](https://img.shields.io/readthedocs/lunr.svg)](http://lunr.readthedocs.io/en/latest/)
  [![Downloads](http://pepy.tech/badge/lunr)](http://pepy.tech/project/lunr)
  [![shoutouts.dev](https://shoutouts.dev/projects/yeraydiazdiaz/lunr.py/badge)](https://shoutouts.dev/projects/yeraydiazdiaz/lunr.py)



  A Python implementation of [Lunr.js](https://lunrjs.com) by [Oliver Nightingale](https://github.com/olivernn).

  > A bit like Solr, but much smaller and not as bright.

  This Python version of Lunr.js aims to bring the simple and powerful full text search
  capabilities into Python guaranteeing results as close as the original
  implementation as possible.

  - [Documentation](http://lunr.readthedocs.io/en/latest/)



  Lunr is a simple full text search solution for situations where deploying a full
  scale solution like Elasticsearch isn't possible, viable or you're simply prototyping.
  Lunr parses a set of documents and creates an inverted index for quick full text
  searches in the same way other more complicated solution.

  The trade-off is that Lunr keeps the inverted index in memory and requires you
  to recreate or read the index at the start of your application.



  A core objective of Lunr.py is to provide
  [interoperability with the JavaScript version](https://lunr.readthedocs.io/en/latest/lunrjs-interop).

  An example can be found in the [MkDocs documentation library](http://www.mkdocs.org/).
  MkDocs produces a set of documents from the pages of the documentation and uses
  [Lunr.js](https://lunrjs.com) in the frontend to power its built-in searching
  engine. This set of documents is in the form of a JSON file which needs to be
  fetched and parsed by Lunr.js to create the inverted index at startup of your application.

  While this is not a problem for most sites, depending on the size of your document
  set, this can take some time.

  Lunr.py provides a backend solution, allowing you to parse the documents in Python
  of time and create a serialized Lunr.js index you can pass have the browser
  version read, minimizing start up time of your application.

  Each version of lunr.py
  [targets a specific version of lunr.js](https://github.com/yeraydiazdiaz/lunr.py/blob/master/lunr/__init__.py#L12)
  and produces the same results for a
  [non-trivial corpus of documents](https://github.com/yeraydiazdiaz/lunr.py/blob/master/tests/acceptance_tests/fixtures/mkdocs_index.json).



  `pip install lunr`

  An optional and experimental support for other languages thanks to the
  [Natural Language Toolkit](http://www.nltk.org/) stemmers is also available via
  `pip install lunr[languages]`. The usage of the language feature is subject to
  [NTLK corpus licensing clauses](https://github.com/nltk/nltk#redistributing).

  Please refer to the
  [documentation page on languages](https://lunr.readthedocs.io/en/latest/languages/)
  for more information.



  First, you'll need a list of dicts representing the documents you want to search on.
  These documents must have a unique field which will serve as a reference and a
  series of fields you'd like to search on.

  Lunr provides a convenience `lunr` function to quickly index this set of documents:

  ```python
  >>> from lunr import lunr
  >>>
  >>> documents = [{
  ...     'id': 'a',
  ...     'title': 'Mr. Green kills Colonel Mustard',
  ...     'body': 'Mr. Green killed Colonel Mustard in the study with the candlestick.',
  ... }, {
  ...     'id': 'b',
  ...     'title': 'Plumb waters plant',
  ...     'body': 'Professor Plumb has a green plant in his study',
  ... }]
  >>> idx = lunr(
  ...     ref='id', fields=('title', 'body'), documents=documents
  ... )
  >>> idx.search('kill')
  [{'ref': 'a', 'score': 0.6931722372559913, 'match_data': <MatchData "kill">}]
  >>> idx.search('study')
  [{'ref': 'b', 'score': 0.23576799568081389, 'match_data': <MatchData "studi">}, {'ref': 'a', 'score': 0.2236629211724517, 'match_data': <MatchData "studi">}]
  ```

  Please refer to the [documentation](http://lunr.readthedocs.io/en/latest/)
  for more usage examples.


pkgId: 176420d136d436be10a373ca13d0459b94aa70ef5b7d684b05f96db3f36957ba
name: python-lupa
arch: src
version: 1.14.1
epoch: 0
release: 1
summary: Python wrapper around Lua and LuaJIT
url: https://github.com/scoder/lupa
rpm_license: MIT style
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-61c3663c-3e0e-47b8-87ae-38ee526a46a2
location_href: 00004134-python-lupa/python-lupa-1.14.1-1.src.rpm
checksum_type: sha256
description:
  Lupa integrates the runtimes of Lua_ or LuaJIT2_ into CPython.
  It is a partial rewrite of LunaticPython_ in Cython_ with some
  additional features such as proper coroutine support.
  For questions not answered here, please contact the `Lupa mailing list`_.


pkgId: cdfcc688f6085a83fcd54bf47f9151b620715f9dcc4ed6fff0da92aac0176368
name: python-lupa-debuginfo
arch: aarch64
version: 1.14.1
epoch: 0
release: 1
summary: Debug information for package python-lupa
url: https://github.com/scoder/lupa
rpm_license: MIT style
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-61c3663c-3e0e-47b8-87ae-38ee526a46a2
rpm_sourcerpm: python-lupa-1.14.1-1.src.rpm
location_href: 00004134-python-lupa/python-lupa-debuginfo-1.14.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-lupa.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: be5b1d619fb4a6730272136ecee7ce376e6e0b5cdeda8f150bdd209f008d5ef8
name: python-lupa-debugsource
arch: aarch64
version: 1.14.1
epoch: 0
release: 1
summary: Debug sources for package python-lupa
url: https://github.com/scoder/lupa
rpm_license: MIT style
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-61c3663c-3e0e-47b8-87ae-38ee526a46a2
rpm_sourcerpm: python-lupa-1.14.1-1.src.rpm
location_href: 00004134-python-lupa/python-lupa-debugsource-1.14.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-lupa.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 5cd1b2ae763e6a2ca86396cddb4dcdf80025a0e0e4e5a04ef7f23b05d573bbef
name: python-lyricsgenius
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: Download lyrics and metadata from Genius.com
url: https://github.com/johnwmillr/lyricsgenius
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c6d801f0-c45b-4d1e-a10f-70bab045d839
location_href: 00010775-python-lyricsgenius/python-lyricsgenius-3.0.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/johnwmillr/LyricsGenius.svg?branch=master)](https://travis-ci.org/johnwmillr/LyricsGenius)
  [![Documentation Status](https://readthedocs.org/projects/lyricsgenius/badge/?version=master)](https://lyricsgenius.readthedocs.io/en/latest/?badge=master)
  [![PyPI version](https://badge.fury.io/py/lyricsgenius.svg)](https://pypi.org/project/lyricsgenius/)
  [![Python version](https://img.shields.io/badge/python-3.x-brightgreen.svg)](https://pypi.org/project/lyricsgenius/)

  `lyricsgenius` provides a simple interface to the song, artist, and lyrics data stored on [Genius.com](https://www.genius.com).

  The full documentation for `lyricsgenius` is available online at [Read the Docs](https://lyricsgenius.readthedocs.io/en/master/).


  Before using this package you'll need to sign up for a (free) account that authorizes access to [the Genius API](http://genius.com/api-clients). The Genius account provides a `access_token` that is required by the package. See the [Usage section](https://github.com/johnwmillr/LyricsGenius#usage) below for examples.


  `lyricsgenius` requires Python 3.

  Use `pip` to install the package from PyPI:

  ```bash
  pip install lyricsgenius
  ```

  Or, install the latest version of the package from GitHub:

  ```bash
  pip install git+https://github.com/johnwmillr/LyricsGenius.git
  ```


  Import the package and initiate Genius:

  ```python
  import lyricsgenius
  genius = lyricsgenius.Genius(token)
  ```

  If you don't pass a token to the `Genius` class, `lyricsgenus` will look for an environment variable called `GENIUS_ACCESS_TOKEN` and attempt to use that for authentication.

  ```python
  genius = Genius()
  ```

  Search for songs by a given artist:

  ```python
  artist = genius.search_artist("Andy Shauf", max_songs=3, sort="title")
  print(artist.songs)
  ```
  By default, the `search_artist()` only returns songs where the given artist is the primary artist.
  However, there may be instances where it is desirable to get all of the songs that the artist appears on.
  You can do this by setting the `include_features` argument to `True`.

  ```python
  artist = genius.search_artist("Andy Shauf", max_songs=3, sort="title", include_features=True)
  print(artist.songs)
  ```

  Search for a single song by the same artist:

  ```python
  song = artist.song("To You")


  print(song.lyrics)
  ```

  Add the song to the artist object:

  ```python
  artist.add_song(song)


  ```

  Save the artist's songs to a JSON file:

  ```python
  artist.save_lyrics()
  ```

  Searching for an album and saving it:

  ```python
  album = genius.search_album("The Party", "Andy Shauf")
  album.save_lyrics()
  ```

  There are various options configurable as parameters within the `Genius` class:

  ```python
  genius.verbose = False # Turn off status messages
  genius.remove_section_headers = True # Remove section headers (e.g. [Chorus]) from lyrics when searching
  genius.skip_non_songs = False # Include hits thought to be non-songs (e.g. track lists)
  genius.excluded_terms = ["(Remix)", "(Live)"] # Exclude songs with these words in their title
  ```

  You can also call the package from the command line:

  ```bash
  export GENIUS_ACCESS_TOKEN="my_access_token_here"
  python3 -m lyricsgenius --help
  ```

  Search for and save lyrics to a given song and album:

  ```bash
  python3 -m lyricsgenius song "Begin Again" "Andy Shauf" --save
  python3 -m lyricsgenius album "The Party" "Andy Shauf" --save
  ```

  Search for five songs by 'The Beatles' and save the lyrics:

  ```bash
  python3 -m lyricsgenius artist "The Beatles" --max-songs 5 --save
  ```



    - [Trucks and Beer: A textual analysis of popular country music](http://www.johnwmillr.com/trucks-and-beer/)
    - [Neural machine translation: Explaining the Meaning Behind Lyrics](https://github.com/tsandefer/dsi_capstone_3)
    - [What makes some blink-182 songs more popular than others?](http://jdaytn.com/posts/download-blink-182-data/)
    - [Sentiment analysis on hip-hop lyrics](https://github.com/Hugo-Nattagh/2017-Hip-Hop)
    - [Does Country Music Drink More Than Other Genres?](https://towardsdatascience.com/does-country-music-drink-more-than-other-genres-a21db901940b)
    - [49 Years of Lyrics: Why So Angry?](https://towardsdatascience.com/49-years-of-lyrics-why-so-angry-1adf0a3fa2b4)


  Please contribute! If you want to fix a bug, suggest improvements, or add new features to the project, just [open an issue](https://github.com/johnwmillr/LyricsGenius/issues) or send me a pull request.


pkgId: 187df7eeec78f4b446af9d3e427d0e45b8270967210a659b03c412c13005cf8c
name: python-lz4-debuginfo
arch: aarch64
version: 4.3.2
epoch: 0
release: 1
summary: Debug information for package python-lz4
url: https://github.com/python-lz4/python-lz4
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-79594d2e-6b7d-41bc-abed-5dbc0373c6a3
rpm_sourcerpm: python-lz4-4.3.2-1.src.rpm
location_href: 00004138-python-lz4/python-lz4-debuginfo-4.3.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-lz4.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 1aa77d218ae5a99362698fc4a1aecb93d3d58374a0559566ddeed6cd17664d53
name: python-lz4-debugsource
arch: aarch64
version: 4.3.2
epoch: 0
release: 1
summary: Debug sources for package python-lz4
url: https://github.com/python-lz4/python-lz4
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-79594d2e-6b7d-41bc-abed-5dbc0373c6a3
rpm_sourcerpm: python-lz4-4.3.2-1.src.rpm
location_href: 00004138-python-lz4/python-lz4-debugsource-4.3.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-lz4.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 80a8ac3a3ab91b8115361717d9516cf487272f84a1e16200c779aa60f7f2fbc1
name: python-m2r2
arch: src
version: 0.3.3.post2
epoch: 0
release: 1
summary: Markdown and reStructuredText in a single file.
url: https://github.com/crossnox/m2r2
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ca1638ed-3d67-484f-b745-766496971bbd
location_href: 00011822-python-m2r2/python-m2r2-0.3.3.post2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/m2r2.svg)](https://pypi.python.org/pypi/m2r2)
  [![PyPI version](https://img.shields.io/pypi/pyversions/m2r2.svg)](https://pypi.python.org/pypi/m2r2)
  [![Documentation](https://img.shields.io/badge/docs-latest-brightgreen.svg)](https://crossnox.github.io/m2r2)


pkgId: da1f64bffc527e01b124ddb63cda6ad20765cd6c7b8a2004cf16e1bff4fd18c2
name: python-macholib
arch: src
version: 1.16.2
epoch: 0
release: 1
summary: Mach-O header analysis and editing
url: http://github.com/ronaldoussoren/macholib
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f792a82b-2b44-4386-b588-b3a9e924fc27
location_href: 00011048-python-macholib/python-macholib-1.16.2-1.src.rpm
checksum_type: sha256
description:
  * .. image:: https://github.com/ronaldoussoren/macholib/workflows/Lint/badge.svg
  * .. image:: https://github.com/ronaldoussoren/macholib/workflows/Test/badge.svg


pkgId: 6c687fb09ec24f769ea083fc30f8d12a11def2cde821a8f4be9b5a68479eb72d
name: python-magic-wormhole
arch: src
version: 0.12.0
epoch: 0
release: 1
summary: Securely transfer data between computers
url: https://github.com/warner/magic-wormhole
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b5856441-7af4-459c-b538-a1d099317804
location_href: 00004141-python-magic-wormhole/python-magic-wormhole-0.12.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](http://img.shields.io/pypi/v/magic-wormhole.svg)](https://pypi.python.org/pypi/magic-wormhole)
  [![Build Status](https://travis-ci.org/warner/magic-wormhole.svg?branch=master)](https://travis-ci.org/warner/magic-wormhole)
  [![Windows Build Status](https://ci.appveyor.com/api/projects/status/mfnn5rsyfnrq576a/branch/master?svg=true)](https://ci.appveyor.com/project/warner/magic-wormhole)
  [![codecov.io](https://codecov.io/github/warner/magic-wormhole/coverage.svg?branch=master)](https://codecov.io/github/warner/magic-wormhole?branch=master)
  [![Docs](https://readthedocs.org/projects/magic-wormhole/badge/?version=latest)](https://magic-wormhole.readthedocs.io)

  Get things from one computer to another, safely.

  This package provides a library and a command-line tool named `wormhole`,
  which makes it possible to get arbitrary-sized files and directories
  (or short pieces of text) from one computer to another. The two endpoints are
  identified by using identical "wormhole codes": in general, the sending
  machine generates and displays the code, which must then be typed into the
  receiving machine.

  The codes are short and human-pronounceable, using a phonetically-distinct
  wordlist. The receiving side offers tab-completion on the codewords, so
  usually only a few characters must be typed. Wormhole codes are single-use
  and do not need to be memorized.

  * PyCon 2016 presentation: [Slides](http://www.lothar.com/~warner/MagicWormhole-PyCon2016.pdf), [Video](https://youtu.be/oFrTqQw0_3c)

  For complete documentation, please see https://magic-wormhole.readthedocs.io
  or the docs/ subdirectory.



  Magic-Wormhole is released under the MIT license, see the `LICENSE` file for details.

  This library is compatible with Python 3.5 and higher (tested against 3.5,
  3.6, 3.7, and 3.8). It also still works with Python 2.7.



  Magic Wormhole packages are included in many operating systems.

  [![Packaging status](https://repology.org/badge/vertical-allrepos/magic-wormhole.svg)](https://repology.org/project/magic-wormhole/versions)

  To install it without an OS package, follow the [Installation docs](https://magic-wormhole.readthedocs.io/en/latest/welcome.html#installation).


pkgId: afbbfbd3609012adbfb0557aa5d58624a604b180ea199485c778924d86e01b17
name: python-magic-wormhole-mailbox-server
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Securely transfer data between computers
url: https://github.com/warner/magic-wormhole-mailbox-server
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-63cc496c-f1ec-44a7-ae9f-a4973b67b9db
location_href: 00004142-python-magic-wormhole-mailbox-server/python-magic-wormhole-mailbox-server-0.4.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](http://img.shields.io/pypi/v/magic-wormhole-mailbox-server.svg)](https://pypi.python.org/pypi/magic-wormhole-mailbox-server)
  [![Build Status](https://travis-ci.org/warner/magic-wormhole-mailbox-server.svg?branch=master)](https://travis-ci.org/warner/magic-wormhole-mailbox-server)
  [![Windows Build Status](https://ci.appveyor.com/api/projects/status/mfnn5rsyfnrq576a/branch/master?svg=true)](https://ci.appveyor.com/project/warner/magic-wormhole-mailbox-server)
  [![codecov.io](https://codecov.io/github/warner/magic-wormhole-mailbox-server/coverage.svg?branch=master)](https://codecov.io/github/warner/magic-wormhole-mailbox-server?branch=master)

  This repository holds the code for the main server that
  [Magic-Wormhole](http://magic-wormhole.io) clients connect to. The server
  performs store-and-forward delivery for small key-exchange and control
  messages. Bulk data is sent over a direct TCP connection, or through a
  [transit-relay](https://github.com/warner/magic-wormhole-transit-relay).

  Clients connect with WebSockets, for low-latency delivery in the happy case
  where both clients are attached at the same time. Message are stored to
  enable non-simultaneous clients to make forward progress. The server uses a
  small SQLite database for persistence (and clients will reconnect
  automatically, allowing the server to be rebooted without losing state). An
  optional "usage DB" tracks historical activity for status monitoring and
  operational maintenance.



  ```
  pip install magic-wormhole-mailbox-server
  ```

  You either want to do this into a "user" environment (putting the ``twist``
  and ``twistd`` executables in ``~/.local/bin/``) like this:

  ```
  pip install --user magic-wormhole-mailbox-server
  ```

  or put it into a virtualenv, to avoid modifying the system python's
  libraries, like this:

  ```
  virtualenv venv
  source venv/bin/activate
  pip install magic-wormhole-mailbox-server
  ```

  You probably *don't* want to use ``sudo`` when you run ``pip``, since the
  dependencies that get installed may conflict with other python programs on
  your computer. ``pipsi`` is usually a good way to install into isolated
  environments, but unfortunately it doesn't work for
  magic-wormhole-mailbox-server, because we don't have a dedicated command to
  start the server (``twist``, described below, comes from the ``twisted``
  package, and pipsi doesn't expose executables from dependencies).

  For the installation from source, ``clone`` this repo, ``cd`` into the folder,
  create and activate a virtualenv, and run ``pip install .``.



  Note that the standard [Magic-Wormhole](http://magic-wormhole.io)
  command-line tool is preconfigured to use a mailbox server hosted by the
  project, so running your own server is only necessary for custom applications
  that use magic-wormhole as a library.

  The mailbox server is deployed as a twist/twistd plugin. Running a basic
  server looks like this:

  ```
  twist wormhole-mailbox --usage-db=usage.sqlite
  ```

  Use ``twist wormhole-mailbox --help`` for more details.

  If you use the default ``--port=tcp:4000``, on a machine named
  ``example.com``, then clients can reach your server with the following
  option:

  ```
  wormhole --relay-url=ws://example.com:4000/v1 send FILENAME
  ```



  This library is released under the MIT license, see LICENSE for details.

  This library is compatible with python2.7, and python3 (3.5 and higher).


pkgId: d67c6c38ee69e551c1891ead5f279b82b07f14ee172648e798385219d25fd3a7
name: python-magic-wormhole-mailbox-server-help
arch: noarch
version: 0.4.1
epoch: 0
release: 1
summary: Development documents and examples for magic-wormhole-mailbox-server
url: https://github.com/warner/magic-wormhole-mailbox-server
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-63cc496c-f1ec-44a7-ae9f-a4973b67b9db
rpm_sourcerpm: python-magic-wormhole-mailbox-server-0.4.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](http://img.shields.io/pypi/v/magic-wormhole-mailbox-server.svg)](https://pypi.python.org/pypi/magic-wormhole-mailbox-server)
  [![Build Status](https://travis-ci.org/warner/magic-wormhole-mailbox-server.svg?branch=master)](https://travis-ci.org/warner/magic-wormhole-mailbox-server)
  [![Windows Build Status](https://ci.appveyor.com/api/projects/status/mfnn5rsyfnrq576a/branch/master?svg=true)](https://ci.appveyor.com/project/warner/magic-wormhole-mailbox-server)
  [![codecov.io](https://codecov.io/github/warner/magic-wormhole-mailbox-server/coverage.svg?branch=master)](https://codecov.io/github/warner/magic-wormhole-mailbox-server?branch=master)

  This repository holds the code for the main server that
  [Magic-Wormhole](http://magic-wormhole.io) clients connect to. The server
  performs store-and-forward delivery for small key-exchange and control
  messages. Bulk data is sent over a direct TCP connection, or through a
  [transit-relay](https://github.com/warner/magic-wormhole-transit-relay).

  Clients connect with WebSockets, for low-latency delivery in the happy case
  where both clients are attached at the same time. Message are stored to
  enable non-simultaneous clients to make forward progress. The server uses a
  small SQLite database for persistence (and clients will reconnect
  automatically, allowing the server to be rebooted without losing state). An
  optional "usage DB" tracks historical activity for status monitoring and
  operational maintenance.



  ```
  pip install magic-wormhole-mailbox-server
  ```

  You either want to do this into a "user" environment (putting the ``twist``
  and ``twistd`` executables in ``~/.local/bin/``) like this:

  ```
  pip install --user magic-wormhole-mailbox-server
  ```

  or put it into a virtualenv, to avoid modifying the system python's
  libraries, like this:

  ```
  virtualenv venv
  source venv/bin/activate
  pip install magic-wormhole-mailbox-server
  ```

  You probably *don't* want to use ``sudo`` when you run ``pip``, since the
  dependencies that get installed may conflict with other python programs on
  your computer. ``pipsi`` is usually a good way to install into isolated
  environments, but unfortunately it doesn't work for
  magic-wormhole-mailbox-server, because we don't have a dedicated command to
  start the server (``twist``, described below, comes from the ``twisted``
  package, and pipsi doesn't expose executables from dependencies).

  For the installation from source, ``clone`` this repo, ``cd`` into the folder,
  create and activate a virtualenv, and run ``pip install .``.



  Note that the standard [Magic-Wormhole](http://magic-wormhole.io)
  command-line tool is preconfigured to use a mailbox server hosted by the
  project, so running your own server is only necessary for custom applications
  that use magic-wormhole as a library.

  The mailbox server is deployed as a twist/twistd plugin. Running a basic
  server looks like this:

  ```
  twist wormhole-mailbox --usage-db=usage.sqlite
  ```

  Use ``twist wormhole-mailbox --help`` for more details.

  If you use the default ``--port=tcp:4000``, on a machine named
  ``example.com``, then clients can reach your server with the following
  option:

  ```
  wormhole --relay-url=ws://example.com:4000/v1 send FILENAME
  ```



  This library is released under the MIT license, see LICENSE for details.

  This library is compatible with python2.7, and python3 (3.5 and higher).

location_href:
  00004142-python-magic-wormhole-mailbox-server/python-magic-wormhole-mailbox-server-help-0.4.1-1.noarch.rpm


pkgId: 552f7237ab6cab1095d7cced035d00dc081c6e4e389a5e0e257dd495a5c82992
name: python-magic-wormhole-mailbox-server-help
arch: noarch
version: 0.4.1
epoch: 0
release: 1
summary: Development documents and examples for magic-wormhole-mailbox-server
url: https://github.com/warner/magic-wormhole-mailbox-server
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c56a2b7d-94cd-405c-b424-98d655f9001f
rpm_sourcerpm: python-magic-wormhole-mailbox-server-0.4.1-1.src.rpm
checksum_type: sha256
description:
[cell repeats an earlier one in this file: 3359 characters]

location_href:
  00007486-python-magic-wormhole-mailbox-server/python-magic-wormhole-mailbox-server-help-0.4.1-1.noarch.rpm


pkgId: 23f98af1f721e3e4b51927ad466db6ea6ccfa661a8771df9c2532464dc6194b3
name: python-magic-wormhole-transit-relay-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for magic-wormhole-transit-relay
url: https://github.com/warner/magic-wormhole-transit-relay
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d429dbee-3577-4b7e-b95f-bec8475ee401
rpm_sourcerpm: python-magic-wormhole-transit-relay-0.2.1-1.src.rpm
checksum_type: sha256
location_href:
  00004143-python-magic-wormhole-transit-relay/python-magic-wormhole-transit-relay-help-0.2.1-1.noarch.rpm


pkgId: 6a9dbc98ff7b436b0e7a3971357244ec338c8d1901cb91fc610c377675e0348a
name: python-magic-wormhole-transit-relay-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for magic-wormhole-transit-relay
url: https://github.com/warner/magic-wormhole-transit-relay
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-57687483-d1c3-4925-95e1-a1886923b08e
rpm_sourcerpm: python-magic-wormhole-transit-relay-0.2.1-1.src.rpm
checksum_type: sha256
location_href:
  00007487-python-magic-wormhole-transit-relay/python-magic-wormhole-transit-relay-help-0.2.1-1.noarch.rpm


pkgId: 715513880661b8d06233eebf9e5a5a3c4a6543b3ef3d2e23814c07c8b8219850
name: python-mail-parser
arch: src
version: 3.15.0
epoch: 0
release: 1
summary: Wrapper for email standard library
url: https://github.com/SpamScope/mail-parser
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5ef3a504-c767-4f8f-8db1-592b371f2e19
location_href: 00011327-python-mail-parser/python-mail-parser-3.15.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/mail-parser.svg)](https://badge.fury.io/py/mail-parser)
  [![Build Status](https://travis-ci.org/SpamScope/mail-parser.svg?branch=develop)](https://travis-ci.org/SpamScope/mail-parser)
  [![Coverage Status](https://coveralls.io/repos/github/SpamScope/mail-parser/badge.svg?branch=develop)](https://coveralls.io/github/SpamScope/mail-parser?branch=develop)
  [![BCH compliance](https://bettercodehub.com/edge/badge/SpamScope/mail-parser?branch=develop)](https://bettercodehub.com/)
  [![](https://images.microbadger.com/badges/image/fmantuano/spamscope-mail-parser.svg)](https://microbadger.com/images/fmantuano/spamscope-mail-parser "Get your own image badge on microbadger.com")

  ![SpamScope](https://raw.githubusercontent.com/SpamScope/spamscope/develop/docs/logo/spamscope.png)



  mail-parser is not only a wrapper for [email](https://docs.python.org/2/library/email.message.html) Python Standard Library.
  It give you an easy way to pass from raw mail to Python object that you can use in your code.
  It's the key module of [SpamScope](https://github.com/SpamScope/spamscope).

  mail-parser can parse Outlook email format (.msg). To use this feature, you need to install `libemail-outlook-message-perl` package. For Debian based systems:

  ```
  $ apt-get install libemail-outlook-message-perl
  ```

  For more details:

  ```
  $ apt-cache show libemail-outlook-message-perl
  ```

  mail-parser supports Python 3.



  mail-parser can be downloaded, used, and modified free of charge. It is available under the Apache 2 license.

  If you want support the project:


  [![Donate](https://www.paypal.com/en_US/i/btn/btn_donateCC_LG.gif "Donate")](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=VEPXYP745KJF2)

  ![Bitcoin Donate](https://i.stack.imgur.com/MnQ6V.png)

  ![](https://github.com/SpamScope/mail-parser/raw/develop/docs/bitcoin-qrcode.png)



   - [Splunk app](https://splunkbase.splunk.com/app/4129/)
   - [FreeBSD port](https://www.freshports.org/mail/py-mail-parser/)
   - [Arch User Repository](https://aur.archlinux.org/packages/mailparser/)




  mail-parser takes as input a raw email and generates a parsed object. The properties of this object are the same name of
  [RFC headers](https://www.iana.org/assignments/message-headers/message-headers.xhtml):

    - bcc
    - cc
    - date
    - delivered_to
    - from\_ (not `from` because is a keyword of Python)
    - message_id
    - received
    - reply_to
    - subject
    - to

  There are other properties to get:
    - body
    - body html
    - body plain
    - headers
    - attachments
    - sender IP address
    - to domains
    - timezone

  The `attachments` property is a list of objects. Every object has the following keys:
    - binary: it's true if the attachment is a binary
    - charset
    - content_transfer_encoding
    - content-disposition
    - content-id
    - filename
    - mail_content_type
    - payload: attachment payload in base64

  To get custom headers you should replace "-" with "\_".
  Example for header `X-MSMail-Priority`:

  ```
  $ mail.X_MSMail_Priority
  ```

  The `received` header is parsed and splitted in hop. The fields supported are:
   - by
   - date
   - date_utc
   - delay (between two hop)
   - envelope_from
   - envelope_sender
   - for
   - from
   - hop
   - with


  mail-parser can detect defect in mail:
    - [defects](https://docs.python.org/2/library/email.message.html#email.message.Message.defects): mail with some not compliance RFC part

  All properties have a JSON and raw property that you can get with:
   - name_json
   - name_raw

  Example:

  ```
  $ mail.to (Python object)
  $ mail.to_json (JSON)
  $ mail.to_raw (raw header)
  ```

  The command line tool use the JSON format.


  These defects can be used to evade the antispam filter. An example are the mails with a malformed boundary that can hide a not legitimate epilogue (often malware).
  This library can take these epilogues.





  **Fedele Mantuano**: [LinkedIn](https://www.linkedin.com/in/fmantuano/)




  Clone repository

  ```
  git clone https://github.com/SpamScope/mail-parser.git
  ```

  and install mail-parser with `setup.py`:

  ```
  $ cd mail-parser

  $ python setup.py install
  ```

  or use `pip`:

  ```
  $ pip install mail-parser
  ```



  Import `mailparser` module:

  ```
  import mailparser

  mail = mailparser.parse_from_bytes(byte_mail)
  mail = mailparser.parse_from_file(f)
  mail = mailparser.parse_from_file_msg(outlook_mail)
  mail = mailparser.parse_from_file_obj(fp)
  mail = mailparser.parse_from_string(raw_mail)
  ```

  Then you can get all parts

  ```
  mail.attachments: list of all attachments
  mail.body
  mail.date: datetime object in UTC
  mail.defects: defect RFC not compliance
  mail.defects_categories: only defects categories
  mail.delivered_to
  mail.from_
  mail.get_server_ipaddress(trust="my_server_mail_trust")
  mail.headers
  mail.mail: tokenized mail in a object
  mail.message: email.message.Message object
  mail.message_as_string: message as string
  mail.message_id
  mail.received
  mail.subject
  mail.text_plain: only text plain mail parts in a list
  mail.text_html: only text html mail parts in a list
  mail.text_not_managed: all not managed text (check the warning logs to find content subtype)
  mail.to
  mail.to_domains
  mail.timezone: returns the timezone, offset from UTC
  mail.mail_partial: returns only the mains parts of emails
  ```

  It's possible to write the attachments on disk with the method:

  ```
  mail.write_attachments(base_path)
  ```



  If you installed mailparser with `pip` or `setup.py` you can use it with command-line.

  These are all swithes:

  ```
  usage: mailparser [-h] (-f FILE | -s STRING | -k)
                     [-l {CRITICAL,ERROR,WARNING,INFO,DEBUG,NOTSET}] [-j] [-b]
                     [-a] [-r] [-t] [-dt] [-m] [-u] [-c] [-d] [-o]
                     [-i Trust mail server string] [-p] [-z] [-v]

  Wrapper for email Python Standard Library

  optional arguments:
    -h, --help            show this help message and exit
    -f FILE, --file FILE  Raw email file (default: None)
    -s STRING, --string STRING
                          Raw email string (default: None)
    -k, --stdin           Enable parsing from stdin (default: False)
    -l {CRITICAL,ERROR,WARNING,INFO,DEBUG,NOTSET}, --log-level {CRITICAL,ERROR,WARNING,INFO,DEBUG,NOTSET}
                          Set log level (default: WARNING)
    -j, --json            Show the JSON of parsed mail (default: False)
    -b, --body            Print the body of mail (default: False)
    -a, --attachments     Print the attachments of mail (default: False)
    -r, --headers         Print the headers of mail (default: False)
    -t, --to              Print the to of mail (default: False)
    -dt, --delivered-to   Print the delivered-to of mail (default: False)
    -m, --from            Print the from of mail (default: False)
    -u, --subject         Print the subject of mail (default: False)
    -c, --receiveds       Print all receiveds of mail (default: False)
    -d, --defects         Print the defects of mail (default: False)
    -o, --outlook         Analyze Outlook msg (default: False)
    -i Trust mail server string, --senderip Trust mail server string
                          Extract a reliable sender IP address heuristically
                          (default: None)
    -p, --mail-hash       Print mail fingerprints without headers (default:
                          False)
    -z, --attachments-hash
                          Print attachments with fingerprints (default: False)
    -sa, --store-attachments
                          Store attachments on disk (default: False)
    -ap ATTACHMENTS_PATH, --attachments-path ATTACHMENTS_PATH
                          Path where store attachments (default: /tmp)
    -v, --version         show program's version number and exit

  It takes as input a raw mail and generates a parsed object.
  ```

  Example:

  ```shell
  $ mailparser -f example_mail -j
  ```

  This example will show you the tokenized mail in a JSON pretty format.

  From [raw mail](https://gist.github.com/fedelemantuano/5dd702004c25a46b2bd60de21e67458e) to
  [parsed mail](https://gist.github.com/fedelemantuano/e958aa2813c898db9d2d09469db8e6f6).




  Exceptions hierarchy of mail-parser:

  ```
  MailParserError: Base MailParser Exception
  |
  \── MailParserOutlookError: Raised with Outlook integration errors
  |
  \── MailParserEnvironmentError: Raised when the environment is not correct
  |
  \── MailParserOSError: Raised when there is an OS error
  |
  \── MailParserReceivedParsingError: Raised when a received header cannot be parsed
  ```


pkgId: 27291a6310145acf2d9bf3e136b6d2255e5faeb8c851f8da7898f400dd1177d4
name: python-mailer
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: A module to send email simply in Python
url: https://bitbucket.org/ginstrom/mailer
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a41bed9c-30ec-4b77-90e3-07bbc1a93729
location_href: 00004146-python-mailer/python-mailer-0.8.1-1.src.rpm
checksum_type: sha256
description:
  The API for Mailer.To is changed. Use a string to specify a single recipient,
  and an iterable to specify more than one.


pkgId: 450d18a579c0c334ce8e70202f1b6c72412b4dbe32d42009943717a9e481e518
name: python-mailmerge
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: A simple, command line mail merge tool
url: https://github.com/awdeorio/mailmerge/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e966db4b-6ac9-41ec-9678-c4e0eb111780
location_href: 00004147-python-mailmerge/python-mailmerge-2.2.1-1.src.rpm
checksum_type: sha256
description:
  [![CI main](https://github.com/awdeorio/mailmerge/workflows/CI/badge.svg?branch=develop)](https://github.com/awdeorio/mailmerge/actions?query=branch%3Adevelop)
  [![codecov](https://codecov.io/gh/awdeorio/mailmerge/branch/develop/graph/badge.svg)](https://codecov.io/gh/awdeorio/mailmerge)
  [![PyPI](https://img.shields.io/pypi/v/mailmerge.svg)](https://pypi.org/project/mailmerge/)
  A simple, command line mail merge tool.
  `mailmerge` uses plain text files and the [jinja2 template engine](http://jinja.pocoo.org/docs/latest/templates/).
  **Table of Contents**
  - [Quickstart](#quickstart)
  - [Install](#install)
  - [Example](#example)
  - [Advanced template example](#advanced-template-example)
  - [HTML formatting](#html-formatting)
  - [Markdown formatting](#markdown-formatting)
  - [Attachments](#attachments)
  - [Inline Image Attachments](#inline-image-attachments)
  - [Contributing](#contributing)
  - [Acknowledgements](#acknowledgements)

  ```console
  $ pip install mailmerge
  $ mailmerge
  ```
  `mailmerge` will guide you through the process.  Don't worry, it won't send real emails by default.

  System-wide install.
  ```console
  $ pip install mailmerge
  ```
  System-wide install requiring administrator privileges.  Use this if you get a `Permission denied` error.
  ```console
  $ sudo pip install mailmerge
  ```
  Fedora package install.
  ```console
  $ sudo dnf install python3-mailmerge
  ```

  This example will walk you through the steps for creating a template email, database and STMP server configuration.  Then, it will show how to test it before sending real emails.

  ```console
  $ mailmerge --sample
  Created sample template email "mailmerge_template.txt"
  Created sample database "mailmerge_database.csv"
  Created sample config file "mailmerge_server.conf"
  Edit these files, then run mailmerge again.
  ```

  The defaults are set up for GMail.  Be sure to change your username.  If you use 2-factor authentication, create an [app password](https://support.google.com/accounts/answer/185833?hl=en) first.  Other configuration examples are in the comments of `mailmerge_server.conf`.
  **Pro-tip:** SSH or VPN into your network first.  Running mailmerge from the same network as the SMTP server can help you avoid spam filters and server throttling.  This tip doesn't apply to Gmail.
  ```
  [smtp_server]
  host = smtp.gmail.com
  port = 465
  security = SSL/TLS
  username = YOUR_USERNAME_HERE
  ```

  The `TO`, `SUBJECT`, and `FROM` fields are required.  The remainder is the body of the message.  Use `{{ }}` to indicate customized parameters that will be read from the database.  For example, `{{email}}` will be filled in from the `email` column of `mailmerge_database.csv`.
  ```
  TO: {{email}}
  SUBJECT: Testing mailmerge
  FROM: My Self <myself@mydomain.com>
  Hi, {{name}},
  Your number is {{number}}.
  ```

  Notice that the first line is a header that matches the parameters in the template example, for example, `{{email}}`.
  **Pro-tip**: Add yourself as the first recipient.  This is helpful for testing.
  ```
  email,name,number
  myself@mydomain.com,"Myself",17
  bob@bobdomain.com,"Bob",42
  ```

  First, dry run one email message (`mailmerge` defaults).  This will fill in the template fields of the first email message and print it to the terminal.
  ```console
  $ mailmerge
  >>> message 1
  TO: myself@mydomain.com
  SUBJECT: Testing mailmerge
  FROM: My Self <myself@mydomain.com>
  MIME-Version: 1.0
  Content-Type: text/plain; charset="us-ascii"
  Content-Transfer-Encoding: 7bit
  Date: Thu, 19 Dec 2019 19:49:11 -0000
  Hi, Myself,
  Your number is 17.
  >>> sent message 1
  >>> Limit was 1 message.  To remove the limit, use the --no-limit option.
  >>> This was a dry run.  To send messages, use the --no-dry-run option.
  ```
  If this looks correct, try a second dry run, this time with all recipients using the `--no-limit` option.
  ```console
  $ mailmerge --no-limit
  >>> message 1
  TO: myself@mydomain.com
  SUBJECT: Testing mailmerge
  FROM: My Self <myself@mydomain.com>
  MIME-Version: 1.0
  Content-Type: text/plain; charset="us-ascii"
  Content-Transfer-Encoding: 7bit
  Date: Thu, 19 Dec 2019 19:49:33 -0000
  Hi, Myself,
  Your number is 17.
  >>> sent message 1
  >>> message 2
  TO: bob@bobdomain.com
  SUBJECT: Testing mailmerge
  FROM: My Self <myself@mydomain.com>
  MIME-Version: 1.0
  Content-Type: text/plain; charset="us-ascii"
  Content-Transfer-Encoding: 7bit
  Date: Thu, 19 Dec 2019 19:49:33 -0000
  Hi, Bob,
  Your number is 42.
  >>> sent message 2
  >>> This was a dry run.  To send messages, use the --no-dry-run option.
  ```

  We're being extra careful in this example to avoid sending spam, so next we'll send *only one real email* (`mailmerge` default).  Recall that you added yourself as the first email recipient.
  ```console
  $ mailmerge --no-dry-run
  >>> message 1
  TO: myself@mydomain.com
  SUBJECT: Testing mailmerge
  FROM: My Self <myself@mydomain.com>
  MIME-Version: 1.0
  Content-Type: text/plain; charset="us-ascii"
  Content-Transfer-Encoding: 7bit
  Date: Thu, 19 Dec 2019 19:50:24 -0000
  Hi, Myself,
  Your number is 17.
  >>> sent message 1
  >>> Limit was 1 message.  To remove the limit, use the --no-limit option.
  ```
  You may have to type your email password when prompted. (If you use GMail with 2-factor authentication, don't forget to use the [app password](https://support.google.com/accounts/answer/185833?hl=en) you created while [setting up the SMTP server config](#edit-the-smtp-server-config-mailmerge_serverconf).)
  Now, check your email and make sure the message went through.  If everything looks OK, then it's time to send all the messages.

  ```console
  $ mailmerge --no-dry-run --no-limit
  >>> message 1
  TO: myself@mydomain.com
  SUBJECT: Testing mailmerge
  FROM: My Self <myself@mydomain.com>
  MIME-Version: 1.0
  Content-Type: text/plain; charset="us-ascii"
  Content-Transfer-Encoding: 7bit
  Date: Thu, 19 Dec 2019 19:51:01 -0000
  Hi, Myself,
  Your number is 17.
  >>> sent message 1
  >>> message 2
  TO: bob@bobdomain.com
  SUBJECT: Testing mailmerge
  FROM: My Self <myself@mydomain.com>
  MIME-Version: 1.0
  Content-Type: text/plain; charset="us-ascii"
  Content-Transfer-Encoding: 7bit
  Date: Thu, 19 Dec 2019 19:51:01 -0000
  Hi, Bob,
  Your number is 42.
  >>> sent message 2
  ```

  This example will send progress reports to students.  The template uses more of the advanced features of the [jinja2 template engine documentation](http://jinja.pocoo.org/docs/latest/templates/) to customize messages to students.

  ```
  TO: {{email}}
  SUBJECT: EECS 280 Mid-semester Progress Report
  FROM: My Self <myself@mydomain.com>
  Dear {{name}},
  This email contains our record of your grades EECS 280, as well as an estimated letter grade.
  Project 1: {{p1}}
  Project 2: {{p2}}
  Project 3: {{p3}}
  Midterm exam: {{midterm}}
  At this time, your estimated letter grade is {{grade}}.
  {% if grade == "C-" -%}
  I am concerned that if the current trend in your scores continues, you will be on the border of the pass/fail line.
  I have a few suggestions for the rest of the semester.  First, it is absolutely imperative that you turn in all assignments.  Attend lecture and discussion sections.  Get started early on the programming assignments and ask for help.  Finally, plan a strategy to help you prepare well for the final exam.
  The good news is that we have completed about half of the course grade, so there is an opportunity to fix this problem.  The other professors and I are happy to discuss strategies together during office hours.
  {% elif grade in ["D+", "D", "D-", "E", "F"] -%}
  I am writing because I am concerned about your grade in EECS 280.  My concern is that if the current trend in your scores continues, you will not pass the course.
  If you plan to continue in the course, I urge you to see your instructor in office hours to discuss a plan for the remainder of the semester.  Otherwise, if you plan to drop the course, please see your academic advisor.
  {% endif -%}
  ```

  Again, we'll use the best practice of making yourself the first recipient, which is helpful for testing.
  ```
  email,name,p1,p2,p3,midterm,grade
  myself@mydomain.com,"My Self",100,100,100,100,A+
  borderline@fixme.com,"Borderline Name",50,50,50,50,C-
  failing@fixme.com,"Failing Name",0,0,0,0,F
  ```

  Mailmerge supports HTML formatting.

  This example will use HTML to format an email.  Add `Content-Type: text/html` just under the email headers, then begin your message with `<html>`.

  ```
  TO: {{email}}
  SUBJECT: Testing mailmerge
  FROM: My Self <myself@mydomain.com>
  Content-Type: text/html
  <html>
  <body>
  <p>Hi, {{name}},</p>
  <p>Your number is {{number}}.</p>
  <p>Sent by <a href="https://github.com/awdeorio/mailmerge">mailmerge</a></p>
  </body>
  </html>
  ```

  This example shows how to provide both HTML and plain text versions in the same message.  A user's mail reader can select either one.

  ```
  TO: {{email}}
  SUBJECT: Testing mailmerge
  FROM: My Self <myself@mydomain.com>
  MIME-Version: 1.0
  Content-Type: multipart/alternative; boundary="boundary"
  This is a MIME-encoded message. If you are seeing this, your mail
  reader is old.
  --boundary
  Content-Type: text/plain; charset=us-ascii
  Hi, {{name}},
  Your number is {{number}}.
  Sent by mailmerge https://github.com/awdeorio/mailmerge
  --boundary
  Content-Type: text/html; charset=us-ascii
  <html>
  <body>
  <p>Hi, {{name}},</p>
  <p>Your number is {{number}}.</p>
  <p>Sent by <a href="https://github.com/awdeorio/mailmerge">mailmerge</a></p>
  </body>
  </html>
  ```

  Mailmerge supports [Markdown](https://daringfireball.net/projects/markdown/syntax) formatting by including the custom custom header `Content-Type: text/markdown` in the message. Mailmerge will render the markdown to HTML, then include both HTML and plain text versions in a multiplart message. A recipient's mail reader can then select either format.

  ```
  TO: {{email}}
  SUBJECT: Testing mailmerge
  FROM: My Self <myself@mydomain.com>
  CONTENT-TYPE: text/markdown
  You can add:
  - Emphasis, aka italics, with *asterisks*.
  - Strong emphasis, aka bold, with **asterisks**.
  - Combined emphasis with **asterisks and _underscores_**.
  - Unordered lists like this one.
  - Ordered lists with numbers:
      1. Item 1
      2. Item 2
  - Preformatted text with `backticks`.
  - How about some [hyperlinks](http://bit.ly/eecs485-wn19-p6)?


  Here's an image not attached with the email:
  ![python logo not attached](http://pluspng.com/img-png/python-logo-png-open-2000.png)
  ```

  This example shows how to add attachments with a special `ATTACHMENT` header.

  ```
  TO: {{email}}
  SUBJECT: Testing mailmerge
  FROM: My Self <myself@mydomain.com>
  ATTACHMENT: file1.docx
  ATTACHMENT: ../file2.pdf
  ATTACHMENT: /z/shared/{{name}}_submission.txt
  Hi, {{name}},
  This email contains three attachments.
  Pro-tip: Use Jinja to customize the attachments based on your database!
  ```
  Dry run to verify attachment files exist. If an attachment filename includes a template, it's a good idea to dry run with the `--no-limit` flag.
  ```console
  $ mailmerge
  >>> message 1
  TO: myself@mydomain.com
  SUBJECT: Testing mailmerge
  FROM: My Self <myself@mydomain.com>
  Hi, Myself,
  This email contains three attachments.
  Pro-tip: Use Jinja to customize the attachments based on your database!
  >>> attached /Users/awdeorio/Documents/test/file1.docx
  >>> attached /Users/awdeorio/Documents/file2.pdf
  >>> attached /z/shared/Myself_submission.txt
  >>> sent message 1
  >>> This was a dry run.  To send messages, use the --no-dry-run option.
  ```

  This example shows how to add inline-image-attachments so that the images are rendered directly in the email body. You **must** add the inline-image as an attachment before referencing it in the body.

  ```
  TO: {{email}}
  SUBJECT: Testing mailmerge
  FROM: My Self <myself@mydomain.com>
  Content-Type: text/html
  ATTACHMENT: image.jpg
  ATTACHMENT: second/image.jpg
  <html>
  <body>
  <p>Hi, {{name}},</p>
  <img alt="Sample image" src="image.jpg" />
  The second image: <img alt="second" src="second/image.jpg">
  <p>Sent by <a href="https://github.com/awdeorio/mailmerge">mailmerge</a></p>
  </body>
  </html>
  ```

  ```
  TO: {{email}}
  SUBJECT: Testing mailmerge
  FROM: My Self <myself@mydomain.com>
  ATTACHMENT: image.jpg
  CONTENT-TYPE: text/markdown
  Hi, {{name}},
  ![image alt-description](image.jpg)
  ```

  Contributions from the community are welcome! Check out the [guide for contributing](CONTRIBUTING.md).

  Mailmerge is written by Andrew DeOrio <awdeorio@umich.edu>, [http://andrewdeorio.com](http://andrewdeorio.com).  Sesh Sadasivam (@seshrs) contributed many features and bug fixes.


pkgId: d66dad8058e3868f8a1761923a9e0c23895dcf40ce56dbba3e8e49bdb3403585
name: python-makeelf
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: ELF reader-writer library
url: https://github.com/v3l0c1r4pt0r/makeelf
rpm_license: GNU General Public License v3 (GPLv3)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-77dc3c7b-0c7c-4963-b018-f021623fec5f
location_href: 00004148-python-makeelf/python-makeelf-0.3.4-1.src.rpm
checksum_type: sha256
description:
  MakeELF is a Python library to parse, modify and create ELF binaries. It provides following features:

   - easy to use, standard Python interface
   - reading existing ELF files to Python representation
   - modification of every aspect of ELF format structures
   - ability to skip any validation to test other parsers for potential errors
   - creating new valid ELF files with just one step
   - easy serialization of every structure present in ELF file


pkgId: c81d8bed230624bf6f2422bf0b4ec699eee01122a0ba1aec6095c4fb14b68df6
name: python-makefun
arch: src
version: 1.15.1
epoch: 0
release: 1
summary: Small library to dynamically create python functions.
url: https://github.com/smarie/python-makefun
rpm_license: BSD 3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6fb93ee2-af63-4a13-8426-2eef2b08b0cc
location_href: 00004149-python-makefun/python-makefun-1.15.1-1.src.rpm
checksum_type: sha256
description:
  [![Python versions](https://img.shields.io/pypi/pyversions/makefun.svg)](https://pypi.python.org/pypi/makefun/) [![Build Status](https://github.com/smarie/python-makefun/actions/workflows/base.yml/badge.svg)](https://github.com/smarie/python-makefun/actions/workflows/base.yml) [![Tests Status](https://smarie.github.io/python-makefun/reports/junit/junit-badge.svg?dummy=8484744)](https://smarie.github.io/python-makefun/reports/junit/report.html) [![Coverage Status](https://smarie.github.io/python-makefun/reports/coverage/coverage-badge.svg?dummy=8484744)](https://smarie.github.io/python-makefun/reports/coverage/index.html) [![codecov](https://codecov.io/gh/smarie/python-makefun/branch/main/graph/badge.svg)](https://codecov.io/gh/smarie/python-makefun) [![Flake8 Status](https://smarie.github.io/python-makefun/reports/flake8/flake8-badge.svg?dummy=8484744)](https://smarie.github.io/python-makefun/reports/flake8/index.html)

  [![Documentation](https://img.shields.io/badge/doc-latest-blue.svg)](https://smarie.github.io/python-makefun/) [![PyPI](https://img.shields.io/pypi/v/makefun.svg)](https://pypi.python.org/pypi/makefun/) [![Downloads](https://pepy.tech/badge/makefun)](https://pepy.tech/project/makefun) [![Downloads per week](https://pepy.tech/badge/makefun/week)](https://pepy.tech/project/makefun) [![GitHub stars](https://img.shields.io/github/stars/smarie/python-makefun.svg)](https://github.com/smarie/python-makefun/stargazers)

  Small library to dynamically create python functions.

  The documentation for users is available here: [https://smarie.github.io/python-makefun/](https://smarie.github.io/python-makefun/)

  A readme for developers is available here: [https://github.com/smarie/python-makefun](https://github.com/smarie/python-makefun)


pkgId: ca15fb167b8f30c800f41ed9888070379985aba20dead8dd47880c921ca10749
name: python-maltego-trx
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: Python library used to develop Maltego transforms
url: https://github.com/paterva/maltego-trx/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f1aa9cc9-4096-46a4-a268-87ecb4582757
location_href: 00012890-python-maltego-trx/python-maltego-trx-1.6.0-1.src.rpm
checksum_type: sha256
description:
  [![Runs with Python3.6 - Python3.10](https://github.com/paterva/maltego-trx/actions/workflows/pythonx-boot-check.yaml/badge.svg)](https://github.com/paterva/maltego-trx/actions/workflows/pythonx-boot-check.yaml)
  [![PyTest with Python3.6 - Python3.10](https://github.com/paterva/maltego-trx/actions/workflows/pythonx-pytest.yaml/badge.svg)](https://github.com/paterva/maltego-trx/actions/workflows/pythonx-pytest.yaml)
  [![Sonatype Jake](https://github.com/paterva/maltego-trx/actions/workflows/sonatype-jack.yml/badge.svg)](https://github.com/paterva/maltego-trx/actions/workflows/sonatype-jack.yml)



  __1.6.0__: Automatically generate am `.mtz` for your local transforms

  __1.5.2__: Add logging output for invalid / missing params in xml serialization

  __1.5.1__: Add ignored files to starter and use README for pypi

  __1.5.0__: XML Serialization via `ElementTree` instead of string interpolation

  __1.4.4__: Added skeletons for csv export in template dir and made project.py application import compatible with docs

  __1.4.0 + 1.4.1:__ Both versions are incompatible with python3.7 and lower.

  __1.4.2__: Fixed python3.6 incompatibility



  _Note: Support for Python 2 has been officially discontinued as of July 2021. Please use Python 3.6 or higher to use
  up-to-date versions of Maltego TRX._

  To install the trx library run the following command:

  ``` bash
  pip install maltego-trx
  ```

  After installing, you can create a new project by running the following command:

  ``` bash
  maltego-trx start new_project
  ```

  This will create a folder new_project with the recommended project structure.

  If you want to copy the starter files to your current directory, run the following command:

  ```bash
  maltego-trx init
  ```

  Alternatively, you can copy either the `gunicorn` or `apache` example projects from the `demo` directory. These also
  include Dockerfile and corresponding docker-compose configuration files for production deployment.

  **Adding a Transform:**

  Add a new transform by creating a new python file in the "transforms" folder of your directory.

  Any file in the folder where the **class name matches the filename**, and the class inherits from Transform, will
  automatically be discovered and added to your server.

  A simple transform would look like the following:

  `new_project/transforms/GreetPerson.py`

  ``` python
  from maltego_trx.entities import Phrase
  from maltego_trx.transform import DiscoverableTransform


  class GreetPerson(DiscoverableTransform):
      """
      Returns a phrase greeting a person on the graph.
      """

      @classmethod
      def create_entities(cls, request, response):
          person_name = request.Value

          response.addEntity(Phrase, "Hi %s, nice to meet you!" % person_name)
  ```





  You can start the development server, by running the following command:

  ``` bash
  python project.py runserver
  ```

  This will start up a development server that automatically reloads every time the code is changed.



  You can run a gunicorn transform server, after installing gunicorn on the host machine and then running the command:

  ``` bash
  gunicorn --bind=0.0.0.0:8080 --threads=25 --workers=2 project:application
  ```

  *For publicly accessible servers, it is recommended to run your Gunicorn server behind proxy servers such as Nginx.*



  The `demo` folder provides an example project. The Docker files given can be used to set up and run your project in
  Docker.

  The Dockerfile and docker-compose file can be used to easily set up and run a development transform server.

  If you have copied the `docker-compose.yml`, `Dockerfile` and `prod.yml` files into your project, then you can use the
  following commands to run the server in Docker.

  Run the following to start the development server:

  ``` bash
  docker-compose up
  ```

  Run the following command to run a production gunicorn server:

  ``` bash
  docker-compose -f prod.yml up --build
  ```

  *For publicly accessible servers, it is recommended to run your Gunicorn server behind proxy servers such as Nginx.*



  [Documentation](https://docs.maltego.com/support/solutions/articles/15000017605-writing-local-transforms-in-python)

  Transforms written using this library can be used as either local or server transforms.

  To run a local transform from your project, you will need to pass the following arguments:

  ``` bash
  project.py local <transform_name>
  ```

  You can find the correct transform_name to use by running `python project.py list`.



  The following values are not passed to local transforms, and will have dummy values in their place:

  - `type`: `local.Unknown`
  - `weight`: 100
  - `slider`: 100
  - `transformSettings`: {}





  The Transform Registry enables you to annotate Transforms with metadata like display name, description, input and output
  entities as well as settings. The Transform Registry will automatically generate CSV files that you can import into the
  pTDS and/or your iTDS.



  You can configure your registry with all the info you would normally add for every transform/seed on a TDS. We recommend
  creating your registry in an extra file, traditionally called `extensions.py`, to avoid circular imports.

  ```python

  from maltego_trx.decorator_registry import TransformRegistry

  registry = TransformRegistry(
      owner="ACME Corporation",
      author="John Doe <johndoe@acme.com>",
      host_url="https://transforms.acme.org",
      seed_ids=["demo"]
  )




  registry.version = "0.1"


  registry.display_name_suffix = " [ACME]"


  registry.oauth_settings_id = ['github-oauth']

  ```



  ```python

  ...
  from extensions import registry


  @registry.register_transform(
      display_name='Greet Person',
      input_entity='maltego.Phrase',
      description='Returns a phrase greeting a person on the graph.',
      output_entities=['maltego.Phrase'],
      disclaimer='This disclaimer is optional and has to be accepted before this transform is run'
  )
  class GreetPerson(DiscoverableTransform):

      @classmethod
      def create_entities(cls, request, response):
          ...
  ```

  **Pro Tip:** If the `display_name` is either `None` or `""`, the registry will try to create a display name from the
  class name:

  - `DNSToIP` 'DNS To IP'
  - `GreetPerson` 'Greet Person'



  You can declare transform settings in a central location and add them to the registry.



  These settings will apply to all transforms which can be very helpful for api keys.

  ```python

  from maltego_trx.decorator_registry import TransformSetting

  api_key_setting = TransformSetting(name='api_key',
                                     display_name='API Key',
                                     setting_type='string',
                                     global_setting=True)
  ```

  ```python

  from settings import api_key_setting

  from maltego_trx.decorator_registry import TransformRegistry

  registry = TransformRegistry(
      owner="ACME Corporation",
      author="John Doe <johndoe@acme.com>",
      host_url="https://transforms.acme.org",
      seed_ids=["demo"]
  )

  registry.global_settings = [api_key_setting]
  ```



  Settings that aren't required for every transform have to be added to the `register_transform` decorator explicitly. To
  access the setting on the request, use the `id` property, which will have the global prefix if it's a global setting.
  The `name` property won't work on global settings.

  ```python

  ...

  language_setting = TransformSetting(name='language',
                                      display_name="Language",
                                      setting_type='string',
                                      default_value='en',
                                      optional=True,
                                      popup=True)
  ```

  ```python

  ...
  from settings import language_setting

  from maltego_trx.transform import DiscoverableTransform


  @registry.register_transform(display_name="Greet Person",
                               input_entity="maltego.Phrase",
                               description='Returns a phrase greeting a person on the graph.',
                               settings=[language_setting])
  class GreetPerson(DiscoverableTransform):

      @classmethod
      def create_entities(cls, request: MaltegoMsg, response: MaltegoTransform):
          language = request.getTransformSetting(language_setting.id)
          ...
  ```



  To export the configurations, use the registry methods `write_transforms_config()` and `write_settings_config()`. These
  methods have to executed after they have been registered with the TRX server.

  ```python


  import sys
  import transforms

  from maltego_trx.registry import register_transform_function, register_transform_classes
  from maltego_trx.server import application
  from maltego_trx.handler import handle_run


  from extensions import registry

  register_transform_classes(transforms)

  registry.write_transforms_config()
  registry.write_settings_config()

  handle_run(__name__, sys.argv, application)
  ```



  Since `maltego-trx>=1.6.0` you can generate an `.mtz` config file with your local transforms.

  If you're already using the `TransformRegistry`, just invoke the `write_local_config()` method.

  ```python


  registry.write_local_mtz()
  ```

  This will create a file called `local.mtz` in the current directory. You can then import this file into Maltego and
  start using your local transforms faster. Just remember that settings are not passed to local transforms.

  The method takes in the same arguments as the interface in the Maltego client.
  If you are using a `virtualenv` environment, you might want to change the `command` argument to use that.

  ```bash


  registry.write_local_mtz(
      mtz_path: str = "./local.mtz", # path to the local .mtz file
      working_dir: str = ".",
      command: str = "python3", # for a venv you might want to use `./venv/bin/python3`
      params: str = "project.py",
      debug: bool = True
  )
  ```



  [Documentation](https://docs.maltego.com/support/solutions/articles/15000018299-porting-old-trx-transforms-to-the-latest-version)

  If you have old TRX transforms that are written as functions, they can be registered with the server using
  the `maltego_trx.registry.register_transform_function` method.

  In order to port your old transforms, make two changes:

  1. Import the MaltegoTransform class from the `maltego_trx` package instead of from a local file.
  2. Call the `register_transform_function` in order for the transform to be registered in your project.

  For example

  In the legacy transform file, change:

  ``` python
  from Maltego import *

  def old_transform(m):
  ```

  To:

  ```python

  from maltego_trx.maltego import MaltegoTransform


  def old_transform(m):
      ...
  ```

  In the `project.py` file add the following:

  ```python
  from maltego_trx.registry import register_transform_function
  from legacy_transform import trx_DNS2IP

  register_transform_function(trx_DNS2IP)
  ```



  The following commands can be run using the project.py file.



  ``` bash
  python project.py runserver
  ```

  Start a development server that you can use to develop new transforms.



  ``` bash
  python project.py list
  ```

  List the available transforms together with their transform server URLs and local transform names.





  The following constants can be imported from `maltego_trx.maltego`.

  **Message Types:**

  - `UIM_FATAL`
  - `UIM_PARTIAL`
  - `UIM_INFORM`
  - `UIM_DEBUG`

  **Please take note:**
  You need to enable the `debug` filter option in the Desktop client Output window to view `debug` transform messages.

  **Bookmark Colors:**

  - `BOOKMARK_COLOR_NONE`
  - `BOOKMARK_COLOR_BLUE`
  - `BOOKMARK_COLOR_GREEN`
  - `BOOKMARK_COLOR_YELLOW`
  - `BOOKMARK_COLOR_PURPLE`
  - `BOOKMARK_COLOR_RED`

  **Link Styles:**

  - `LINK_STYLE_NORMAL`
  - `LINK_STYLE_DASHED`
  - `LINK_STYLE_DOTTED`
  - `LINK_STYLE_DASHDOT`



  **Overlays:**

  Overlays Enums are imported from `maltego_trx.overlays`

  *Overlay OverlayPosition:*

  - `NORTH = "N"`
  - `SOUTH = "S"`
  - `WEST = "W"`
  - `NORTH_WEST = "NW"`
  - `SOUTH_WEST = "SW"`
  - `CENTER = "C"`

  *Overlay Type*

  - `IMAGE = "image"`
  - `COLOUR = "colour"`
  - `TEXT = "text"`



  The request/maltego msg object given to the transform contains the information about the input entity.

  **Attributes:**

  - `Value: str`: The display value of the input entity on the graph
  - `Weight: int`: The weight of the input entity
  - `Slider: int`: Results slider setting in the client
  - `Type: str`: The input entity type
  - `Properties: dict(str: str)`: A key-value dictionary of the input entity properties
  - `TransformSettings: dict(str: str)`: A key-value dictionary of the transform settings
  - `Genealogy: list(dict(str: str))`: A key-value dictionary of the Entity genealogy, this is only applicable for
    extended entities e.g. Website Entity

  **Methods:**

  - `getProperty(name: str)`: Get a property value of the input entity
  - `getTransformSetting(name: str)`: Get a transform setting value
  - `clearLegacyProperties()`: Delete (duplicate) legacy properties from the input entity. This will not result in
    property information being lost, it will simply clear out some properties that the TRX library duplicates on all
    incoming Transform requests. In older versions of TRX, these Entity properties would have a different internal ID when
    sent the server than what the Maltego client would advertise in the Entity Manager UI. For a list of Entities with
    such properties and their corresponding legacy and actual IDs, see `entity_property_map` in `maltego_trx/entities.py`.
    For the majority of projects this distinction can be safely ignored.



  **Methods:**

  - `addEntity(type: str, value: str) -> Entity`: Add an entity to the transform response. Returns an Entity object
    created by the method.
  - `addUIMessage(message: str, messageType='Inform')`: Return a UI message to the user. For message type, use a message
    type constant.



  **Methods:**

  - `setType(type: str)`: Set the entity type (e.g. "Phrase" for maltego.Phrase entity)
  - `setValue(value: str)`: Set the entity value
  - `setWeight(weight: int)`: Set the entity weight
  - `addDisplayInformation(content: str, title: str)`: Add display information for the entity.
  - `addProperty(fieldName: str, displayName: str, matchingRule: str, value: str)`: Add a property to the entity. Matching
    rule can be `strict` or `loose`.
  - `addOverlay(propertyName: str, position: OverlayPosition, overlay_type: OverlayType)`: Add an overlay to the entity.
    `OverlayPosition` and `OverlayType` are defined in the `maltego_trx.overlays`

  Overlay can be added as Text, Image or Color

  ```python

          person_name = request.Value
          entity = response.addEntity(Phrase, "Hi %s, nice to meet you!" % person_name)

          
          
          
          
          entity.addProperty(
              'dynamic_overlay_icon_name',
              displayName="Name for overlay image",
              value="Champion"  # references an icon in the Maltego client
          )
          entity.addOverlay('dynamic_overlay_icon_name', OverlayPosition.WEST, OverlayType.IMAGE)

          
          
          
          
          entity.addOverlay(
              'DE', # name of an icon, however, could also accidentally be a property name
              OverlayPosition.SOUTH_WEST,
              OverlayType.IMAGE
          )

          
          entity.addProperty("exampleDynamicPropertyName", "Example Dynamic Property", "loose", "Maltego Overlay Testing")
          entity.addOverlay('exampleDynamicPropertyName', OverlayPosition.NORTH, OverlayType.TEXT)

          
          entity.addOverlay('#45e06f', OverlayPosition.NORTH_WEST, OverlayType.COLOUR)
  ```

  - `setIconURL(url: str)`: Set the entity icon URL
  - `setBookmark(bookmark: int)`: Set bookmark color index (e.g. -1 for BOOKMARK_COLOR_NONE, 3 for BOOKMARK_COLOR_PURPLE)
  - `setNote(note: str)`: Set note content
  - `setGenealogy(genealogy: dict)`: Set genealogy

  **Link Methods:**

  - `setLinkColor(color: str)`: Set the link color (e.g. hex "#0000FF" for blue)
  - `setLinkStyle(style: int)`: Set the link style index (e.g. 0 for LINK_STYLE_NORMAL, 2 for LINK_STYLE_DOTTED)
  - `setLinkThickness(thick: int)`: Set link thickness (default is 1)
  - `setLinkLabel(label: str)`: Set the label of the link
  - `reverseLink()`: Reverse the link direction
  - `addCustomLinkProperty(fieldName=None, displayName=None, value=None)`: Set a custom property for the link


pkgId: 46f3dd698bc2cdaa04447cbebad48637ccb1585b5a0855319ef421ff91cd5cc8
name: python-mando
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: Create Python CLI apps with little to no effort at all!
url: https://mando.readthedocs.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d2f68cbc-9e13-4c24-b622-bea269e752e0
location_href: 00010139-python-mando/python-mando-0.7.1-1.src.rpm
checksum_type: sha256
description:
  mando is a wrapper around ``argparse``, and allows you to write complete CLI
  applications in seconds while maintaining all the flexibility.


pkgId: f5d158548bc4304a00542074f16603d9fbf8b62cf7e2797ea8cd692949d597c3
name: python-mandrill
arch: src
version: 1.0.60
epoch: 0
release: 1
url: https://bitbucket.org/mailchimp/mandrill-api-python/
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-86c5f10e-04d9-4723-9908-e5334617a010
location_href: 00010161-python-mandrill/python-mandrill-1.0.60-1.src.rpm
checksum_type: sha256
summary:
  Deprecated. Replaced by mailchimp-transactional - A CLI client and Python API library for the Mandrill email as a service platform.

description:
  This SDK is deprecated, and replaced by mailchimp-transactional
  Find the current Mailchimp Transactional SDKs at https://mailchimp.com/developer/tools/


pkgId: 2bc2bf923778a89eff81d270c96dd6a8def46dd1cb639534b71691ed3e2a3408
name: python-mangum
arch: src
version: 0.17.0
epoch: 0
release: 1
summary: AWS Lambda support for ASGI applications
url: https://github.com/jordaneremieff/mangum
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b7eff80a-dc67-4f60-a8a9-388066f12ad3
location_href: 00011405-python-mangum/python-mangum-0.17.0-1.src.rpm
checksum_type: sha256
description:
  <a href="https://pypi.org/project/mangum/">
      <img src="https://badge.fury.io/py/mangum.svg" alt="Package version">
  </a>
  <a href="https://travis-ci.org/jordaneremieff/mangum">
      <img src="https://travis-ci.org/jordaneremieff/mangum.svg?branch=master" alt="Build Status">
  </a>
  <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/mangum.svg?style=flat-square">

  Mangum is an adapter for running [ASGI](https://asgi.readthedocs.io/en/latest/) applications in AWS Lambda to handle Function URL, API Gateway, ALB, and Lambda@Edge events.

  ***Documentation***: https://mangum.io/



  - Event handlers for API Gateway [HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api.html) and [REST](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-rest-api.html) APIs, [Application Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/lambda-functions.html), [Function URLs](https://docs.aws.amazon.com/lambda/latest/dg/lambda-urls.html), and [CloudFront Lambda@Edge](https://docs.aws.amazon.com/lambda/latest/dg/lambda-edge.html).

  - Compatibility with ASGI application frameworks, such as [Starlette](https://www.starlette.io/), [FastAPI](https://fastapi.tiangolo.com/), [Quart](https://pgjones.gitlab.io/quart/) and [Django](https://www.djangoproject.com/).

  - Support for binary media types and payload compression in API Gateway using GZip or Brotli.

  - Works with existing deployment and configuration tools, including [Serverless Framework](https://www.serverless.com/) and [AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html).

  - Startup and shutdown [lifespan](https://asgi.readthedocs.io/en/latest/specs/lifespan.html) events.



  Python 3.7+



  ```shell
  pip install mangum
  ```



  ```python
  from mangum import Mangum

  async def app(scope, receive, send):
      await send(
          {
              "type": "http.response.start",
              "status": 200,
              "headers": [[b"content-type", b"text/plain; charset=utf-8"]],
          }
      )
      await send({"type": "http.response.body", "body": b"Hello, world!"})


  handler = Mangum(app, lifespan="off")
  ```

  Or using a framework:

  ```python
  from fastapi import FastAPI
  from mangum import Mangum

  app = FastAPI()


  @app.get("/")
  def read_root():
      return {"Hello": "World"}


  @app.get("/items/{item_id}")
  def read_item(item_id: int, q: str = None):
      return {"item_id": item_id, "q": q}

  handler = Mangum(app, lifespan="off")
  ```


