# packages

pkgId: fd49c98bd13e9140bec70a665b746e4cda0063d7636d61b76107a9ebb8f324e8
name: python-graphql-server
arch: src
version: 3.0.0b5
epoch: 0
release: 1
summary: GraphQL Server tools for powering your server
url: https://github.com/graphql-python/graphql-server
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-17b5ee02-df74-4647-a3fb-066a40e4408f
location_href: 00003812-python-graphql-server/python-graphql-server-3.0.0b5-1.src.rpm
checksum_type: sha256
description:
  <img src="https://raw.githubusercontent.com/graphql-python/graphql-server/master/docs/_static/graphql-server-logo.svg" height="128px">

  [![PyPI version](https://badge.fury.io/py/graphql-server.svg)](https://badge.fury.io/py/graphql-server)
  [![Coverage Status](https://codecov.io/gh/graphql-python/graphql-server/branch/master/graph/badge.svg)](https://codecov.io/gh/graphql-python/graphql-server)

  GraphQL-Server is a base library that serves as a helper
  for building GraphQL servers or integrations into existing web frameworks using
  [GraphQL-Core](https://github.com/graphql-python/graphql-core).



  | Server integration          | Docs                                                                                    |
  | --------------------------- | --------------------------------------------------------------------------------------- |
  | Flask                       | [flask](https://github.com/graphql-python/graphql-server/blob/master/docs/flask.md)     |
  | Sanic                       | [sanic](https://github.com/graphql-python/graphql-server/blob/master/docs/sanic.md)     |
  | AIOHTTP                     | [aiohttp](https://github.com/graphql-python/graphql-server/blob/master/docs/aiohttp.md) |
  | WebOb (Pyramid, TurboGears) | [webob](https://github.com/graphql-python/graphql-server/blob/master/docs/webob.md)     |



  | Server integration | Package                                                                                                 |
  | ------------------ | ------------------------------------------------------------------------------------------------------- |
  | WSGI               | [wsgi-graphql](https://github.com/moritzmhmk/wsgi-graphql)                                              |
  | Responder          | [responder.ext.graphql](https://github.com/kennethreitz/responder/blob/master/responder/ext/graphql.py) |



  | Server integration | Package                                                               |
  | ------------------ | --------------------------------------------------------------------- |
  | Django             | [graphene-django](https://github.com/graphql-python/graphene-django/) |



  The `graphql_server` package provides these public helper functions:

  - `run_http_query`
  - `encode_execution_results`
  - `load_json_body`
  - `json_encode`
  - `json_encode_pretty`

  **NOTE:** the `json_encode_pretty` is kept as backward compatibility change as it uses `json_encode` with `pretty` parameter set to `True`.

  All functions in the package are annotated with type hints and docstrings,
  and you can build HTML documentation from these using `bin/build_docs`.

  You can also use one of the existing integrations listed above as
  blueprint to build your own integration or GraphQL server implementations.

  Please let us know when you have built something new, so we can list it here.



  See [CONTRIBUTING.md](https://github.com/graphql-python/graphql-server/blob/master/CONTRIBUTING.md)


pkgId: 405b197bfee96daa94bc9e57d6a30852c628ed66912faf3e212167cbf97c484b
name: python-graphql-server-core
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: GraphQL Server tools for powering your server
url: https://github.com/graphql-python/graphql-server-core
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-657750d3-be8b-4d44-ae53-7e2864b5d245
location_href: 00010295-python-graphql-server-core/python-graphql-server-core-2.0.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/graphql-server-core.svg)](https://badge.fury.io/py/graphql-server-core)
  [![Build Status](https://travis-ci.org/graphql-python/graphql-server-core.svg?branch=master)](https://travis-ci.org/graphql-python/graphql-server-core)
  [![Coverage Status](https://codecov.io/gh/graphql-python/graphql-server-core/branch/master/graph/badge.svg)](https://codecov.io/gh/graphql-python/graphql-server-core)

  GraphQL-Server-Core is a base library that serves as a helper
  for building GraphQL servers or integrations into existing web frameworks using
  [GraphQL-Core](https://github.com/graphql-python/graphql-core).



  | Server integration | Package |
  |---|---|
  | Flask | [flask-graphql](https://github.com/graphql-python/flask-graphql/) |
  | Sanic |[sanic-graphql](https://github.com/graphql-python/sanic-graphql/) |
  | AIOHTTP | [aiohttp-graphql](https://github.com/graphql-python/aiohttp-graphql) |
  | WebOb (Pyramid, TurboGears) |  [webob-graphql](https://github.com/graphql-python/webob-graphql/) |
  | WSGI | [wsgi-graphql](https://github.com/moritzmhmk/wsgi-graphql) |
  | Responder | [responder.ext.graphql](https://github.com/kennethreitz/responder/blob/master/responder/ext/graphql.py) |



  | Server integration | Package |
  |---|---|
  | Django | [graphene-django](https://github.com/graphql-python/graphene-django/) |



  The `graphql_server` package provides these public helper functions:

   * `run_http_query`
   * `encode_execution_results`
   * `load_json_body`
   * `json_encode`
   * `json_encode_pretty`

  All functions in the package are annotated with type hints and docstrings,
  and you can build HTML documentation from these using `bin/build_docs`.

  You can also use one of the existing integrations listed above as
  blueprint to build your own integration or GraphQL server implementations.

  Please let us know when you have built something new, so we can list it here.


  See [CONTRIBUTING.md](CONTRIBUTING.md)


pkgId: 0e7466c267d28753e9ee17c32f8a5598224c3714a9b13ac1159dad8dfcc42afb
name: python-graphqlclient
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: Simple GraphQL client for Python 2.7+
url: https://github.com/prismagraphql/python-graphql-client
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a3ae4477-9951-4cbe-8f4a-ad229dd692de
location_href: 00011933-python-graphqlclient/python-graphqlclient-0.2.4-1.src.rpm
checksum_type: sha256
description:
  Simple GraphQL client for Python 2.7+



  ```sh
  pip install graphqlclient
  ```




  ```py
  from graphqlclient import GraphQLClient

  client = GraphQLClient('http://graphql-swapi.parseapp.com/')

  result = client.execute('''
  {
    allFilms {
      films {
        title
      }
    }
  }
  ''')

  print(result)
  ```



  Authorization tokens can be added to the request using the client's `inject_token` method:

  ```py
  client.inject_token('very-long-and-secure-token')
  ```

  which defaults to http header name `Authorization`.
  An alternative http header name for the token can be set by passing in the alternative header name, e.g. for `x-api-key`:

  ```py
  client.inject_token('very-long-and-secure-token','x-api-key')
  ```



  [MIT License](http://opensource.org/licenses/MIT)


pkgId: 6cb1b937b966c28d4752b7fbc87a42cd4b4020a4ced028122d8864906b5f7481
name: python-graphviz
arch: src
version: 0.20.1
epoch: 0
release: 1
summary: Simple Python interface for Graphviz
url: https://github.com/xflr6/graphviz
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f2fc8ce4-f14a-4080-8fb5-8e742aa7090b
location_href: 00003816-python-graphviz/python-graphviz-0.20.1-1.src.rpm
checksum_type: sha256
description:
  |PyPI version| |License| |Supported Python| |Wheel| |Downloads|
  |Build| |Codecov| |Readthedocs-stable| |Readthedocs-latest|
  |Binder-stable|
  This package facilitates the creation and rendering of graph descriptions in
  the DOT_ language of the Graphviz_ graph drawing software (`upstream repo`_)
  from Python.
  Create a graph object, assemble the graph by adding nodes and edges, and
  retrieve its DOT source code string. Save the source code to a file and render
  it with the Graphviz installation of your system.
  Use the ``view`` option/method to directly inspect the resulting (PDF, PNG,
  SVG, etc.) file with its default application. Graphs can also be rendered
  and displayed within `Jupyter notebooks`_ (formerly known as
  `IPython notebooks`_,
  `example <notebook_>`_, `nbviewer <notebook-nbviewer_>`_)
  as well as the `Jupyter QtConsole`_.


pkgId: 2e61fdf2f31102888a089cf4c99fbd9af1917b54516a88e8a5e3dff1173a5436
name: python-graphyte
arch: src
version: 1.7.1
epoch: 0
release: 1
summary: Python 3 compatible library to send data to a Graphite metrics server (Carbon)
url: https://github.com/benhoyt/graphyte
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cd7f127a-0ae8-4c6f-a308-16581d55b607
location_href: 00011883-python-graphyte/python-graphyte-1.7.1-1.src.rpm
checksum_type: sha256
description:
  graphyte is a small Python library that sends data to a Graphite metrics
  server (Carbon). We wrote it because the existing `graphitesend`_ library
  didn’t support Python 3, and it also required gevent for asyncronous use.
  graphyte is tested on Python 3.5+ as well as Python 2.7, and uses the
  standard library’s ``threading`` module for asynchronous use.
  The library is `on the Python Package Index (PyPI)`_, so to install it, fire up
  a command prompt, activate your virtualenv if you’re using one, and type:
      pip install graphyte
  Using graphyte is simple – just call ``init()`` to initialize the default
  sender and then ``send()`` to send a message. For example, to send
  ``system.sync.foo.bar 42 {timestamp}\n`` to graphite.example.com:2003
  synchronously:
      import graphyte
      graphyte.init('graphite.example.com', prefix='system.sync')
      graphyte.send('foo.bar', 42)
  If you want to send asynchronously on a background thread (for example, in a
  web server context), just specify a send interval. For example, this will
  setup a background thread to send every 10 seconds:
      graphyte.init('graphite.example.com', prefix='system.async', interval=10)
      graphyte.send('foo.bar', 42)
  If you want to send tagged metrics, the usage is as follows:
      graphite.send('foo.bar', 42, tags={'ding': 'dong'})
  For more advanced usage, for example if you want to send to multiple servers
  or if you want to subclass ``Sender``, you can instantiate instances of
  ``Sender`` directly. For example, to instantiate two senders sending to
  different   servers (one synchronous, one using a background thread with send
  interval 10   seconds), use something like the following:
      sender1 = graphyte.Sender('graphite1.example.com', prefix='system.one')
      sender2 = graphyte.Sender('graphite2.example.com', prefix='system.two', interval=10)
      sender1.send('foo.bar1', 42)
      sender2.send('foo.bar2', 43)
  If you want to send via UDP instead of TCP, just add   ``protocol='udp'`` to
  the ``init()`` or ``Sender()`` call.
  Or, to customize how messages are logged or sent to the socket, subclass
  ``Sender`` and override ``send_message`` (or even ``send_socket`` if you
  want to override logging and exception handling):
      class CustomSender(graphyte.Sender):
          def send_message(self, message):
              print('Sending bytes in some custom way: {!r}'.format(message))
  By default, exceptions that occur when sending a message are logged. If you
  want to raise and propagate exceptions instead, instantiate ``Sender`` with
  ``raise_send_errors=True``. It's an error to set ``raise_send_errors`` when
  ``interval`` is specified.
  Socket sending errors are logged using the Python logging system (using
  logger name “graphyte”). If the sender is initialized with
  ``log_sends=True``, all sends are logged at the INFO level.
  You can also use graphyte to send metrics directly from the command line:
      python -m graphyte foo.bar 42
  There are command line arguments to specify the server and port and other
  configuration. Type ``python -m graphyte --help`` for help.
  Read the code in `graphyte.py`_ for more details – it’s pretty small!
  graphyte was written by `Ben Hoyt`_ and is licensed with a
  permissive MIT license (see `LICENSE.txt`_).
  **Related work:** `delphid`_ has a fork of graphyte which supports the statsd
  protocol. See the changes on `delphid's branch`_.


pkgId: 3f6d27f276fcffbce477f260282013c1cc69162b7cabfde7e213c81d32ae8c96
name: python-graypy
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Python logging handlers that send messages in the Graylog Extended Log Format (GELF).
url: https://github.com/severb/graypy
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-64a9f7d6-e5c4-4aaa-a3b7-54457de4bbce
location_href: 00011132-python-graypy/python-graypy-2.1.0-1.src.rpm
checksum_type: sha256
description:
  Python logging handlers that send log messages in the
  Graylog Extended Log Format (GELF_).
  graypy supports sending GELF logs to both Graylog2 and Graylog3 servers.


pkgId: 87ea40e9722cfee72b2541a506905322191d6cc84d1eb91135fe8ab03c9cfaab
name: python-greenlet
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: Lightweight in-process concurrent programming
url: https://greenlet.readthedocs.io/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1f1474b1-e613-4330-95f4-faf5ed250fd9
location_href: 00003817-python-greenlet/python-greenlet-2.0.2-1.src.rpm
checksum_type: sha256
description:
  There are several libraries that use Greenlet as a more flexible
  alternative to Python's built in coroutine support:
   - `Concurrence`_
   - `Eventlet`_
   - `Gevent`_


pkgId: 25291cd1691fa466956c582e39966a8ceda34b876ae1de00252dbefb814e1582
name: python-grpc-google-iam-v1
arch: src
version: 0.12.6
epoch: 0
release: 1
summary: IAM API client library
url: https://github.com/googleapis/python-grpc-google-iam-v1
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-90469f9c-8601-4945-bcc9-f5b7444865a7
location_href: 00009174-python-grpc-google-iam-v1/python-grpc-google-iam-v1-0.12.6-1.src.rpm
checksum_type: sha256
description:
  |preview| |pypi| |versions|
  `IAM API`_:
  - `Client Library Documentation`_
  - `Product Documentation`_
  Installation
  ~~~~~~~~~~~~
  Install this library in a `virtualenv`_ using pip. `virtualenv`_ is a tool to
  create isolated Python environments. The basic problem it addresses is one of
  dependencies and versions, and indirectly permissions.
  With `virtualenv`_, it's possible to install this library without needing system
  install permissions, and without clashing with the installed system
  dependencies.
  Supported Python Versions
  ^^^^^^^^^^^^^^^^^^^^^^^^^
  Python >= 3.7
  Mac/Linux
  ^^^^^^^^^
      pip install virtualenv
      virtualenv <your-env>
      source <your-env>/bin/activate
      <your-env>/bin/pip install grpc-google-iam-v1
  Windows
  ^^^^^^^
      pip install virtualenv
      virtualenv <your-env>
      <your-env>\Scripts\activate
      <your-env>\Scripts\pip.exe install grpc-google-iam-v1
  Next Steps
  ~~~~~~~~~~
  -  Read the `Client Library Documentation`_ for IAM
     API to see other available methods on the client.
  -  Read the `IAM API Product documentation`_ to learn
     more about the product and see How-to Guides.
  -  View this `README`_ to see the full list of Cloud
     APIs that we cover.


pkgId: d4243af109e2874d713df47a2f490263a0c00b263a1560e5b2b69b92c92f28c7
name: python-grpc-google-logging-v2
arch: src
version: 0.11.1
epoch: 0
release: 1
summary: GRPC library for the google-logging-v2 service
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e967eeff-7b8b-4544-a8ba-e365f1546afe
location_href: 00011366-python-grpc-google-logging-v2/python-grpc-google-logging-v2-0.11.1-1.src.rpm
checksum_type: sha256
description:
  gRPC library for google-logging-v2

  grpc-google-logging-v2 is the IDL-derived library for the google-logging (v2) service in the googleapis_ repository.

  .. _`googleapis`: https://github.com/googleapis/googleapis/tree/master/google/logging/v2


pkgId: 60a3e540a75c4194529b596879a0439a05503e24c8698183129455ad091db3a0
name: python-grpc-interceptor
arch: src
version: 0.15.0
epoch: 0
release: 1
summary: Simplifies gRPC interceptors
url: https://github.com/d5h-foss/grpc-interceptor
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-241b65d9-b216-45b9-a26c-2dcd4523545d
location_href: 00013791-python-grpc-interceptor/python-grpc-interceptor-0.15.0-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/d5h-foss/grpc-interceptor/workflows/Tests/badge.svg)](https://github.com/d5h-foss/grpc-interceptor/actions?workflow=Tests)
  [![Codecov](https://codecov.io/gh/d5h-foss/grpc-interceptor/branch/master/graph/badge.svg)](https://codecov.io/gh/d5h-foss/grpc-interceptor)
  [![Read the Docs](https://readthedocs.org/projects/grpc-interceptor/badge/)](https://grpc-interceptor.readthedocs.io/)
  [![PyPI](https://img.shields.io/pypi/v/grpc-interceptor.svg)](https://pypi.org/project/grpc-interceptor/)



  Simplified Python gRPC interceptors.

  The Python `grpc` package provides service interceptors, but they're a bit hard to
  use because of their flexibility. The `grpc` interceptors don't have direct access
  to the request and response objects, or the service context. Access to these are often
  desired, to be able to log data in the request or response, or set status codes on the
  context.



  To just get the interceptors (and probably not write your own):

  ```console
  $ pip install grpc-interceptor
  ```

  To also get the testing framework, which is good if you're writing your own interceptors:

  ```console
  $ pip install grpc-interceptor[testing]
  ```





  To define your own interceptor (we can use `ExceptionToStatusInterceptor` as an example):

  ```python
  from grpc_interceptor import ServerInterceptor
  from grpc_interceptor.exceptions import GrpcException

  class ExceptionToStatusInterceptor(ServerInterceptor):
      def intercept(
          self,
          method: Callable,
          request: Any,
          context: grpc.ServicerContext,
          method_name: str,
      ) -> Any:
          """Override this method to implement a custom interceptor.
           You should call method(request, context) to invoke the
           next handler (either the RPC method implementation, or the
           next interceptor in the list).
           Args:
               method: The next interceptor, or method implementation.
               request: The RPC request, as a protobuf message.
               context: The ServicerContext pass by gRPC to the service.
               method_name: A string of the form
                   "/protobuf.package.Service/Method"
           Returns:
               This should generally return the result of
               method(request, context), which is typically the RPC
               method response, as a protobuf message. The interceptor
               is free to modify this in some way, however.
           """
          try:
              return method(request, context)
          except GrpcException as e:
              context.set_code(e.status_code)
              context.set_details(e.details)
              raise
  ```

  Then inject your interceptor when you create the `grpc` server:

  ```python
  interceptors = [ExceptionToStatusInterceptor()]
  server = grpc.server(
      futures.ThreadPoolExecutor(max_workers=10),
      interceptors=interceptors
  )
  ```

  To use `ExceptionToStatusInterceptor`:

  ```python
  from grpc_interceptor.exceptions import NotFound

  class MyService(my_pb2_grpc.MyServiceServicer):
      def MyRpcMethod(
          self, request: MyRequest, context: grpc.ServicerContext
      ) -> MyResponse:
          thing = lookup_thing()
          if not thing:
              raise NotFound("Sorry, your thing is missing")
          ...
  ```

  This results in the gRPC status status code being set to `NOT_FOUND`,
  and the details `"Sorry, your thing is missing"`. This saves you the hassle of
  catching exceptions in your service handler, or passing the context down into
  helper functions so they can call `context.abort` or `context.set_code`. It allows
  the more Pythonic approach of just raising an exception from anywhere in the code,
  and having it be handled automatically.



  We will use an invocation metadata injecting interceptor as an example of defining
  a client interceptor:

  ```python
  from grpc_interceptor import ClientCallDetails, ClientInterceptor

  class MetadataClientInterceptor(ClientInterceptor):

      def intercept(
          self,
          method: Callable,
          request_or_iterator: Any,
          call_details: grpc.ClientCallDetails,
      ):
          """Override this method to implement a custom interceptor.

          This method is called for all unary and streaming RPCs. The interceptor
          implementation should call `method` using a `grpc.ClientCallDetails` and the
          `request_or_iterator` object as parameters. The `request_or_iterator`
          parameter may be type checked to determine if this is a singluar request
          for unary RPCs or an iterator for client-streaming or client-server streaming
          RPCs.

          Args:
              method: A function that proceeds with the invocation by executing the next
                  interceptor in the chain or invoking the actual RPC on the underlying
                  channel.
              request_or_iterator: RPC request message or iterator of request messages
                  for streaming requests.
              call_details: Describes an RPC to be invoked.

          Returns:
              The type of the return should match the type of the return value received
              by calling `method`. This is an object that is both a
              `Call <https://grpc.github.io/grpc/python/grpc.html#grpc.Call>`_ for the
              RPC and a `Future <https://grpc.github.io/grpc/python/grpc.html#grpc.Future>`_.

              The actual result from the RPC can be got by calling `.result()` on the
              value returned from `method`.
          """
          new_details = ClientCallDetails(
              call_details.method,
              call_details.timeout,
              [("authorization", "Bearer mysecrettoken")],
              call_details.credentials,
              call_details.wait_for_ready,
              call_details.compression,
          )

          return method(request_or_iterator, new_details)
  ```

  Now inject your interceptor when you create the ``grpc`` channel:

  ```python
  interceptors = [MetadataClientInterceptor()]
  with grpc.insecure_channel("grpc-server:50051") as channel:
      channel = grpc.intercept_channel(channel, *interceptors)
      ...
  ```

  Client interceptors can also be used to retry RPCs that fail due to specific errors, or
  a host of other use cases. There are some basic approaches in the tests to get you
  started.



  The examples above showed usage for simple unary-unary RPC calls. For examples of
  streaming and asyncio RPCs, read the
  [complete documentation here](https://grpc-interceptor.readthedocs.io/).

  Note that there is no asyncio client interceptors at the moment, though contributions
  are welcome.


pkgId: e29e61f97db57af2a2c19684e3afe72b33eff6610066f2a9686f20cd44313129
name: python-grpc-stubs
arch: src
version: 1.53.0.1
epoch: 0
release: 1
summary: Mypy stubs for gRPC
url: https://github.com/shabbyrobe/grpc-stubs
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-06096832-9076-4d60-be4a-2d03338fde2d
location_href: 00010740-python-grpc-stubs/python-grpc-stubs-1.53.0.1-1.src.rpm
checksum_type: sha256
description:
  This is a PEP-561-compliant stub-only package which provides type information of
  [gRPC](https://grpc.io>).
  Install using pip:
      pip install grpc-stubs
  Tests (courtesy of [pytest-mypy-plugins](https://github.com/typeddjango/pytest-mypy-plugins>):
      pip install -r requirements-dev.txt
      ./tools.sh test

  grpc-stubs is tested with 3.7 or later, but ideally it should support Python 3.6 as
  grpc still supports this. Python 3.6 had to be disabled in the tests due to
  various cascading fiascos and a lack of time to contend with them. Feel free
  to submit a PR if you'd like to see it returned, or open issues. Ensure that
  you supply an MRE as per the contributing guidelines below.


  Unfortunately, due to the fussy nature of `grpc` and its dependencies, and the huge amount of time
  required to construct a context in which to verify and debug issues, starting from 2022-04-16, fairly strict issue and
  pull request templates have been added.
  Minimum Reproducible Examples are now a hard requirement for pull requests that touch the typing surface,
  and a soft requirement for issues. PRs without a functioning MRE transfer the burden entirely from the
  contributor to the maintainer, and I simply don't have time to do the deep-dives required to build out MREs
  from scratch when issues inevitably crop up. PRs without a trivially executable MRE will be closed without further
  consideration; of course you are always welcome to reopen once you have added a verified MRE!

  This project uses a slightly old version of https://github.com/TypedDjango/pytest-mypy-plugins for testing.
  All new contributions will be required to include at least one, but probably multiple tests. See
  `typesafety/test_*.yml`.

  PRs containing auto-generated stubs have had to be reverted several times due to issues. Starting
  from 2022-04-16, autogenerated stubs from `mypy-protobuf` will not be accepted without extensive
  tests, and will not be accepted with edit warnings left in. It's ok to use this tool to seed stubs,
  but not to refresh stubs - once contributed to this repo, the stubs should be presumed to have been
  written by hand.

  There are several areas where `grpc-stubs` could use some TLC. If you'd like to help with any
  of this, please reach out!

  It's unlikely I'll be returning to grpc full-time for the foreseeable future, and my knowledge of the
  minutiae fades with each passing year. If anyone wishes to assume maintainership of this project ongoing,
  please reach out.

  - https://github.com/TypedDjango
  - https://github.com/typeddjango/pytest-mypy-plugins
  - https://github.com/typeddjango/awesome-python-stubs


pkgId: af2de837df23f10770db1decb606508b49ee7c85d900688846e0e039b1c52488
name: python-grpcio-debuginfo
arch: aarch64
version: 1.53.0
epoch: 0
release: 1
summary: Debug information for package python-grpcio
url: https://grpc.io
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-3fbd4df5-1c3a-499e-a1d3-ec64c24c7868
rpm_sourcerpm: python-grpcio-1.53.0-1.src.rpm
location_href: 00008944-python-grpcio/python-grpcio-debuginfo-1.53.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-grpcio.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 4392db5b93b9d295443c07e6a3be59a8d58837c29633cc37b68675bc70091d3a
name: python-grpcio-debugsource
arch: aarch64
version: 1.53.0
epoch: 0
release: 1
summary: Debug sources for package python-grpcio
url: https://grpc.io
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-3fbd4df5-1c3a-499e-a1d3-ec64c24c7868
rpm_sourcerpm: python-grpcio-1.53.0-1.src.rpm
location_href: 00008944-python-grpcio/python-grpcio-debugsource-1.53.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-grpcio.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 407aabc8e250a1e1cca8d4aed42f20778262b356c0ef5fe89033cd4ca5d45d3c
name: python-grpcio-tools-debuginfo
arch: aarch64
version: 1.53.0
epoch: 0
release: 1
summary: Debug information for package python-grpcio-tools
url: https://grpc.io
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-5400ddbc-0e27-4a6e-8e33-0eab8b9d5e61
rpm_sourcerpm: python-grpcio-tools-1.53.0-1.src.rpm
location_href: 00009211-python-grpcio-tools/python-grpcio-tools-debuginfo-1.53.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-grpcio-tools.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: dfcf0ed246893778e32a298667b73cd6ad7f21e5fd2f744ffa8b9d3b275b454e
name: python-grpcio-tools-debugsource
arch: aarch64
version: 1.53.0
epoch: 0
release: 1
summary: Debug sources for package python-grpcio-tools
url: https://grpc.io
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-5400ddbc-0e27-4a6e-8e33-0eab8b9d5e61
rpm_sourcerpm: python-grpcio-tools-1.53.0-1.src.rpm
location_href: 00009211-python-grpcio-tools/python-grpcio-tools-debugsource-1.53.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-grpcio-tools.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: fd6649ea6a4f4ec02ccd2ed08ca8a9fe66fb3c81695a67160f3d3f3f03730c75
name: python-grpclib
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: Pure-Python gRPC implementation for asyncio
url: https://github.com/vmagamedov/grpclib
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6098bc5e-a9c8-461b-8b38-c2941ad17302
location_href: 00011550-python-grpclib/python-grpclib-0.4.3-1.src.rpm
checksum_type: sha256
description:
  |project|_ |documentation|_ |version|_ |tag|_ |license|_
  This project is based on `hyper-h2`_ and **requires Python >= 3.7**.
  Example
  ~~~~~~~
  See `examples`_ directory in the project's repository for all available
  examples.


pkgId: 4acb3a3670959f2b8ca7eca86227cf0b600a9c5629e4b2d29da0c16ddcb925ba
name: python-gsd
arch: src
version: 2.8.0
epoch: 0
release: 1
summary: General simulation data file format.
url: https://gsd.readthedocs.io
rpm_license: BSD - 2 clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-95658293-9ec6-4bec-8f4a-c01c7056241f
location_href: 00003821-python-gsd/python-gsd-2.8.0-1.src.rpm
checksum_type: sha256
description:
  The **GSD** file format is the native file format for [HOOMD-blue](https://glotzerlab.engin.umich.edu/hoomd-blue/).
  **GSD** files store trajectories of the **HOOMD-blue** system state in a binary file with efficient random access to
  frames. **GSD** allows all particle and topology properties to vary from one frame to the next. Use the **GSD** Python
  API to specify the initial condition for a **HOOMD-blue** simulation or analyze trajectory output with a script. Read a
  **GSD** trajectory with a visualization tool to explore the behavior of the simulation.



  * [GSD documentation](http://gsd.readthedocs.io): Tutorials, Python API, C API, usage information, and format
    specification.
  * [Installation Guide](INSTALLING.rst): Instructions for installing and compiling **GSD**.
  * [HOOMD-blue](https://glotzerlab.engin.umich.edu/hoomd-blue/): Simulation engine that reads and writes **GSD** files.
  * [hoomd-users Google Group](https://groups.google.com/d/forum/hoomd-users):
    Ask questions to the **HOOMD-blue** community.
  * [freud](https://freud.readthedocs.io): A powerful set of tools for analyzing trajectories.
  * [OVITO](https://www.ovito.org/): The Open Visualization Tool works with **GSD** files.
  * [gsd-vmd plugin](https://github.com/mphoward/gsd-vmd): VMD plugin to support **GSD** files.



  Create a hoomd gsd file.
  ```python
  >>> s = gsd.hoomd.Frame()
  >>> s.particles.N = 4
  >>> s.particles.types = ['A', 'B']
  >>> s.particles.typeid = [0,0,1,1]
  >>> s.particles.position = [[0,0,0],[1,1,1], [-1,-1,-1], [1,-1,-1]]
  >>> s.configuration.box = [3, 3, 3, 0, 0, 0]
  >>> traj = gsd.hoomd.open(name='test.gsd', mode='wb')
  >>> traj.append(s)
  ```

  Append frames to a gsd file:
  ```python
  >>> def create_frame(i):
  ...     s = gsd.hoomd.Frame();
  ...     s.configuration.step = i;
  ...     s.particles.N = 4+i;
  ...     s.particles.position = numpy.random.random(size=(4+i,3))
  ...     return s;
  >>> with gsd.hoomd.open('test.gsd', 'ab') as t:
  ...     t.extend( (create_frame(i) for i in range(10)) )
  ...     print(len(t))
  11
  ```

  Randomly index frames:
  ```python
  >>> with gsd.hoomd.open('test.gsd', 'rb') as t:
  ...     frame = t[5]
  ...     print(frame.configuration.step)
  4
  ...     print(frame.particles.N)
  8
  ...     print(frame.particles.position)
  [[ 0.56993282  0.42243481  0.5502916 ]
   [ 0.36892486  0.38167036  0.27310368]
   [ 0.04739023  0.13603486  0.196539  ]
   [ 0.120232    0.91591144  0.99463677]
   [ 0.79806316  0.16991436  0.15228257]
   [ 0.13724308  0.14253527  0.02505   ]
   [ 0.39287439  0.82519054  0.01613089]
   [ 0.23150323  0.95167434  0.7715748 ]]
  ```

  Slice frames:
  ```python
  >>> with gsd.hoomd.open('test.gsd', 'rb') as t:
  ...     for s in t[5:-2]:
  ...         print(s.configuration.step, end=' ')
  4 5 6 7
  ```



  ```python
  with gsd.fl.open(name='file.gsd', mode='wb') as f:
      f.write_chunk(name='position', data=numpy.array([[1,2,3],[4,5,6]], dtype=numpy.float32));
      f.write_chunk(name='angle', data=numpy.array([0, 1], dtype=numpy.float32));
      f.write_chunk(name='box', data=numpy.array([10, 10, 10], dtype=numpy.float32));
      f.end_frame()
  ```

  ```python
  with gsd.fl.open(name='file.gsd', mode='rb') as f:
      for i in range(1,f.nframes):
          position = f.read_chunk(frame=i, name='position');
          do_something(position);
  ```


pkgId: b828c9fa755618a506018815214a25451e9e6a4a7e2eb732d827696c7315b70d
name: python-gsheets
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Pythonic wrapper for the Google Sheets API
url: https://github.com/xflr6/gsheets
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b04be2d8-5f4b-458c-b74c-037810e09e36
location_href: 00010872-python-gsheets/python-gsheets-0.6.1-1.src.rpm
checksum_type: sha256
description:
  |PyPI version| |License| |Supported Python| |Wheel|
  |Build| |Codecov| |Readthedocs-stable| |Readthedocs-latest|
  ``gsheets`` is a small wrapper around the `Google Sheets API`_ (v4) to provide
  more convenient access to `Google Sheets`_ from Python scripts.
  `Turn on the API`_, download an OAuth client ID as JSON file, and create a
  ``Sheets`` object from it. Use its index access (``__getitem__``) to retrieve
  SpreadSheet objects by their id, or use ``.get()`` with a sheet URL.
  Iterate over the ``Sheets`` object for all spreadsheets, or fetch spreadsheets
  by title with the ``.find()`` and ``.findall()`` methods.
  SpreadSheet objects are collections of WorkSheets, which provide access to the
  cell values via spreadsheet coordinates/slices (e.g. ``ws['A1']``) and
  zero-based cell position (e.g. ``ws.at(0, 1)``).
  Save WorkSheets (or all from a SpreadSheet) as CSV files with the
  ``.to_csv()``-method. Create ``pandas.DataFrames`` from worksheet with the
  ``.to_frame()``-method.


pkgId: e563a328cc81f657559ca7432ab87f8f17c5e3cb6617a15c4050eee892765da9
name: python-gspread
arch: src
version: 5.8.0
epoch: 0
release: 1
summary: Google Spreadsheets Python API
url: https://github.com/burnash/gspread
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dd4a2561-74ad-4288-9c9e-f9692a644156
location_href: 00009172-python-gspread/python-gspread-5.8.0-1.src.rpm
checksum_type: sha256
description:
  * Google Sheets API v4.
  * Open a spreadsheet by title, key or url.
  * Read, write, and format cell ranges.
  * Sharing and access control.
  * Batching updates.


pkgId: a80b81b45756332ebe6a4880c975abd66dda997579870e89d90f253003238950
name: python-gspread-dataframe
arch: src
version: 3.3.0
epoch: 0
release: 1
summary: Read/write gspread worksheets using pandas DataFrames
url: https://github.com/robin900/gspread-dataframe
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d582793c-04a1-420e-bd88-4b7b08d3728d
location_href: 00009593-python-gspread-dataframe/python-gspread-dataframe-3.3.0-1.src.rpm
checksum_type: sha256
description:
  This package allows easy data flow between a worksheet in a Google spreadsheet
  and a Pandas DataFrame. Any worksheet you can obtain using the ``gspread`` package
  can be retrieved as a DataFrame with ``get_as_dataframe``; DataFrame objects can
  be written to a worksheet using ``set_with_dataframe``:
      import pandas as pd
      from gspread_dataframe import get_as_dataframe, set_with_dataframe
      worksheet = some_worksheet_obtained_from_gspread_client
      df = pd.DataFrame.from_records([{'a': i, 'b': i * 2} for i in range(100)])
      set_with_dataframe(worksheet, df)
      df2 = get_as_dataframe(worksheet)
  The ``get_as_dataframe`` function supports the keyword arguments
  that are supported by your Pandas version's text parsing readers,
  such as ``pandas.read_csv``. Consult `your Pandas documentation for a full list of options <https://pandas.pydata.org/docs/reference/api/pandas.read_csv.html>`__. Since the ``'python'`` engine in Pandas is used for parsing,
  only options supported by that engine are acceptable:
      import pandas as pd
      from gspread_dataframe import get_as_dataframe
      worksheet = some_worksheet_obtained_from_gspread_client
      df = get_as_dataframe(worksheet, parse_dates=True, usecols=[0,2], skiprows=1, header=None)
  Formatting Google worksheets for DataFrames
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  If you install the ``gspread-formatting`` package, you can additionally format a Google worksheet to suit the
  DataFrame data you've just written. See the `package documentation for details <https://github.com/robin900/gspread-formatting#formatting-a-worksheet-using-a-pandas-dataframe>`__, but here's a short example using the default formatter:
      import pandas as pd
      from gspread_dataframe import get_as_dataframe, set_with_dataframe
      from gspread_formatting.dataframe import format_with_dataframe
      worksheet = some_worksheet_obtained_from_gspread_client
      df = pd.DataFrame.from_records([{'a': i, 'b': i * 2} for i in range(100)])
      set_with_dataframe(worksheet, df)
      format_with_dataframe(worksheet, df, include_column_header=True)


pkgId: e3907e091359c62995e49df277dd65256cbb23ab0c6e74c1efee42c54b1dcab6
name: python-gspread-pandas
arch: src
version: 3.2.2
epoch: 0
release: 1
url: https://github.com/aiguofer/gspread-pandas
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-343da40f-63ee-4dfb-a980-7b6b896ca5a6
location_href: 00010556-python-gspread-pandas/python-gspread-pandas-3.2.2-1.src.rpm
checksum_type: sha256
summary:
  A package to easily open an instance of a Google spreadsheet and interact with worksheets through Pandas DataFrames.


pkgId: 9dd5b277173a68029abdc413ad870dddb87c602f9672502a6162f08fb55ddfe4
name: python-gsq
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: G Square Conditional Independence Test
url: https://github.com/keiichishima/gsq/
rpm_license: GNU General Public License v2 or later (GPLv2+)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-24eb2b15-d723-4648-947c-4c5cd09ebbcf
location_href: 00009623-python-gsq/python-gsq-0.1.6-1.src.rpm
checksum_type: sha256
description:
  This package contains conditional independence test functions using
  the G-square test.



  The code fragments included in this package are logically copied and
  pasted from [the pcalg package for R]
  (http://cran.r-project.org/web/packages/pcalg/index.html) developed by
  Markus Kalisch, Alain Hauser, Martin Maechler, Diego Colombo, Doris
  Entner, Patrik Hoyer, Antti Hyttinen, and Jonas Peters.



  The source code is available at https://github.com/keiichishima/gsq



  Please submit bug reports or patches through the GitHub interface.



  - Joost H. van der Linden, https://github.com/joosthvanderlinden
  - Satoru Kobayashi, https://github.com/cpflat



  Keiichi SHIMA
  / IIJ Innovation Institute Inc.
  / WIDE project


pkgId: 9682635724f472c5e7f9b9680cf1ae0ab7ef27909da5baea4f254edaca6dbce3
name: python-guessit
arch: src
version: 3.7.1
epoch: 0
release: 1
summary: GuessIt - a library for guessing information from video filenames.
url: https://guessit-io.github.io/guessit
rpm_license: LGPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bae520a5-e5dc-4d30-babc-c06cbcdb0614
location_href: 00003826-python-guessit/python-guessit-3.7.1-1.src.rpm
checksum_type: sha256
description:
  This project is hosted on [GitHub](https://github.com/guessit-io/guessit). Feel free to open an issue if you think you have found a bug or something is missing in guessit.
  GuessIt relies on [Rebulk](https://github.com/Toilal/rebulk) project for pattern and rules registration.


pkgId: 65c00f3a407bfc0f42f63a486856dafaa0b061f90970647ebc7a65e19a86c3a1
name: python-guizero
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Python module to allow learners to easily create GUIs
url: https://github.com/lawsie/guizero
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7bf1c6f8-afb9-4ff1-a590-8285a3de9f77
location_href: 00003827-python-guizero/python-guizero-1.4.0-1.src.rpm
checksum_type: sha256
description:
  guizero is designed to allow new learners to quickly and easily create GUIs for their programs.

  There is comprehensive documentation at [lawsie.github.io/guizero](https://lawsie.github.io/guizero/)



  If you can download and unzip a file, you can [install guizero](https://lawsie.github.io/guizero/#easy-install) - **no special permissions or administrator rights are required**.

  If you have administrator rights and are connected to the internet, you can use [pip to quickly install guizero]((https://lawsie.github.io/guizero/#install-using-pip).

  guizero only requires `tkinter` to be installed, which is included with a standard Python installation on all platforms except Linux.
  A python module to allow learners to easily create GUIs. guizero is designed to be used by new learners.



  guizero is simple to use, taking away much of the complexity of creating simple GUIs.

  ```python
  from guizero import App, Text
  app = App(title="Hello world")
  message = Text(app, text="Welcome to the Hello world app!")
  app.display()
  ```


pkgId: 06e2b01eb707b7fd9e6d6e243254dd8da43057675f15f06da766a052ab47c2f1
name: python-gunicorn
arch: src
version: 20.1.0
epoch: 0
release: 1
summary: WSGI HTTP Server for UNIX
url: https://gunicorn.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0da84337-ea1e-4f42-91ba-3b7d7e2e8bb1
location_href: 00008965-python-gunicorn/python-gunicorn-20.1.0-1.src.rpm
checksum_type: sha256
description:
  Gunicorn 'Green Unicorn' is a Python WSGI HTTP Server for UNIX. It's a pre-fork
  worker model ported from Ruby's Unicorn_ project. The Gunicorn server is broadly
  compatible with various web frameworks, simply implemented, light on server
  resource usage, and fairly speedy.
  Feel free to join us in `#gunicorn`_ on Freenode_.


pkgId: 984e20a6e6662460bd6dc954454fe6b1b3f1168a7674632bb93c20dcc5ca6f1c
name: python-guppy3
arch: src
version: 3.1.2
epoch: 0
release: 1
summary: Guppy 3 -- Guppy-PE ported to Python 3
url: https://github.com/zhuyifei1999/guppy3/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fa5683c2-b49d-4c6b-adbf-d1c238708183
location_href: 00010965-python-guppy3/python-guppy3-3.1.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://img.shields.io/travis/com/zhuyifei1999/guppy3?label=tests)](https://travis-ci.com/zhuyifei1999/guppy3) [![Codecov](https://img.shields.io/codecov/c/github/zhuyifei1999/guppy3)](https://codecov.io/gh/zhuyifei1999/guppy3) [![PyPI version](https://img.shields.io/pypi/v/guppy3)](https://pypi.org/project/guppy3/) [![Repology - Repositories](https://img.shields.io/repology/repositories/python:guppy3)](https://repology.org/project/python:guppy3/versions)
  [![PyPI - Implementation](https://img.shields.io/pypi/implementation/guppy3)](https://pypi.org/project/guppy3/) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/guppy3)](https://pypi.org/project/guppy3/) [![PyPI - Downloads](https://img.shields.io/pypi/dm/guppy3)](https://pypistats.org/packages/guppy3) [![PyPI - License](https://img.shields.io/pypi/l/guppy3)](https://github.com/zhuyifei1999/guppy3/blob/master/LICENSE)

  A Python Programming Environment & Heap analysis toolset.

  This package contains the following subpackages:
  * etc - Support modules. Contains especially the Glue protocol module.
  * gsl - The Guppy Specification Language implementation. This can be used
    to create documents and tests from a common source.
  * heapy - The heap analysis toolset. It can be used to find information about
    the objects in the heap and display the information in various ways.
  * sets - Bitsets and 'nodesets' implemented in C.

  Guppy 3 is a fork of Guppy-PE, created by Sverker Nilsson for Python 2.



  You should have Python 3.6, 3.7, 3.8, or 3.9. This package is CPython only;
  PyPy and other Python implementations are not supported. Python 2 support
  can be obtained from [guppy-pe](http://guppy-pe.sourceforge.net/) by
  Sverker Nilsson, from which this package is forked.

  To use the graphical browser, Tkinter is needed.
  To use the remote monitor, threading must be available.



  Install with pip by:

  ```
  pip install guppy3
  ```

  Install with conda by:
  ```
  conda install -c conda-forge guppy3
  ```



  The following example shows

  1. How to create the session context: `h=hpy()`
  2. How to show the reachable objects in the heap: `h.heap()`
  4. How to show the shortest paths from the root to the single largest object: `h.heap().byid[0].sp`
  3. How to create and show a set of objects: `h.iso(1,[],{})`

  ```python
  >>> from guppy import hpy; h=hpy()
  >>> h.heap()
  Partition of a set of 30976 objects. Total size = 3544220 bytes.
   Index  Count   %     Size   % Cumulative  % Kind (class / dict of class)
       0   8292  27   739022  21    739022  21 str
       1   7834  25   625624  18   1364646  39 tuple
       2   2079   7   300624   8   1665270  47 types.CodeType
       3    400   1   297088   8   1962358  55 type
       4   4168  13   279278   8   2241636  63 bytes
       5   1869   6   269136   8   2510772  71 function
       6    400   1   228464   6   2739236  77 dict of type
       7     79   0   139704   4   2878940  81 dict of module
       8   1061   3    93368   3   2972308  84 types.WrapperDescriptorType
       9    172   1    81712   2   3054020  86 dict (no owner)
  <89 more rows. Type e.g. '_.more' to view.>
  >>> h.heap().byid[0].sp
   0: h.Root.i0_modules['os'].__dict__
  >>> h.iso(1,[],{})
  Partition of a set of 3 objects. Total size = 348 bytes.
   Index  Count   %     Size   % Cumulative  % Kind (class / dict of class)
       0      1  33      248  71       248  71 dict (no owner)
       1      1  33       72  21       320  92 list
       2      1  33       28   8       348 100 int
  >>>
  ```

  People have written awesome posts on how to use this toolset, including:
  * [How to use guppy/heapy for tracking down memory usage](https://smira.ru/wp-content/uploads/2011/08/heapy.html)
  * [Debugging Django memory leak with TrackRefs and Guppy](https://opensourcehacker.com/2008/03/07/debugging-django-memory-leak-with-trackrefs-and-guppy/)
  * [Diagnosing Memory "Leaks" in Python](https://chase-seibert.github.io/blog/2013/08/03/diagnosing-memory-leaks-python.html)
  * [Digging into python memory issues in ckan with heapy](https://leastsignificant.blogspot.com/2015/06/digging-into-python-memory-issues-in.html)

  Formal and API documentation are [also available](https://zhuyifei1999.github.io/guppy3/).



  Issues and pull requests are welcome. You may also ask for help on using this
  toolset; however, in such cases, we will only provide guidance, and not profile
  your code for you.

  Please make sure to update tests as appropriate.



  To test if the heapy build and installation was ok, you can do:

  ```python
  >>> from guppy import hpy
  >>> hpy().test()
  Testing sets
  Test #0
  Test #1
  Test #2
  ...
  ```

  There will be several more tests. Some tests may take a while.



  Copyright (C) 2005-2013 Sverker Nilsson, S. Nilsson Computer System AB
  Copyright (C) 2019-2021 YiFei Zhu

  The right is granted to copy, use, modify and redistribute this code
  according to the rules in what is commonly referred to as an MIT
  license.

  *** USE AT YOUR OWN RISK AND BE AWARE THAT THIS IS AN EARLY RELEASE ***


pkgId: 7f64950898dd01e731add4c0543282e8cb2af380ac5131cbe2243c411ba45384
name: python-guppy3-debuginfo
arch: aarch64
version: 3.1.2
epoch: 0
release: 1
summary: Debug information for package python-guppy3
url: https://github.com/zhuyifei1999/guppy3/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-fa5683c2-b49d-4c6b-adbf-d1c238708183
rpm_sourcerpm: python-guppy3-3.1.2-1.src.rpm
location_href: 00010965-python-guppy3/python-guppy3-debuginfo-3.1.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-guppy3.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 72fe2a65d740a9d14bc0de909a306731d139255091052a1cffaa854103c8a605
name: python-guppy3-debugsource
arch: aarch64
version: 3.1.2
epoch: 0
release: 1
summary: Debug sources for package python-guppy3
url: https://github.com/zhuyifei1999/guppy3/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-fa5683c2-b49d-4c6b-adbf-d1c238708183
rpm_sourcerpm: python-guppy3-3.1.2-1.src.rpm
location_href: 00010965-python-guppy3/python-guppy3-debugsource-3.1.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-guppy3.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 4a4c6611da055d32d192f153a6c35d5eeb4b70303acb76715d001baab0ef63d9
name: python-gwebsockets
arch: src
version: 0.7
epoch: 0
release: 1
summary: GLib based websockets server
url: http://github.com/sugarlabs/gwebsockets
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8e7429c1-c956-431c-adb4-06206d6afc31
location_href: 00003828-python-gwebsockets/python-gwebsockets-0.7-1.src.rpm
checksum_type: sha256
description:
  A websocket server written in python. It uses GIO for network communication
  and hence it easily integrates with the GLib mainloop.


pkgId: 55ee9732bf310ff82cdf04e8cb8d2e9a2bf8680e6d181a415b27a1f4bcda8dbf
name: python-gym
arch: src
version: 0.26.2
epoch: 0
release: 1
summary: Gym: A universal API for reinforcement learning environments
url: https://www.gymlibrary.dev/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f9310235-43bb-4aff-b48b-3094080b5b6d
location_href: 00009625-python-gym/python-gym-0.26.2-1.src.rpm
checksum_type: sha256
description:
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://pre-commit.com/) [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)


pkgId: d79699f931bacedfce09212efeebb812a577f09501bfea6e43aca46813d2c580
name: python-h11
arch: src
version: 0.14.0
epoch: 0
release: 1
summary: A pure-Python, bring-your-own-I/O implementation of HTTP/1.1
url: https://github.com/python-hyper/h11
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-492b8e99-03d1-464b-8f89-524d5c4ac7fd
location_href: 00003830-python-h11/python-h11-0.14.0-1.src.rpm
checksum_type: sha256
description:
  This is a little HTTP/1.1 library written from scratch in Python,
  heavily inspired by `hyper-h2 <https://hyper-h2.readthedocs.io/>`_.
  It's a "bring-your-own-I/O" library; h11 contains no IO code
  whatsoever. This means you can hook h11 up to your favorite network
  API, and that could be anything you want: synchronous, threaded,
  asynchronous, or your own implementation of `RFC 6214
  <https://tools.ietf.org/html/rfc6214>`_ -- h11 won't judge you.
  (Compare this to the current state of the art, where every time a `new
  network API <https://trio.readthedocs.io/>`_ comes along then someone
  gets to start over reimplementing the entire HTTP protocol from
  scratch.) Cory Benfield made an `excellent blog post describing the
  benefits of this approach
  <https://lukasa.co.uk/2015/10/The_New_Hyper/>`_, or if you like video
  then here's his `PyCon 2016 talk on the same theme
  <https://www.youtube.com/watch?v=7cC3_jGwl_U>`_.
  This also means that h11 is not immediately useful out of the box:
  it's a toolkit for building programs that speak HTTP, not something
  that could directly replace ``requests`` or ``twisted.web`` or
  whatever. But h11 makes it much easier to implement something like
  ``requests`` or ``twisted.web``.
  At a high level, working with h11 goes like this:
  1) First, create an ``h11.Connection`` object to track the state of a
     single HTTP/1.1 connection.
  2) When you read data off the network, pass it to
     ``conn.receive_data(...)``; you'll get back a list of objects
     representing high-level HTTP "events".
  3) When you want to send a high-level HTTP event, create the
     corresponding "event" object and pass it to ``conn.send(...)``;
     this will give you back some bytes that you can then push out
     through the network.
  For example, a client might instantiate and then send a
  ``h11.Request`` object, then zero or more ``h11.Data`` objects for the
  request body (e.g., if this is a POST), and then a
  ``h11.EndOfMessage`` to indicate the end of the message. Then the
  server would then send back a ``h11.Response``, some ``h11.Data``, and
  its own ``h11.EndOfMessage``. If either side violates the protocol,
  you'll get a ``h11.ProtocolError`` exception.
  h11 is suitable for implementing both servers and clients, and has a
  pleasantly symmetric API: the events you send as a client are exactly
  the ones that you receive as a server and vice-versa.
  `Here's an example of a tiny HTTP client
  <https://github.com/python-hyper/h11/blob/master/examples/basic-client.py>`_
  It also has `a fine manual <https://h11.readthedocs.io/>`_.


pkgId: 59255d95dccda236f829388404137fa2f37991d453c05ad6268960bbd0282a26
name: python-h2o
arch: src
version: 3.40.0.3
epoch: 0
release: 1
summary: H2O, Fast Scalable Machine Learning, for python
url: https://github.com/h2oai/h2o-3.git
rpm_license: Apache v2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3ca57a60-aac6-4305-91aa-dcf5e9ccf048
location_href: 00010006-python-h2o/python-h2o-3.40.0.3-1.src.rpm
checksum_type: sha256
description:
  H2O makes Hadoop do math! H2O scales statistics, machine learning and math over BigData. H2O is extensible and users can build blocks using simple math legos in the core. H2O keeps familiar interfaces like python, R, Excel & JSON so that BigData enthusiasts & experts can explore, munge, model and score datasets using a range of simple to advanced algorithms. Data collection is easy. Decision making is hard. H2O makes it fast and easy to derive insights from your data through faster and better predictive modeling. H2O has a vision of online scoring and modeling in a single platform.


pkgId: 62a0e2468d9e2b172e4463339c39089a50077776ba3efc943c83ba13971ab624
name: python-h5io
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: Python Objects Onto HDF5
url: http://h5io.github.io
rpm_license: BSD (3-clause)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-65072351-cb53-495b-a4f5-c1baa2d489e3
location_href: 00003832-python-h5io/python-h5io-0.1.7-1.src.rpm
checksum_type: sha256
description:
  h5io is a package designed to facilitate saving some standard Python
  objects into the forward-compatible HDF5 format. It is a higher-level
  package than ``h5py``.
  Get the latest code
  ^^^^^^^^^^^^^^^^^^^
  To get the latest code using git, simply type::
      git clone git://github.com/h5io/h5io.git
  If you don't have git installed, you can download a zip or tarball
  of the latest code: https://github.com/h5io/h5io/archives/master
  Install h5io
  ^^^^^^^^^^^^
  As any Python packages, to install h5io, go in the source code directory
  and do::
      python setup.py install
  or if you don't have admin access to your python setup (permission denied
  when install) use::
      python setup.py install --user
  You can also install the latest release version with pip::
      pip install h5io --upgrade
  or for the latest development version (the most up to date)::
      pip install -e git+https://github.com/h5io/h5io#egg=h5io-dev --user
  Dependencies
  ^^^^^^^^^^^^
  The required dependencies to build the software are ``h5py`` and ``numpy``.
  ``scipy`` is required for sparse matrix IO support.
  Licensing
  ^^^^^^^^^
  h5io is **BSD-licenced** (3 clause):
      This software is OSI Certified Open Source Software.
      OSI Certified is a certification mark of the Open Source Initiative.
      Copyright (c) 2011, authors of h5io
      All rights reserved.
      Redistribution and use in source and binary forms, with or without
      modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright notice,
        this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright notice,
        this list of conditions and the following disclaimer in the documentation
        and/or other materials provided with the distribution.
      * Neither the names of h5io authors nor the names of any
        contributors may be used to endorse or promote products derived from
        this software without specific prior written permission.
      **This software is provided by the copyright holders and contributors
      "as is" and any express or implied warranties, including, but not
      limited to, the implied warranties of merchantability and fitness for
      a particular purpose are disclaimed. In no event shall the copyright
      owner or contributors be liable for any direct, indirect, incidental,
      special, exemplary, or consequential damages (including, but not
      limited to, procurement of substitute goods or services; loss of use,
      data, or profits; or business interruption) however caused and on any
      theory of liability, whether in contract, strict liability, or tort
      (including negligence or otherwise) arising in any way out of the use
      of this software, even if advised of the possibility of such
      damage.**


pkgId: 93f0306e337bbd55e60f4ba5b2fc3460417150dbfaa52f41abd8325b925ea874
name: python-h5netcdf
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: netCDF4 via h5py
url: https://h5netcdf.org
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-90442ca3-05ed-4659-bf78-3f7b56b8f20d
location_href: 00012731-python-h5netcdf/python-h5netcdf-1.1.0-1.src.rpm
checksum_type: sha256
description:
  A Python interface for the `netCDF4`_ file-format that reads and writes local or
  remote HDF5 files directly via `h5py`_ or `h5pyd`_, without relying on the Unidata
  netCDF library.


pkgId: ac9c03638cfa19109c6aebddb06c6a11b118e9a86a22492bc2b650604daf7c49
name: python-hachoir
arch: src
version: 3.2.0
epoch: 0
release: 1
summary: Package of Hachoir parsers used to open binary files
url: http://hachoir.readthedocs.io/
rpm_license: GNU GPL v2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c1f2f6f9-792c-4505-8087-c61a8bd544bd
location_href: 00010043-python-hachoir/python-hachoir-3.2.0-1.src.rpm
checksum_type: sha256
description:
  *******
  Hachoir
  *******

  .. image:: https://img.shields.io/pypi/v/hachoir.svg
     :alt: Latest release on the Python Cheeseshop (PyPI)
     :target: https://pypi.python.org/pypi/hachoir

  .. image:: https://github.com/vstinner/hachoir/actions/workflows/build.yml/badge.svg
     :alt: Build status of hachoir on GitHub Actions
     :target: https://github.com/vstinner/hachoir/actions

  .. image:: http://unmaintained.tech/badge.svg
     :target: http://unmaintained.tech/
     :alt: No Maintenance Intended

  Hachoir is a Python library to view and edit a binary stream field by field.
  In other words, Hachoir allows you to "browse" any binary stream just like you
  browse directories and files.

  A file is splitted in a tree of fields, where the smallest field is just one
  bit. Examples of fields types: integers, strings, bits, padding types, floats,
  etc. Hachoir is the French word for a meat grinder (meat mincer), which is used
  by butchers to divide meat into long tubes; Hachoir is used by computer
  butchers to divide binary files into fields.

  * `Hachoir website <http://hachoir.readthedocs.io/>`_ (source code, bugs)
  * `Hachoir on GitHub (Source code, bug tracker) <https://github.com/vstinner/hachoir>`_
  * License: GNU GPL v2

  Command line tools using Hachoir parsers:

  * hachoir-grep: find a text pattern in a binary file
  * hachoir-metadata: get metadata from binary files
  * hachoir-strip: modify a file to remove metadata
  * hachoir-urwid: display the content of a binary file in text mode

  Installation instructions: http://hachoir.readthedocs.io/en/latest/install.html

  Hachoir is written for Python 3.6 or newer.


pkgId: e3f7b03d204fce5c16da22c8e870fd71663352b2b15852a4833066234bb889aa
name: python-hacking
arch: src
version: 5.0.0
epoch: 0
release: 1
summary: OpenStack Hacking Guideline Enforcement
url: https://docs.openstack.org/hacking/latest/
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dc7e3339-9403-4072-9abc-3e7e2815b3e8
location_href: 00003836-python-hacking/python-hacking-5.0.0-1.src.rpm
checksum_type: sha256
description:
  hacking is a set of flake8 plugins that test and enforce the
  `OpenStack StyleGuide <https://docs.openstack.org/hacking/latest/user/hacking.html#styleguide>`_
  Hacking pins its dependencies, as a new release of some dependency can break
  hacking based gating jobs. This is because new versions of dependencies can
  introduce new rules, or make existing rules stricter.


pkgId: 5f4351bcb9724df927088ad3311bbdffd2510b6aab936a05d282758d6820d1f6
name: python-hammock
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: rest like a boss
url: https://github.com/kadirpekel/hammock
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9b121fb0-aac6-4693-a895-9f33764a196b
location_href: 00014289-python-hammock/python-hammock-0.2.4-1.src.rpm
checksum_type: sha256
description:
  Let's play with github::
      >>> from hammock import Hammock as Github
      >>> # Let's create the first chain of hammock using base api url
      >>> github = Github('https://api.github.com')
      >>> # Ok, let the magic happens, ask github for hammock watchers
      >>> resp = github.repos('kadirpekel', 'hammock').watchers.GET()
      >>> # now you're ready to take a rest for the rest the of code :)
      >>> for watcher in resp.json: print watcher.get('login')
      kadirpekel
      .
  Not convinced? This is also how you can watch this project to see its future capabilities::
      >>> github.user.watched('kadirpekel', 'hammock').PUT(auth=('<user>', '<pass>'),
                                                          headers={'content-length': '0'})
      <Response [204]>


pkgId: 0cee357bc474909f0f43416518e89ff49bf2e4054a392a011fd2101a7f88870c
name: python-hanziconv
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Hanzi Converter for Traditional and Simplified Chinese
url: https://github.com/berniey/hanziconv
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4fa8eb07-b199-4b6c-abc1-ce3dcbc134e1
location_href: 00012634-python-hanziconv/python-hanziconv-0.3.2-1.src.rpm
checksum_type: sha256
description:
  This tool converts between simplified and traditional Chinese Characters.
  It consists of two parts:
    - a command line tool: ``hanzi-convert``
    - a python library: ``hanziconv``
  This module supports both Python 2 and 3


pkgId: ba6103ad2751beda4c8ae7892a2156f92bc80a378848a63073a9960b28939a92
name: python-happybase
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: A developer-friendly Python library to interact with Apache HBase
url: https://github.com/wbolster/happybase
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f2f78a5a-06db-43e1-86b7-bf54ff882632
location_href: 00011653-python-happybase/python-happybase-1.2.0-1.src.rpm
checksum_type: sha256
description:
  **HappyBase** is a developer-friendly Python_ library to interact with Apache
  HBase_.
  * `Documentation <https://happybase.readthedocs.io/>`_ (Read the Docs)
  * `Downloads <http://pypi.python.org/pypi/happybase/>`_ (PyPI)
  * `Source code <https://github.com/wbolster/happybase>`_ (Github)
     you can generate the HTML documentation by running "make doc" and browsing
     to doc/build/html/index.html to see the result.


pkgId: ea91db396563469b4c7378708de0cd565053a43d88a1bc94e4fec46d3864156c
name: python-hdfs
arch: src
version: 2.7.0
epoch: 0
release: 1
summary: HdfsCLI: API and command line interface for HDFS.
url: https://hdfscli.readthedocs.io
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2f7cf5aa-01be-4c9a-8c70-2f6dfe9f0a25
location_href: 00003842-python-hdfs/python-hdfs-2.7.0-1.src.rpm
checksum_type: sha256
description:
  API and command line interface for HDFS.

  ```
  $ hdfscli --alias=dev

  Welcome to the interactive HDFS python shell.
  The HDFS client is available as `CLIENT`.

  In [1]: CLIENT.list('models/')
  Out[1]: ['1.json', '2.json']

  In [2]: CLIENT.status('models/2.json')
  Out[2]: {
    'accessTime': 1439743128690,
    'blockSize': 134217728,
    'childrenNum': 0,
    'fileId': 16389,
    'group': 'supergroup',
    'length': 48,
    'modificationTime': 1439743129392,
    'owner': 'drwho',
    'pathSuffix': '',
    'permission': '755',
    'replication': 1,
    'storagePolicy': 0,
    'type': 'FILE'
  }

  In [3]: with CLIENT.read('models/2.json', encoding='utf-8') as reader:
    ...:     from json import load
    ...:     model = load(reader)
    ...:
  ```



  * Python (2 and 3) bindings for the [WebHDFS][] (and [HttpFS][]) API,
    supporting both secure and insecure clusters.
  * Command line interface to transfer files and start an interactive client
    shell, with aliases for convenient namenode URL caching.
  * Additional functionality through optional extensions:

    + `avro`, to [read and write Avro files directly from HDFS][].
    + `dataframe`, to [load and save Pandas dataframes][].
    + `kerberos`, to [support Kerberos authenticated clusters][].

  See the [documentation][] to learn more.



  ```sh
  $ pip install hdfs
  ```

  Then hop on over to the [quickstart][] guide. A [Conda
  feedstock](https://github.com/conda-forge/python-hdfs-feedstock) is also
  available.



  HdfsCLI is tested against both [WebHDFS][] and [HttpFS][]. There are two ways
  of running tests (see `scripts/` for helpers to set up a test HDFS cluster):

  ```sh
  $ HDFSCLI_TEST_URL=http://localhost:50070 nosetests # Using a namenode's URL.
  $ HDFSCLI_TEST_ALIAS=dev nosetests # Using an alias.
  ```



  We'd love to hear what you think on the [issues][] page. Pull requests are also
  most welcome!

  [HttpFS]: http://hadoop.apache.org/docs/current/hadoop-hdfs-httpfs/
  [WebHDFS]: http://hadoop.apache.org/docs/current/hadoop-project-dist/hadoop-hdfs/WebHDFS.html
  [read and write Avro files directly from HDFS]: https://hdfscli.readthedocs.io/en/latest/api.html#module-hdfs.ext.avro
  [load and save Pandas dataframes]: https://hdfscli.readthedocs.io/en/latest/api.html#module-hdfs.ext.dataframe
  [support Kerberos authenticated clusters]: https://hdfscli.readthedocs.io/en/latest/api.html#module-hdfs.ext.kerberos
  [documentation]: https://hdfscli.readthedocs.io/
  [quickstart]: https://hdfscli.readthedocs.io/en/latest/quickstart.html
  [issues]: https://github.com/mtth/hdfs/issues


pkgId: 2d80138cbe415e0af55022cc8f5aa870194441776e1c49c7b98fed10c503a7df
name: python-hdfs3
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Python wrappers for libhdfs3, a native HDFS client
url: http://github.com/dask/hdfs3/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9d7c2ffd-aec7-4bfc-abcc-48ef5d71b23d
location_href: 00011300-python-hdfs3/python-hdfs3-0.3.1-1.src.rpm
checksum_type: sha256
description:
  |Build Status|
  This project is not undergoing development
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  Pyarrow's JNI `hdfs interface`_ is mature and stable. It also has fewer problems
  with configuration and various security settings, and does not require the complex
  build process of libhdfs3. Therefore, all users who have trouble with hdfs3 are
  recommended to try pyarrow.
  Old README
  ~~~~~~~~~~
  hdfs3 is a lightweight Python wrapper for libhdfs3_, a native C/C++ library to interact with the Hadoop File System (HDFS).
  View the documentation_ for hdfs3.


pkgId: d1d1be7341d06d6bfbef38bb41014fd50f35aca58494116ef0ee409e2a2b9854
name: python-hellosign-python-sdk
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: A Python wrapper for the HelloSign API (http://www.hellosign.com/api)
url: https://github.com/hellosign/hellosign-python-sdk
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-95d85831-6f8e-4089-9fb2-6de75c61a8c9
location_href: 00012541-python-hellosign-python-sdk/python-hellosign-python-sdk-4.0.0-1.src.rpm
checksum_type: sha256
description:
  A Python wrapper for the [HelloSign API](http://www.hellosign.com/api)

  Install using `easy_install`:
  ````sh
  easy_install hellosign-python-sdk
  ````
  Install using `pip`:
  ````sh
  pip install hellosign-python-sdk
  ````
  Install from code:
  ````sh
  git clone https://github.com/HelloSign/hellosign-python-sdk.git
  cd hellosign-python-sdk
  python setup.py install
  ````

  In your application, import `HSClient`:
  ````python
  from hellosign_sdk import HSClient
  ````
  Then create a HSClient object and pass authentication information to initialize it:
  ````python

  client = HSClient(email_address="api_user@example.com", password="your_password")

  client = HSClient(api_key="your_api_key")

  client = HSClient(access_token="your_api_access_token")
  ````
  Note: In case you initialize the HSClient with all the above credentials, the priority order is as follow: access_token, api_key, then email and password.

  For more information about the wrapper, its methods and parameters visit our detailed API documentation on  [readthedocs](http://hellosign-python-sdk.readthedocs.org/en/v3/py-modindex.html).


  ````python
  account = client.get_account_info()
  ````
  The account information is also stored in `client.account`. For example, to print the `email_address` of your account:
  ````python
  print client.account.email_address
  ````

  ````python
  client.account.callback_url = "https://www.example.com/callback"
  client.update_account_info()
  ````

  ````python
  new_account = client.create_account("new_user@example.com")
  ````


  ````python
  signature_request = client.get_signature_request("fa5c8a0b0f492d768749333ad6fcc214c111e967")
  print signature_request.requester_email_address
  print signature_request.signature_request_id
  ````

  ````python
  signature_request_list = client.get_signature_request_list(page=1)

  for signature_request in signature_request_list:
      print signature_request.signatures[0].signer_name
  ````

  ````python
  files = ["NDA.pdf", "AppendixA.pdf"]
  signers = [
      {"name": "Jack", "email_address": "jack@example.com"},
      {"name": "Jill", "email_address": "jill@example.com"}
  ]
  cc_email_addresses = ["lawyer@hellosign.com", "lawyer@example.com"]

  signature_request = client.send_signature_request(
                                  test_mode=True,
                                  files=None,
                                  file_urls=["http://www.example.com/download/sample.pdf"],
                                  title="NDA with Acme Co.",
                                  subject="The NDA we talked about",
                                  message="Please sign this NDA and then we can discuss more. Let me know if you have any questions.",
                                  signing_redirect_url=None,
                                  signers=signers,
                                  cc_email_addresses=cc_email_addresses)

  signature_request = client.send_signature_request(
                                  test_mode=True,
                                  files=files,
                                  file_urls=None,
                                  title="NDA with Acme Co.",
                                  subject="The NDA we talked about",
                                  message="Please sign this NDA and then we can discuss more. Let me know if you have any questions.",
                                  signing_redirect_url=None,
                                  signers=signers,
                                  cc_email_addresses=cc_email_addresses)
  ````

  ````python
  signers = [
      {"name": "Jack", "email_address": "jack@example.com"},
      {"name": "Jill", "email_address": "jill@example.com"}
  ]
  cc_email_addresses = ["lawyer@hellosign.com", "lawyer@example.com"]
  ccs = [
      { "email_address": "lawyer@hellosign.com", "role_name": "Lawyer 1" },
      { "email_address": "lawyer@example.com", "role_name": "Lawyer 2" }
  ]
  custom_fields = [
      { "Field 1": "Value 1" },
      { "Field 2": "Value 2" }
  ]

  signature_request = client.send_signature_request_with_template(
                                          test_mode=True,
                                          template_id="fa5c8a0b0f492d768749333ad6fcc214c111e967",
                                          title="NDA with Acme Co.",
                                          subject="The NDA we talked about",
                                          message="Please sign this NDA and then we can discuss more. Let me know if you have any questions.",
                                          signing_redirect_url=None,
                                          signers=signers,
                                          ccs=ccs,
                                          custom_fields=custom_fields)
  ````


  ````python
  signers = [
      {"name": "Jack", "email_address": "jack@example.com"},
      {"name": "Jill", "email_address": "jill@example.com"}
  ]
  signature_request = client.send_signature_request_embedded(
                                  test_mode=True,
                                  client_id="YOUR CLIENT ID",
                                  files=["path/to/NDA.pdf"],
                                  title="NDA with Acme Co.",
                                  subject="The NDA we talked about",
                                  message="Please sign this NDA and then we can discuss more. Let me know if you have any questions.",
                                  signing_redirect_url=None
                                  signers=signers,
                                  cc_email_addresses=None,
                                  form_fields_per_document=None)

  for signature in signature_request.signatures:
      embedded_obj = client.get_embedded_object(signature.signature_id)
      sign_url = embedded_obj.sign_url
  ````
  More information about the asscociated front-end code can be found [here](https://www.hellosign.com/api/embeddedSigningWalkthrough#ClientSide)

  ````python

  draft = client.create_embedded_unclaimed_draft(
                      test_mode=True,
                      client_id="YOUR CLIENT ID",
                      requester_email_address="requester@example.com",
                      files=["path/to/NDA.pdf"],
                      draft_type="signature_request",
                      subject="The NDA we talked about",
                      message="Please sign this NDA and then we can discuss more. Let me know if you have any questions.",
                      is_for_embedded_signing=False)
  claim_url = draft.claim_url
  ````
  More information about the associated front-end code can be found [here](https://app.hellosign.com/api/embeddedRequestingWalkthrough#EmbeddedRequestingClientSide)
  Once the user edits the draft in the embedded iFrame and sends the signature request your app callback will receive a `signature_request_sent` event containing a `SignatureRequest` object. If we had used `is_for_embedded_signing=True`, we would want to get the signature ids out of the `SignatureRequest` from that event and fetch the signature urls at this point. In your event callback handler, you will need to do something like this:
  ````python
  client = HSClient(api_key='your_api_key')
  event_data = json.loads(request.POST.get('json'))
  if event_data['event']['event_type'] == 'signature_request_sent':
      sig_req = event_data['signature_request']
      for sig in sig_req['signature_request']['signatures']:
          embedded_obj = client.get_embedded_object(sig['signature_id'])
          sign_url = embedded_obj.sign_url
          
  ````

  You can run the test suite by executing the following commands after you cloned the repo:
  Note that it requires to have a HelloSign account, with at least one template and one api app.
  **WARNING:** We advise against running the tests against your personal account as they perform destructive actions.
  ```
  cd hellosign_sdk
  cp tests/test_helper.sample.py tests/test_helper.py
  HELLOSIGN_API_KEY='YOUR API KEY'
  HELLOSIGN_API_CLIENT_ID='YOUR APP CLIENT ID'
  HELLOSIGN_API_CLIENT_SECRET='YOUR APP CLIENT SECRET'
  nosetests --with-coverage --cover-package=hellosign_sdk --include=hellosign_sdk/tests/unit_tests/* --include=hellosign_sdk/tests/functional_tests/*
  ```


  We do not allow app callbacks (event or OAuth) to be set to localhost. However it is still possible to test callbacks against a local server. Tunneling services such as [ngrok](http://ngrok.com) can help you set this up.

  ```
  The MIT License (MIT)
  Copyright (C) 2015 hellosign.com
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
  ```


pkgId: 030a5b980648a89c39e48f5abfcf9e3fc2c4312ce25898257f043e02f54c9dba
name: python-help-tokens
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Django app for linking to help pages with short tokens
url: https://github.com/edx/help-tokens
rpm_license: AGPL 3.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8f48b8ee-c232-4162-b4e2-4fce9e839793
location_href: 00014070-python-help-tokens/python-help-tokens-2.2.0-1.src.rpm
checksum_type: sha256
description:
  Help-tokens reads these Django settings to create URLs:
  * HELP_TOKENS_INI_FILE: Path to a .ini file containing help token definitions.
    The format of the ini file is described below.
  * HELP_TOKENS_BOOKS: a dictionary mapping book slugs to URLs.  For example::
      HELP_TOKENS_BOOKS = {
          'learner': 'http://edx.readthedocs.io/projects/learner-guide',
          'course_author': 'http://edx.readthedocs.io/projects/running-a-course',
      }
  * HELP_TOKENS_VERSION: a string used as part of the final URL, to choose the
    correct version of the book.  For example, `"latest"`.
  * HELP_TOKENS_LANGUAGE_CODE: the language code to use as part of the book URL,
    mapped through the [locales] section of the ini file.


pkgId: c3fd564be85f1046f8a4055871f315176868ab755dabc3a2c1dd778ad3d24f14
name: python-helpdev
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: HelpDev - Extracts information about the Python environment easily.
url: https://gitlab.com/dpizetta/helpdev
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f852f348-9491-4f41-9d0e-dcc213ab917e
location_href: 00003847-python-helpdev/python-helpdev-0.7.1-1.src.rpm
checksum_type: sha256
description:
  Helping users and developers to get information about the environment to
  report bugs or even test your system without spending a day on it. It can
  get information about hardware, OS, paths, Python distribution and packages,
  including Qt-things. Operates in Linux, Windows and Mac. Working on
  Python 2.7+ and Python 3.4+.
  If you want to get information at runtime of your application, you need
  to call using the same environment (and process) in which your application
  is running. This module can be imported and integrated into your application,
  providing a report about the current environment.
  Some information can be depedent or independent of your Python environment,
  and some others can be dependent your running application. So, there are some
  acronymn used to refer to them:
  - PEI: Python environment independent;
  - PED: Python environment DEPENDENT;
  - PEAD: Python environment and application DEPENDENT.
  **Caution:**
  - This script is not supposed to get personal information using the option
    ``--all``, but you must check the information before using the output.
  - Using the option ``--all-for-sure`` it is added information about paths and
    variables that can show personal information. So, be sure when using this
    option when publishing in the web.
  - I'm not responsible for bad use or problems with the information given by
    this script, but if pointed in the Issues, I can help fixing it.
  Installing, updating and uninstalling

  To install and/or update, do ::
      $ pip install -U helpdev
  To remove ::
      $ pip uninstall helpdev
  Running

  You just need to run in the terminal the line(s) below.
  To get a minimalist output ::
      $ helpdev
  To filter a set of packages to get info, which lists all that starts with
  sphinx, qtpy and pyqt5 ::
      $ helpdev --packages="sphinx.*,qtpy,PYQT5"
  To get a complete output without personal information ::
      $ helpdev --all
  To get a complete output WITH PERSONAL INFORMATION ::
      $ helpdev --all-for-sure
  To get some help information ::
      $ helpdev --help
  Examples from v0.6


pkgId: f15f18c8c45b1bd72cb262d5ab4553655c1d280ad49d04f278787618b6c7ec1c
name: python-heroku3
arch: src
version: 5.2.0
epoch: 0
release: 1
summary: Heroku API Wrapper.
url: https://github.com/martyzz1/heroku3.py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9b441733-8235-47b6-91dc-0f86d1acf2eb
location_href: 00009576-python-heroku3/python-heroku3-5.2.0-1.src.rpm
checksum_type: sha256
description:
  This is the updated Python wrapper for the Heroku `API V3. <https://devcenter.heroku.com/articles/platform-api-reference>`_
  The Heroku REST API allows Heroku users to manage their accounts, applications, addons, and
  other aspects related to Heroku. It allows you to easily utilize the Heroku
  platform from your applications.


pkgId: 1c0bcab21d1ed13fda58030539babfd63c434c4ba7b797a8d5e1475abf401b91
name: python-hexbytes
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: hexbytes: Python `bytes` subclass that decodes hex, with a readable console output
url: https://github.com/ethereum/hexbytes
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-da041bcf-22ac-4b5e-bbec-bdb13deb764c
location_href: 00010585-python-hexbytes/python-hexbytes-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [![Join the chat at https://gitter.im/ethereum/web3.py](https://badges.gitter.im/ethereum/web3.py.svg)](https://gitter.im/ethereum/web3.py?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
  [![Build Status](https://circleci.com/gh/ethereum/hexbytes.svg?style=shield)](https://circleci.com/gh/ethereum/hexbytes)
  [![PyPI version](https://badge.fury.io/py/hexbytes.svg)](https://badge.fury.io/py/hexbytes)
  [![Python versions](https://img.shields.io/pypi/pyversions/hexbytes.svg)](https://pypi.python.org/pypi/hexbytes)
  [![Docs build](https://readthedocs.org/projects/hexbytes/badge/?version=latest)](http://hexbytes.readthedocs.io/en/latest/?badge=latest)


  Python `bytes` subclass that decodes hex, with a readable console output

  Read more in the [documentation on ReadTheDocs](https://hexbytes.readthedocs.io/). [View the change log](https://hexbytes.readthedocs.io/en/latest/release_notes.html).



  ```sh
  pip install hexbytes
  ```

  ```py

  >>> HexBytes(b"\x03\x08wf\xbfh\xe7\x86q\xd1\xeaCj\xe0\x87\xdat\xa1'a\xda\xc0 \x01\x1a\x9e\xdd\xc4\x90\x0b\xf1;")
  HexBytes('0x03087766bf68e78671d1ea436ae087da74a12761dac020011a9eddc4900bf13b')


  >>> hb = HexBytes('03087766BF68E78671D1EA436AE087DA74A12761DAC020011A9EDDC4900BF13B')
  HexBytes('0x03087766bf68e78671d1ea436ae087da74a12761dac020011a9eddc4900bf13b')


  >>> hb[0]
  3


  >>> len(hb)
  32


  >>> bytes(hb)
  b"\x03\x08wf\xbfh\xe7\x86q\xd1\xeaCj\xe0\x87\xdat\xa1'a\xda\xc0 \x01\x1a\x9e\xdd\xc4\x90\x0b\xf1;"
  ```



  If you would like to hack on hexbytes, please check out the [Snake Charmers
  Tactical Manual](https://github.com/ethereum/snake-charmers-tactical-manual)
  for information on how we do:

  - Testing
  - Pull Requests
  - Code Style
  - Documentation



  You can set up your dev environment with:

  ```sh
  git clone git@github.com:carver/hexbytes.git
  cd hexbytes
  virtualenv -p python3 venv
  . venv/bin/activate
  pip install -e .[dev]
  ```



  During development, you might like to have tests run on every file save.

  Show flake8 errors on file change:

  ```sh

  when-changed -v -s -r -1 hexbytes/ tests/ -c "clear; flake8 hexbytes tests && echo 'flake8 success' || echo 'error'"
  ```

  Run multi-process tests in one command, but without color:

  ```sh

  pytest --numprocesses=4 --looponfail --maxfail=1

  pytest -n 4 -f --maxfail=1
  ```

  Run in one thread, with color and desktop notifications:

  ```sh
  cd venv
  ptw --onfail "notify-send -t 5000 'Test failure ⚠⚠⚠⚠⚠' 'python 3 test on hexbytes failed'" ../tests ../hexbytes
  ```



  For Debian-like systems:
  ```
  apt install pandoc
  ```

  To release a new version:

  ```sh
  make release bump=$$VERSION_PART_TO_BUMP$$
  ```



  The version format for this repo is `{major}.{minor}.{patch}` for stable, and
  `{major}.{minor}.{patch}-{stage}.{devnum}` for unstable (`stage` can be alpha or beta).

  To issue the next version in line, specify which part to bump,
  like `make release bump=minor` or `make release bump=devnum`. This is typically done from the
  master branch, except when releasing a beta (in which case the beta is released from master,
  and the previous stable branch is released from said branch).

  If you are in a beta version, `make release bump=stage` will switch to a stable.

  To issue an unstable version when the current version is stable, specify the
  new version explicitly, like `make release bump="--new-version 4.0.0-alpha.1 devnum"`


pkgId: b941939f2373b9ec839ccba88bb8fad6d0b77cce2714ab40a56c30adce999fd0
name: python-hexdump
arch: src
version: 3.3
epoch: 0
release: 1
summary: dump binary data to hex format and restore from there
url: https://bitbucket.org/techtonik/hexdump/
rpm_license: Public Domain
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f2b888c3-2733-4312-873d-2763d46d8497
location_href: 00003848-python-hexdump/python-hexdump-3.3-1.src.rpm
checksum_type: sha256
description:
  There are three ways to execute hexdump.py from command line::
     $ python hexdump.py
     $ python hexdump-3.2.zip
     
     $ python -m hexdump
  Dump binary data in hex form::
     $ python -m hexdump binary.dat
     0000000000: 00 00 00 5B 68 65 78 64  75 6D 70 5D 00 00 00 00  ...[hexdump]....
     0000000010: 00 11 22 33 44 55 66 77  88 99 AA BB CC DD EE FF  .."3DUfw........
  Restore binary from a saved hex dump::
     $ python -m hexdump --restore hexdump.txt > binary.dat


pkgId: c166775e8cadc97e0b823a233d84fe3c83138b189ea29aaf1983a8aef34f3316
name: python-hgapi
arch: src
version: 1.7.4
epoch: 0
release: 1
summary: Python API to Mercurial using the command-line interface
url: https://bitbucket.org/haard/hgapi
rpm_license: Do whatever you want, don't blame me
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7a1b981e-5ea1-4d39-b662-f81461271ed5
location_href: 00003849-python-hgapi/python-hgapi-1.7.4-1.src.rpm
checksum_type: sha256
description:
  hgapi is a pure-Python API to Mercurial, that uses the command-line
  interface instead of the internal Mercurial API. The rationale for
  this is twofold: the internal API is unstable, and it is GPL.

  hgapi works for any version of Mercurial, including  < 1.9, and will
  instantly reflect any changes to the repository. It also has a really
  permissive license (do whatever you want, don't blame me).

  For example of code that uses this API, take a look at
  https://bitbucket.org/haard/autohook which now uses hgapi
  exclusively.


pkgId: 262f0d2cce8f952a1af5fa83faed8fab70b98d7565cb316a0bd248f02ca1b611
name: python-hgdistver
arch: src
version: 0.25
epoch: 0
release: 1
summary: obsoleted by setuptools_scm
url: http://bitbucket.org/RonnyPfannschmidt/hgdistver/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fd45765e-7a9a-4048-90d9-9b05169bd6a7
location_href: 00003850-python-hgdistver/python-hgdistver-0.25-1.src.rpm
checksum_type: sha256
description:
  hgdistver
  ~~~~~~~~~

  .. warning::

    this module is superseeded by setuptools_scm

  This module is a simple drop-in to support setup.py
  in mercurial and git based projects.

  Alternatively it can be a setup time requirement.

  It extracts the last Tag as well as the distance to it in commits
  from the scm, and uses these to calculate a version number

  By default, it will increment the last component of the Version by one
  and append .dev{distance}
  in case the last component is .dev, the version will be unchanged

  Tis requires always using all components in tags (i.e. 2.0.0 instead of 2.0)
  to avoid misstakenly releasing higher version
  (i.e. 2.1.devX instead of 2.0.1.devX)




  It uses 4 strategies to archive its task:

  1. try to directly ask hg for the tag/distance
  2. try to infer it from the `.hg_archival.txt` file
  3. try to read the exact version the cache file if it exists
  4. try to read the exact version from the 'PKG-INFO' file
     as generated by `setup.py sdists` (this is a nasty abuse)

  The most simple usage is::

      from setuptools import setup
      from hgdistver import get_version
      setup(
          ...,
          version=get_version(),
          ...,
      )

  `get_version` takes the optional argument `cachefile`,
  which causes it to store the version info in a python script instead
  of abusing PKG-INFO from a sdist.


  The setup requirement usage is::

      from setuptools import setup
      setup(
          ...,
          get_version_from_hg=True,
          setup_requires=['hgdistver'],
          ...,
      )

  The requirement uses the setup argument cache_hg_version_to instead of cachefile.


pkgId: cf22afeea95f59d79b4fa47ce116a3132524f0d9dd506abee6966cb180c85359
name: python-hglib
arch: src
version: 2.6.2
epoch: 0
release: 1
summary: Mercurial Python library
url: https://bitbucket.org/515k4/hglib/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e3e0be75-5df1-4098-b268-1b02d66e2df1
location_href: 00003851-python-hglib/python-hglib-2.6.2-1.src.rpm
checksum_type: sha256
description:
  The hglib is fork of of [hglib](https://www.mercurial-scm.org/wiki/PythonHglib), which is library with a fast, convenient interface to Mercurial. It uses Mercurial's command server for communication with hg.

  Only difference for now is just name of the package and updated tests.



  ```python
  import hglib

  client = hglib.open(path)
  log = client.log(revrange="tip")
  print(log)
  ```



  * Python 2.7 or 3.5



  MIT



  Michal Siska <michal.515k4@gmail.com>


pkgId: fc7e7d1716a9fb1f7a653f65feda6cdf7537288c8464c067f9e1ab2fafd4179a
name: python-hijri-converter
arch: src
version: 2.2.4
epoch: 0
release: 1
summary: Accurate Hijri-Gregorian dates converter based on the Umm al-Qura calendar
url: https://github.com/mhalshehri/hijri-converter
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e97fd06e-8547-45c1-bbdd-42b5e9d5b6dd
location_href: 00009380-python-hijri-converter/python-hijri-converter-2.2.4-1.src.rpm
checksum_type: sha256
description:
  <!-- start description -->

  A Python package to convert accurately between Hijri and Gregorian dates using
  the Umm al-Qura calendar.

  <!-- end description -->

  [![Build Status](https://img.shields.io/github/workflow/status/mhalshehri/hijri-converter/Release)][build]
  [![Coverage Status](https://img.shields.io/badge/coverage-100%25-success)][coverage]
  [![Code Quality](https://img.shields.io/codefactor/grade/github/mhalshehri/hijri-converter/main?&label=codefactor)][quality]
  [![Docs Status](https://img.shields.io/readthedocs/hijri-converter/stable)][docs]
  [![PyPI Downloads](https://img.shields.io/pypi/dm/hijri-converter?color=blue)][downloads]
  [![PyPI Version](https://img.shields.io/pypi/v/hijri-converter)][pypi-version]
  [![Conda Version](https://img.shields.io/conda/vn/conda-forge/hijri-converter)][conda-version]
  [![Package License](https://img.shields.io/github/license/mhalshehri/hijri-converter)][license]

  [build]:
    https://github.com/mhalshehri/hijri-converter/actions/workflows/release.yml
  [coverage]:
    https://github.com/mhalshehri/hijri-converter/actions/workflows/release.yml
  [quality]:
    https://www.codefactor.io/repository/github/mhalshehri/hijri-converter/overview/main
  [docs]: https://hijri-converter.readthedocs.io
  [downloads]: https://pypistats.org/packages/hijri-converter
  [pypi-version]: https://pypi.python.org/pypi/hijri-converter
  [conda-version]: https://anaconda.org/conda-forge/hijri-converter
  [license]: https://github.com/mhalshehri/hijri-converter/blob/main/LICENSE

  <!-- start summary -->



  - Accurate and verified date conversion.
  - Optimized code performance compared to similar packages.
  - Intuitive, clean, and easy-to-use interface.
  - Most of the methods and formats are similar to those of standard library.
  - Multilingual representation of weekday names, months, and calendar era
    notations.
  - Easily extendable to support other natural languages.
  - Rich comparison between dates.
  - Validation of input dates.
  - Works on Python 3.6+ with zero dependencies.
  - Thoroughly tested with 100% test coverage.



  - The date range supported by converter is limited to the period from the
    beginning of 1343 AH (1 August 1924 CE) to the end of 1500 AH (16 November
    2077 CE).
  - The conversion is not intended for religious purposes where sighting of the
    lunar crescent at the beginning of Hijri month is still preferred.



  To install using `pip`, run:

  ```shell
  pip install hijri-converter
  ```

  To install using `conda`, run:

  ```shell
  conda install -c conda-forge hijri-converter
  ```



  ```python
  from hijri_converter import Hijri, Gregorian



  g = Hijri(1403, 2, 17).to_gregorian()


  h = Gregorian(1982, 12, 2).to_hijri()
  ```

  <!-- end summary -->



  Please see <https://hijri-converter.readthedocs.io> for full documentation of
  this package, including background, benchmarking, usage examples and API
  reference.



  This project is licensed under the terms of the MIT license.



  - [R.H. van Gent](http://www.staff.science.uu.nl/~gent0113) &mdash; inspiration,
    scientific guidance and resources.
  - [@AZalshehri7](https://github.com/AZalshehri7) &mdash; support in dates review
    and conversion accuracy verification.


pkgId: 18d50fac29542c01c59768f913686b898ddb5e03d69cd8a902ccee86a2be16ac
name: python-hikvision
arch: src
version: 2.0.4
epoch: 0
release: 1
summary: Provides a python interface to interact with a hikvision camera
url: https://github.com/fbradyirl/hikvision
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5574ff0f-ef1b-4046-8122-f8ad26b8250c
location_href: 00003853-python-hikvision/python-hikvision-2.0.4-1.src.rpm
checksum_type: sha256
description:
  ```python
  git clone --recursive git@github.com:fbradyirl/hikvision.git
  cd hikvision

  pip install -r requirements.txt
  pip install -e .
  ```

  Variables:
  ```python
  import hikvision.api





  hik_camera = hikvision.api.CreateDevice('192.168.2.5', username='admin', password='12345')
  hik_camera.enable_motion_detection()
  hik_camera.disable_motion_detection()
  hik_camera.is_motion_detection_enabled()
  ```
  * `host` (*Required) : This is the IP address of your Hikvision camera. Example: 192.168.1.32
  * `username` (*Required) : Your Hikvision camera username
  * `password` (*Required) : Your Hikvision camera username


pkgId: f14077acf88ed65d918327f38604ce417507e749af9a14989b1d7a52f7367efa
name: python-hiredis
arch: src
version: 2.2.2
epoch: 0
release: 1
summary: Python wrapper for hiredis
url: https://github.com/redis/hiredis-py
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-172b8da9-81c1-48ac-8b21-96d56f5d9cbf
location_href: 00009358-python-hiredis/python-hiredis-2.2.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/redis/hiredis-py/actions/workflows/integration.yaml/badge.svg)](https://github.com/redis/hiredis-py/actions/workflows/integration.yaml)
  [![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)

  Python extension that wraps protocol parsing code in [hiredis][hiredis].
  It primarily speeds up parsing of multi bulk replies.

  [hiredis]: http://github.com/redis/hiredis



  hiredis-py is available on [PyPI](https://pypi.org/project/hiredis/), and can be installed via:

  ```bash
  pip install hiredis
  ```


  Building this repository requires a recursive checkout of submodules, and building hiredis. The following example shows how to clone, compile, and run tests. Please note - you will need the gcc installed.

  ```bash
  git clone --recursse-submodules https://github.com/redis/hiredis-py
  python setup.py build_ext --inplace
  pytest
  ```



  hiredis-py requires **Python 3.7+**.

  Make sure Python development headers are available when installing hiredis-py.
  On Ubuntu/Debian systems, install them with `apt-get install python3-dev`.



  The `hiredis` module contains the `Reader` class. This class is responsible for
  parsing replies from the stream of data that is read from a Redis connection.
  It does not contain functionality to handle I/O.



  The `Reader` class has two methods that are used when parsing replies from a
  stream of data. `Reader.feed` takes a string argument that is appended to the
  internal buffer. `Reader.gets` reads this buffer and returns a reply when the
  buffer contains a full reply. If a single call to `feed` contains multiple
  replies, `gets` should be called multiple times to extract all replies.

  Example:

  ```python
  >>> reader = hiredis.Reader()
  >>> reader.feed("$5\r\nhello\r\n")
  >>> reader.gets()
  b'hello'
  ```

  When the buffer does not contain a full reply, `gets` returns `False`.
  This means extra data is needed and `feed` should be called again before calling
  `gets` again. Alternatively you could provide custom sentinel object via parameter,
  which is useful for RESP3 protocol where native boolean types are supported:

  Example:

  ```python
  >>> reader.feed("*2\r\n$5\r\nhello\r\n")
  >>> reader.gets()
  False
  >>> reader.feed("$5\r\nworld\r\n")
  >>> reader.gets()
  [b'hello', b'world']
  >>> reader = hiredis.Reader(notEnoughData=Ellipsis)
  >>> reader.gets()
  Ellipsis
  ```



  `hiredis.Reader` is able to decode bulk data to any encoding Python supports.
  To do so, specify the encoding you want to use for decoding replies when
  initializing it:

  ```python
  >>> reader = hiredis.Reader(encoding="utf-8", errors="strict")
  >>> reader.feed(b"$3\r\n\xe2\x98\x83\r\n")
  >>> reader.gets()
  '☃'
  ```

  Decoding of bulk data will be attempted using the specified encoding and
  error handler. If the error handler is `'strict'` (the default), a
  `UnicodeDecodeError` is raised when data cannot be dedcoded. This is identical
  to Python's default behavior. Other valid values to `errors` include
  `'replace'`, `'ignore'`, and `'backslashreplace'`. More information on the
  behavior of these error handlers can be found
  [here](https://docs.python.org/3/howto/unicode.html#the-string-type).


  When the specified encoding cannot be found, a `LookupError` will be raised
  when calling `gets` for the first reply with bulk data.



  When a protocol error occurs (because of multiple threads using the same
  socket, or some other condition that causes a corrupt stream), the error
  `hiredis.ProtocolError` is raised. Because the buffer is read in a lazy
  fashion, it will only be raised when `gets` is called and the first reply in
  the buffer contains an error. There is no way to recover from a faulty protocol
  state, so when this happens, the I/O code feeding data to `Reader` should
  probably reconnect.

  Redis can reply with error replies (`-ERR ...`). For these replies, the custom
  error class `hiredis.ReplyError` is returned, **but not raised**.

  When other error types should be used (so existing code doesn't have to change
  its `except` clauses), `Reader` can be initialized with the `protocolError` and
  `replyError` keywords. These keywords should contain a *class* that is a
  subclass of `Exception`. When not provided, `Reader` will use the default
  error types.



  The repository contains a benchmarking script in the `benchmark` directory,
  which uses [gevent](http://gevent.org/) to have non-blocking I/O and redis-py
  to handle connections. These benchmarks are done with a patched version of
  redis-py that uses hiredis-py when it is available.

  All benchmarks are done with 10 concurrent connections.

  * SET key value + GET key
    * redis-py: 11.76 Kops
    * redis-py *with* hiredis-py: 13.40 Kops
    * improvement: **1.1x**

  List entries in the following tests are 5 bytes.

  * LRANGE list 0 **9**:
    * redis-py: 4.78 Kops
    * redis-py *with* hiredis-py: 12.94 Kops
    * improvement: **2.7x**
  * LRANGE list 0 **99**:
    * redis-py: 0.73 Kops
    * redis-py *with* hiredis-py: 11.90 Kops
    * improvement: **16.3x**
  * LRANGE list 0 **999**:
    * redis-py: 0.07 Kops
    * redis-py *with* hiredis-py: 5.83 Kops
    * improvement: **83.2x**

  Throughput improvement for simple SET/GET is minimal, but the larger multi bulk replies
  get, the larger the performance improvement is.



  This code is released under the BSD license, after the license of hiredis.


pkgId: 1fd54be8aac767733c4fb7b74ec22b3354dde98c9c1c369fd447f2ac9bec3f18
name: python-hiredis-debuginfo
arch: aarch64
version: 2.2.2
epoch: 0
release: 1
summary: Debug information for package python-hiredis
url: https://github.com/redis/hiredis-py
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-172b8da9-81c1-48ac-8b21-96d56f5d9cbf
rpm_sourcerpm: python-hiredis-2.2.2-1.src.rpm
location_href: 00009358-python-hiredis/python-hiredis-debuginfo-2.2.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-hiredis.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 8092d85ebfb21ea6a7e4a92943a65085d5e9c89bc585eaa12c09af70c0056670
name: python-hiredis-debugsource
arch: aarch64
version: 2.2.2
epoch: 0
release: 1
summary: Debug sources for package python-hiredis
url: https://github.com/redis/hiredis-py
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-172b8da9-81c1-48ac-8b21-96d56f5d9cbf
rpm_sourcerpm: python-hiredis-2.2.2-1.src.rpm
location_href: 00009358-python-hiredis/python-hiredis-debugsource-2.2.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-hiredis.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: edc0482ef2965a32b4c4f61d975999f697acb3f15ec82d0dc48af1f8ddf11bc2
name: python-hjson
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: Hjson, a user interface for JSON.
url: http://github.com/hjson/hjson-py
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-599fef2f-f143-4331-94ab-d1d351e2b46c
location_href: 00010617-python-hjson/python-hjson-3.1.0-1.src.rpm
checksum_type: sha256
description:
  `Hjson`_, a user interface for JSON
  Hjson works with Python 2.5+ and Python 3.3+ (based on `simplejson`_)


pkgId: 0875fda75b7c762fd60f7e52903538239bd814965dabb3c599799e71fb477dc1
name: python-hkdf
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: HMAC-based Extract-and-Expand Key Derivation Function (HKDF)
url: https://github.com/casebeer/python-hkdf
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-837d30cf-6a07-4ad7-9b50-e87e2c7a6e84
location_href: 00003854-python-hkdf/python-hkdf-0.0.3-1.src.rpm
checksum_type: sha256
description:
  This module implements the HMAC Key Derivation function, defined at
      http://tools.ietf.org/html/draft-krawczyk-hkdf-01
  There are two interfaces: a functional interface, with separate extract
  and expand functions as defined in the draft RFC, and a wrapper class for
  these functions.


pkgId: 7df7e7b07d63044ca4b887df681be4ca537328d3c4afad171843d089826a45c8
name: python-hl7
arch: src
version: 0.4.5
epoch: 0
release: 1
summary: Python library parsing HL7 v2.x messages
url: http://python-hl7.readthedocs.org
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4f00c3cc-6e74-4531-9172-5747e3145a74
location_href: 00003855-python-hl7/python-hl7-0.4.5-1.src.rpm
checksum_type: sha256
description:
  python-hl7 is a simple library for parsing messages of Health Level 7
  (HL7) version 2.x into Python objects.

  * Documentation: http://python-hl7.readthedocs.org
  * Source Code: http://github.com/johnpaulett/python-hl7


pkgId: f30e35b681eae7c4e315b374eb2acb9cfe997872600d5a47ea2a418162fb8dcb
name: python-hl7apy
arch: src
version: 1.3.4
epoch: 0
release: 1
summary: HL7apy: a lightweight Python library to parse, create and handle HL7 v2.x messages
url: http://crs4.github.io/hl7apy/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e14417ec-0a85-46dc-b480-7f32390581b6
location_href: 00014101-python-hl7apy/python-hl7apy-1.3.4-1.src.rpm
checksum_type: sha256
description:
  HL7apy is a lightweight Python package to intuitively handle `HL7 <http://www.hl7.org>`_ v2 messages according to HL7 specifications.
  The main features includes:
   * Message parsing
   * Message creation
   * Message validation following the HL7 xsd specifications
   * Access to elements by name, long name or position
   * Support to all simple and complex datatypes
   * Encoding chars customization
   * Message encoding in ER7 format and compliant with MLLP protocol


pkgId: c9a6a66aa30c74b222409589696dd83aa2fc148a12e01f2ace6df24156bdff24
name: python-hmsclient
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A package interact with the Hive metastore via the Thrift protocol
url: https://github.com/gglanzani/hmsclient
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6f270c63-36fa-4338-b96d-b81ce157d19a
location_href: 00011029-python-hmsclient/python-hmsclient-0.1.1-1.src.rpm
checksum_type: sha256
description:
  This project aims to be an up to date Python client to interact with the Hive metastore
  using the Thrift protocol.


pkgId: 722e93a6c33dec428b99ebb3a0a939b0562c512db854d58045d8e029425b412e
name: python-hole
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Python API for interacting with *hole.
url: https://github.com/home-assistant-ecosystem/python-hole
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8fa450b6-3426-42fc-aaf7-16de230ea2a4
location_href: 00003857-python-hole/python-hole-0.8.0-1.src.rpm
checksum_type: sha256
description:
  Python API for interacting with a xyz-hole instance. You know the thing that is
  blocking Ads by manipulating your DNS requests and run on your single board
  computer or on other hardware with different operating systems.
  This module is consuming the details provided by the endpoint ``api.php`` only
  for now.
  If you wonder why the weird name and that the usage of xzy-hole instead of the
  real name, please contact the trademark holder. They were unhappy with original
  name of the module and came up with very funny ideas which were not feasible
  or match the existing naming standards. Also, it should remind us that a
  community is a vital part of every Open Source project.
  This module is not supported or endorsed by that particular trademark holder.
  The development happens independently, they are not providing resources and
  the module may no longer work if they breaking their API endpoint.


pkgId: 1ad21848fa8a468023821d0ca37625b6f627f325b671d25e66f6a0e88fe424bd
name: python-hologram
arch: src
version: 0.0.16
epoch: 0
release: 1
summary: JSON schema generation from dataclasses
url: https://github.com/fishtown-analytics/hologram
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-61ec6f66-3c08-46d2-9ffb-e6b3b6d327f1
location_href: 00009641-python-hologram/python-hologram-0.0.16-1.src.rpm
checksum_type: sha256
description:
  Hologram is a lightweight library to generate Draft 7 compatible JSON Schemas from python 3.7 dataclasses. Python 3.6 is supported through the [dataclasses backport](https://github.com/ericvsmith/dataclasses). It is forked from [dataclasses-jsonschema](https://github.com/s-knibbs/dataclasses-jsonschema) created by [s-knibbs](https://github.com/s-knibbs).


pkgId: 2cf4b1853d95b0e0ed88791365237cbd589900acd38b7a4c2f9f1d39e5635416
name: python-homeconnect
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: Python client for the BSH Home Connect REST API
url: https://github.com/DavidMStraub/homeconnect
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c6d293bf-d883-4aab-975f-d58d35ea1d7b
location_href: 00003859-python-homeconnect/python-homeconnect-0.7.2-1.src.rpm
checksum_type: sha256
description:
  Simple Python client for the BSH Home Connect REST API implementing OAuth 2 authentication, REST calls, and SSE event stream parsing.



  To use this library, you have to sign up to the [Home Connect Developer Portal](https://developer.home-connect.com/) and register a new application
  to get a client ID, client secret, and redirect URI.

  ```python
  from homeconnect import HomeConnect
  hc = HomeConnect(my_clientid, my_clientsecret, my_redirecturi)

  print(hc.get_authurl())

  hc.get_token(auth_result)

  hc.get_appliances()
  ```



  The package and its author are not affiliated with BSH or Home Connect. Use at your own risk.



  The package is released under the MIT license.


pkgId: 892aef2de6145a5fadd754178eb8c4636c1acbc4932659f5dc72a0d2c4072ed7
name: python-hs-dbus-signature
arch: src
version: 0.7
epoch: 0
release: 1
summary: dbus signature hypothesis strategy generator
url: https://github.com/stratis-storage/hs-dbus-signature
rpm_license: MPL v2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c62654fa-3a3e-40e2-ad4b-674c1e1277bd
location_href: 00003862-python-hs-dbus-signature/python-hs-dbus-signature-0.7-1.src.rpm
checksum_type: sha256
description:
  This package contains a Hypothesis strategy for generating DBus signatures.
  An informal specification of DBus signatures is available at:
  https://dbus.freedesktop.org/doc/dbus-specification.html.
  The strategy is intended to be both sound and complete. That is, it should
  never generate an invalid DBus signature and it should be capable, modulo
  size constraints, of generating any valid DBus signature.


pkgId: 67c7772cad4971631662d70d0115cf1a5b7a650962aab7792f42fcf5fa236967
name: python-hstspreload
arch: src
version: 2023.1.1
epoch: 0
release: 1
summary: Chromium HSTS Preload list as a Python package
url: https://github.com/sethmlarson/hstspreload
rpm_license: BSD-3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6196e3f5-5606-442b-a582-104e16b12117
location_href: 00003863-python-hstspreload/python-hstspreload-2023.1.1-1.src.rpm
checksum_type: sha256
description:
  [![Version](https://img.shields.io/pypi/v/hstspreload)](https://pypi.org/project/hstspreload)
  [![Downloads](https://pepy.tech/badge/hstspreload)](https://pepy.tech/project/hstspreload)
  ![CI](https://img.shields.io/github/workflow/status/sethmlarson/hstspreload/CI/master)

  Chromium HSTS Preload list as a Python package.

  Install via `python -m pip install hstspreload`

  See https://hstspreload.org for more information regarding the list itself.



  The package provides a single function: `in_hsts_preload()` which takes an
  IDNA-encoded host and returns either `True` or `False` regarding whether
  that host should be only accessed via HTTPS.



  This package is built entirely by an automated script running once a month.
  If you need a release sooner of the package please reach out and I'll trigger a release manually.

  This script gathers the HSTS Preload list by monitoring
  [this file in the Chromium repository](https://chromium.googlesource.com/chromium/src/+/main/net/http/transport_security_state_static.json). Changes to the HSTS Preload list can be seen in the history of that file.



  BSD-3


pkgId: 3cea3a709d9d5f31370a085197a51f1a1745d6106ab07bf1b6bb70fca6b27052
name: python-html-telegraph-poster
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Posts your html to telegra.ph blogging service
url: https://github.com/mercuree/html-telegraph-poster
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-89d0f378-03d8-42e5-95dc-d33ed16d61cc
location_href: 00010972-python-html-telegraph-poster/python-html-telegraph-poster-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![build](https://github.com/mercuree/html-telegraph-poster/actions/workflows/python-package.yml/badge.svg)](https://github.com/mercuree/html-telegraph-poster/actions/workflows/python-package.yml)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/html-telegraph-poster?master)](https://pypi.org/project/html-telegraph-poster/)



  Simple python function to post plain html text to https://telegra.ph/.
  Telegra.ph allows `<a>, <blockquote>, <br>, <em>, <figure>, <h3>, <h4>, <img>, <p>, <strong>, ` elements.
  It also supports embedded youtube and vimeo iframe tags.

  About telegram telegra.ph service https://telegram.org/blog/instant-view


  * lxml
  * requests
  * requests_toolbelt


  ```Shell
  pip install html-telegraph-poster
  ```


  ```python
  >>> from html_telegraph_poster import TelegraphPoster
  >>> t = TelegraphPoster(use_api=True)
  >>> t.create_api_token('Elon Musk', 'Elon', 'https://www.spacex.com/') # second and third params are optional
  {'access_token': '9f3bab568f*************', 'auth_url': 'https://edit.telegra.ph/auth/HFYo***********', 'author_name': 'Elon', 'short_name': 'Elon Musk', 'author_url': 'https://www.spacex.com/'}
  >>> t.post(title='Just another funny joke', author='by me', text='<blockquote>Really hard way</blockquote>')
  {'path': 'Just-another-funny-joke-06-05-4', 'url': 'http://telegra.ph/Just-another-funny-joke-06-05-4'}
  ```

  ```python
  >>> t = TelegraphPoster(use_api=True, telegraph_api_url='https://api.graph.org')
  ```

  ```python
  >>> t.edit(text=t.text + '<p>some text at the end</p>')
  {'path': 'Just-another-funny-joke-06-05-4', 'url': 'http://telegra.ph/Just-another-funny-joke-06-05-4'}
  ```

  ```python
  >>> t.edit(text="<p>new text</p>", path='/Another-one-page-06-05')
  {'path': 'Another-one-page-06-05', 'url': 'http://telegra.ph/Another-one-page-06-05'}
  ```


  Actually it's a good idea to generate access token and put it inside environment variables.
  This command will generate .env file or append  TELEGRAPH_ACCESS_TOKEN at the end of it.
  Note: script will not set environment variable. You can use [python-dotenv](https://github.com/theskumar/python-dotenv),
  set it manually or hardcode it when call `TelegraphPoster(access_token='access_token_string')`
  ```Shell
  python -m html_telegraph_poster.create_account "Elon Musk" "Elon" "https://www.spacex.com/"
  ```


  ```python

  from html_telegraph_poster.upload_images import upload_image


  upload_image("file_path.jpg")


  upload_image("http://example.com/img.png")


  upload_image("http://example.com/img.png", get_timeout=(5, 5), upload_timeout=(5, 5))

  ```

  Utils module provides ability to make some pre-process steps before document is passed to the converter.

  ```python
  from html_telegraph_poster.utils import DocumentPreprocessor

  dp = DocumentPreprocessor(html_string)
  dp.upload_all_images()
  dp.get_processed_html() # this should return html string with uploaded and replaced image urls
  ```
  Optionally you can pass base_url if the document contains images with relative paths
  ```python
  dp.upload_all_images(base_url='https://example.com')
  dp.get_processed_html()
  ```


pkgId: f82f5132698833f275ef4abf48bb8ea7c5bac6598f6c433c5040141cdf1870e2
name: python-html2text
arch: src
version: 2020.1.16
epoch: 0
release: 1
summary: Turn HTML into equivalent Markdown-structured text.
url: https://github.com/Alir3z4/html2text/
rpm_license: GNU GPL 3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9d1506b6-b266-4ff4-bde0-24808e21a990
location_href: 00003864-python-html2text/python-html2text-2020.1.16-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://secure.travis-ci.org/Alir3z4/html2text.png)](https://travis-ci.org/Alir3z4/html2text)
  [![Coverage Status](https://coveralls.io/repos/Alir3z4/html2text/badge.png)](https://coveralls.io/r/Alir3z4/html2text)
  [![Downloads](http://badge.kloud51.com/pypi/d/html2text.png)](https://pypi.org/project/html2text/)
  [![Version](http://badge.kloud51.com/pypi/v/html2text.png)](https://pypi.org/project/html2text/)
  [![Wheel?](http://badge.kloud51.com/pypi/wheel/html2text.png)](https://pypi.org/project/html2text/)
  [![Format](http://badge.kloud51.com/pypi/format/html2text.png)](https://pypi.org/project/html2text/)
  [![License](http://badge.kloud51.com/pypi/license/html2text.png)](https://pypi.org/project/html2text/)


  html2text is a Python script that converts a page of HTML into clean, easy-to-read plain ASCII text. Better yet, that ASCII also happens to be valid Markdown (a text-to-HTML format).


  Usage: `html2text [filename [encoding]]`

  | Option                                                 | Description
  |--------------------------------------------------------|---------------------------------------------------
  | `--version`                                            | Show program's version number and exit
  | `-h`, `--help`                                         | Show this help message and exit
  | `--ignore-links`                                       | Don't include any formatting for links
  |`--escape-all`                                          | Escape all special characters.  Output is less readable, but avoids corner case formatting issues.
  | `--reference-links`                                    | Use reference links instead of links to create markdown
  | `--mark-code`                                          | Mark preformatted and code blocks with [code]...[/code]

  For a complete list of options see the [docs](https://github.com/Alir3z4/html2text/blob/master/docs/usage.md)


  Or you can use it from within `Python`:

  ```
  >>> import html2text
  >>>
  >>> print(html2text.html2text("<p><strong>Zed's</strong> dead baby, <em>Zed's</em> dead.</p>"))
  **Zed's** dead baby, _Zed's_ dead.

  ```


  Or with some configuration options:
  ```
  >>> import html2text
  >>>
  >>> h = html2text.HTML2Text()
  >>> # Ignore converting links from HTML
  >>> h.ignore_links = True
  >>> print h.handle("<p>Hello, <a href='https://www.google.com/earth/'>world</a>!")
  Hello, world!

  >>> print(h.handle("<p>Hello, <a href='https://www.google.com/earth/'>world</a>!"))

  Hello, world!

  >>> # Don't Ignore links anymore, I like links
  >>> h.ignore_links = False
  >>> print(h.handle("<p>Hello, <a href='https://www.google.com/earth/'>world</a>!"))
  Hello, [world](https://www.google.com/earth/)!

  ```

  *Originally written by Aaron Swartz. This code is distributed under the GPLv3.*




  `html2text` is available on pypi
  https://pypi.org/project/html2text/

  ```
  $ pip install html2text
  ```




      tox

  To see the coverage results:

      coverage html

  then open the `./htmlcov/index.html` file in your browser.



  Documentation lives [here](https://github.com/Alir3z4/html2text/blob/master/docs/usage.md)


pkgId: e2161a468683b8a4afcb6b09baa8f91c76a117056b41d374a12333d8c8a0fe10
name: python-html5lib
arch: src
version: 1.1
epoch: 0
release: 1
summary: HTML parser based on the WHATWG HTML specification
url: https://github.com/html5lib/html5lib-python
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b5919f8b-a58a-44c2-bcb5-d3430326a52a
location_href: 00009126-python-html5lib/python-html5lib-1.1-1.src.rpm
checksum_type: sha256
description:
  html5lib is a pure-python library for parsing HTML. It is designed to
  conform to the WHATWG HTML specification, as is implemented by all major
  web browsers.


pkgId: a99aa5ed05aad2f40301f2fa489e549b75a66ba624d1ea92f5b46f4139efcbaf
name: python-htmlmin
arch: src
version: 0.1.12
epoch: 0
release: 1
summary: An HTML Minifier
url: https://htmlmin.readthedocs.io/en/latest/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-76404c78-1093-4ae9-81f8-26a46cb91bcf
location_href: 00003866-python-htmlmin/python-htmlmin-0.1.12-1.src.rpm
checksum_type: sha256
description:
  A configurable HTML Minifier with safety features.

  .. image:: https://travis-ci.org/mankyd/htmlmin.png?branch=master
     :target: http://travis-ci.org/mankyd/htmlmin

  Documentation: https://htmlmin.readthedocs.io/en/latest/


pkgId: 7878169e22d0c378e5666ffbf392f5abead2ac82926b5307d4d06d3b56c9181f
name: python-htpasswd
arch: src
version: 2.3
epoch: 0
release: 1
summary: Library to work with htpasswd user (basic authorization) and group files.
url: https://github.com/thesharp/htpasswd
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8bf58183-71a1-4ed8-9344-e5cb3411345e
location_href: 00010430-python-htpasswd/python-htpasswd-2.3-1.src.rpm
checksum_type: sha256
description:
  **htpasswd** is a library for working with htpasswd user (only basic authorization) and group files. It supports CRYPT and MD5 encryption methods. To actually use MD5 encryption method you *MUST* have an ``openssl`` binary installed into system ``$PATH``.


  - Python 2.7 or 3.3 or 3.4
  - [orderedmultidict](http://pypi.python.org/pypi/orderedmultidict/0.7) >= 0.7
  - [future](https://pypi.python.org/pypi/future)
  - [nose](http://pypi.python.org/pypi/nose/) >= 1.1.2 (for tests)


      import htpasswd

      with htpasswd.Basic("/path/to/user.db") as userdb:
          try:
              userdb.add("bob", "password")
          except htpasswd.basic.UserExists, e:
              print e
          try:
              userdb.change_password("alice", "newpassword")
          except htpasswd.basic.UserNotExists, e:
              print e

      with htpasswd.Group("/path/to/group.db") as groupdb:
          try:
              groupdb.add_user("bob", "admins")
          except htpasswd.group.UserAlreadyInAGroup, e:
              print e
          try:
              groupdb.delete_user("alice", "managers")
          except htpasswd.group.UserNotInAGroup, e:
              print e

  To use MD5 encryotion, add ``mode="md5"`` to the constructor:

      with htpasswd.Basic("/path/to/user.db", mode="md5") as userdb




  - ``__contains__(user)``
  - ``users``
  - ``add(user, password)``
  - ``pop(user)``
  - ``change_password(user, password)``
  - ``_encrypt_password(password)``


  - ``__contains__(group)``
  - ``groups``
  - ``is_user_in(user, group)``
  - ``add_user(user, group)``
  - ``delete_user(user,  group)``




  Raised by ``Basic.add`` if user already exists.


  Raised by ``Basic.delete`` and ``Basic.change_password`` if there is no such user.


  Raised by ``Group.delete_user`` if there is no such group.


  Raised by ``Group.add_user`` if user is already in a group.


  Raised by ``Group.delete_user`` if user isn't in a group.


  Raised by _encrypt_password if mode is not 'crypt' or 'md5'.


pkgId: f20aae57b9fe73f868ea2e9774c218b1a1544f4f9a2ab3f0705c21f391b4a3ef
name: python-httpcore
arch: src
version: 0.16.3
epoch: 0
release: 1
summary: A minimal low-level HTTP client.
url: https://github.com/encode/httpcore
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7e87cea1-2951-4b1e-8f36-1c673b6fd8ff
location_href: 00003870-python-httpcore/python-httpcore-0.16.3-1.src.rpm
checksum_type: sha256
description:
  [![Test Suite](https://github.com/encode/httpcore/workflows/Test%20Suite/badge.svg)](https://github.com/encode/httpcore/actions)
  [![Package version](https://badge.fury.io/py/httpcore.svg)](https://pypi.org/project/httpcore/)

  > *Do one thing, and do it well.*

  The HTTP Core package provides a minimal low-level HTTP client, which does
  one thing only. Sending HTTP requests.

  It does not provide any high level model abstractions over the API,
  does not handle redirects, multipart uploads, building authentication headers,
  transparent HTTP caching, URL parsing, session cookie handling,
  content or charset decoding, handling JSON, environment based configuration
  defaults, or any of that Jazz.

  Some things HTTP Core does do:

  * Sending HTTP requests.
  * Thread-safe / task-safe connection pooling.
  * HTTP(S) proxy & SOCKS proxy support.
  * Supports HTTP/1.1 and HTTP/2.
  * Provides both sync and async interfaces.
  * Async backend support for `asyncio` and `trio`.



  Python 3.7+



  For HTTP/1.1 only support, install with:

  ```shell
  $ pip install httpcore
  ```

  For HTTP/1.1 and HTTP/2 support, install with:

  ```shell
  $ pip install httpcore[http2]
  ```

  For SOCKS proxy support, install with:

  ```shell
  $ pip install httpcore[socks]
  ```



  Send an HTTP request:

  ```python
  import httpcore

  response = httpcore.request("GET", "https://www.example.com/")

  print(response)

  print(response.status)

  print(response.headers)

  print(response.content)

  ```

  The top-level `httpcore.request()` function is provided for convenience. In practice whenever you're working with `httpcore` you'll want to use the connection pooling functionality that it provides.

  ```python
  import httpcore

  http = httpcore.ConnectionPool()
  response = http.request("GET", "https://www.example.com/")
  ```

  Once you're ready to get going, [head over to the documentation](https://www.encode.io/httpcore/).



  You *probably* don't want to be using HTTP Core directly. It might make sense if
  you're writing something like a proxy service in Python, and you just want
  something at the lowest possible level, but more typically you'll want to use
  a higher level client library, such as `httpx`.

  The motivation for `httpcore` is:

  * To provide a reusable low-level client library, that other packages can then build on top of.
  * To provide a *really clear interface split* between the networking code and client logic,
    so that each is easier to understand and reason about in isolation.




  All notable changes to this project will be documented in this file.

  The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).



  - Allow `ws` and `wss` schemes. Allows us to properly support websocket upgrade connections. (#625)
  - Forwarding HTTP proxies use a connection-per-remote-host. Required by some proxy implementations. (#637)
  - Don't raise `RuntimeError` when closing a connection pool with active connections. Removes some error cases when cancellations are used. (#631)
  - Lazy import `anyio`, so that it's no longer a hard dependancy, and isn't imported if unused. (#639)



  - Revert 'Fix async cancellation behaviour', which introduced race conditions. (#627)
  - Raise `RuntimeError` if attempting to us UNIX domain sockets on Windows. (#619)



  - Fix HTTP/1.1 interim informational responses, such as "100 Continue". (#605)



  - Support HTTP/1.1 informational responses. (#581)
  - Fix async cancellation behaviour. (#580)
  - Support `h11` 0.14. (#579)



  - Drop Python 3.6 support (#535)
  - Ensure HTTP proxy CONNECT requests include `timeout` configuration. (#506)
  - Switch to explicit `typing.Optional` for type hints. (#513)
  - For `trio` map OSError exceptions to `ConnectError`. (#543)



  - Requests which raise a PoolTimeout need to be removed from the pool queue. (#502)
  - Fix AttributeError that happened when Socks5Connection were terminated. (#501)



  - Fix SOCKS support for `http://` URLs. (#492)
  - Resolve race condition around exceptions during streaming a response. (#491)



  - SOCKS proxy support. (#478)
  - Add proxy_auth argument to HTTPProxy. (#481)
  - Improve error message on 'RemoteProtocolError' exception when server disconnects without sending a response. (#479)



  - Support HTTP/2 on HTTPS tunnelling proxies. (#468)
  - Fix proxy headers missing on HTTP forwarding. (#456)
  - Only instantiate SSL context if required. (#457)
  - More robust HTTP/2 handling. (#253, #439, #440, #441)



  - Fix race condition when removing closed connections from the pool. (#437)



  - Failed connections no longer remain in the pool. (Pull #433)



  - `max_connections` becomes optional. (Pull #429)
  - `certifi` is now included in the install dependancies. (Pull #428)
  - `h2` is now strictly optional. (Pull #428)



  The 0.14 release is a complete reworking of `httpcore`, comprehensively addressing some underlying issues in the connection pooling, as well as substantially redesigning the API to be more user friendly.

  Some of the lower-level API design also makes the components more easily testable in isolation, and the package now has 100% test coverage.

  See [discussion #419](https://github.com/encode/httpcore/discussions/419) for a little more background.

  There's some other neat bits in there too, such as the "trace" extension, which gives a hook into inspecting the internal events that occur during the request/response cycle. This extension is needed for the HTTPX cli, in order to...

  * Log the point at which the connection is established, and the IP/port on which it is made.
  * Determine if the outgoing request should log as HTTP/1.1 or HTTP/2, rather than having to assume it's HTTP/2 if the --http2 flag was passed. (Which may not actually be true.)
  * Log SSL version info / certificate info.

  Note that `curio` support is not currently available in 0.14.0. If you're using `httpcore` with `curio` please get in touch, so we can assess if we ought to prioritize it as a feature or not.



  - Fix broken error messaging when URL scheme is missing, or a non HTTP(S) scheme is used. (Pull #403)





  - Close sockets when read or write timeouts occur. (Pull #365)





  - Resolved niggles with AnyIO EOF behaviours. (Pull #358, #362)





  - Improved error messaging when URL scheme is missing, or a non HTTP(S) scheme is used. (Pull #354)



  - Switched to `anyio` as the default backend implementation when running with `asyncio`. Resolves some awkward [TLS timeout issues](https://github.com/encode/httpx/discussions/1511).





  - Support HTTP/2 prior knowledge, using `httpcore.SyncConnectionPool(http1=False)`. (Pull #333)



  - Handle cases where environment does not provide `select.poll` support. (Pull #331)





  - Improve error message for specific case of `RemoteProtocolError` where server disconnects without sending a response. (Pull #313)





  - More resiliant testing for closed connections. (Pull #311)
  - Don't raise exceptions on ungraceful connection closes. (Pull #310)



  The 0.13 release updates the core API in order to match the HTTPX Transport API,
  introduced in HTTPX 0.18 onwards.

  An example of making requests with the new interface is:

  ```python
  with httpcore.SyncConnectionPool() as http:
      status_code, headers, stream, extensions = http.handle_request(
          method=b'GET',
          url=(b'https', b'example.org', 443, b'/'),
          headers=[(b'host', b'example.org'), (b'user-agent', b'httpcore')]
          stream=httpcore.ByteStream(b''),
          extensions={}
      )
      body = stream.read()
      print(status_code, body)
  ```



  - The `.request()` method is now `handle_request()`. (Pull #296)
  - The `.arequest()` method is now `.handle_async_request()`. (Pull #296)
  - The `headers` argument is no longer optional. (Pull #296)
  - The `stream` argument is no longer optional. (Pull #296)
  - The `ext` argument is now named `extensions`, and is no longer optional. (Pull #296)
  - The `"reason"` extension keyword is now named `"reason_phrase"`. (Pull #296)
  - The `"reason_phrase"` and `"http_version"` extensions now use byte strings for their values. (Pull #296)
  - The `httpcore.PlainByteStream()` class becomes `httpcore.ByteStream()`. (Pull #296)



  - Streams now support a `.read()` interface. (Pull #296)



  - Task cancellation no longer leaks connections from the connection pool. (Pull #305)





  - Abort SSL connections on close rather than waiting for remote EOF when using `asyncio`.  (Pull #167)
  - Fix exception raised in case of connect timeouts when using the `anyio` backend. (Pull #236)
  - Fix `Host` header precedence for `:authority` in HTTP/2. (Pull #241, #243)
  - Handle extra edge case when detecting for socket readability when using `asyncio`. (Pull #242, #244)
  - Fix `asyncio` SSL warning when using proxy tunneling. (Pull #249)





  - Properly wrap connect errors on the asyncio backend. (Pull #235)
  - Fix `ImportError` occurring on Python 3.9 when using the HTTP/1.1 sync client in a multithreaded context. (Pull #237)





  - Add connect retries. (Pull #221)



  - Tweak detection of dropped connections, resolving an issue with open files limits on Linux. (Pull #185)
  - Avoid leaking connections when establishing an HTTP tunnel to a proxy has failed. (Pull #223)
  - Properly wrap OS errors when using `trio`. (Pull #225)





  - HTTP header casing is now preserved, rather than always sent in lowercase. (#216 and python-hyper/h11#104)



  - Add Python 3.9 to officially supported versions.



  - Gracefully handle a stdlib asyncio bug when a connection is closed while it is in a paused-for-reading state. (#201)





  - Add await to async semaphore release() coroutine (#197)
  - Drop incorrect curio classifier (#192)



  The Transport API with 0.11.0 has a couple of significant changes.

  Firstly we've moved changed the request interface in order to allow extensions, which will later enable us to support features
  such as trailing headers, HTTP/2 server push, and CONNECT/Upgrade connections.

  The interface changes from:

  ```python
  def request(method, url, headers, stream, timeout):
      return (http_version, status_code, reason, headers, stream)
  ```

  To instead including an optional dictionary of extensions on the request and response:

  ```python
  def request(method, url, headers, stream, ext):
      return (status_code, headers, stream, ext)
  ```

  Having an open-ended extensions point will allow us to add later support for various optional features, that wouldn't otherwise be supported without these API changes.

  In particular:

  * Trailing headers support.
  * HTTP/2 Server Push
  * sendfile.
  * Exposing raw connection on CONNECT, Upgrade, HTTP/2 bi-di streaming.
  * Exposing debug information out of the API, including template name, template context.

  Currently extensions are limited to:

  * request: `timeout` - Optional. Timeout dictionary.
  * response: `http_version` - Optional. Include the HTTP version used on the response.
  * response: `reason` - Optional. Include the reason phrase used on the response. Only valid with HTTP/1.*.

  See https://github.com/encode/httpx/issues/1274#issuecomment-694884553 for the history behind this.

  Secondly, the async version of `request` is now namespaced as `arequest`.

  This allows concrete transports to support both sync and async implementations on the same class.



  - Add curio support. (Pull #168)
  - Add anyio support, with `backend="anyio"`. (Pull #169)



  - Update the Transport API to use 'ext' for optional extensions. (Pull #190)
  - Update the Transport API to use `.request` and `.arequest` so implementations can support both sync and async. (Pull #189)





  - Added Unix Domain Socket support. (Pull #139)



  - Always include the port on proxy CONNECT requests. (Pull #154)
  - Fix `max_keepalive_connections` configuration. (Pull #153)
  - Fixes behaviour in HTTP/1.1 where server disconnects can be used to signal the end of the response body. (Pull #164)



  - Include `max_keepalive_connections` on `AsyncHTTPProxy`/`SyncHTTPProxy` classes.



  The most notable change in the 0.10.0 release is that HTTP/2 support is now fully optional.

  Use either `pip install httpcore` for HTTP/1.1 support only, or `pip install httpcore[http2]` for HTTP/1.1 and HTTP/2 support.



  - HTTP/2 support becomes optional. (Pull #121, #130)
  - Add `local_address=...` support. (Pull #100, #134)
  - Add `PlainByteStream`, `IteratorByteStream`, `AsyncIteratorByteStream`. The `AsyncByteSteam` and `SyncByteStream` classes are now pure interface classes. (#133)
  - Add `LocalProtocolError`, `RemoteProtocolError` exceptions. (Pull #129)
  - Add `UnsupportedProtocol` exception. (Pull #128)
  - Add `.get_connection_info()` method. (Pull #102, #137)
  - Add better TRACE logs. (Pull #101)



  - `max_keepalive` is deprecated in favour of `max_keepalive_connections`. (Pull #140)



  - Improve handling of server disconnects. (Pull #112)





  - Proper host resolution for sync case, including IPv6 support. (Pull #97)
  - Close outstanding connections when connection pool is closed. (Pull #98)





  - URL port becomes an `Optional[int]` instead of `int`. (Pull #92)



  - Honor HTTP/2 max concurrent streams settings. (Pull #89, #90)
  - Remove incorrect debug log. (Pull #83)





  - Logging via HTTPCORE_LOG_LEVEL and HTTPX_LOG_LEVEL environment variables
  and TRACE level logging. (Pull #79)



  - Reuse of connections on HTTP/2 in close concurrency situations. (Pull #81)





  - Include `Host` and `Accept` headers on proxy "CONNECT" requests.
  - De-duplicate any headers also contained in proxy_headers.
  - HTTP/2 flag not being passed down to proxy connections.





  - Fix connections using proxy forwarding requests not being added to the
  connection pool properly. (Pull #70)





  - Allow inherintance of both `httpcore.AsyncByteStream`, `httpcore.SyncByteStream` without type conflicts.





  - Fixed tunnel proxy support.



  - New `TimeoutException` base class.



  - First integration with HTTPX.


pkgId: 1e0c607aa85759606bed7da57d8055872526a7695cbeaa0c51456e63df8f15ae
name: python-httpie
arch: src
version: 3.2.1
epoch: 0
release: 1
summary: HTTPie: modern, user-friendly command-line HTTP client for the API era.
url: https://httpie.io/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-de2bd6fe-b8c3-4e79-9ebc-27e6271cc292
location_href: 00010840-python-httpie/python-httpie-3.2.1-1.src.rpm
checksum_type: sha256
description:
  <br/>
  <a href="https://httpie.io" target="blank_">
      <img height="100" alt="HTTPie" src="https://raw.githubusercontent.com/httpie/httpie/master/docs/httpie-logo.svg" />
  </a>
  <br/>



  HTTPie (pronounced _aitch-tee-tee-pie_) is a command-line HTTP client.
  Its goal is to make CLI interaction with web services as human-friendly as possible.
  HTTPie is designed for testing, debugging, and generally interacting with APIs & HTTP servers.
  The `http` & `https` commands allow for creating and sending arbitrary HTTP requests.
  They use simple and natural syntax and provide formatted and colorized output.

  [![Docs](https://img.shields.io/badge/stable%20docs-httpie.io%2Fdocs-brightgreen?style=flat&color=%2373DC8C&label=Docs)](https://httpie.org/docs)
  [![Latest version](https://img.shields.io/pypi/v/httpie.svg?style=flat&label=Latest&color=%234B78E6&logo=&logoColor=white)](https://pypi.python.org/pypi/httpie)
  [![Build](https://img.shields.io/github/workflow/status/httpie/httpie/Build?color=%23FA9BFA&label=Build)](https://github.com/httpie/httpie/actions)
  [![Coverage](https://img.shields.io/codecov/c/github/httpie/httpie?style=flat&label=Coverage&color=%2373DC8C)](https://codecov.io/gh/httpie/httpie)
  [![Twitter](https://img.shields.io/twitter/follow/httpie?style=flat&color=%234B78E6&logoColor=%234B78E6)](https://twitter.com/httpie)
  [![Chat](https://img.shields.io/badge/chat-Discord-brightgreen?style=flat&label=Chat%20on&color=%23FA9BFA)](https://httpie.io/discord)

  <img src="https://raw.githubusercontent.com/httpie/httpie/master/docs/httpie-animation.gif" alt="HTTPie in action" width="100%"/>




  Please note we recently accidentally made this repo private for a moment, and GitHub deleted our community that took a decade to build. Read the full story here: https://httpie.io/blog/stardust

  ![](docs/stardust.png)




  - [Installation instructions →](https://httpie.io/docs#installation)
  - [Full documentation →](https://httpie.io/docs)



  - Expressive and intuitive syntax
  - Formatted and colorized terminal output
  - Built-in JSON support
  - Forms and file uploads
  - HTTPS, proxies, and authentication
  - Arbitrary request data
  - Custom headers
  - Persistent sessions
  - `wget`-like downloads

  [See all features →](https://httpie.io/docs)



  Hello World:

  ```bash
  $ https httpie.io/hello
  ```

  Custom [HTTP method](https://httpie.io/docs#http-method), [HTTP headers](https://httpie.io/docs#http-headers) and [JSON](https://httpie.io/docs#json) data:

  ```bash
  $ http PUT pie.dev/put X-API-Token:123 name=John
  ```

  Build and print a request without sending it using [offline mode](https://httpie.io/docs#offline-mode):

  ```bash
  $ http --offline pie.dev/post hello=offline
  ```

  Use [GitHub API](https://developer.github.com/v3/issues/comments/#create-a-comment) to post a comment on an [Issue](https://github.com/httpie/httpie/issues/83) with [authentication](https://httpie.io/docs#authentication):

  ```bash
  $ http -a USERNAME POST https://api.github.com/repos/httpie/httpie/issues/83/comments body='HTTPie is awesome! :heart:'
  ```

  [See more examples →](https://httpie.io/docs#examples)



  - Visit the [HTTPie website](https://httpie.io) for full documentation and useful links.
  - Join our [Discord server](https://httpie.io/discord) is to ask questions, discuss features, and for general API chat.
  - Tweet at [@httpie](https://twitter.com/httpie) on Twitter.
  - Use [StackOverflow](https://stackoverflow.com/questions/tagged/httpie) to ask questions and include a `httpie` tag.
  - Create [GitHub Issues](https://github.com/httpie/httpie/issues) for bug reports and feature requests.
  - Subscribe to the [HTTPie newsletter](https://httpie.io) for occasional updates.



  Have a look through existing [Issues](https://github.com/httpie/httpie/issues) and [Pull Requests](https://github.com/httpie/httpie/pulls) that you could help with. If you'd like to request a feature or report a bug, please [create a GitHub Issue](https://github.com/httpie/httpie/issues) using one of the templates provided.

  [See contribution guide →](https://github.com/httpie/httpie/blob/master/CONTRIBUTING.md)


pkgId: 33128f66023d3a45af544e0d431b5da8e4f4753f91f5652545f603c1a7cf163c
name: python-httplib2
arch: src
version: 0.22.0
epoch: 0
release: 1
summary: A comprehensive HTTP client library.
url: https://github.com/httplib2/httplib2
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-339cef41-f83d-40ef-91d6-ee71e735f5bf
location_href: 00008976-python-httplib2/python-httplib2-0.22.0-1.src.rpm
checksum_type: sha256
description:
  A comprehensive HTTP client library, ``httplib2`` supports many features left out of other HTTP libraries.

  **HTTP and HTTPS**
    HTTPS support is only available if the socket module was compiled with SSL support.


  **Keep-Alive**
    Supports HTTP 1.1 Keep-Alive, keeping the socket open and performing multiple requests over the same connection if possible.


  **Authentication**
    The following three types of HTTP Authentication are supported. These can be used over both HTTP and HTTPS.

    * Digest
    * Basic
    * WSSE

  **Caching**
    The module can optionally operate with a private cache that understands the Cache-Control:
    header and uses both the ETag and Last-Modified cache validators. Both file system
    and memcached based caches are supported.


  **All Methods**
    The module can handle any HTTP request method, not just GET and POST.


  **Redirects**
    Automatically follows 3XX redirects on GETs.


  **Compression**
    Handles both 'deflate' and 'gzip' types of compression.


  **Lost update support**
    Automatically adds back ETags into PUT requests to resources we have already cached. This implements Section 3.2 of Detecting the Lost Update Problem Using Unreserved Checkout


  **Unit Tested**
    A large and growing set of unit tests.


pkgId: 3d8f11a0d058178302c4776b40cde750051892bdb3dd0842beee361660855d9c
name: python-httplib2shim
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: A wrapper over urllib3 that matches httplib2's interface
url: https://github.com/GoogleCloudPlatform/httplib2shim
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-612bc82c-4f2b-4367-8d28-511152018f12
location_href: 00013369-python-httplib2shim/python-httplib2shim-0.0.3-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Coverage Status| |PyPI Version|
  ``httplib2shim`` is a wrapper over ``httplib2`` that uses ``urllib3`` to perform HTTP requests. This library is intended to help existing legacy libraries (and their users) to migrate away from ``httplib2``. It is not intended to be a general purpose replacement for ``httplib2``. It does not support every feature and edge case for ``httplib2``, although contributions are welcome in order to help us cover these cases.
  Presently, ``httplib2shim`` passes the test suite for ``httplib2``. A few non-applicable tests were disabled, and it's very possible that the tests do not account for behavior that is depended on by clients.


pkgId: 8fe541eedde26970d870c97730479cbfc60cda6e07a292f7c9c6cdabc9262e97
name: python-httpretty
arch: src
version: 1.1.4
epoch: 0
release: 1
summary: HTTP client mock for Python
url: https://httpretty.readthedocs.io/en/latest/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9941e4ad-b939-49be-9d7d-f9bf83239ac3
location_href: 00010019-python-httpretty/python-httpretty-1.1.4-1.src.rpm
checksum_type: sha256
description:
  HTTP Client mocking tool for Python created by `Gabriel Falcão <https://github.com/gabrielfalcao>`_ . It provides a full fake TCP socket module. Inspired by `FakeWeb <https://github.com/chrisk/fakeweb>`_
  - `Github Repository <https://github.com/gabrielfalcao/HTTPretty>`_
  - `Documentation <https://httpretty.readthedocs.io/en/latest/>`_
  - `PyPI Package <https://pypi.org/project/httpretty/>`_
  **Python Support:**
  - **3.6**
  - **3.7**
  - **3.8**
  - **3.9**


pkgId: d90481009930769b637ff9cae6518feb4c03cd5484114357a48ddc374d73c477
name: python-httpsig_cffi
arch: src
version: 15.0.0
epoch: 0
release: 1
summary: Secure HTTP request signing using the HTTP Signature draft specification
url: https://github.com/hawkowl/httpsig_cffi
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0f90d165-e1ac-49ff-a486-bec1988a96d7
location_href: 00003871-python-httpsig-cffi/python-httpsig_cffi-15.0.0-1.src.rpm
checksum_type: sha256
description:
  Sign HTTP requests with secure signatures according to the IETF HTTP Signatures specification (`Draft 3`_).
  This is `a fork`_ of the fork_ of the original module_ that was made to fully support both RSA and HMAC schemes as well as unit test both schemes to prove they work.
  This particular fork moves from PyCrypto to Cryptography, which provides PyPy support.
  See the original project_, original Python module_, original spec_, and `current IETF draft`_ for more details on the signing scheme.


pkgId: af9018a7f4aa7fe75baba162c5577d68b03ce1e5fe93467f9f62b5cef4616594
name: python-httptools
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: A collection of framework independent HTTP protocol utils.
url: https://github.com/MagicStack/httptools
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fc79fe75-ef58-4034-b75d-66cf4f5e6242
location_href: 00003872-python-httptools/python-httptools-0.5.0-1.src.rpm
checksum_type: sha256
description:
  ![Tests](https://github.com/MagicStack/httptools/workflows/Tests/badge.svg)

  httptools is a Python binding for the nodejs HTTP parser.

  The package is available on PyPI: `pip install httptools`.




  httptools contains two classes `httptools.HttpRequestParser`,
  `httptools.HttpResponseParser` (fulfilled through
  [llhttp](https://github.com/nodejs/llhttp)) and a function for
  parsing URLs `httptools.parse_url` (through
  [http-parse](https://github.com/nodejs/http-parser) for now).
  See unittests for examples.


  ```python

  class HttpRequestParser:

      def __init__(self, protocol):
          """HttpRequestParser

          protocol -- a Python object with the following methods
          (all optional):

            - on_message_begin()
            - on_url(url: bytes)
            - on_header(name: bytes, value: bytes)
            - on_headers_complete()
            - on_body(body: bytes)
            - on_message_complete()
            - on_chunk_header()
            - on_chunk_complete()
            - on_status(status: bytes)
          """

      def get_http_version(self) -> str:
          """Return an HTTP protocol version."""

      def should_keep_alive(self) -> bool:
          """Return ``True`` if keep-alive mode is preferred."""

      def should_upgrade(self) -> bool:
          """Return ``True`` if the parsed request is a valid Upgrade request.
  	The method exposes a flag set just before on_headers_complete.
  	Calling this method earlier will only yield `False`.
  	"""

      def feed_data(self, data: bytes):
          """Feed data to the parser.

          Will eventually trigger callbacks on the ``protocol``
          object.

          On HTTP upgrade, this method will raise an
          ``HttpParserUpgrade`` exception, with its sole argument
          set to the offset of the non-HTTP data in ``data``.
          """

      def get_method(self) -> bytes:
          """Return HTTP request method (GET, HEAD, etc)"""


  class HttpResponseParser:

      """Has all methods except ``get_method()`` that
      HttpRequestParser has."""

      def get_status_code(self) -> int:
          """Return the status code of the HTTP response"""


  def parse_url(url: bytes):
      """Parse URL strings into a structured Python object.

      Returns an instance of ``httptools.URL`` class with the
      following attributes:

        - schema: bytes
        - host: bytes
        - port: int
        - path: bytes
        - query: bytes
        - fragment: bytes
        - userinfo: bytes
      """
  ```




  1. Clone this repository with
     `git clone --recursive git@github.com:MagicStack/httptools.git`

  2. Create a virtual environment with Python 3:
     `python3 -m venv envname`

  3. Activate the environment with `source envname/bin/activate`

  4. Install development requirements with `pip install -e .[test]`

  5. Run `make` and `make test`.




  MIT.


pkgId: 3e2460d4583580d16c603bc453da9f3c492bdc0d03da10957bb7fb4e5092a16f
name: python-httptools-debuginfo
arch: aarch64
version: 0.5.0
epoch: 0
release: 1
summary: Debug information for package python-httptools
url: https://github.com/MagicStack/httptools
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-fc79fe75-ef58-4034-b75d-66cf4f5e6242
rpm_sourcerpm: python-httptools-0.5.0-1.src.rpm
location_href: 00003872-python-httptools/python-httptools-debuginfo-0.5.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-httptools.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 4b8b551cdfd1fd3709a8980882e57ffc04a4d21b8c82b7b706903542592381f8
name: python-httptools-debugsource
arch: aarch64
version: 0.5.0
epoch: 0
release: 1
summary: Debug sources for package python-httptools
url: https://github.com/MagicStack/httptools
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-fc79fe75-ef58-4034-b75d-66cf4f5e6242
rpm_sourcerpm: python-httptools-0.5.0-1.src.rpm
location_href: 00003872-python-httptools/python-httptools-debugsource-0.5.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-httptools.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 953677198fb1ed745f18c0ff400621b1594270b0170f0134952c5c315a3962f0
name: python-httpx-socks
arch: src
version: 0.7.5
epoch: 0
release: 1
summary: Proxy (HTTP, SOCKS) transports for httpx
url: https://github.com/romis2012/httpx-socks
rpm_license: Apache 2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d001592d-92f1-4ec2-be7e-cd06571f34a2
location_href: 00011605-python-httpx-socks/python-httpx-socks-0.7.5-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://api.travis-ci.com/romis2012/httpx-socks.svg?branch=master)](https://travis-ci.com/github/romis2012/httpx-socks)
  [![Coverage Status](https://coveralls.io/repos/github/romis2012/httpx-socks/badge.svg?branch=master&_=q)](https://coveralls.io/github/romis2012/httpx-socks?branch=master)
  [![PyPI version](https://badge.fury.io/py/httpx-socks.svg)](https://badge.fury.io/py/httpx-socks)
  <!--
  [![Downloads](https://pepy.tech/badge/httpx-socks/month)](https://pepy.tech/project/httpx-socks)
  -->

  The `httpx-socks` package provides proxy transports for [httpx](https://github.com/encode/httpx) client.
  SOCKS4(a), SOCKS5(h), HTTP (tunneling) proxy supported.
  It uses [python-socks](https://github.com/romis2012/python-socks) for core proxy functionality.



  - Python >= 3.6
  - httpx>=0.21.0
  - python-socks>=2.0.0
  - async-timeout>=3.0.1 (optional)
  - trio>=0.16.0 (optional)




  only sync proxy support:
  ```
  pip install httpx-socks
  ```

  to include optional asyncio support (it requires async-timeout):
  ```
  pip install httpx-socks[asyncio]
  ```

  to include optional trio support:
  ```
  pip install httpx-socks[trio]
  ```





  ```python
  import httpx
  from httpx_socks import SyncProxyTransport

  def fetch(url):
      transport = SyncProxyTransport.from_url('socks5://user:password@127.0.0.1:1080')
      with httpx.Client(transport=transport) as client:
          res = client.get(url)
          return res.text
  ```


  ```python
  import httpx
  from httpx_socks import AsyncProxyTransport

  async def fetch(url):
      transport = AsyncProxyTransport.from_url('socks5://user:password@127.0.0.1:1080')
      async with httpx.AsyncClient(transport=transport) as client:
          res = await client.get(url)
          return res.text
  ```


  ```python
  import ssl
  import httpx
  from httpx_socks import AsyncProxyTransport

  async def fetch(url):
      proxy_ssl = ssl.SSLContext(ssl.PROTOCOL_TLS)
      proxy_ssl.verify_mode = ssl.CERT_REQUIRED
      proxy_ssl.load_verify_locations(...)

      transport = AsyncProxyTransport.from_url('http://user:password@127.0.0.1:8080', proxy_ssl=proxy_ssl)
      async with httpx.AsyncClient(transport=transport) as client:
          res = await client.get(url)
          return res.text
  ```


pkgId: 0077978f636d41313af2ce1275bbd51f52a91d78cebdc13abcb2feee5e7a04fe
name: python-hubspot3
arch: src
version: 3.2.52
epoch: 0
release: 1
url: https://github.com/jpetrucciani/hubspot3.git
rpm_license: LICENSE
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a4d6ac1e-09e3-463d-b7ad-648c4e2a9975
location_href: 00013726-python-hubspot3/python-hubspot3-3.2.52-1.src.rpm
checksum_type: sha256
summary:
  A python wrapper around HubSpot's APIs, for python 3. Built initially around hapipy, but heavily modified.

description:
  [![PyPI
  version](https://badge.fury.io/py/hubspot3.svg)](https://badge.fury.io/py/hubspot3)
  [![Code style:
  black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
  [![Documentation
  Status](https://readthedocs.org/projects/hubspot3/badge/?version=latest)](https://hubspot3.readthedocs.io/en/latest/?badge=latest)
  [![Python 3.7+
  supported](https://img.shields.io/badge/python-3.7+-blue.svg)](https://www.python.org/downloads/release/python-360/)

  A python wrapper around HubSpot's APIs, _for python 3.7+_.

  Built initially around hapipy, but heavily modified.

  Check out the [documentation
  here](https://hubspot3.readthedocs.io/en/latest/)\! (thanks readthedocs)







  ```bash

  pip install hubspot3
  ```



  ```python
  from hubspot3 import Hubspot3

  API_KEY = "your-api-key"

  client = Hubspot3(api_key=API_KEY)


  contact = client.contacts.get_contact_by_email('testingapis@hubspot.com')
  contact_id = contact['vid']

  all_companies = client.companies.get_all()


  client.usage_limits


  client.usage_limits.calls_remaining

  ```



  ```python
  from hubspot3.companies import CompaniesClient

  API_KEY = "your-api-key"

  client = CompaniesClient(api_key=API_KEY)

  for company in client.get_all():
      print(company)
  ```



  ```python
  import json
  from hubspot3.deals import DealsClient

  deal_id = "12345"
  API_KEY = "your_api_key"

  deals_client = DealsClient(api_key=API_KEY)

  params = {
      "includePropertyVersions": "true"
  }  # Note values are camelCase as they appear in the Hubspot Documentation!

  deal_data = deals_client.get(deal_id, params=params)
  print(json.dumps(deal_data))
  ```



  There is also a command-line tool available. Install the extra
  requirement for that tool via:

  ```bash
  pip install hubspot3[cli]
  ```

  and you can use it as a command:

  ```bash
  hubspot3 --help
  ```

  See the Sphinx documentation for more details and explanations.



  Be aware that this uses the HubSpot API directly, so you are subject to
  all of the [guidelines that HubSpot has in
  place](https://developers.hubspot.com/apps/api_guidelines).

  at the time of writing, HubSpot has the following limits in place for
  API requests:

  Free & Starter:

  - 10 requests per second
  - 250,000 requests per day.

  Professional & Enterprise:

  - 10 requests per second
  - 500,000 requests per day.

  This daily limit resets at midnight based on the time zone setting of
  the HubSpot account. There is also an additional addon you can purchase
  for more requests.



  By default, hubspot3 will attempt to retry all API calls up to 2 times
  upon failure.

  If you'd like to override this behavior, you can add a `number_retries`
  keyword argument to any Client constructor, or to individual API calls.



  Some of the APIs are not yet complete\! If you'd like to use an API that
  isn't yet in this repo, you can extend the BaseClient class\!

  ```python
  import json
  from hubspot3.base import BaseClient


  PIPELINES_API_VERSION = "1"


  class PipelineClient(BaseClient):
      """
      Lets you extend to non-existing clients, this example extends pipelines
      """

      def __init__(self, *args, **kwargs):
          super(PipelineClient, self).__init__(*args, **kwargs)

      def get_pipelines(self, **options):
          params = {}

          return self._call("pipelines", method="GET", params=params)

      def _get_path(self, subpath):
          return f"deals/v{self.options.get('version') or PIPELINES_API_VERSION}/{subpath}"


  if __name__ == "__main__":
      API_KEY = "your_api_key"
      a = PipelineClient(api_key=API_KEY)
      print(json.dumps(a.get_pipelines()))
  ```



  This is an example of how you can use the `oauth2_token_getter` and `oauth2_token_setter` kwargs on the client to use custom storage (in this case redis) so that multiple clients can share the same access/refresh tokens generated by the oauth2 requests.

  ```python
  import aioredis
  from hubspot3 import Hubspot3


  redis_client = await aioredis.create_redis_pool(url, db=db, encoding='utf-8', timeout=10)

  def oauth2_token_getter(token_type: str, client_id: str) -> str:
      loop = asyncio.get_event_loop()
      key = f'hubspot-oauth2-tokens:{token_type}:{client_id}'
      return loop.run_until_complete(redis_client.get(key))

  def oauth2_token_setter(token_type: str, client_id: str, token: str) -> None:
      loop = asyncio.get_event_loop()
      key = f'hubspot-oauth2-tokens:{token_type}:{client_id}'
      
      
      expire_in_seconds = 6 * 60 * 60
      loop.run_until_complete(redis_client.set(key, token, expire=expire_in_seconds))


  hubspot3_client = Hubspot3(
      access_token=access_token,
      client_id=client_id,
      client_secret=client_secret,
      refresh_token=refresh_token,
      oauth2_token_getter=oauth2_token_getter,
      oauth2_token_setter=oauth2_token_setter,
  )
  ```



  I'm currently working on rewriting many of the tests with
  [pytest](https://docs.pytest.org/en/latest/) to work against the public
  API and ensure that we get the correct type of mock data back. These
  tests are currently in a **very** early state - I'll be working soon to
  get them all built out.

  ```bash

  pip install pytest pytest-cov

  pip install -r requirements-dev.txt


  make

  make test_all
  ```


pkgId: 4b9916dac360c958175ec0c5e5761544e569fcfc6b7e158d3c24675355eac83a
name: python-humanfriendly
arch: src
version: 10.0
epoch: 0
release: 1
summary: Human friendly output for text interfaces using Python
url: https://humanfriendly.readthedocs.io
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1a93c92f-6aac-4298-ad06-be6b57e7f02b
location_href: 00003874-python-humanfriendly/python-humanfriendly-10.0-1.src.rpm
checksum_type: sha256
description:
  The functions and classes in the `humanfriendly` package can be used to make
  text interfaces more user friendly. Some example features:
  - Parsing and formatting numbers, file sizes, pathnames and timespans in
    simple, human friendly formats.
  - Easy to use timers for long running operations, with human friendly
    formatting of the resulting timespans.
  - Prompting the user to select a choice from a list of options by typing the
    option's number or a unique substring of the option.
  - Terminal interaction including text styling (`ANSI escape sequences`_), user
    friendly rendering of usage messages and querying the terminal for its
    size.
  The `humanfriendly` package is currently tested on Python 2.7, 3.5+ and PyPy
  (2.7) on Linux and macOS. While the intention is to support Windows as well,
  you may encounter some rough edges.


pkgId: bb4f01c08304d71cf69cd0df3007287d2138f3c6e786a1ce34ff16ffce9720e0
name: python-humblewx
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Library that simplifies creating user interfaces with wxPython.
url: https://github.com/thetimelineproj/humblewx
rpm_license: GPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d6d53238-c40a-4049-8ef5-c47e89ec484f
location_href: 00003875-python-humblewx/python-humblewx-0.2.2-1.src.rpm
checksum_type: sha256
description:
  * License: GPLv3
  * Contributions: Fork this repository and send a pull request

  For more information, see the `documentation
  <http://humblewx.readthedocs.org/en/latest/>`_.


pkgId: 73b1a259dba87fbf3f135258c9f94bacdc455d4932c21e16e61b5572c7d015c0
name: python-hurry.filesize
arch: src
version: 0.9
epoch: 0
release: 1
summary: A simple Python library for human readable file sizes (or anything sized in bytes).
url: UNKNOWN
rpm_license: ZPL 2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0f904749-590c-4386-a80e-0c02bd9f9adc
location_href: 00011085-python-hurry-filesize/python-hurry.filesize-0.9-1.src.rpm
checksum_type: sha256
description:
  hurry.filesize a simple Python library that can take a number of bytes and
  returns a human-readable string with the size in it, in kilobytes (K),
  megabytes (M), etc.
  The default system it uses is "traditional", where multipliers of 1024
  increase the unit size::
    >>> from hurry.filesize import size
    >>> size(1024)
    '1K'
  An alternative, slightly more verbose system::
    >>> from hurry.filesize import alternative
    >>> size(1, system=alternative)
    '1 byte'
    >>> size(10, system=alternative)
    '10 bytes'
    >>> size(1024, system=alternative)
    '1 KB'
  A verbose system::
    >>> from hurry.filesize import verbose
    >>> size(10, system=verbose)
    '10 bytes'
    >>> size(1024, system=verbose)
    '1 kilobyte'
    >>> size(2000, system=verbose)
    '1 kilobyte'
    >>> size(3000, system=verbose)
    '2 kilobytes'
    >>> size(1024 * 1024, system=verbose)
    '1 megabyte'
    >>> size(1024 * 1024 * 3, system=verbose)
    '3 megabytes'
  You can also use the SI system, where multipliers of 1000 increase the unit
  size::
    >>> from hurry.filesize import si
    >>> size(1000, system=si)
    '1K'


pkgId: efe7b45cc2f949a372f4301dd282fb7d944dfbb0e7a3bde9a602473240804f4e
name: python-husl
arch: src
version: 4.0.3
epoch: 0
release: 1
summary: Human-friendly HSL
url: http://www.husl-colors.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-21863344-b571-4f4b-b4ea-55c25f2808bf
location_href: 00003877-python-husl/python-husl-4.0.3-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/husl-colors/husl-python.svg?branch=master)](http://travis-ci.org/husl-colors/husl-python)
  [![Package Version](https://img.shields.io/pypi/v/husl.svg)](https://pypi.python.org/pypi/husl/)

  A Python implementation of [HUSL](http://www.husl-colors.org) (revision 3).



  `pip install husl`



  **husl_to_hex(hue, saturation, lightness)**

  `hue` is a float between 0 and 360, `saturation` and `lightness` are floats between 0 and 100. This function returns the resulting color as a hex string.

  **husl_to_rgb(hue, saturation, lightness)**

  Like above, but returns a list of 3 floats between 0 and 1, for each RGB channel.

  **hex_to_husl(hex)**

  Takes a hex string and returns the HUSL color as a list of floats as defined above.

  **rgb_to_husl(red, green, blue)**

  Like above, but `red`, `green` and `blue` are passed as floats between 0 and 1.

  For HUSLp (the pastel variant), use `huslp_to_hex`, `huslp_to_rgb`, `hex_to_huslp` and `rgb_to_huslp`.



  Run `python setup.py test`.



  * Robert McGinley ([mcginleyr1](http://github.com/mcginleyr1))
  * Alexei Boronine ([boronine](http://github.com/boronine))


pkgId: d06a2572464a7ba922a60fe2d7d7340c054a4b6731d51d0a72d4c04166221d93
name: python-hvac
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: HashiCorp Vault API client
url: https://github.com/hvac/hvac
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-816c2b8c-6c1d-41b2-8106-40220c722440
location_href: 00003878-python-hvac/python-hvac-1.1.0-1.src.rpm
checksum_type: sha256
description:
  ![Header image](https://raw.githubusercontent.com/hvac/hvac/main/docs/_static/hvac_logo_800px.png)

  [HashiCorp](https://hashicorp.com/) [Vault](https://www.vaultproject.io) API client for Python 3.x

  [![Test](https://github.com/hvac/hvac/workflows/Test/badge.svg)](https://github.com/hvac/hvac/actions?query=workflow%3ATest)
  [![codecov](https://codecov.io/gh/hvac/hvac/branch/main/graph/badge.svg)](https://codecov.io/gh/hvac/hvac)
  [![Documentation Status](https://readthedocs.org/projects/hvac/badge/)](https://hvac.readthedocs.io/en/latest/?badge=latest)
  [![PyPI version](https://badge.fury.io/py/hvac.svg)](https://badge.fury.io/py/hvac)
  [![Twitter - @python_hvac](https://img.shields.io/twitter/follow/python_hvac.svg?label=Twitter%20-%20@python_hvac&style=social?style=plastic)](https://twitter.com/python_hvac)
  [![Gitter chat](https://badges.gitter.im/hvac/community.png)](https://gitter.im/hvac/community)

  Tested against the latest release, HEAD ref, and 3 previous minor versions (counting back from the latest release) of Vault.
  Current official support covers Vault v1.4.7 or later.

  > **NOTE:**  Support for EOL Python versions will be dropped at the end of 2022.  Starting in 2023, hvac will track
  > with the CPython EOL dates.



  ```console
  pip install hvac
  ```

  If you would like to be able to return parsed HCL data as a Python dict for methods that support it:

  ```console
  pip install "hvac[parser]"
  ```



  Additional documentation for this module available at: [hvac.readthedocs.io](https://hvac.readthedocs.io/en/stable/usage/index.html):

  * [Getting Started](https://hvac.readthedocs.io/en/stable/overview.html#getting-started)
  * [Usage](https://hvac.readthedocs.io/en/stable/usage/index.html)
  * [Advanced Usage](https://hvac.readthedocs.io/en/stable/advanced_usage.html)
  * [Source Reference / Autodoc](https://hvac.readthedocs.io/en/stable/source/index.html)
  * [Contributing](https://hvac.readthedocs.io/en/stable/contributing.html)
  * [Changelog](https://hvac.readthedocs.io/en/stable/changelog.html)


pkgId: 1729d1f51b6c7a4d2870c0bb61c45b8541b58bc4dc161f545a75d27b407df85a
name: python-hyperlink
arch: src
version: 21.0.0
epoch: 0
release: 1
summary: A featureful, immutable, and correct URL for Python.
url: https://github.com/python-hyper/hyperlink
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0bc4271a-6797-47f4-919f-205458968bdb
location_href: 00009452-python-hyperlink/python-hyperlink-21.0.0-1.src.rpm
checksum_type: sha256
description:
  The humble, but powerful, URL runs everything around us. Chances
  are you've used several just to read this text.

  Hyperlink is a featureful, pure-Python implementation of the URL, with
  an emphasis on correctness. MIT licensed.

  See the docs at http://hyperlink.readthedocs.io.


pkgId: 2a6003b6078e11eaa7ba48bf6a8888c9f0db2da09d21354d0741e92861d457a0
name: python-hypothesis-fspaths
arch: src
version: 0.1
epoch: 0
release: 1
summary: Hypothesis extension for generating filesystem paths
url: https://github.com/lazka/hypothesis-fspaths
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1f634549-3e97-4ea7-9d8a-42ba6105e089
location_href: 00003879-python-hypothesis-fspaths/python-hypothesis-fspaths-0.1-1.src.rpm
checksum_type: sha256
description:
      from hypothesis import given
      from hypothesis_fspaths import fspaths
      @given(fspaths())
      def test_open_file(path):
          try:
              open(path).close()
          except IOError:
              pass


pkgId: 795485773ca612936ff2a84e988931bdd38b1fca2ffa30f22b8f73e9d05f21c2
name: python-hypothesis-jsonschema
arch: src
version: 0.22.1
epoch: 0
release: 1
summary: Generate test data from JSON schemata with Hypothesis
url: https://github.com/Zac-HD/hypothesis-jsonschema
rpm_license: MPL 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-32b13953-ae6f-4bd5-bcb2-b1565be74113
location_href: 00011985-python-hypothesis-jsonschema/python-hypothesis-jsonschema-0.22.1-1.src.rpm
checksum_type: sha256
description:
  A [Hypothesis](https://hypothesis.readthedocs.io) strategy for generating data
  that matches some [JSON schema](https://json-schema.org/).

  [Here's the PyPI page.](https://pypi.org/project/hypothesis-jsonschema/)



  The public API consists of just one function: `hypothesis_jsonschema.from_schema`,
  which takes a JSON schema and returns a strategy for allowed JSON objects.

  ```python
  from hypothesis import given

  from hypothesis_jsonschema import from_schema


  @given(from_schema({"type": "integer", "minimum": 1, "exclusiveMaximum": 10}))
  def test_integers(value):
      assert isinstance(value, int)
      assert 1 <= value < 10


  @given(
      from_schema(
          {"type": "string", "format": "card"},
          
          
          custom_formats={"card": st.sampled_from(EXAMPLE_CARD_NUMBERS)},
      )
  )
  def test_card_numbers(value):
      assert isinstance(value, str)
      assert re.match(r"^\d{4} \d{4} \d{4} \d{4}$", value)
  ```

  For more details on property-based testing and how to use or customise
  strategies, [see the Hypothesis docs](https://hypothesis.readthedocs.io/).

  JSONSchema drafts 04, 05, and 07 are fully tested and working.
  As of version 0.11, this includes resolving non-recursive references!




  `hypothesis-jsonschema` requires Python 3.6 or later.
  In general, 0.x versions will require very recent versions of all dependencies
  because I don't want to deal with compatibility workarounds.

  `hypothesis-jsonschema` may make backwards-incompatible changes at any time
  before version 1.x - that's what semver means! - but I've kept the API surface
  small enough that this should be avoidable.  The main source of breaks will be
  if or when schema that never really worked turn into explicit errors instead
  of generating values that don't quite match.

  You can [sponsor me](https://github.com/sponsors/Zac-HD) to get priority
  support, roadmap input, and prioritized feature development.




  We love external contributions - and try to make them both easy and fun.
  You can [read more details in our contributing guide](https://github.com/Zac-HD/hypothesis-jsonschema/blob/master/CONTRIBUTING.md),
  and [see everyone who has contributed on GitHub](https://github.com/Zac-HD/hypothesis-jsonschema/graphs/contributors).
  Thanks, everyone!




  Patch notes [can be found in `CHANGELOG.md`](https://github.com/Zac-HD/hypothesis-jsonschema/blob/master/CHANGELOG.md).



  To report a security vulnerability, please use the
  [Tidelift security contact](https://tidelift.com/security).
  Tidelift will coordinate the fix and disclosure.


pkgId: cdb7bb47725f9ae82c41862165030b644642317d0473fc9cd3af91b936821f3b
name: python-i3ipc
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: An improved Python library to control i3wm and sway
url: https://github.com/altdesktop/i3ipc-python
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-72a9e91c-cef2-43c5-880b-6a8d26bf0854
location_href: 00003880-python-i3ipc/python-i3ipc-2.2.1-1.src.rpm
checksum_type: sha256
description:
  An improved Python library to control `i3wm <http://i3wm.org>`__ and `sway <https://swaywm.org/>`__.


pkgId: ba5bddc10050286e72f8207193c956ccc53019ffbe62aea2689e5a01c0634eb3
name: python-ibis-bigquery
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: Ibis BigQuery backend
url: https://github.com/ibis-project/ibis-bigquery
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fa1eba5f-d108-4029-a4da-d10e37e61995
location_href: 00013122-python-ibis-bigquery/python-ibis-bigquery-2.2.1-1.src.rpm
checksum_type: sha256
description:
  This package provides a `BigQuery <https://cloud.google.com/bigquery>`_ backend
  for `Ibis <https://ibis-project.org/>`_.


pkgId: 316232ee4dd6444693fb4deb5b853eb6b3382c7f620271194ed48074a5dd011e
name: python-ibm-cloud-sdk-core
arch: src
version: 3.16.5
epoch: 0
release: 1
summary: Core library used by SDKs for IBM Cloud Services
url: https://github.com/IBM/python-sdk-core
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-934e1104-0bb1-4a26-9f0e-9231e4aedf47
location_href: 00011245-python-ibm-cloud-sdk-core/python-ibm-cloud-sdk-core-3.16.5-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://app.travis-ci.com/IBM/python-sdk-core.svg?branch=main)](https://app.travis-ci.com/IBM/python-sdk-core)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ibm-cloud-sdk-core)](https://pypi.org/project/ibm-cloud-sdk-core/)
  [![Latest Stable Version](https://img.shields.io/pypi/v/ibm-cloud-sdk-core.svg)](https://pypi.python.org/pypi/ibm-cloud-sdk-core)
  [![CLA assistant](https://cla-assistant.io/readme/badge/ibm/python-sdk-core)](https://cla-assistant.io/ibm/python-sdk-core)
  [![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)


  This project contains core functionality required by Python code generated by the IBM Cloud OpenAPI SDK Generator
  (openapi-sdkgen).


  The current minimum Python version supported is 3.7.



  To install, use `pip` or `easy_install`:

  ```bash
  pip install --upgrade ibm-cloud-sdk-core
  ```

  or

  ```bash
  easy_install --upgrade ibm-cloud-sdk-core
  ```


  The python-sdk-core project supports the following types of authentication:
  - Basic Authentication
  - Bearer Token Authentication
  - Identity and Access Management (IAM) Authentication
  - Container Authentication
  - VPC Instance Authentication
  - Cloud Pak for Data Authentication
  - No Authentication (for testing)

  For more information about the various authentication types and how to use them with your services, click [here](Authentication.md).



  If you encounter an issue with this project, you are welcome to submit a [bug report](https://github.com/IBM/python-sdk-core/issues).
  Before opening a new issue, please search for similar issues. It's possible that someone has already reported it.





  ```python
  import logging
  logging.basicConfig(level=logging.DEBUG)
  ```

  This would show output of the form:
  ```
  DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): iam.cloud.ibm.com:443
  DEBUG:urllib3.connectionpool:https://iam.cloud.ibm.com:443 "POST /identity/token HTTP/1.1" 200 1809
  DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): gateway.watsonplatform.net:443
  DEBUG:urllib3.connectionpool:https://gateway.watsonplatform.net:443 "POST /assistant/api/v1/workspaces?version=2018-07-10 HTTP/1.1" 201 None
  DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): gateway.watsonplatform.net:443
  DEBUG:urllib3.connectionpool:https://gateway.watsonplatform.net:443 "GET /assistant/api/v1/workspaces/883a2a44-eb5f-4b1a-96b0-32a90b475ea8?version=2018-07-10&export=true HTTP/1.1" 200 None
  DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1): gateway.watsonplatform.net:443
  DEBUG:urllib3.connectionpool:https://gateway.watsonplatform.net:443 "DELETE /assistant/api/v1/workspaces/883a2a44-eb5f-4b1a-96b0-32a90b475ea8?version=2018-07-10 HTTP/1.1" 200 28
  ```


  To get low level information of the requests/ responses:

  ```python
  from http.client import HTTPConnection
  HTTPConnection.debuglevel = 1
  ```



  Find more open source projects on the [IBM Github Page](http://github.com/IBM)



  This library is licensed under Apache 2.0. Full license text is
  available in [LICENSE](LICENSE).



  See [CONTRIBUTING.md](CONTRIBUTING.md).


pkgId: 47f4715691faac4019d7d8c373be40c4ed08fb0d6b904c7001dd1ef3f41f6b51
name: python-ibm-cos-sdk
arch: src
version: 2.13.0
epoch: 0
release: 1
summary: IBM SDK for Python
url: https://github.com/ibm/ibm-cos-sdk-python
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1ab1e975-ab30-42ee-95ee-f3afc8318e60
location_href: 00011091-python-ibm-cos-sdk/python-ibm-cos-sdk-2.13.0-1.src.rpm
checksum_type: sha256
description:
  This package allows Python developers to write software that interacts with [IBM Cloud Object Storage](https://cloud.ibm.com/docs/services/cloud-object-storage/about-cos.html). It is a fork of the [`boto3` library](https://github.com/boto/boto3) and can stand as a drop-in replacement if the application needs to connect to object storage using an S3-like API and does not make use of other AWS services.



  IBM has added a [Language Support Policy](#language-support-policy). Language versions will be deprecated on the published schedule without additional notice.



  * [Core documentation for IBM COS](https://cloud.ibm.com/docs/services/cloud-object-storage/getting-started.html)
  * [Python API reference documentation](https://ibm.github.io/ibm-cos-sdk-python)
  * [REST API reference documentation](https://cloud.ibm.com/docs/services/cloud-object-storage/api-reference/about-api.html)

  For release notes, see the [CHANGELOG](CHANGELOG.md).

  * [Building from Source](#building-from-source)
  * [Getting Help](#getting-help)



  You\'ll need:

  * An instance of COS.
  * An API key from [IBM Cloud Identity and Access Management](https://cloud.ibm.com/docs/iam/users_roles.html) with at least `Writer` permissions.
  * The ID of the instance of COS that you are working with.
  * Token acquisition endpoint.
  * Service endpoint.

  These values can be found in the IBM Cloud Console by [generating a \'service credential\'](https://cloud.ibm.com/docs/services/cloud-object-storage/iam/service-credentials.html).



  Use of the Python SDK and example code can be found [here](https://cloud.ibm.com/docs/cloud-object-storage?topic=cloud-object-storage-python).



  After generating a Service Credential, the resulting JSON document can be saved to `~/.bluemix/cos_credentials`. The SDK will automatically source credentials from this file unless other credentials are explicitly set during client creation. If the cos_credentials file contains HMAC keys the client authenticates with a signature, otherwise the client uses the provided API key to authenticate by using a bearer token (using an API key still requires the `config=Config(signature_version="oauth")` to be included during client creation).



  You can automatically archive objects after a specified length of time or after a specified date. Once archived, a temporary copy of an object can be restored for access as needed. Restore time may take up to 15 hours.

  An archive policy is set at the bucket level by calling the `put_bucket_lifecycle_configuration` method on a client instance. A newly added or modified archive policy applies to new objects uploaded and does not affect existing objects. For more detail, [see the documentation](https://cloud.ibm.com/docs/services/cloud-object-storage/libraries/python.html#python).



  Users can configure buckets with an Immutable Object Storage policy to prevent objects from being modified or deleted for a defined period of time. The retention period can be specified on a per-object basis, or objects can inherit a default retention period set on the bucket. It is also possible to set open-ended and permanent retention periods. Immutable Object Storage meets the rules set forth by the SEC governing record retention, and IBM Cloud administrators are unable to bypass these restrictions. For more detail, [see the IBM Cloud documentation](https://cloud.ibm.com/docs/services/cloud-object-storage/libraries/python.html#python).

  Note: Immutable Object Storage does not support Aspera transfers via the SDK to upload objects or directories at this stage.



  Users can set an archive rule that would allow data restore from an archive in 2 hours or 12 hours.



  Aspera high-speed transfer through the COS SDK using the `cos-aspera` library is now legacy. New users and applications should use the [Aspera Transfer SDK](https://developer.ibm.com/apis/catalog/aspera--aspera-transfer-sdk/Introduction) instead. Existing users should begin new projects with the Aspera Transfer SDK and make plans to migrate existing applications. Users who use S3 for transfers and do not install `cos-aspera` are unaffected.



  Assuming that you have Python and `virtualenv` installed, set up your environment and install the required dependencies like this instead of the `pip install ibm-cos-sdk` defined above:

  ```sh
  git clone https://github.com/ibm/ibm-cos-sdk-python.git
  cd ibm-cos-sdk-python
  $ virtualenv venv
  ...
  . venv/bin/activate
  pip install -r requirements.txt
  pip install -e .
  ```



  Feel free to use GitHub issues for tracking bugs and feature requests, but for help please use one of the following resources:

  * Read a quick start guide in [IBM Cloud Docs](https://cloud.ibm.com/docs/services/cloud-object-storage/libraries/python.html#python).
  * Ask a question on [Stack Overflow](https://stackoverflow.com/) and tag it with `ibm` and `object-storage`.
  * Open a support ticket with [IBM Cloud Support](https://cloud.ibm.com/unifiedsupport/supportcenter/)
  * If it turns out that you may have found a bug, please [open an issue](https://github.com/ibm/ibm-cos-sdk-python/issues/new).



  IBM supports [current public releases](https://devguide.python.org/#status-of-python-branches). IBM will deprecate language versions 90 days after a version reaches end-of-life. All clients will need to upgrade to a supported version before the end of the grace period.



  This SDK is distributed under the [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0), see LICENSE.txt and NOTICE.txt for more information.


pkgId: 7f7831083e94373ee247d3d15e3b602adb67d137d63dae173e9c8b00f8443c6e
name: python-ibm-cos-sdk-core
arch: src
version: 2.13.0
epoch: 0
release: 1
summary: Low-level, data-driven core of IBM SDK for Python
url: https://github.com/ibm/ibm-cos-sdk-python-core
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-816c10d7-2c61-45ee-9ac3-16d673171926
location_href: 00011454-python-ibm-cos-sdk-core/python-ibm-cos-sdk-core-2.13.0-1.src.rpm
checksum_type: sha256
description:
  A low-level interface to IBM Cloud Object Storage based on the `ibm_botocore` package. This core package is the foundation for the [`ibm-cos-sdk-python`](https://github.com/ibm/ibm-cos-sdk-python) package.



  Documentation for `ibm-cos-sdk-python-core` can be found [here](https://ibm.github.io/ibm-cos-sdk-python-core/).



  Feel free to use GitHub issues for tracking bugs and feature requests, but for help please use one of the following resources:

  * Ask a question on [Stack Overflow](https://stackoverflow.com/) and tag it with `ibm` and `object-storage`.
  * Open a support ticket with [IBM Cloud Support](https://cloud.ibm.com/unifiedsupport/supportcenter/)
  * If it turns out that you may have found a bug, please [open an issue](https://github.com/ibm/ibm-cos-sdk-python-core/issues/new)


pkgId: 75e8de12b82f6b271b1d21f621a9c2aa7e83c17cfd19680c12997d010bdd0602
name: python-icecream
arch: src
version: 2.1.3
epoch: 0
release: 1
description: Information and documentation can be found at https://github.com/gruns/icecream.
url: https://github.com/gruns/icecream
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-63979725-ac4b-4bab-9d2b-e048e124d58a
location_href: 00011407-python-icecream/python-icecream-2.1.3-1.src.rpm
checksum_type: sha256
summary:
  Never use print() to debug again; inspect variables, expressions, and program execution with a single, simple function call.


pkgId: ab0b069e62d9e0be5137c3302a60ed6df73b9709c90aac184572f14a6cf5d81f
name: python-icmplib
arch: src
version: 3.0.3
epoch: 0
release: 1
summary: The power to forge ICMP packets and do ping and traceroute.
url: https://github.com/ValentinBELYN/icmplib
rpm_license: GNU Lesser General Public License v3.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e79c38e8-b556-4573-8eac-62dd58126986
location_href: 00014112-python-icmplib/python-icmplib-3.0.3-1.src.rpm
checksum_type: sha256
description:
  <br>
  <img src="https://raw.githubusercontent.com/ValentinBELYN/icmplib/main/media/icmplib-logo.png" height="125" width="100" alt="icmplib">
  <br>

  icmplib is a brand new and modern implementation of the ICMP protocol in Python.<br>
  Use the built-in functions or build your own, you have the choice!

  <br>



  - 🌳 **Ready-to-use:** icmplib offers ready-to-use functions such as the most popular ones: `ping`, `multiping` and `traceroute`. An extensive documentation also helps you get started.
  - 💎 **Modern:** This library uses the latest mechanisms offered by Python 3.6/3.7+ and is fully object-oriented.
  - 🚀 **Fast:** Each class and function has been designed and optimized to deliver the best performance. Some functions are also asynchronous like the `async_ping` and `async_multiping` functions. You can ping the world in seconds!
  - ⚡️ **Powerful:** Use the library without root privileges, set the traffic class of ICMP packets, customize their payload, send broadcast requests and more!
  - 🔩 **Evolutive:** Easily build your own classes and functions with `ICMPv4` and `ICMPv6` sockets.
  - 🔥 **Seamless integration of IPv6:** Use IPv6 the same way you use IPv4.
  - 🍺 **Cross-platform:** Optimized for Linux, macOS and Windows. The library automatically manages the specificities of each system.
  - 🤘 **No dependency:** icmplib is a pure Python implementation of the ICMP protocol. It does not rely on any external dependency.

  <br>



  - **Install icmplib**

    The recommended way to install icmplib is to use `pip3`:

    ```shell
    $ pip3 install icmplib
    ```

    *Since icmplib 3, Python 3.7 or later is required to use the library.*<br>
    *If you are using Python 3.6 and you cannot update it, you can still install icmplib 2.*

  - **Import basic functions**

    ```python
    from icmplib import ping, multiping, traceroute, resolve
    ```

  - **Import asynchronous functions**

    ```python
    from icmplib import async_ping, async_multiping, async_resolve
    ```

  - **Import sockets (advanced)**

    ```python
    from icmplib import ICMPv4Socket, ICMPv6Socket, AsyncSocket, ICMPRequest, ICMPReply
    ```

  - **Import exceptions**

    ```python
    from icmplib import ICMPLibError, NameLookupError, ICMPSocketError
    from icmplib import SocketAddressError, SocketPermissionError
    from icmplib import SocketUnavailableError, SocketBroadcastError, TimeoutExceeded
    from icmplib import ICMPError, DestinationUnreachable, TimeExceeded
    ```

    *Import only what you need.*

  <br>





  Send ICMP Echo Request packets to a network host.

  ```python
  ping(address, count=4, interval=1, timeout=2, id=None, source=None, family=None, privileged=True, **kwargs)
  ```



  - `address`

    The IP address, hostname or FQDN of the host to which messages should be sent. For deterministic behavior, prefer to use an IP address.

    - Type: `str`

  - `count`

    The number of ping to perform.

    - Type: `int`
    - Default: `4`

  - `interval`

    The interval in seconds between sending each packet.

    - Type: `int` or `float`
    - Default: `1`

  - `timeout`

    The maximum waiting time for receiving a reply in seconds.

    - Type: `int` or `float`
    - Default: `2`

  - `id`

    The identifier of ICMP requests. Used to match the responses with requests. In practice, a unique identifier should be used for every ping process. On Linux, this identifier is ignored when the `privileged` parameter is disabled. The library handles this identifier itself by default.

    - Type: `int`
    - Default: `None`

  - `source`

    The IP address from which you want to send packets. By default, the interface is automatically chosen according to the specified destination.

    - Type: `str`
    - Default: `None`

  - `family`

    The address family if a hostname or FQDN is specified. Can be set to `4` for IPv4 or `6` for IPv6 addresses. By default, this function searches for IPv4 addresses first before searching for IPv6 addresses.

    - Type: `int`
    - Default: `None`

  - `privileged`

    When this option is enabled, this library fully manages the exchanges and the structure of ICMP packets. Disable this option if you want to use this function without root privileges and let the kernel handle ICMP headers.

    [Learn more about the `privileged` parameter.](https://github.com/ValentinBELYN/icmplib/blob/main/docs/6-use-icmplib-without-privileges.md)

    *Only available on Unix systems. Ignored on Windows.*

    - Type: `bool`
    - Default: `True`

  - `payload`

    The payload content in bytes. A random payload is used by default.

    - Type: `bytes`
    - Default: `None`

  - `payload_size`

    The payload size. Ignored when the `payload` parameter is set.

    - Type: `int`
    - Default: `56`

  - `traffic_class`

    The traffic class of ICMP packets. Provides a defined level of service to packets by setting the DS Field (formerly TOS) or the Traffic Class field of IP headers. Packets are delivered with the minimum priority by default (Best-effort delivery). Intermediate routers must be able to support this feature.

    *Only available on Unix systems. Ignored on Windows.*

    - Type: `int`
    - Default: `0`



  - A `Host` object containing statistics about the desired destination:<br>
    `address`, `min_rtt`, `avg_rtt`, `max_rtt`, `rtts`, `packets_sent`, `packets_received`, `packet_loss`, `jitter`, `is_alive`



  - `NameLookupError`

    If you pass a hostname or FQDN in parameters and it does not exist or cannot be resolved.

  - `SocketPermissionError`

    If the privileges are insufficient to create the socket.

  - `SocketAddressError`

    If the source address cannot be assigned to the socket.

  - `ICMPSocketError`

    If another error occurs. See the `ICMPv4Socket` or `ICMPv6Socket` class for details.



  ```python
  >>> from icmplib import ping

  >>> host = ping('1.1.1.1', count=10, interval=0.2)

  >>> host.address              # The IP address of the host that responded
  '1.1.1.1'                     # to the request

  >>> host.min_rtt              # The minimum round-trip time in milliseconds
  5.761

  >>> host.avg_rtt              # The average round-trip time in milliseconds
  12.036

  >>> host.max_rtt              # The maximum round-trip time in milliseconds
  16.207

  >>> host.rtts                 # The list of round-trip times expressed in
  [ 11.595, 13.135, 9.614,      # milliseconds
    16.018, 11.960, 5.761,      # The results are not rounded unlike other
    16.207, 11.937, 12.098 ]    # properties

  >>> host.packets_sent         # The number of requests transmitted to the
  10                            # remote host

  >>> host.packets_received     # The number of ICMP responses received from
  9                             # the remote host

  >>> host.packet_loss          # Packet loss occurs when packets fail to
  0.1                           # reach their destination. Returns a float
                                

  >>> host.jitter               # The jitter in milliseconds, defined as the
  4.575                         # variance of the latency of packets flowing
                                

  >>> host.is_alive             # Indicates whether the host is reachable
  True
  ```

  <br>



  Send ICMP Echo Request packets to several network hosts.

  ```python
  multiping(addresses, count=2, interval=0.5, timeout=2, concurrent_tasks=50, source=None, family=None, privileged=True, **kwargs)
  ```



  - `addresses`

    The IP addresses of the hosts to which messages should be sent. Hostnames and FQDNs are allowed but not recommended. You can easily retrieve their IP address by calling the built-in `resolve` function.

    - Type: `list[str]`

  - `count`

    The number of ping to perform per address.

    - Type: `int`
    - Default: `2`

  - `interval`

    The interval in seconds between sending each packet.

    - Type: `int` or `float`
    - Default: `0.5`

  - `timeout`

    The maximum waiting time for receiving a reply in seconds.

    - Type: `int` or `float`
    - Default: `2`

  - `concurrent_tasks`

    The maximum number of concurrent tasks to speed up processing. This value cannot exceed the maximum number of file descriptors configured on the operating system.

    - Type: `int`
    - Default: `50`

  - `source`

    The IP address from which you want to send packets. By default, the interface is automatically chosen according to the specified destinations. This parameter should not be used if you are passing both IPv4 and IPv6 addresses to this function.

    - Type: `str`
    - Default: `None`

  - `family`

    The address family if a hostname or FQDN is specified. Can be set to `4` for IPv4 or `6` for IPv6 addresses. By default, this function searches for IPv4 addresses first before searching for IPv6 addresses.

    - Type: `int`
    - Default: `None`

  - `privileged`

    When this option is enabled, this library fully manages the exchanges and the structure of ICMP packets. Disable this option if you want to use this function without root privileges and let the kernel handle ICMP headers.

    [Learn more about the `privileged` parameter.](https://github.com/ValentinBELYN/icmplib/blob/main/docs/6-use-icmplib-without-privileges.md)

    *Only available on Unix systems. Ignored on Windows.*

    - Type: `bool`
    - Default: `True`

  - `payload`

    The payload content in bytes. A random payload is used by default.

    - Type: `bytes`
    - Default: `None`

  - `payload_size`

    The payload size. Ignored when the `payload` parameter is set.

    - Type: `int`
    - Default: `56`

  - `traffic_class`

    The traffic class of ICMP packets. Provides a defined level of service to packets by setting the DS Field (formerly TOS) or the Traffic Class field of IP headers. Packets are delivered with the minimum priority by default (Best-effort delivery). Intermediate routers must be able to support this feature.

    *Only available on Unix systems. Ignored on Windows.*

    - Type: `int`
    - Default: `0`



  - A list of `Host` objects containing statistics about the desired destinations:<br>
    `address`, `min_rtt`, `avg_rtt`, `max_rtt`, `rtts`, `packets_sent`, `packets_received`, `packet_loss`, `jitter`, `is_alive`

    The list is sorted in the same order as the addresses passed in parameters.



  - `NameLookupError`

    If you pass a hostname or FQDN in parameters and it does not exist or cannot be resolved.

  - `SocketPermissionError`

    If the privileges are insufficient to create the socket.

  - `SocketAddressError`

    If the source address cannot be assigned to the socket.

  - `ICMPSocketError`

    If another error occurs. See the `ICMPv4Socket` or `ICMPv6Socket` class for details.



  ```python
  >>> from icmplib import multiping

  >>> hosts = multiping(['10.0.0.5', '127.0.0.1', '::1'])

  >>> for host in hosts:
  ...     if host.is_alive:
  ...         # See the Host class for details
  ...         print(f'{host.address} is up!')
  ...     else:
  ...         print(f'{host.address} is down!')




  ```

  <br>



  Determine the route to a destination host.

  The Internet is a large and complex aggregation of network hardware, connected together by gateways. Tracking the route one's packets follow can be difficult. This function uses the IP protocol time to live field and attempts to elicit an ICMP Time Exceeded response from each gateway along the path to some host.

  *This function requires root privileges to run.*

  ```python
  traceroute(address, count=2, interval=0.05, timeout=2, first_hop=1, max_hops=30, fast=False, id=None, source=None, family=None, **kwargs)
  ```



  - `address`

    The IP address, hostname or FQDN of the host to reach. For deterministic behavior, prefer to use an IP address.

    - Type: `str`

  - `count`

    The number of ping to perform per hop.

    - Type: `int`
    - Default: `2`

  - `interval`

    The interval in seconds between sending each packet.

    - Type: `int` or `float`
    - Default: `0.05`

  - `timeout`

    The maximum waiting time for receiving a reply in seconds.

    - Type: `int` or `float`
    - Default: `2`

  - `first_hop`

    The initial time to live value used in outgoing probe packets.

    - Type: `int`
    - Default: `1`

  - `max_hops`

    The maximum time to live (max number of hops) used in outgoing probe packets.

    - Type: `int`
    - Default: `30`

  - `fast`

    When this option is enabled and an intermediate router has been reached, skip to the next hop rather than perform additional requests. The `count` parameter then becomes the maximum number of requests in the event of no response.

    - Type: `bool`
    - Default: `False`

  - `id`

    The identifier of ICMP requests. Used to match the responses with requests. In practice, a unique identifier should be used for every traceroute process. The library handles this identifier itself by default.

    - Type: `int`
    - Default: `None`

  - `source`

    The IP address from which you want to send packets. By default, the interface is automatically chosen according to the specified destination.

    - Type: `str`
    - Default: `None`

  - `family`

    The address family if a hostname or FQDN is specified. Can be set to `4` for IPv4 or `6` for IPv6 addresses. By default, this function searches for IPv4 addresses first before searching for IPv6 addresses.

    - Type: `int`
    - Default: `None`

  - `payload`

    The payload content in bytes. A random payload is used by default.

    - Type: `bytes`
    - Default: `None`

  - `payload_size`

    The payload size. Ignored when the `payload` parameter is set.

    - Type: `int`
    - Default: `56`

  - `traffic_class`

    The traffic class of ICMP packets. Provides a defined level of service to packets by setting the DS Field (formerly TOS) or the Traffic Class field of IP headers. Packets are delivered with the minimum priority by default (Best-effort delivery). Intermediate routers must be able to support this feature.

    *Only available on Unix systems. Ignored on Windows.*

    - Type: `int`
    - Default: `0`



  - A list of `Hop` objects representing the route to the desired destination. A `Hop` has the same properties as a `Host` object but it also has a `distance`:<br>
    `address`, `min_rtt`, `avg_rtt`, `max_rtt`, `rtts`, `packets_sent`, `packets_received`, `packet_loss`, `jitter`, `is_alive`, `distance`

    The list is sorted in ascending order according to the distance, in terms of hops, that separates the remote host from the current machine. Gateways that do not respond to requests are not added to this list.



  - `NameLookupError`

    If you pass a hostname or FQDN in parameters and it does not exist or cannot be resolved.

  - `SocketPermissionError`

    If the privileges are insufficient to create the socket.

  - `SocketAddressError`

    If the source address cannot be assigned to the socket.

  - `ICMPSocketError`

    If another error occurs. See the `ICMPv4Socket` or `ICMPv6Socket` class for details.



  ```python
  >>> from icmplib import traceroute

  >>> hops = traceroute('1.1.1.1')

  >>> print('Distance/TTL    Address    Average round-trip time')
  >>> last_distance = 0

  >>> for hop in hops:
  ...     if last_distance + 1 != hop.distance:
  ...         print('Some gateways are not responding')
  ...
  ...     # See the Hop class for details
  ...     print(f'{hop.distance}    {hop.address}    {hop.avg_rtt} ms')
  ...
  ...     last_distance = hop.distance








  ```

  <br>



  Send ICMP Echo Request packets to a network host.

  *This function is non-blocking.*

  ```python
  async_ping(address, count=4, interval=1, timeout=2, id=None, source=None, family=None, privileged=True, **kwargs)
  ```



  The same parameters, return value and exceptions as for the `ping` function.



  ```python
  >>> import asyncio
  >>> from icmplib import async_ping

  >>> async def is_alive(address):
  ...     host = await async_ping(address, count=10, interval=0.2)
  ...     return host.is_alive

  >>> asyncio.run(is_alive('1.1.1.1'))
  True
  ```

  <br>



  Send ICMP Echo Request packets to several network hosts.

  *This function is non-blocking.*

  ```python
  async_multiping(addresses, count=2, interval=0.5, timeout=2, concurrent_tasks=50, source=None, family=None, privileged=True, **kwargs)
  ```



  The same parameters, return values and exceptions as for the `multiping` function.



  ```python
  >>> import asyncio
  >>> from icmplib import async_multiping

  >>> async def are_alive(*addresses):
  ...     hosts = await async_multiping(addresses)
  ...
  ...     for host in hosts:
  ...         if not host.is_alive:
  ...             return False
  ...
  ...     return True

  >>> asyncio.run(are_alive('10.0.0.5', '127.0.0.1', '::1'))
  False
  ```

  <br>



  This page only gives an overview of the features of icmplib.

  To learn more about the built-in functions, on how to create your own and handle exceptions, you can click on the following link:

  - 🚀 [Documentation](https://github.com/ValentinBELYN/icmplib/tree/main/docs)



  Comments and enhancements are welcome.

  All development is done on [GitHub](https://github.com/ValentinBELYN/icmplib). Use [Issues](https://github.com/ValentinBELYN/icmplib/issues) to report problems and submit feature requests. Please include a minimal example that reproduces the bug.



  icmplib is completely free and open source. It has been fully developed on my free time. If you enjoy it, please consider donating to support the development.

  - 🎉 [Donate via PayPal](https://paypal.me/ValentinBELYN)



  Copyright 2017-2021 Valentin BELYN.

  Code released under the GNU LGPLv3 license. See the [LICENSE](https://github.com/ValentinBELYN/icmplib/blob/main/LICENSE) for details.


pkgId: 1f662704c2ce1e32eaf6081280a5bada4239eda10bf19e109f7e90f6a402d7fb
name: python-identify
arch: src
version: 2.5.19
epoch: 0
release: 1
summary: File identification library for Python
url: https://github.com/pre-commit/identify
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-66c0f1e4-2f28-4425-9bd9-d724a34d6e5d
location_href: 00003882-python-identify/python-identify-2.5.19-1.src.rpm
checksum_type: sha256
description:
  File identification library for Python.
  Given a file (or some information about a file), return a set of standardized
  tags identifying what the file is.

  ```bash
  pip install identify
  ```


  If you have an actual file on disk, you can get the most information possible
  (a superset of all other methods):
  ```python
  >>> from identify import identify
  >>> identify.tags_from_path('/path/to/file.py')
  {'file', 'text', 'python', 'non-executable'}
  >>> identify.tags_from_path('/path/to/file-with-shebang')
  {'file', 'text', 'shell', 'bash', 'executable'}
  >>> identify.tags_from_path('/bin/bash')
  {'file', 'binary', 'executable'}
  >>> identify.tags_from_path('/path/to/directory')
  {'directory'}
  >>> identify.tags_from_path('/path/to/symlink')
  {'symlink'}
  ```
  When using a file on disk, the checks performed are:
  * File type (file, symlink, directory, socket)
  * Mode (is it executable?)
  * File name (mostly based on extension)
  * If executable, the shebang is read and the interpreter interpreted

  ```python
  >>> identify.tags_from_filename('file.py')
  {'text', 'python'}
  ```

  ```python
  >>> identify.tags_from_interpreter('python3.5')
  {'python', 'python3'}
  >>> identify.tags_from_interpreter('bash')
  {'shell', 'bash'}
  >>> identify.tags_from_interpreter('some-unrecognized-thing')
  set()
  ```

  ```
  $ identify-cli --help
  usage: identify-cli [-h] [--filename-only] path
  positional arguments:
    path
  optional arguments:
    -h, --help       show this help message and exit
    --filename-only
  ```
  ```console
  $ identify-cli setup.py; echo $?
  ["file", "non-executable", "python", "text"]
  0
  $ identify-cli setup.py --filename-only; echo $?
  ["python", "text"]
  0
  $ identify-cli wat.wat; echo $?
  wat.wat does not exist.
  1
  $ identify-cli wat.wat --filename-only; echo $?
  1
  ```

  `identify` also has an api for determining what type of license is contained
  in a file.  This routine is roughly based on the approaches used by
  [licensee] (the ruby gem that github uses to figure out the license for a
  repo).
  The approach that `identify` uses is as follows:
  1. Strip the copyright line
  2. Normalize all whitespace
  3. Return any exact matches
  4. Return the closest by edit distance (where edit distance < 5%)
  To use the api, install via `pip install identify[license]`
  ```pycon
  >>> from identify import identify
  >>> identify.license_id('LICENSE')
  'MIT'
  ```
  The return value of the `license_id` function is an [SPDX] id.  Currently
  licenses are sourced from [choosealicense.com].
  [licensee]: https://github.com/benbalter/licensee
  [SPDX]: https://spdx.org/licenses/
  [choosealicense.com]: https://github.com/github/choosealicense.com

  A call to `tags_from_path` does this:
  1. What is the type: file, symlink, directory? If it's not file, stop here.
  2. Is it executable? Add the appropriate tag.
  3. Do we recognize the file extension? If so, add the appropriate tags, stop
     here. These tags would include binary/text.
  4. Peek at the first X bytes of the file. Use these to determine whether it is
     binary or text, add the appropriate tag.
  5. If identified as text above, try to read and interpret the shebang, and add
     appropriate tags.
  By design, this means we don't need to partially read files where we recognize
  the file extension.


pkgId: 3a57bf5d92d764476dc257e60b52ea4834a3f1b4deb333a0d26ba321c18661b8
name: python-idle
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: Alternavtive of notepad
url: https://pypi.org/project/idle/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3ff270c3-74de-4e5c-859d-6253cbdb86a6
location_href: 00003883-python-idle/python-idle-1.0.4-1.src.rpm
checksum_type: sha256
description:
  | ![PyPI](https://img.shields.io/pypi/v/idle?style=for-the-badge) | ![PyPI - Format](https://img.shields.io/pypi/format/idle?style=for-the-badge) |
  |------|-----|
  | ![PowerShell Gallery](https://img.shields.io/powershellgallery/p/DNS.1.1.1.1?style=for-the-badge) | ![PyPI - License](https://img.shields.io/pypi/l/idle?style=for-the-badge) |
  | ![Lines of code](https://img.shields.io/tokei/lines/github/devesh01032008/idle?style=for-the-badge) | ![GitHub release (latest by date)](https://img.shields.io/github/v/release/devesh01032008/idle?style=for-the-badge) |

  This is a program written in tkinter which acts as text editor.This can be used to edit file and as alternative of notepad.


  | ![Demo Photo](img/idle-text-editor.jpg) | ![Save Photo](img/save-as-photo.jpg) |
  |------|-------|


  ```

  sudo apt install python3
  pip3 install idle


  pip install idle


  brew install python3
  pip install idle
  ```
  It would automatically launch when it is imported in program and nothing is required to launch this program

  ```
  import idle


  ```


  ![Devesh Sharma](img/devesh.jpeg)

  I am Devesh Sharma.I read in class 9. I live in samalkha,panipat located in India has created this program as alternative of text editor such as notepad
  This program aim to provide a graphical user interface to users which uses python.


  [Github](https://www.github.com/devesh01032008/)<br />
  [Email](mailto:deveshsharma1009@gmail.com)


  ```
                    Licenced
                  © Copyright 2021-22
                  All rights reserved
  ```


pkgId: a1af846b7ca86fb83be28ca7b6edcef2bb1b70b619062feb1be3dfc7dd01ca25
name: python-idna
arch: src
version: 3.4
epoch: 0
release: 1
summary: Internationalized Domain Names in Applications (IDNA)
url: https://pypi.org/project/idna/
rpm_license: None
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-87620a9c-a304-4d1f-aed7-ce3ccb4a17b0
location_href: 00008881-python-idna/python-idna-3.4-1.src.rpm
checksum_type: sha256
description:
  Support for the Internationalized Domain Names in
  Applications (IDNA) protocol as specified in `RFC 5891
  <https://tools.ietf.org/html/rfc5891>`_. This is the latest version of
  the protocol and is sometimes referred to as “IDNA 2008”.
  This library also provides support for Unicode Technical
  Standard 46, `Unicode IDNA Compatibility Processing
  <https://unicode.org/reports/tr46/>`_.
  This acts as a suitable replacement for the “encodings.idna”
  module that comes with the Python standard library, but which
  only supports the older superseded IDNA specification (`RFC 3490
  <https://tools.ietf.org/html/rfc3490>`_).
  Basic functions are simply executed:
      >>> import idna
      >>> idna.encode('ドメイン.テスト')
      b'xn--eckwd4c7c.xn--zckzah'
      >>> print(idna.decode('xn--eckwd4c7c.xn--zckzah'))
      ドメイン.テスト


pkgId: 4d77236b4e33c12fe22858fc3f9e7e59872b180188e745a8682c685ff0c898b6
name: python-ifaddr
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Cross-platform network interface and IP address enumeration library
url: https://github.com/pydron/ifaddr
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2f5f8f29-d6ba-4716-b7e6-b5e3389bca60
location_href: 00003887-python-ifaddr/python-ifaddr-0.2.0-1.src.rpm
checksum_type: sha256
description:
  `ifaddr` is a small Python library that allows you to find all the Ethernet and
  IP addresses of the computer. It is tested on **Linux**, **OS X**, and
  **Windows**. Other BSD derivatives like **OpenBSD**, **FreeBSD**, and
  **NetBSD** should work too, but I haven't personally tested those.
  **Solaris/Illumos** should also work.
  This library is open source and released under the MIT License. It works
  with Python 3.7+.
  You can install it with `pip install ifaddr`. It doesn't need to
  compile anything, so there shouldn't be any surprises. Even on Windows.
  Project links:
  * `ifaddr GitHub page <https://github.com/smurn/ifaddr>`_
  * `ifaddr documentation (although there isn't much to document) <http://pythonhosted.org/ifaddr/>`_


pkgId: 51182c556e20f620f8acb7fa5c8272475b540c09dcaa5338e68c9301676aa871
name: python-igraph
arch: src
version: 0.10.4
epoch: 0
release: 1
summary: High performance graph data structures and algorithms
url: https://igraph.org/python
rpm_license: GNU General Public License (GPL)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-721cb244-e86f-439e-b0ce-89f1d521833d
location_href: 00003889-python-igraph/python-igraph-0.10.4-1.src.rpm
checksum_type: sha256
description:
  Python interface to the igraph high performance graph
  library, primarily aimed at complex network research and analysis.

  Graph plotting functionality is provided by the Cairo library, so make
  sure you install the Python bindings of Cairo if you want to generate
  publication-quality graph plots. You can try either `pycairo
  <http://cairographics.org/pycairo>`_ or `cairocffi <http://cairocffi.readthedocs.io>`_,
  ``cairocffi`` is recommended because there were bug reports affecting igraph
  graph plots in Jupyter notebooks when using ``pycairo`` (but not with
  ``cairocffi``).


pkgId: 6e5ef94d6b3ed484bc8564594ac1d279496909952317b74c1be42e11eb8ac12b
name: python-image
arch: src
version: 1.5.33
epoch: 0
release: 1
url: https://github.com/francescortiz/image
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-19344bae-f685-43bd-8389-b40c99b46d38
location_href: 00010559-python-image/python-image-1.5.33-1.src.rpm
checksum_type: sha256
summary:
  Django application that provides cropping, resizing, thumbnailing, overlays and masking for images and videos with the ability to set the center of attention,

description:
  Django application that provides cropping, resizing, thumbnailing, overlays and masking for images and videos with the ability to set the center of attention,


pkgId: c3408ac479f6dd61a80c34b7d261db110087f5c0c7c070edfe88139f34f2fbe8
name: python-imageio
arch: src
version: 2.27.0
epoch: 0
release: 1
url: https://github.com/imageio/imageio
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6d50f360-db43-4db2-821d-c82dc19dbdde
location_href: 00009076-python-imageio/python-imageio-2.27.0-1.src.rpm
checksum_type: sha256
summary:
  Library for reading and writing a wide range of image, video, scientific, and volumetric data formats.

description:
  .. image:: https://github.com/imageio/imageio/workflows/CI/badge.svg
      :target: https://github.com/imageio/imageio/actions


  Imageio is a Python library that provides an easy interface to read and
  write a wide range of image data, including animated images, volumetric
  data, and scientific formats. It is cross-platform, runs on Python 3.5+,
  and is easy to install.

  Main website: https://imageio.readthedocs.io/


  Release notes: https://github.com/imageio/imageio/blob/master/CHANGELOG.md

  Example:

  .. code-block:: python

      >>> import imageio
      >>> im = imageio.imread('imageio:astronaut.png')
      >>> im.shape  # im is a numpy array
      (512, 512, 3)
      >>> imageio.imwrite('astronaut-gray.jpg', im[:, :, 0])

  See the `API Reference <https://imageio.readthedocs.io/en/stable/reference/index.html>`_
  or `examples <https://imageio.readthedocs.io/en/stable/examples.html>`_
  for more information.


pkgId: 29104c7e77535388368cb3b2bdf44864361d55cfd49ac1cca4527d98b96e0ff4
name: python-imagesize
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: Getting image size from png/jpeg/jpeg2000/gif file
url: https://github.com/shibukawa/imagesize_py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-95f0d86c-d707-4b26-b1ed-832503fdb753
location_href: 00009210-python-imagesize/python-imagesize-1.4.1-1.src.rpm
checksum_type: sha256
description:
  It parses image files' header and return image size.

  * PNG
  * JPEG
  * JPEG2000
  * GIF
  * TIFF
  * SVG
  * Netpbm
  * WebP

  This is a pure Python library.


pkgId: 3c27925aaedcaef4a600b6f0140c57bd8f72708f5d411e11d2f9f070b98c8354
name: python-imbalanced-learn
arch: src
version: 0.10.1
epoch: 0
release: 1
summary: Toolbox for imbalanced dataset in machine learning.
url: https://github.com/scikit-learn-contrib/imbalanced-learn
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-53509055-6e12-4c97-8811-76ab58f59bf8
location_href: 00003894-python-imbalanced-learn/python-imbalanced-learn-0.10.1-1.src.rpm
checksum_type: sha256
description:
  imbalanced-learn is a python package offering a number of re-sampling techniques
  commonly used in datasets showing strong between-class imbalance.
  It is compatible with scikit-learn_ and is part of scikit-learn-contrib_
  projects.


pkgId: e8b14c94e8e092cbeff09e58f055e566bc757b272c88c6d0b1d39d52cdc4392e
name: python-img2pdf
arch: src
version: 0.4.4
epoch: 0
release: 1
summary: Convert images to PDF via direct JPEG inclusion.
url: https://gitlab.mister-muffin.de/josch/img2pdf
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0ccf4310-69e6-4eb8-ba83-5a0ac71283b4
location_href: 00003895-python-img2pdf/python-img2pdf-0.4.4-1.src.rpm
checksum_type: sha256
description:
  Lossless conversion of raster images to PDF. You should use img2pdf if your
  priorities are (in this order):
   1. **always lossless**: the image embedded in the PDF will always have the
      exact same color information for every pixel as the input
   2. **small**: if possible, the difference in filesize between the input image
      and the output PDF will only be the overhead of the PDF container itself
   3. **fast**: if possible, the input image is just pasted into the PDF document
      as-is without any CPU hungry re-encoding of the pixel data
  Conventional conversion software (like ImageMagick) would either:
   1. not be lossless because lossy re-encoding to JPEG
   2. not be small because using wasteful flate encoding of raw pixel data
   3. not be fast because input data gets re-encoded
  Another advantage of not having to re-encode the input (in most common
  situations) is, that img2pdf is able to handle much larger input than other
  software, because the raw pixel data never has to be loaded into memory.
  The following table shows how img2pdf handles different input depending on the
  input file format and image color space.
  | Format                                | Colorspace                     | Result        |
  | ------------------------------------- | ------------------------------ | ------------- |
  | JPEG                                  | any                            | direct        |
  | JPEG2000                              | any                            | direct        |
  | PNG (non-interlaced, no transparency) | any                            | direct        |
  | TIFF (CCITT Group 4)                  | monochrome                     | direct        |
  | any                                   | any except CMYK and monochrome | PNG Paeth     |
  | any                                   | monochrome                     | CCITT Group 4 |
  | any                                   | CMYK                           | flate         |
  For JPEG, JPEG2000, non-interlaced PNG and TIFF images with CCITT Group 4
  encoded data, img2pdf directly embeds the image data into the PDF without
  re-encoding it. It thus treats the PDF format merely as a container format for
  the image data. In these cases, img2pdf only increases the filesize by the size
  of the PDF container (typically around 500 to 700 bytes). Since data is only
  copied and not re-encoded, img2pdf is also typically faster than other
  solutions for these input formats.
  For all other input types, img2pdf first has to transform the pixel data to
  make it compatible with PDF. In most cases, the PNG Paeth filter is applied to
  the pixel data. For monochrome input, CCITT Group 4 is used instead. Only for
  CMYK input no filter is applied before finally applying flate compression.


pkgId: ee60ef189b647e549d52b29742a34e16c8971e5b94413f8290cd509a8e7ab80a
name: python-imgaug
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Image augmentation library for deep neural networks
url: https://github.com/aleju/imgaug
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2d68f12a-33e5-4909-9f15-e9fd61123474
location_href: 00010547-python-imgaug/python-imgaug-0.4.0-1.src.rpm
checksum_type: sha256
description:
  A library for image augmentation in machine learning experiments, particularly convolutional
  neural networks. Supports the augmentation of images, keypoints/landmarks, bounding boxes, heatmaps and segmentation
  maps in a variety of different ways.


pkgId: c1b58334f5715e74d8adec09400b4d5037bd40ab5287ab290564151cf57c35f5
name: python-imgkit
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: Wkhtmltopdf python wrapper to convert html to image using the webkit rendering engine and qt
url: https://github.com/jarrekk/imgkit
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-92bab188-6d55-4ea9-b8ed-15010e59fc27
location_href: 00011679-python-imgkit/python-imgkit-1.2.3-1.src.rpm
checksum_type: sha256
description:
  [![Unit Test](https://github.com/jarrekk/imgkit/actions/workflows/unit_test.yml/badge.svg?branch=master)](https://github.com/jarrekk/imgkit/actions/workflows/unit_test.yml)
  [![codecov](https://codecov.io/gh/jarrekk/imgkit/branch/master/graph/badge.svg?token=pNl4TtuAzz)](https://codecov.io/gh/jarrekk/imgkit)
  [![Codacy Badge](https://app.codacy.com/project/badge/Grade/581cfb2ff94b46aa930f11824703ea88)](https://www.codacy.com/gh/jarrekk/imgkit/dashboard?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=jarrekk/imgkit&amp;utm_campaign=Badge_Grade)
  [![Release](https://github.com/jarrekk/imgkit/actions/workflows/release.yml/badge.svg)](https://github.com/jarrekk/imgkit/actions/workflows/release.yml)
  [![PyPI version](https://badge.fury.io/py/imgkit.svg)](https://badge.fury.io/py/imgkit)

  ```text
    _____   __  __    _____   _  __  _   _
   |_   _| |  \/  |  / ____| | |/ / (_) | |
     | |   | \  / | | |  __  | ' /   _  | |_
     | |   | |\/| | | | |_ | |  <   | | | __|
    _| |_  | |  | | | |__| | | . \  | | | |_
   |_____| |_|  |_|  \_____| |_|\_\ |_|  \__|

  ```

  Python 2 and 3 wrapper for wkhtmltoimage utility to convert HTML to IMG using Webkit.



  1.  Install imgkit:

      ```python
      pip install imgkit
      ```

  1.  Install wkhtmltopdf:

      - Debian/Ubuntu:

        ```bash
        sudo apt-get install wkhtmltopdf
        ```

        **Warning!** Version in debian/ubuntu repos have reduced functionality (because it compiled without the wkhtmltopdf QT patches), such as adding outlines, headers, footers, TOC etc. To use this options you should install static binary from [wkhtmltopdf](http://wkhtmltopdf.org/) site or you can use this [script](https://github.com/jarrekk/imgkit/blob/master/travis/init.sh).

      - MacOSX:

        ```bash
        brew install --cask wkhtmltopdf
        ```

      - Windows and other options:

        Check [wkhtmltopdf homepage](http://wkhtmltopdf.org/) for binary installers or [wiki page](https://github.com/pdfkit/pdfkit/wiki/Installing-WKHTMLTOPDF).



  Simple example:

  ```python
  import imgkit

  imgkit.from_url('http://google.com', 'out.jpg')
  imgkit.from_file('test.html', 'out.jpg')
  imgkit.from_string('Hello!', 'out.jpg')
  ```

  Also you can pass an opened file:

  ```python
  with open('file.html') as f:
      imgkit.from_file(f, 'out.jpg')
  ```

  If you wish to further process generated IMG, you can read it to a variable:

  ```python

  img = imgkit.from_url('http://google.com', False)
  ```

  You can find all wkhtmltoimage options by type `wkhtmltoimage` command or visit this [Manual](https://wkhtmltopdf.org/usage/wkhtmltopdf.txt). You can drop '--' in option name. If option without value, use _None, False_ or _''_ for dict value:. For repeatable options (incl. allow, cookie, custom-header, post, postfile, run-script, replace) you may use a list or a tuple. With option that need multiple values (e.g. --custom-header Authorization secret) we may use a 2-tuple (see example below).

  ```python
  options = {
      'format': 'png',
      'crop-h': '3',
      'crop-w': '3',
      'crop-x': '3',
      'crop-y': '3',
      'encoding': "UTF-8",
      'custom-header' : [
          ('Accept-Encoding', 'gzip')
      ],
      'cookie': [
          ('cookie-name1', 'cookie-value1'),
          ('cookie-name2', 'cookie-value2'),
      ],
      'no-outline': None
  }

  imgkit.from_url('http://google.com', 'out.png', options=options)
  ```

  At some headless servers, perhaps you need to install **xvfb**:

  ```bash

  sudo apt-get install xvfb

  yum install xorg-x11-server-Xvfb
  ```

  Then use **IMGKit** with option **xvfb**: `{"xvfb": ""}`.

  By default, IMGKit will show all `wkhtmltoimage` output. If you don't want it, you need to pass `quiet` option:

  ```python
  options = {
      'quiet': ''
      }

  imgkit.from_url('google.com', 'out.jpg', options=options)
  ```

  Due to wkhtmltoimage command syntax, **TOC** and **Cover** options must be specified separately. If you need cover before TOC, use `cover_first` option:

  ```python
  toc = {
      'xsl-style-sheet': 'toc.xsl'
  }

  cover = 'cover.html'

  imgkit.from_file('file.html', options=options, toc=toc, cover=cover)
  imgkit.from_file('file.html', options=options, toc=toc, cover=cover, cover_first=True)
  ```

  You can specify external CSS files when converting files or strings using _css_ option.

  ```python

  css = 'example.css'
  imgkit.from_file('file.html', options=options, css=css)


  css = ['example.css', 'example2.css']
  imgkit.from_file('file.html', options=options, css=css)
  ```

  You can also pass any options through meta tags in your HTML:

  ```python
  body = """
  <html>
    <head>
      <meta name="imgkit-format" content="png"/>
      <meta name="imgkit-orientation" content="Landscape"/>
    </head>
    Hello World!
  </html>
  """

  imgkit.from_string(body, 'out.png')
  ```



  Each API call takes an optional config paramater. This should be an instance of `imgkit.config()` API call. It takes the config options as initial paramaters. The available options are:

  - `wkhtmltoimage` - the location of the `wkhtmltoimage` binary. By default `imgkit` will attempt to locate this using which` (on UNIX type systems) or where` (on Windows).
  - `xvfb` - the location of the `xvfb-run` binary. By default `imgkit` will attempt to locate this using which` (on UNIX type systems) or where` (on Windows).
  - `meta_tag_prefix` - the prefix for `imgkit` specific meta tags - by default this is `imgkit-`

  Example - for when `wkhtmltopdf` or `xvfb` is not in `$PATH`:

  ```python
  config = imgkit.config(wkhtmltoimage='/opt/bin/wkhtmltoimage', xvfb='/opt/bin/xvfb-run')
  imgkit.from_string(html_string, output_file, config=config)
  ```



  - `IOError: 'No wkhtmltopdf executable found'`:

    Make sure that you have wkhtmltoimage in your `$PATH` or set via custom configuration (see preceding section). _where wkhtmltoimage_ in Windows or _which wkhtmltoimage_ on Linux should return actual path to binary.

  - `IOError: 'No xvfb executable found'`:

    Make sure that you have xvfb-run in your `$PATH` or set via custom configuration (see preceding section). _where xvfb_ in Windows or _which xvfb-run_ or _which Xvfb_ on Linux should return actual path to binary.

  - `IOError: 'Command Failed'`:

    This error means that IMGKit was unable to process an input. You can try to directly run a command from error message and see what error caused failure (on some wkhtmltoimage versions this can be cause by segmentation faults)



  [python PDFKit](https://github.com/JazzCore/python-pdfkit)



  - **jarrekk** <https://github.com/jarrekk>



  - **v-hunt** <https://github.com/v-hunt>
  - **archydeberker** <https://github.com/archydeberker>
  - **arayate** <https://github.com/arayate>
  - **xtrntr** <https://github.com/xtrntr>
  - **mike1703** <https://github.com/mike1703>
  - **themeewa** <https://github.com/themeewa>



  Go to https://github.com/jarrekk/imgkit/wiki/CHANGE-LOG.


pkgId: af288a859553aef592034947bd38d2f726af7488cb62fc67f4b165c9b8260143
name: python-imgtag
arch: src
version: 1.1.6
epoch: 0
release: 1
summary: Simple XMP Image Tag & Metadata Editing Library
url: https://github.com/nimaid/python-imgtag
rpm_license: GNU General Public License v3 (GPLv3)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0232a104-70b1-4929-934d-776055231ee4
location_href: 00012612-python-imgtag/python-imgtag-1.1.6-1.src.rpm
checksum_type: sha256
description:
  It is recomended to install using Conda to create a virtual python environment, as it makes it easy to install and manage different packages. Use the following commands to set up an environment:
  ```
  conda env create -f environment.yml
  conda activate imgtag
  ```

  <br/>

  If you choose to install manually, you must install `exempi` for your OS.

  For Debian:
  ```
  sudo apt-get install -y exempi
  ```
  For a Conda environment:
  ```
  conda install -c conda-forge exempi
  ```

  Once `exempi` is installed, install `imgtag` with:
  ```
  python3 -m pip install -y imgtag
  ```

  <br/>

  To use `imgtag`:
  ```python
  from imgtag import ImgTag


  test = ImgTag(
             filename="test.jpg",   # The image file
             force_case="lower",    # Converts the case of all tags
                                    
                                    
             strip=True,            # Strips whitespace from the ends of all tags
                                    
             no_duplicates=True,    # Removes all duplicate tags (case sensitive)
                                    
             use_warnings=True      # Toggles warnings
                                    
             memory_limit_ratio=0.8 # The maximum percent of free memory to use
                                    
         )


  print("Current tags:")
  for tag in test.get_tags():
      print("  Tag:", tag)


  test.add_tags(["sleepy", "happy"])


  test.remove_tags(["cute"])


  test.set_tags(["dog", "good boy"])


  test.close()


  test.open()


  test.clear_tags()


  del(test)
  ```


pkgId: 12d2970326c7f7ae53c556748b5e75c0b9ed4cfc72ff8d688a87707920f6fc0b
name: python-imgui
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: Cython-based Python bindings for dear imgui
url: https://github.com/swistakm/pyimgui
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-edf854b3-d6c0-4717-82bc-f911ce3b1e02
location_href: 00011886-python-imgui/python-imgui-1.4.1-1.src.rpm
checksum_type: sha256
description:
  [![completion](https://img.shields.io/badge/completion-81%25%20%28375%20of%20460%29-blue.svg)](https://github.com/pyimgui/pyimgui)
  [![Coverage Status](https://coveralls.io/repos/github/swistakm/pyimgui/badge.svg?branch=master)](https://coveralls.io/github/swistakm/pyimgui?branch=master)
  [![Documentation Status](https://readthedocs.org/projects/pyimgui/badge/?version=latest)](https://pyimgui.readthedocs.io/en/latest/?badge=latest)
  [![Build status](https://ci.appveyor.com/api/projects/status/mr97t941p6k4c261/branch/master?svg=true)](https://ci.appveyor.com/project/KinoxKlark/pyimgui/branch/master)




  Python bindings for the amazing
  [dear imgui](https://github.com/ocornut/imgui) C++ library - a Bloat-free
  Immediate Mode Graphical User Interface.

  Documentation: [pyimgui.readthedocs.io](https://pyimgui.readthedocs.io/en/latest/index.html)



  **pyimgui** is available on PyPI so you can easily install it with `pip`:

      pip install imgui[full]

  Above command will install `imgui` package with additional dependencies for all
  built-in rendering backend integrations (pygame, cocos2d, etc.). If you don't
  want to install all additional dependencies you can always use bare
  `pip install imgui` command or select a specific set of extra requirements:

  * for pygame backend use `pip install imgui[pygame]`
  * for GLFW3 backend use `pip install imgui[glfw]`
  * for SDL2 backend use `pip install imgui[sdl2]`
  * for Cocos2d backend use `pip install imgui[cocos2d]`
  * for pyglet backend use `pip install imgui[pyglet]`

  Package is distributed in form of *built wheels* so it does not require
  compilation on most operating systems. For more details about compatibility
  with diffferent OSes and Python versions see the *Project ditribution*
  section of this documentation page.




  The `imgui` package provides support for the majority of core ImGui widgets and
  functionalities. Some low-level API elements and complex widgets (like plots)
  may be missing. We are working hard to provide 100% feature mapping of the core
  ImGui library. The *completion badge* shows up-to-date status of that goal.

  > The current version of *pyimgui* is based on an old version of *DearImgui* and consequently doesn't have its most recent fixes and functionalities. Version 2.0 of *pyimgui* is under development and will support recent features. If you are interested, you can look at the corresponding branch.



  This project has a working build pipeline on Appveyor and Travis. It builds
  succesfully for all major operating systems with different architectures:

  * Windows (32bit & 64bit)
  * Linux (32bit & 64bit)
  * OS X (universal build)

  Right now we are ready to shipping the built wheels for these three systems
  (even for Linux using `manylinux1` wheels). The build pipeline covers multiple
  Python versions:

  * py27
  * py33 (macOS wheel not available on PyPI)
  * py34
  * py35
  * py36
  * py37
  * py38
  * py39


  **pyimgui** provides documentation with multiple visual examples.
  Thanks to custom Sphinx extensions we are able to render GUI examples off
  screen directly from docstring snippets. These examples work also as automated
  functional tests. Documentation is hosted on
  [pyimgui.readthedocs.io](https://pyimgui.readthedocs.io/en/latest/index.html).

  If none of these wheels work in your environment you can install the `imgui`
  package by compiling it directly from sdist distribution using one of following
  commands:

      
      pip install imgui[Cython] --no-binary imgui

      
      pip install imgui --no-binary imgui



  We have tried hard to make the process of bootstrapping this project as simple
  as possible.

  In order to build and install project locally ,ake sure you have created and
  activated virtual environment using `virtualenv` or `python -m venv` (for newer
  Python releases). Then you can just run:

      make build

  This command will bootstrap whole environment (pull git submodules, install
  dev requirements etc.) and build the project. `make` will automatically install
  `imgui` in the *development/editable* mode. Then you can run some examples
  found in the `doc/examples` directory in order to verify if project is working.

  For building documentation and running tests you will need some additional
  requirements from `doc/requirements-test.txt`.

  You can run tests with:

      py.test


  If you have any problems with building or installing the project just ask us
  for help by creating GitHub issue.


pkgId: 3757a5e55ad9f34a6655b648298f8d64465fdd71a00f4ddee7a8cd14df832e19
name: python-imgui-debuginfo
arch: aarch64
version: 1.4.1
epoch: 0
release: 1
summary: Debug information for package python-imgui
url: https://github.com/swistakm/pyimgui
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-edf854b3-d6c0-4717-82bc-f911ce3b1e02
rpm_sourcerpm: python-imgui-1.4.1-1.src.rpm
location_href: 00011886-python-imgui/python-imgui-debuginfo-1.4.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-imgui.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: e8039eeb2e435565804067a31ed847e07ee4b4cf469de9f1543190606c87fdf3
name: python-imgui-debugsource
arch: aarch64
version: 1.4.1
epoch: 0
release: 1
summary: Debug sources for package python-imgui
url: https://github.com/swistakm/pyimgui
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-edf854b3-d6c0-4717-82bc-f911ce3b1e02
rpm_sourcerpm: python-imgui-1.4.1-1.src.rpm
location_href: 00011886-python-imgui/python-imgui-debugsource-1.4.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-imgui.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: a600c75425726741eb11870d584a43b65c6b709ffdaaf857565ead710127381d
name: python-immutables
arch: src
version: 0.19
epoch: 0
release: 1
summary: Immutable Collections
url: https://github.com/MagicStack/immutables
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f1c6a59a-18ae-400d-8f95-ca4a961e011c
location_href: 00009424-python-immutables/python-immutables-0.19-1.src.rpm
checksum_type: sha256
description:
  An immutable mapping type for Python.
  The underlying datastructure is a Hash Array Mapped Trie (HAMT)
  used in Clojure, Scala, Haskell, and other functional languages.
  This implementation is used in CPython 3.7 in the ``contextvars``
  module (see `PEP 550 <https://www.python.org/dev/peps/pep-0550/>`_ and
  `PEP 567 <https://www.python.org/dev/peps/pep-0567/>`_ for more details).
  Immutable mappings based on HAMT have O(log N) performance for both
  ``set()`` and ``get()`` operations, which is essentially O(1) for
  relatively small mappings.
  Below is a visualization of a simple get/set benchmark comparing
  HAMT to an immutable mapping implemented with a Python dict
  copy-on-write approach (the benchmark code is available
  `here <https://gist.github.com/1st1/292e3f0bbe43bd65ff3256f80aa2637d>`_):


pkgId: 8256fab9a3a511c6470117b82e78373a3cd227c0415d844d3a10770f127c1221
name: python-immutables-debuginfo
arch: aarch64
version: 0.19
epoch: 0
release: 1
summary: Debug information for package python-immutables
url: https://github.com/MagicStack/immutables
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-f1c6a59a-18ae-400d-8f95-ca4a961e011c
rpm_sourcerpm: python-immutables-0.19-1.src.rpm
location_href: 00009424-python-immutables/python-immutables-debuginfo-0.19-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-immutables.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 401bfdee196aa3a792cd3a7dc113893c6161c8744dc56d4c202b2cf9cb4e5edf
name: python-immutables-debugsource
arch: aarch64
version: 0.19
epoch: 0
release: 1
summary: Debug sources for package python-immutables
url: https://github.com/MagicStack/immutables
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-f1c6a59a-18ae-400d-8f95-ca4a961e011c
rpm_sourcerpm: python-immutables-0.19-1.src.rpm
location_href: 00009424-python-immutables/python-immutables-debugsource-0.19-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-immutables.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 5018b42a5176fa4962e4d49bc0c2f195888ef9adf72873c1e8cf038770e7da11
name: python-impacket
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: Network protocols Constructors and Dissectors
url: https://www.secureauth.com/labs/open-source-tools/impacket
rpm_license: Apache modified
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ea121f21-059d-456e-9dc0-61a9956d2b51
location_href: 00003898-python-impacket/python-impacket-0.10.0-1.src.rpm
checksum_type: sha256
description:
  [![Latest Version](https://img.shields.io/pypi/v/impacket.svg)](https://pypi.python.org/pypi/impacket/)
  [![Build and test Impacket](https://github.com/SecureAuthCorp/impacket/actions/workflows/build_and_test.yml/badge.svg)](https://github.com/SecureAuthCorp/impacket/actions/workflows/build_and_test.yml)
  SECUREAUTH LABS. Copyright (C) 2022 SecureAuth Corporation. All rights reserved.
  Impacket is a collection of Python classes for working with network
  protocols. Impacket is focused on providing low-level
  programmatic access to the packets and for some protocols (e.g.
  SMB1-3 and MSRPC) the protocol implementation itself.
  Packets can be constructed from scratch, as well as parsed from
  raw data, and the object-oriented API makes it simple to work with
  deep hierarchies of protocols. The library provides a set of tools
  as examples of what can be done within the context of this library.
  A description of some of the tools can be found at
  [SecureAuth Labs' Open Source Website](https://www.secureauth.com/labs/open-source-tools/impacket).


pkgId: 8a85bf656fa386f19ef8030fe936b3ad9815dd240179a72bee410e46f696f55c
name: python-importlab
arch: src
version: 0.8
epoch: 0
release: 1
summary: A library to calculate python dependency graphs.
url: https://github.com/google/importlab
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3a4773df-5051-4dd7-abed-e732af5b14bf
location_href: 00010777-python-importlab/python-importlab-0.8-1.src.rpm
checksum_type: sha256
description:
  Importlab is a library for Python that automatically infers dependencies
  and calculates a dependency graph. It can perform dependency ordering of
  a set of files, including cycle detection.
  Importlab's main use case is to work with static analysis tools that
  process one file at a time, ensuring that a file's dependencies are
  analysed before it is.
  (This is not an official Google product.)


pkgId: 8618fd81c730eeca2177fcbb389abc258ff2818354877567727655e1539b5a4e
name: python-impyla
arch: src
version: 0.18.0
epoch: 0
release: 1
summary: Python client for the Impala distributed query engine
url: https://github.com/cloudera/impyla
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7df10527-bcb4-4aed-b902-d765659a5109
location_href: 00009989-python-impyla/python-impyla-0.18.0-1.src.rpm
checksum_type: sha256
description:
  Python client for HiveServer2 implementations (e.g., Impala, Hive) for
  distributed query engines.

  For higher-level Impala functionality, including a Pandas-like interface over
  distributed data sets, see the [Ibis project][ibis].



  * HiveServer2 compliant; works with Impala and Hive, including nested data

  * Fully [DB API 2.0 (PEP 249)][pep249]-compliant Python client (similar to
  sqlite or MySQL clients) supporting Python 2.6+ and Python 3.3+.

  * Works with Kerberos, LDAP, SSL

  * [SQLAlchemy][sqlalchemy] connector

  * Converter to [pandas][pandas] `DataFrame`, allowing easy integration into the
  Python data stack (including [scikit-learn][sklearn] and
  [matplotlib][matplotlib]); but see the [Ibis project][ibis] for a richer
  experience



  Required:

  * Python 2.7+ or 3.5+

  * `six`, `bitarray`

  * `thrift==0.16.0`

  * `thrift_sasl==0.4.3`

  Optional:

  * `kerberos>=1.3.0` for Kerberos over HTTP support. This also requires Kerberos libraries
     to be installed on your system - see [System Kerberos](#system-kerberos)

  * `pandas` for conversion to `DataFrame` objects; but see the [Ibis project][ibis] instead

  * `sqlalchemy` for the SQLAlchemy engine

  * `pytest` for running tests; `unittest2` for testing on Python 2.6




  Different systems require different packages to be installed to enable Kerberos support in
  Impyla. Some examples of how to install the packages on different distributions follow.

  Ubuntu:
  ```bash
  apt-get install libkrb5-dev krb5-user
  ```

  RHEL/CentOS:
  ```bash
  yum install krb5-libs krb5-devel krb5-server krb5-workstation
  ```



  Install the latest release with `pip`:

  ```bash
  pip install impyla
  ```

  For the latest (dev) version, install directly from the repo:

  ```bash
  pip install git+https://github.com/cloudera/impyla.git
  ```

  or clone the repo:

  ```bash
  git clone https://github.com/cloudera/impyla.git
  cd impyla
  python setup.py install
  ```



  impyla uses the [pytest][pytest] toolchain, and depends on the following
  environment variables:

  ```bash
  export IMPYLA_TEST_HOST=your.impalad.com
  export IMPYLA_TEST_PORT=21050
  export IMPYLA_TEST_AUTH_MECH=NOSASL
  ```

  To run the maximal set of tests, run

  ```bash
  cd path/to/impyla
  py.test --connect impala
  ```

  Leave out the `--connect` option to skip tests for DB API compliance.




  Impyla implements the [Python DB API v2.0 (PEP 249)][pep249] database interface
  (refer to it for API details):

  ```python
  from impala.dbapi import connect
  conn = connect(host='my.host.com', port=21050)
  cursor = conn.cursor()
  cursor.execute('SELECT * FROM mytable LIMIT 100')
  print cursor.description  # prints the result set's schema
  results = cursor.fetchall()
  ```

  The `Cursor` object also exposes the iterator interface, which is buffered
  (controlled by `cursor.arraysize`):

  ```python
  cursor.execute('SELECT * FROM mytable LIMIT 100')
  for row in cursor:
      print(row)
  ```

  Furthermore the `Cursor` object returns you information about the columns
  returned in the query. This is useful to export your data as a csv file.

  ```python
  import csv

  cursor.execute('SELECT * FROM mytable LIMIT 100')
  columns = [datum[0] for datum in cursor.description]
  targetfile = '/tmp/foo.csv'

  with open(targetfile, 'w', newline='') as outcsv:
      writer = csv.writer(outcsv, delimiter=',', quotechar='"', quoting=csv.QUOTE_ALL, lineterminator='\n')
      writer.writerow(columns)
      for row in cursor:
          writer.writerow(row)
  ```

  You can also get back a pandas DataFrame object

  ```python
  from impala.util import as_pandas
  df = as_pandas(cur)

  ```


  [pep249]: http://legacy.python.org/dev/peps/pep-0249/
  [pandas]: http://pandas.pydata.org/
  [sklearn]: http://scikit-learn.org/
  [matplotlib]: http://matplotlib.org/
  [pytest]: http://pytest.org/latest/
  [sqlalchemy]: http://www.sqlalchemy.org/
  [ibis]: http://www.ibis-project.org/


  You need to first sign and return an
  [ICLA](https://github.com/cloudera/native-toolchain/blob/icla/Cloudera%20ICLA_25APR2018.pdf)
  and
  [CCLA](https://github.com/cloudera/native-toolchain/blob/icla/Cloudera%20CCLA_25APR2018.pdf)
  before we can accept and redistribute your contribution. Once these are submitted you are
  free to start contributing to impyla. Submit these to CLA@cloudera.com.


  We use Github issues to track bugs for this project. Find an issue that you would like to
  work on (or file one if you have discovered a new issue!). If no-one is working on it,
  assign it to yourself only if you intend to work on it shortly.

  It's a good idea to discuss your intended approach on the issue. You are much more
  likely to have your patch reviewed and committed if you've already got buy-in from the
  impyla community before you start.


  Now start coding! As you are writing your patch, please keep the following things in mind:

  First, please include tests with your patch. If your patch adds a feature or fixes a bug
  and does not include tests, it will generally not be accepted. If you are unsure how to
  write tests for a particular component, please ask on the issue for guidance.

  Second, please keep your patch narrowly targeted to the problem described by the issue.
  It's better for everyone if we maintain discipline about the scope of each patch. In
  general, if you find a bug while working on a specific feature, file a issue for the bug,
  check if you can assign it to yourself and fix it independently of the feature. This helps
  us to differentiate between bug fixes and features and allows us to build stable
  maintenance releases.

  Finally, please write a good, clear commit message, with a short, descriptive title and
  a message that is exactly long enough to explain what the problem was, and how it was
  fixed.

  Please create a pull request on github with your patch.


pkgId: 1198908b44c34053f72a08984a5ac4c1a2549309c459589109d1597d37b0c7e6
name: python-incremental
arch: src
version: 22.10.0
epoch: 0
release: 1
summary: "A small library that versions your Python projects."
url: https://github.com/twisted/incremental
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b5cc16ae-e64c-4481-8d9b-b4749eb89280
location_href: 00009360-python-incremental/python-incremental-22.10.0-1.src.rpm
checksum_type: sha256
description:
  |gha|
  |pypi|
  |coverage|
  Incremental is a small library that versions your Python projects.
  API documentation can be found `here <https://twisted.github.io/incremental/docs/>`_.


pkgId: 1f71c5d26960b121802cc345e5e877cf34201c7602167392875e0b4584c3e3e4
name: python-indexed-gzip
arch: src
version: 1.7.0
epoch: 0
release: 1
summary: Fast random access of gzip files in Python
url: https://github.com/pauldmccarthy/indexed_gzip
rpm_license: zlib
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-72d2dd16-9aea-4564-94c8-c6888eb9af3c
location_href: 00003900-python-indexed_gzip/python-indexed-gzip-1.7.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPi version](https://img.shields.io/pypi/v/indexed_gzip.svg)](https://pypi.python.org/pypi/indexed_gzip/) [![Anaconda version](https://anaconda.org/conda-forge/indexed_gzip/badges/version.svg)](https://anaconda.org/conda-forge/indexed_gzip/)![Test status](https://github.com/pauldmccarthy/indexed_gzip/actions/workflows/master.yaml/badge.svg)


   *Fast random access of gzip files in Python*


   * [Overview](#overview)
   * [Installation](#installation)
   * [Usage](#usage)
   * [Using with `nibabel`](#using-with-nibabel)
   * [Index import/export](#index-import-export)
   * [Write support](#write-support)
   * [Performance](#performance)
   * [Acknowledgements](#acknowledgements)
   * [License](#license)





  The `indexed_gzip` project is a Python extension which aims to provide a
  drop-in replacement for the built-in Python `gzip.GzipFile` class, the
  `IndexedGzipFile`.


  `indexed_gzip` was written to allow fast random access of compressed
  [NIFTI](http://nifti.nimh.nih.gov/) image files (for which GZIP is the
  de-facto compression standard), but will work with any GZIP file.
  `indexed_gzip` is easy to use with `nibabel` (http://nipy.org/nibabel/).


  The standard `gzip.GzipFile` class exposes a random access-like interface (via
  its `seek` and `read` methods), but every time you seek to a new point in the
  uncompressed data stream, the `GzipFile` instance has to start decompressing
  from the beginning of the file, until it reaches the requested location.


  An `IndexedGzipFile` instance gets around this performance limitation by
  building an index, which contains *seek points*, mappings between
  corresponding locations in the compressed and uncompressed data streams. Each
  seek point is accompanied by a chunk (32KB) of uncompressed data which is used
  to initialise the decompression algorithm, allowing us to start reading from
  any seek point. If the index is built with a seek point spacing of 1MB, we
  only have to decompress (on average) 512KB of data to read from any location
  in the file.





  You may find `indexed_gzip` useful if you need to read from large GZIP files.
  A major advantage of `indexed_gzip` is that it will work with any GZIP file.
  However, if you have control over the creation of your GZIP files, you may
  wish to consider some alternatives:

   * [`mgzip`](https://github.com/vinlyx/mgzip/) provides an accelerated
     GZIP compression and decompression library.
   * Compression formats other than GZIP, such as `bzip2` and `xz`, have better
     support for random access.





  `indexed_gzip` is available on [PyPi](https://pypi.python.org/pypi) - to
  install, simply type:
  ```sh
  pip install indexed_gzip
  ```


  You can also install `indexed_gzip` from conda-forge:

  ```sh
  conda install -c conda-forge indexed_gzip
  ```

  To compile `indexed_gzip`, make sure you have [cython](http://cython.org/)
  installed (and `numpy` if you want to compile the tests), and then run:
  ```sh
  python setup.py develop
  ```


  To run the tests, type the following; you will need `numpy`, `nibabel`,
  `pytest`, `pytest-cov`, and `coverage` installed:

  ```sh
  python -m indexed_gzip.tests
  ```




  You can use the `indexed_gzip` module directly:


  ```python
  import indexed_gzip as igzip






  myfile = igzip.IndexedGzipFile('big_file.gz')

  some_offset_into_uncompressed_data = 234195



  myfile.seek(some_offset_into_uncompressed_data)
  data = myfile.read(1048576)
  ```




  You can use `indexed_gzip` with any Python file-like object. For example:

  ```python

  import io
  import indexed_gzip as igzip


  with open('my_file.gz') as f:
      data = f.read()



  gzf = igzip.IndexedGzipFile(fileobj=io.BytesIO(data))
  uncompressed = gzf.read(1048576)
  ```





  You can use `indexed_gzip` with `nibabel`. `nibabel` >= 2.3.0 will
  automatically use `indexed_gzip` if it is present:


  ```python
  import nibabel as nib

  image = nib.load('big_image.nii.gz')
  ```


  If you are using `nibabel` 2.2.x, you need to explicitly set the
  `keep_file_open` flag:


  ```python
  import nibabel as nib

  image = nib.load('big_image.nii.gz', keep_file_open='auto')
  ```


  To use `indexed_gzip` with `nibabel` 2.1.0 or older, you need to do a little
  more work:


  ```python
  import nibabel      as nib
  import indexed_gzip as igzip




  fobj = igzip.IndexedGzipFile(
      filename='big_image.nii.gz',
      spacing=4194304,
      readbuf_size=131072)



  fmap = nib.Nifti1Image.make_file_map()
  fmap['image'].fileobj = fobj
  image = nib.Nifti1Image.from_file_map(fmap)




  vol3 = image.dataobj[:, :, :, 3]
  ```





  If you have a large file, you may wish to pre-generate the index once, and
  save it out to an index file:


  ```python
  import indexed_gzip as igzip



  fobj = igzip.IndexedGzipFile('big_file.gz')
  fobj.build_full_index()
  fobj.export_index('big_file.gzidx')
  ```


  The next time you open the same file, you can load in the index:


  ```python
  import indexed_gip as igzip
  fobj = igzip.IndexedGzipFile('big_file.gz', index_file='big_file.gzidx')
  ```





  `indexed_gzip` does not currently have any support for writing. Currently if
  you wish to write to a file, you will need to save the file by alternate means
  (e.g.  via `gzip` or `nibabel`), and then re-create a new `IndexedGzipFile`
  instance.  For example:


  ```python

  import nibabel as nib


  image = nib.load('big_image.nii.gz')
  data = image.get_data()


  data[:, :, :, 5] *= 100


  nib.save(data, 'big_image.nii.gz')


  image = nib.load('big_image.nii.gz')
  ```





  A small [test script](indexed_gzip/tests/benchmark.py) is included with
  `indexed_gzip`; this script compares the performance of the `IndexedGzipFile`
  class with the `gzip.GzipFile` class. This script does the following:

    1. Generates a test file.

    2. Generates a specified number of seek locations, uniformly spaced
       throughout the test file.

    3. Randomly shuffles these locations

    4. Seeks to each location, and reads a chunk of data from the file.


  This plot shows the results of this test for a few compresed files of varying
  sizes, with 500 seeks:


  ![Indexed gzip performance](./performance.png)





  The `indexed_gzip` project is based upon the `zran.c` example (written by Mark
  Alder) which ships with the [zlib](http://www.zlib.net/) source code.


  `indexed_gzip` was originally inspired by Zalan Rajna's (@zrajna)
  [zindex](https://github.com/zrajna/zindex) project:

      Z. Rajna, A. Keskinarkaus, V. Kiviniemi and T. Seppanen
      "Speeding up the file access of large compressed NIfTI neuroimaging data"
      Engineering in Medicine and Biology Society (EMBC), 2015 37th Annual
      International Conference of the IEEE, Milan, 2015, pp. 654-657.

      https://sourceforge.net/projects/libznzwithzindex/


  Initial work on `indexed_gzip` took place at
  [Brainhack](http://www.brainhack.org/) Paris, at the Institut Pasteur,
  24th-26th February 2016, with the support of the
  [FMRIB Centre](https://www.ndcn.ox.ac.uk/divisions/fmrib/), at the
  University of Oxford, UK.

  Many thanks to the following contributors (listed chronologically):

   - Zalan Rajna (@zrajna): Bug fixes (#2)
   - Martin Craig (@mcraig-ibme): Porting `indexed_gzip` to Windows (#3)
   - Chris Markiewicz (@effigies): Option to drop file handles (#6)
   - Omer Ozarslan (@ozars): Index import/export (#8)
   - @DarioDaF: Windows overflow bug (#30)
   - Sławomir Zborowski (@szborows): `seek_points` method (#35), README fixes
     (#34)
   - Ashwin Ramaswami (@epicfaace): Support for in-memory file objects (#55),
     bug fixes (#63, #64, #65).
   - Michał Górny (@mgorny): Remove hard dependency on `nibabel` from test suite
     (#78).
   - Alexander Gorban (@alexgorban) Fix memory leak (#82, #83).
   - Maximilian Knespel (@mxmlnkn) Change default read buffer size to
     improve performance (#90).





  `indexed_gzip` inherits the [zlib](http://www.zlib.net) license, available for
  perusal in the [LICENSE](LICENSE) file.


pkgId: f8342cd627e1301c98af588fdbdd708fa4c71ad1501e46cb493bd8a7469a606c
name: python-inema
arch: src
version: 0.8.7
epoch: 0
release: 1
summary: A Python interface to the Deutsche Post Internetmarke and Warenpost International Online Franking
url: https://git.sysmocom.de/odoo/python-inema/
rpm_license: AGPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6d7b9a68-7d07-48b9-a8af-9cee0cef50d8
location_href: 00003901-python-inema/python-inema-0.8.7-1.src.rpm
checksum_type: sha256
description:
  This is a python module for interfacing the "Internetmarke" API provided
  by the German postal company "Deutsche Post".  It implements V3 of this
  API.  It also implements the new (2020) "Warenpost International API".
  The Internetmarke API allows you to buy online franking for national and
  international postal products like post cards and letters of all weight
  classes and service classes (normal, registered, ...).


pkgId: 545fc575fd81856c698c48d1f7b12a0212b065f793770ea8aa3577c587a838bd
name: python-inflection
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: A port of Ruby on Rails inflector to Python
url: https://github.com/jpvanhal/inflection
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eacd581f-2500-442b-a592-85a513592bfe
location_href: 00003903-python-inflection/python-inflection-0.5.1-1.src.rpm
checksum_type: sha256
description:
  |build status|_
  Inflection is a string transformation library.  It singularizes and pluralizes
  English words, and transforms strings from CamelCase to underscored string.
  Inflection is a port of `Ruby on Rails`_' `inflector`_ to Python.


pkgId: 564e3fbc6dd5e89d0f0cbea631292b7dd6fd53412546977400baf8d0f4939f33
name: python-influxdb
arch: src
version: 5.3.1
epoch: 0
release: 1
summary: InfluxDB client
url: https://github.com/influxdb/influxdb-python
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3e5f8b8d-da90-4775-8cbd-62ef94918b2e
location_href: 00003904-python-influxdb/python-influxdb-5.3.1-1.src.rpm
checksum_type: sha256
description:
  InfluxDB-Python is a client for interacting with InfluxDB_.
  Development of this library is maintained by:
  +-----------+-------------------------------+
  | Github ID | URL                           |
  +===========+===============================+
  | @aviau    | (https://github.com/aviau)    |
  +-----------+-------------------------------+
  | @xginn8   | (https://github.com/xginn8)   |
  +-----------+-------------------------------+
  | @sebito91 | (https://github.com/sebito91) |
  +-----------+-------------------------------+
  InfluxDB is an open-source distributed time series database, find more about InfluxDB_ at https://docs.influxdata.com/influxdb/latest


pkgId: bc6c74f5c66252dd0ccd095dfb2ff21d09e902245507876b0f0571ee3c7a3a2c
name: python-iniparse
arch: src
version: 0.5
epoch: 0
release: 1
summary: Accessing and Modifying INI files
url: https://github.com/candlepin/python-iniparse
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-56308390-57ed-4b32-9ade-19306d749643
location_href: 00012218-python-iniparse/python-iniparse-0.5-1.src.rpm
checksum_type: sha256
description:
  iniparse is an INI parser for Python which is API compatible
  with the standard library's ConfigParser, preserves structure of INI
  files (order of sections & options, indentation, comments, and blank
  lines are preserved when data is updated), and is more convenient to
  use.


pkgId: eb79557183ecc23c70c7a491aa3e5a0f1de7ba1b7d145ff859b6bed968291df9
name: python-inotify-simple
arch: src
version: 1.3.5
epoch: 0
release: 1
url: https://github.com/chrisjbillington/inotify_simple
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-85968cb2-741c-4438-9f21-efbe3f33e35d
location_href: 00003908-python-inotify_simple/python-inotify-simple-1.3.5-1.src.rpm
checksum_type: sha256
summary:
  A simple wrapper around inotify. No fancy bells and whistles, just a literal wrapper with ctypes. Under 100 lines of code!

description:
  `inotify_simple` is a simple Python wrapper around
  [inotify](http://man7.org/linux/man-pages/man7/inotify.7.html).
  No fancy bells and whistles, just a literal wrapper with ctypes. Only  \~100
  lines of code!

  `inotify_init1()` is wrapped as a file-like object, `INotify()`, holding the inotify
  file descriptor. `INotify().read()` reads available data from the file descriptor and
  returns events as `namedtuple` objects after unpacking them with the `struct` module.
  `inotify_add_watch()` and `inotify_rm_watch()` are wrapped with no changes at all,
  taking and returning watch descriptor integers that calling code is expected to keep
  track of itself, just as one would use `inotify` from C. Works with Python 2.7 and
  Python >= 3.2.

  [View on PyPI](http://pypi.python.org/pypi/inotify_simple) |
  [Fork me on github](https://github.com/chrisjbillington/inotify_simple) |
  [Read the docs](http://inotify_simple.readthedocs.org)




  to install `inotify_simple`, run:

  ```
  $ pip3 install inotify_simple
  ```

  or to install from source:

  ```
  $ python3 setup.py install
  ```

  Note:  If on Python < 3.4, you'll need the backported [enum34
  module](https://pypi.python.org/pypi/enum34).



  There are many inotify python wrappers out there. [I found them all
  unsatisfactory](https://xkcd.com/927/). Most are far too high-level for my
  tastes, and the supposed convenience they provide actually limits one from
  using inotify in ways other than those the author imagined. Others are C
  extensions, requiring compilation for different platforms and Python versions,
  rather than a pure python module using ctypes. This one is pretty low-level
  and really just does what inotify itself does and nothing more. So hopefully
  if I've written it right, it will remain functional well into the future with
  no changes, recompilation or attention on my part.



  ```python
  import os
  from inotify_simple import INotify, flags

  os.mkdir('/tmp/inotify_test')

  inotify = INotify()
  watch_flags = flags.CREATE | flags.DELETE | flags.MODIFY | flags.DELETE_SELF
  wd = inotify.add_watch('/tmp/inotify_test', watch_flags)


  os.chdir('/tmp/inotify_test')

  os.system('mkdir foo')

  os.system('echo hello > test.txt')

  os.system('echo world >> test.txt')

  os.system('rm test.txt')

  os.system('rmdir foo')
  os.chdir('/tmp')


  os.system('rmdir inotify_test')


  for event in inotify.read():
      print(event)
      for flag in flags.from_mask(event.mask):
          print('    ' + str(flag))
  ```

  This outputs the following:
  ```
  Event(wd=1, mask=1073742080, cookie=0, name=u'foo')
      flags.CREATE
      flags.ISDIR
  Event(wd=1, mask=256, cookie=0, name=u'test.txt')
      flags.CREATE
  Event(wd=1, mask=2, cookie=0, name=u'test.txt')
      flags.MODIFY
  Event(wd=1, mask=512, cookie=0, name=u'test.txt')
      flags.DELETE
  Event(wd=1, mask=1073742336, cookie=0, name=u'foo')
      flags.DELETE
      flags.ISDIR
  Event(wd=1, mask=1024, cookie=0, name=u'')
      flags.DELETE_SELF
  Event(wd=1, mask=32768, cookie=0, name=u'')
      flags.IGNORED
  ```

  Note that the flags, since they are defined with an `enum.IntEnum`, print as
  what they are called rather than their integer values. However they are still
  just integers and so can be bitwise-ANDed and ORed etc with masks etc. The
  `flags.from_mask()` method bitwise-ANDs a mask with all possible flags and
  returns a list of matches. This is for convenience and useful for debugging
  which events are coming through, but performance critical code should
  generally bitwise-AND masks with flags of interest itself so as to not do
  unnecessary checks.

  [See here](http://inotify_simple.readthedocs.org) for more.


pkgId: 01626fe64c2dd979b2c918c84fec18fb1397115c32790f2417a69fb3bd3d4395
name: python-inspecta
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: A colorized object pretty printer - for Python.
url: https://github.com/grimen/python-inspecta
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8af9c9fe-7669-4bbb-9236-3f657ecc3659
location_href: 00012845-python-inspecta/python-inspecta-0.1.3-1.src.rpm
checksum_type: sha256
description:
  *A colorized object pretty printer - for Python.*



  The default `pprint` is not human friendly enough - color syntax highlighting to the rescue.




  Install using **pip**:

  ```sh
  $ pip install inspecta
  ```




  Very basic **[example](https://github.com/grimen/python-inspecta/tree/master/examples/basic.py)**:

  ```python
  import inspecta

  data = {
      'foo': {
          'bar': {
              'baz': [
                  {
                      'a': 1,
                      'b': 'two',
                      'c': ('three', 4, 'five')
                  }
              ]
          }
      },
      'bar': [1, 2, 3],
      'baz': True
  }

  print('\n.inspect(data)\n')

  print(inspecta.inspect(data))

  print('\n.print(data)\n')

  inspecta.print(data)
  ```

  Run this with optional environment variables `COLORS` / `ERROR_COLORS` set too truthy or falsy values, so see various error info formatting in terminal.

  Something like this (imagine some colorized formatting):

  ```bash

  .inspect(data)

  {   'bar': [1, 2, 3],
      'baz': True,
      'foo': {'bar': {'baz': [{'a': 1, 'b': 'two', 'c': ('three', 4, 'five')}]}}}


  .print(data)

  {   'bar': [1, 2, 3],
      'baz': True,
      'foo': {'bar': {'baz': [{'a': 1, 'b': 'two', 'c': ('three', 4, 'five')}]}}}


  ```




  Clone down source code:

  ```sh
  $ make install
  ```

  Run **colorful tests**, with only native environment (dependency sandboxing up to you):

  ```sh
  $ make test
  ```

  Run **less colorful tests**, with **multi-environment** (using **tox**):

  ```sh
  $ make test-tox
  ```




  This project was mainly initiated - in lack of solid existing alternatives - to be used at our work at **[Markable.ai](https://markable.ai)** to have common code conventions between various programming environments where **Python** (research, CV, AI) is heavily used.




  Released under the MIT license.


pkgId: e97464f32746a59304eb07bcd94a625f5e25c59ece437ffb0da7af0e69b27e46
name: python-instagrapi
arch: src
version: 1.17.3
epoch: 0
release: 1
summary: Fast and effective Instagram Private API wrapper
url: https://github.com/adw0rd/instagrapi
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f8c979e4-81ef-492d-9ea4-5db0ddbf308b
location_href: 00013471-python-instagrapi/python-instagrapi-1.17.3-1.src.rpm
checksum_type: sha256
description:
  Fast and effective Instagram Private API wrapper (public+private requests and challenge resolver).

  Use the most recent version of the API from Instagram.

  Features:

  1. Performs Public API (web, anonymous) or Private API (mobile app, authorized)
     requests depending on the situation (to avoid Instagram limits)
  2. Challenge Resolver have Email (as well as recipes for automating receive a code from email) and SMS handlers
  3. Support upload a Photo, Video, IGTV, Clips (Reels), Albums and Stories
  4. Support work with User, Media, Insights, Collections, Location (Place), Hashtag and Direct objects
  5. Like, Follow, Edit account (Bio) and much more else
  6. Insights by account, posts and stories
  7. Build stories with custom background, font animation, swipe up link and mention users
  8. In the next release, account registration and captcha passing will appear


pkgId: 07ca3aa9e76379a7724212c68d79f7594a8257f73bf74ce493b7d3f3372fae1a
name: python-install
arch: src
version: 1.3.5
epoch: 0
release: 1
summary: Install packages from within code
url: https://github.com/eugenekolo/pip-install
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-36916aac-d47c-4c00-91eb-c4f0e7307288
location_href: 00010275-python-install/python-install-1.3.5-1.src.rpm
checksum_type: sha256
description:
  A package to install pip packages from within code.

  Requires Python 2.7+, 3.5+

  Usage:
  ```
  import install
  install.install('pkg_you_want')


  install.install('requirements.txt', requirements=True)


  install.install('my_pkg', pip_options=['--isolated'], install_options=['--no-clean', '--pre'])
  ```


pkgId: 3ea042901e8e0a90a85847c6d14490b3271b4609f5d41d265e6b2a44af497c45
name: python-instaloader
arch: src
version: 4.9.6
epoch: 0
release: 1
summary: Download pictures (or videos) along with their captions and other metadata from Instagram.
url: https://instaloader.github.io/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f86d60b8-aa0d-4032-9b2a-bbf6d80b212e
location_href: 00012768-python-instaloader/python-instaloader-4.9.6-1.src.rpm
checksum_type: sha256
description:
  To **download all pictures and videos of a profile**, as well as the
  **profile picture**, do
      instaloader profile [profile ...]
  where ``profile`` is the name of a profile you want to download. Instead
  of only one profile, you may also specify a list of profiles.
  To later **update your local copy** of that profiles, you may run
      instaloader --fast-update profile [profile ...]
  If ``--fast-update`` is given, Instaloader stops when arriving at the
  first already-downloaded picture.
  Alternatively, you can use ``--latest-stamps`` to have Instaloader store
  the time each profile was last downloaded and only download newer media:
      instaloader --latest-stamps -- profile [profile ...]
  With this option it's possible to move or delete downloaded media and still keep
  the archive updated.
  When updating profiles, Instaloader
  automatically **detects profile name changes** and renames the target directory
  accordingly.
  Instaloader can also be used to **download private profiles**. To do so,
  invoke it with
      instaloader --login=your_username profile [profile ...]
  When logging in, Instaloader **stores the session cookies** in a file in your
  temporary directory, which will be reused later the next time ``--login``
  is given.  So you can download private profiles **non-interactively** when you
  already have a valid session cookie file.
  `Instaloader Documentation <https://instaloader.github.io/basic-usage.html>`__


pkgId: 5e7acb6340f29b1084fb75b3e7d2d15755c944bc16c10a79014b0b1cb927fb4d
name: python-instana
arch: src
version: 1.38.2
epoch: 0
release: 1
summary: 🐍 Python Distributed Tracing & Metrics Sensor for Instana
url: https://www.instana.com/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-316f9347-7d49-46bf-9b95-b98e1251ff49
location_href: 00009726-python-instana/python-instana-1.38.2-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
  <img src="https://disznc.s3.amazonaws.com/python-dashboard-2019.gif"/>
  </div>



  The `instana` Python package collects key metrics and distributed traces for [Instana](https://www.instana.com/).

  This package supports Python 2.7 or greater.

  Any and all feedback is welcome.  Happy Python visibility.

  [![CircleCI](https://circleci.com/gh/instana/python-sensor/tree/master.svg?style=svg)](https://circleci.com/gh/instana/python-sensor/tree/master)
  [![OpenTracing Badge](https://img.shields.io/badge/OpenTracing-enabled-blue.svg)](http://opentracing.io)



  None

  _Instana remotely instruments your Python web servers automatically via Instana [AutoTrace™️](https://www.instana.com/supported-technologies/instana-autotrace/).  To configure which Python processes this applies to, see the [Configuration page](https://docs.instana.io/ecosystem/python/configuration/#general)._



  If you wish to manually instrument your applications you can install the package with the following into the virtualenv, pipenv or container ([hosted on pypi](https://pypi.python.org/pypi/instana)):

      pip install instana

  or to alternatively update an existing installation:

      pip install -U instana



  The Instana package can then be activated _without any code changes required_ by setting the following environment variable for your Python application:

      export AUTOWRAPT_BOOTSTRAP=instana

  This will cause the Instana Python package to automatically instrument your Python application.  Once it finds the Instana host agent, it will begin to report Python metrics and distributed traces.



  Alternatively, if you prefer the really manual method, simply import the `instana` package inside of your Python application:

      import instana

  See also our detailed [Installation document](https://www.instana.com/docs/ecosystem/python/#installing) for additional information covering Django, Flask, End-user Monitoring (EUM) and more.



  You can find more documentation covering supported components and minimum versions in the Instana [documentation portal](https://docs.instana.io/ecosystem/python/).



  Bug reports and pull requests are welcome on GitHub at https://github.com/instana/python-sensor.



  Want to instrument other languages?  See our [Node.js](https://github.com/instana/nodejs), [Go](https://github.com/instana/golang-sensor), [Ruby](https://github.com/instana/ruby-sensor) instrumentation or [many other supported technologies](https://www.instana.com/supported-technologies/).


pkgId: 4a8369cda93e842820e9bb9197e6c14bd9876950f7cbf1dfbe25878a771f87ed
name: python-insteon
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: A utility for interacting with insteon modems and hubs
url: https://github.com/pfrommerd/python-insteon
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9dc3bd9e-932e-49b8-b1c7-85ba01d080e0
location_href: 00003910-python-insteon/python-insteon-0.0.2-1.src.rpm
checksum_type: sha256
description:
  A set of utilities for interacting with insteon modems and hubs

  Used as a backend for the Insteon Terminal and several insteon plugins


pkgId: 64ff9585288b16d61cdf78aac9c3b1ccdfb32372897c5f89d0b6cd7c059a7ed7
name: python-intelhex
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: Python library for Intel HEX files manipulations
url: https://github.com/python-intelhex/intelhex
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-714da9d5-b34e-43ed-a817-ed20ff656f16
location_href: 00003911-python-intelhex/python-intelhex-2.3.0-1.src.rpm
checksum_type: sha256
description:
  The Intel HEX file format is widely used in microprocessors and microcontrollers
  area (embedded systems etc) as the de facto standard
  for representation of code to be programmed into microelectronic devices.
  This work implements an ``intelhex`` Python library to read, write,
  create from scratch and manipulate data from Intel HEX file format.
  The distribution package also includes several convenience Python scripts,
  including "classic" ``hex2bin`` and ``bin2hex`` converters and more,
  those based on the library itself. Check the docs to know more.


pkgId: ca5ded8357d0e272193cac852fdfc598d57a72cc0290a89bfd80fcad46e335e9
name: python-interpret
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Fit interpretable models. Explain blackbox machine learning.
url: https://github.com/interpretml/interpret
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2a5cebd8-be51-495e-bc0b-0be8f3fdaabe
location_href: 00012775-python-interpret/python-interpret-0.3.2-1.src.rpm
checksum_type: sha256
description:
  In the beginning machines learned in darkness, and data scientists struggled in the void to explain them.

  Let there be light.

  https://github.com/interpretml/interpret


pkgId: 64a368860b7a11f2cfa2e00080dece70e4a2ac0e5d88cfcb202da4a28c4bfd5c
name: python-intervaltree
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: Editable interval tree data structure for Python 2 and 3
url: https://github.com/chaimleib/intervaltree
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d99419c3-b898-4526-9b3c-b7051a417756
location_href: 00003913-python-intervaltree/python-intervaltree-3.1.0-1.src.rpm
checksum_type: sha256
description:
  A mutable, self-balancing interval tree for Python 2 and 3. Queries may be by point, by range overlap, or by range envelopment.
  This library was designed to allow tagging text and time intervals, where the intervals include the lower bound but not the upper bound.
  **Version 3 changes!**
  * The `search(begin, end, strict)` method no longer exists. Instead, use one of these:
      * `at(point)`
      * `overlap(begin, end)`
      * `envelop(begin, end)`
  * The `extend(items)` method no longer exists. Instead, use `update(items)`.
  * Methods like `merge_overlaps()` which took a `strict` argument consistently default to `strict=True`. Before, some methods defaulted to `True` and others to `False`.


pkgId: c773fcb14a03c3964f71321543331b43e65206b82435c66b43cdfe3f39ecef11
name: python-into-dbus-python
arch: src
version: 0.8
epoch: 0
release: 1
summary: transforms values into properly wrapped dbus-python objects
url: https://github.com/stratis-storage/into-dbus-python
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-94bee1e4-95f8-4f35-b3d7-17112be69466
location_href: 00003914-python-into-dbus-python/python-into-dbus-python-0.8-1.src.rpm
checksum_type: sha256
description:
  Facilities for converting an object that inhabits core Python types, e.g.,
  lists, ints, dicts, to an object that inhabits dbus-python types, e.g.,
  dbus.Array, dbus.UInt32, dbus.Dictionary based on a specified dbus signature.


pkgId: bdae8af57d753c9578d5e7482c44de32ee96cdb862683a56a58884777e98f820
name: python-intuit-oauth
arch: src
version: 1.2.4
epoch: 0
release: 1
summary: Intuit OAuth Client
url: https://github.com/intuit/oauth-pythonclient
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9beeb68b-4657-49a1-972d-320b0453bf69
location_href: 00012755-python-intuit-oauth/python-intuit-oauth-1.2.4-1.src.rpm
checksum_type: sha256
description:
  |build| |coverage| |docs|
  This client library is meant to work with Intuit's OAuth and OpenID implementation. The `AuthClient` object response can be used for User Info API, Accounting API and Payments API. This library supports:
  - Generating Authorization URL
  - Getting OAuth2 Bearer Token
  - Getting User Info
  - Validating OpenID token
  - Refreshing OAuth2 Token
  - Revoking OAuth2 Token
  - Migrating tokens from OAuth1.0 to OAuth2


pkgId: 1e90bbf59a30c8650f523c2ce7838d3a28fbc66de653e4b769ffe70beb23de27
name: python-invoke
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Pythonic task execution
url: https://pyinvoke.org
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ff6be5c4-f3c3-4956-9a8f-b10b4b33fc96
location_href: 00009375-python-invoke/python-invoke-2.0.0-1.src.rpm
checksum_type: sha256
description:
  Invoke is a Python (2.7 and 3.4+) library for managing shell-oriented
  subprocesses and organizing executable Python code into CLI-invokable tasks. It
  draws inspiration from various sources (``make``/``rake``, Fabric 1.x, etc) to
  arrive at a powerful & clean feature set.
  To find out what's new in this version of Invoke, please see `the changelog
  <https://pyinvoke.org/changelog.html#{}>`_.
  The project maintainer keeps a `roadmap
  <https://bitprophet.org/projects#roadmap>`_ on his website.
  For a high level introduction, including example code, please see `our main
  project website <https://pyinvoke.org>`_; or for detailed API docs, see `the
  versioned API website <https://docs.pyinvoke.org>`_.


pkgId: cc464b457044b2fca6e52e4674850810417c20a7167597171a54855c5895002f
name: python-iowait
arch: src
version: 0.2
epoch: 0
release: 1
summary: Platform-independent module for I/O completion events
url: https://launchpad.net/python-iowait
rpm_license: GNU LGPL v3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c9fc714f-34fe-478e-bb5a-9bab95c7dde2
location_href: 00003915-python-iowait/python-iowait-0.2-1.src.rpm
checksum_type: sha256
description:
  Different operating systems provide different ways to wait for I/O completion
  events: there's ``select()``, ``poll()``, ``epoll()`` and ``kqueue()``. For
  cross-platform applications it can be a pain to support all this system
  functions, especially because each one provides a different interface.
  IOWait solves this problem by providing a unified interface and using always
  the best and faster function available in the platform. Its only limitation is
  that, on Windows, it only works for sockets.
  This library is compatible both with Python 2 and 3.


pkgId: 0a917f8f36c27ca27661b6758e25f575db89aa4ec5de57cd3dce2d652f3743a7
name: python-ipaddr
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Google's IP address manipulation library
url: https://github.com/google/ipaddr-py
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1fc5adb7-01a6-46ef-a02f-de9673789021
location_href: 00010244-python-ipaddr/python-ipaddr-2.2.0-1.src.rpm
checksum_type: sha256
description:
  ipaddr.py is a library for working with IP addresses, both IPv4 and IPv6.

  It has been superseded by ipaddress from the Python 3 standard library, and its
  Python 2 backport.


pkgId: 25befd30d18b83f126c5ba1327de6bca8dd1b33a7cf2998d6229b0d717707fe4
name: python-ipfshttpclient
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Python IPFS HTTP CLIENT library
url: https://ipfs.io/ipns/12D3KooWEqnTdgqHnkkwarSrJjeMP2ZJiADWLYADaNvUb6SQNyPF/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c87a3efc-35db-4f3e-b63a-5d948a8a5166
location_href: 00010733-python-ipfshttpclient/python-ipfshttpclient-0.7.0-1.src.rpm
checksum_type: sha256
description:
  [![Made by the IPFS Community](https://img.shields.io/badge/made%20by-IPFS%20Community-blue.svg?style=flat-square)](https://docs.ipfs.io/community/)
  [![IRC #py-ipfs on chat.freenode.net](https://img.shields.io/badge/freenode%20IRC-%23py--ipfs-blue.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23py-ipfs)
  [![Matrix #py-ipfs:ninetailed.ninja](https://img.shields.io/matrix/py-ipfs:ninetailed.ninja?color=blue&label=matrix%20chat&server_fqdn=matrix.ninetailed.ninja&style=flat-square)](https://matrix.to/#/#py-ipfs:ninetailed.ninja?via=matrix.ninetailed.ninja&via=librem.one)
  [![Standard README Compliant](https://img.shields.io/badge/standard--readme-OK-green.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
  [![PyPI Package ipfshttpclient](https://img.shields.io/pypi/dm/ipfshttpclient.svg?style=flat-square)](https://pypi.python.org/pypi/ipfshttpclient)
  [![Build Status](https://img.shields.io/travis/com/ipfs-shipyard/py-ipfs-http-client/master.svg?style=flat-square)](https://travis-ci.com/github/ipfs-shipyard/py-ipfs-http-client)

  ![Python IPFS HTTP Client Library](https://ipfs.io/ipfs/QmQJ68PFMDdAsgCZvA1UVzzn18asVcf7HVvCDgpjiSCAse)

  Check out [the HTTP Client reference](https://ipfs.io/ipns/12D3KooWEqnTdgqHnkkwarSrJjeMP2ZJiADWLYADaNvUb6SQNyPF/docs/) for the full command reference.

  **Note**: The `ipfsapi` PIP package and Python module have both been renamed to `ipfshttpclient`!
  See the [relevant section of the CHANGELOG](CHANGELOG.md#py-ipfs-http-client-0411-13052019) for details. There is also a `ipfsApi` library from which this library originated that is completely
  unmaintained and does not work with any recent go-IPFS version.

  **Note**: This library occasionally has to change to stay compatible with the IPFS HTTP API.
  Currently, this library is tested against [go-ipfs v0.7.0](https://github.com/ipfs/go-ipfs/releases/tag/v0.7.0).
  We strive to support the last 5 releases of go-IPFS at any given time; go-IPFS v0.4.23 therefore
  being to oldest supported version at this time.



  - [Install](#install)
  - [Usage](#usage)
  - [Documentation](#documentation)
    - [Migrating from 0.4.x to 0.6.0](#migrating-from-04x-to-060)
  - [Featured Projects](#featured-projects)
  - [Contributing](#contributing)
    - [Bug reports](#bug-reports)
    - [Pull requests](#pull-requests)
    - [Chat with Us (IRC/Matrix)](#chat-with-us-ircmatrix)
  - [License](#license)



  Install with pip:

  ```sh
  pip install ipfshttpclient
  ```



  ```sh

  git clone https://github.com/ipfs/py-ipfs-http-client.git
  cd py-ipfs-http-client


  flit install --pth-file
  ```



  Basic use-case (requires a running instance of IPFS daemon):

  ```py
  >>> import ipfshttpclient
  >>> client = ipfshttpclient.connect()  # Connects to: /dns/localhost/tcp/5001/http
  >>> res = client.add('test.txt')
  >>> res
  {'Hash': 'QmWxS5aNTFEc9XbMX1ASvLET1zrqEaTssqt33rVZQCQb22', 'Name': 'test.txt'}
  >>> client.cat(res['Hash'])
  'fdsafkljdskafjaksdjf\n'
  ```

  *Please note*: You should specify the address for an IPFS *API server*, using the address of a *gateway* (such as the public `ipfs.io` one at `/dns/ipfs.io/tcp/443/https`) will only give you [extremely limited access](https://github.com/ipfs/go-ipfs/blob/master/docs/gateway.md#read-only-api) and may not work at all. If you are only interested in downloading IPFS content through public gateway servers then this library is unlikely of being of much help.

  For real-world scripts you can reuse TCP connections using a context manager or manually closing the session after use:

  ```py
  import ipfshttpclient


  with ipfshttpclient.connect() as client:
  	hash = client.add('test.txt')['Hash']
  	print(client.stat(hash))


  class SomeObject:
  	def __init__(self):
  		self._client = ipfshttpclient.connect(session=True)

  	def do_something(self):
  		hash = self._client.add('test.txt')['Hash']
  		print(self._client.stat(hash))

  	def close(self):  # Call this when your done
  		self._client.close()
  ```

  Administrative functions:

  ```py
  >>> client.id()
  {'Addresses': ['/ip4/127.0.0.1/tcp/4001/ipfs/QmS2C4MjZsv2iP1UDMMLCYqJ4WeJw8n3vXx1VKxW1UbqHS',
                 '/ip6/::1/tcp/4001/ipfs/QmS2C4MjZsv2iP1UDMMLCYqJ4WeJw8n3vXx1VKxW1UbqHS'],
   'AgentVersion': 'go-ipfs/0.4.10',
   'ID': 'QmS2C4MjZsv2iP1UDMMLCYqJ4WeJw8n3vXx1VKxW1UbqHS',
   'ProtocolVersion': 'ipfs/0.1.0',
   'PublicKey': 'CAASpgIwgg ... 3FcjAgMBAAE='}
  ```

  Pass in API options:

  ```py
  >>> client.pin.ls(type='all')
  {'Keys': {'QmNMELyizsfFdNZW3yKTi1SE2pErifwDTXx6vvQBfwcJbU': {'Count': 1,
                                                               'Type': 'indirect'},
            'QmNQ1h6o1xJARvYzwmySPsuv9L5XfzS4WTvJSTAWwYRSd8': {'Count': 1,
                                                               'Type': 'indirect'},
            …
  ```

  Add a directory and match against a filename pattern:

  ```py
  >>> client.add('photos', pattern='*.jpg')
  [{'Hash': 'QmcqBstfu5AWpXUqbucwimmWdJbu89qqYmE3WXVktvaXhX',
    'Name': 'photos/photo1.jpg'},
   {'Hash': 'QmSbmgg7kYwkSNzGLvWELnw1KthvTAMszN5TNg3XQ799Fu',
    'Name': 'photos/photo2.jpg'},
   {'Hash': 'Qma6K85PJ8dN3qWjxgsDNaMjWjTNy8ygUWXH2kfoq9bVxH',
    'Name': 'photos/photo3.jpg'}]
  ```

  Or add a directory recursively:

  ```py
  >>> client.add('fake_dir', recursive=True)
  [{'Hash': 'QmQcCtMgLVwvMQGu6mvsRYLjwqrZJcYtH4mboM9urWW9vX',
    'Name': 'fake_dir/fsdfgh'},
   {'Hash': 'QmNuvmuFeeWWpxjCQwLkHshr8iqhGLWXFzSGzafBeawTTZ',
    'Name': 'fake_dir/test2/llllg'},
   {'Hash': 'QmX1dd5DtkgoiYRKaPQPTCtXArUu4jEZ62rJBUcd5WhxAZ',
    'Name': 'fake_dir/test2'},
   {'Hash': 'Qmenzb5J4fR9c69BbpbBhPTSp2Snjthu2hKPWGPPJUHb9M',
    'Name': 'fake_dir'}]
  ```

  This module also contains some helper functions for adding strings and JSON to IPFS:

  ```py
  >>> lst = [1, 77, 'lol']
  >>> client.add_json(lst)
  'QmQ4R5cCUYBWiJpNL7mFe4LDrwD6qBr5Re17BoRAY9VNpd'
  >>> client.get_json(_)
  [1, 77, 'lol']
  ```

  Use an IPFS server with basic auth (replace username and password with real creds):

  ```py
  >>> import ipfshttpclient
  >>> client = ipfshttpclient.connect('/dns/ipfs-api.example.com/tcp/443/https', auth=("username", "password"))
  ```

  Pass custom headers to the IPFS daemon with each request:
  ```py
  >>> import ipfshttpclient
  >>> headers = {"CustomHeader": "foobar"}
  >>> client = ipfshttpclient.connect('/dns/ipfs-api.example.com/tcp/443/https', headers=headers)
  ```

  Connect to the IPFS daemon using a Unix domain socket (plain HTTP only):
  ```py
  >>> import ipfshttpclient
  >>> client = ipfshttpclient.connect("/unix/run/ipfs/ipfs.sock")
  ```





  Documentation (currently mostly API documentation unfortunately) is available on IPFS:

  https://ipfs.io/ipns/12D3KooWEqnTdgqHnkkwarSrJjeMP2ZJiADWLYADaNvUb6SQNyPF/docs/

  The `ipfs` [command-line Client documentation](https://ipfs.io/docs/commands/) may also be useful in some cases.



  Please see the CHANGELOG for [the minor breaking changes between these releases](CHANGELOG.md#py-ipfs-http-client-060-30062020).



  Projects that currently use py-ipfs-http-client. If your project isn't here, feel free to submit a PR to add it!

  - [InterPlanetary Wayback](https://github.com/oduwsdl/ipwb) interfaces web archive ([WARC](https://www.iso.org/standard/44717.html)) files for distributed indexing and replay using IPFS.





  Over time many smaller day-to-day tasks have piled up (mostly supporting some
  newer APIs). If want to help out without getting too involved picking up one
  of tasks of our [help wanted issue list](https://github.com/ipfs-shipyard/py-ipfs-http-client/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22)
  would go a long way towards making this library more feature-complete. 👍



  You can submit bug reports using the
  [GitHub issue tracker](https://github.com/ipfs/py-ipfs-http-client/issues).



  Pull requests are welcome.  Before submitting a new pull request, please
  make sure that your code passes both the
  [code formatting](https://www.python.org/dev/peps/pep-0008/)
  (PEP-8 with tab indentation) and
  [typing](https://mypy.readthedocs.io/en/stable/cheat_sheet_py3.html)
  (PEP-484 using mypy) checks:

      $ tox -e styleck -e typeck

  As well as the unit tests:

      $ tox -e py3 -e py3-httpx

  If you are unsure, don't hasitate to just submit your code and a human will
  take a look. 🙂

  If you can, Please make sure to include new unit tests for new features or
  changes in behavior. We aim to bring coverage to 100% at some point.



  You can arrange for the code style and typing tests to be run automatically
  before each commit by installing the GIT `pre-commit` hook:

      $ ./tools/pre-commit --install



  You can find us on [#py-ipfs on chat.freenode.org](http://webchat.freenode.net/?channels=%23py-ipfs)
  or in our [Matrix chat room](https://matrix.to/#/#py-ipfs:ninetailed.ninja?via=ninetailed.ninja&via=librem.one).
  Join us if you have any suggestions, questions or if you just want to discuss
  IPFS and Python in general.

  Please note that the channel is not monitored all the time and hence you may
  only receive a reply to your message later that day. Using Matrix makes it
  easier to stay connected in the background, so please prefer the Matrix option
  or use an IRC bouncer.



  This code is distributed under the terms of the [MIT license](https://opensource.org/licenses/MIT).  Details can be found in the file
  [LICENSE](LICENSE) in this repository.


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


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

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


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

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


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

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

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



  You can install individual packages like so.

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

  You can also install multiple packages by passing a list.

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

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

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




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

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

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

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

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



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

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

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

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

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



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

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

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

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



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



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

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


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

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

  The enhanced interactive Python shells have the following main features:

   * Comprehensive object introspection.

   * Input history, persistent across sessions.

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

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

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

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

   * Session logging and reloading.

   * Extensible syntax processing for special purpose situations.

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

   * Easily embeddable in other Python programs and GUIs.

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

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


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

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



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

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


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


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


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


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


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


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



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

  ```
  P3Y6M4DT12H30M5S
  ```

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

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



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

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

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

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

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

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



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

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

  Adapt to your own likings and/or needs.

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




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


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


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


  Because this wonderful representation is not unique.


  Probably because the standard made me to.


  Probably because the standard doesn't allow me to.


  I'm confused.


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


  Yes.



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


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

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

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

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

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

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

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

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

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

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


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


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


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


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

  Basic immutable container types for Python.

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

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

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



  Install using `pip`:

      pip install itypes



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



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



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

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



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



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

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



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

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



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



      >>> hash(d)
      277752239



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

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



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

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

  Example:

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

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

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

  Using the custom class:

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



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

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

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

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

  Using immutable objects:

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


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


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

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


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

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

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


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


  ```sh

  pipenv install japanize-matplotlib


  pip install japanize-matplotlib
  ```


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



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

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

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


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

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


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


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


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


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

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

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



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

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





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

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

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

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

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



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

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

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



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

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



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

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



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

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



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



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



  Un-marshalling of Java serialised object:

  ```python
  import javaobj

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

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

  Or, you can use `JavaObjectUnmarshaller` object directly:

  ```python
  import javaobj

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

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

      pobj = marshaller.readObject()
  ```

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




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

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

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

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

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

  Sample usage:

  ```python
  import javaobj.v2 as javaobj

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

  print(pobj.dump())
  ```



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

  The Java object instance parsing works in two main steps:

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

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

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

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

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

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

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

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

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

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

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

                  
                  return True

          
          return False

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

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



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

  The sample given here is used in the unit tests.



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

  ```java
  class CustomClass implements Serializable {

      private static final long serialVersionUID = 1;

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

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

  class RandomChild extends Random {

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

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

  class CustomWriter implements Serializable {
      protected RandomChild custom_obj;

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

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

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

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

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



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

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

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

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

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

          return None

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

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

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

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

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

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

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

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

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

          return False


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

          return False
  ```

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

  ```python

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




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


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



  Stable version:

  ```
  pip install javascriptpy
  ```

  Working version:

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



  ```python
  from javascript import *

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

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



  ```py
  from javascript import console, Array

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

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



  - Added RegExp, Date, JSON


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



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

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




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

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

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

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

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

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

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

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

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


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


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

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

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

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



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



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

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

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

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

  ```

  You can differentiate to any order with `grad`.

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

  ```

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

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

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

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

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

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

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



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

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

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

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

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

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



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

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

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

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

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

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

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

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

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

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

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

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

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



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

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

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


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


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


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

  ```

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

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

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

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

  ```

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

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

  ```python
  from jax import grad

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

  print(f(x))





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




  ```

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

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



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

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



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

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

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



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

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

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



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

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

  ```bash
  pip install --upgrade pip



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



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



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

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

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

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

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

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


  To install, run

  ```bash
  pip install --upgrade pip



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



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


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

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

  You can find your CUDA version with the command:

  ```bash
  nvcc --version
  ```

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

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

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


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


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



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

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

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

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

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

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


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



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

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



  To cite this repository:

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

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

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



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

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


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

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

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


     Simple example of usage is followings

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


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


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


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

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

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

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

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




  String comparison:

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

  Phonetic encoding:

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



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

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


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


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


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


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


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


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

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

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

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

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



  ```shell
  $ pip install jikanpy
  ```



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



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

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

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

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

  archive = jikan.season_archive()
  ```



  ```python
  import asyncio
  from jikanpy import AioJikan

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

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

  asyncio.run(main())
  ```



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



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

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

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

  ```python
  import requests
  from jikanpy import Jikan

  session = requests.Session()

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

  jikan = Jikan(session=session)
  ```

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

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

  ```python
  import aiohttp
  import asyncio

  from jikanpy import AioJikan

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

  asyncio.run(main())
  ```



  ```shell

  $ pytest
  ```






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





  - Updated aiohttp to 3.7.4





  - Calling season method with no arguments defaults to current season





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





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





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



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



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





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





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



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



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



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





  - Added extension forum/episodes for anime endpoint





  - Added MIT license to Jikanpy





  - Added Jikanpy to PyPI





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



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





  - Jikan URL and response headers to Jikanpy response



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





  - This changelog





  - Bug when passing in genre_exclude as boolean





  - selected_base constructor arg to aio_jikan



  - search and user methods to adhere with REST 3.3





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





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





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



  - No more support for Python versions before 3.6



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





  - Tests to reach 100% coverage



  - Abstract methods raise `NotImplementedError`





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



  - README examples for user method





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





  - Tests and examples for person method





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



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





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



  - No more support for Python versions before 3.5





  - Subtypes checking for top endpoint





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





  - Checking key and value in search method





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





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



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





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





  - semver for versioning
  - setup.py





  - AioJikan async wrapper for Jikan





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



  - Generalized error checking





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





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



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



  - user list method





  - DeprecationWarning to DeprecatedEndpoint



  - ID typos in README usage





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





  - Initial version with anime and manga methods and exceptions


