# packages

pkgId: 8a8fbaccb5520a0816c9c460497af30be6a75c0a8f45c0e963cacacc8fc777b1
name: python-sgp4-debuginfo
arch: x86_64
version: 2.21
epoch: 0
release: 1
summary: Debug information for package python-sgp4
url: https://github.com/brandon-rhodes/python-sgp4
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-dc46c421-0603-47d3-a54e-827fddb3b92c
rpm_sourcerpm: python-sgp4-2.21-1.src.rpm
location_href: 00011007-python-sgp4/python-sgp4-debuginfo-2.21-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-sgp4.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 509dca43d2df0ec76c84ff50e63f572d70be062f23660065db89f415ff643561
name: python-sgp4-debugsource
arch: x86_64
version: 2.21
epoch: 0
release: 1
summary: Debug sources for package python-sgp4
url: https://github.com/brandon-rhodes/python-sgp4
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-dc46c421-0603-47d3-a54e-827fddb3b92c
rpm_sourcerpm: python-sgp4-2.21-1.src.rpm
location_href: 00011007-python-sgp4/python-sgp4-debugsource-2.21-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-sgp4.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 59d5b4f7a8789c45536d4347e6ca8bbe3de7e2bb13e7807dd9c069ac1d4f8ed8
name: python-sgqlc
arch: src
version: 16.1
epoch: 0
release: 1
summary: Simple GraphQL Client
url: http://github.com/profusion/sgqlc
rpm_license: ISCL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5591df4f-4ccd-4233-9579-d66d45e3e3a7
location_href: 00011970-python-sgqlc/python-sgqlc-16.1-1.src.rpm
checksum_type: sha256
description:
  This package offers an easy to use `GraphQL <http://graphql.org>`_
  client. It's composed of the following modules:
  - :literal:`sgqlc.types`: declare GraphQL in Python, base to generate and
    interpret queries. Submodule :literal:`sgqlc.types.datetime` will
    provide bindings for :literal:`datetime` and ISO 8601, while
    ``Connection``.
  - :literal:`sgqlc.operation`: use declared types to generate and
    interpret queries.
  - :literal:`sgqlc.endpoint`: provide access to GraphQL endpoints, notably


pkgId: c127f0bb3e6ed1eaecfb7538539b93d74832520a2f12e50d17a5f2e6d9cfbed6
name: python-shade
arch: src
version: 1.33.0
epoch: 0
release: 1
summary: Simple client library for interacting with OpenStack clouds
url: http://docs.openstack.org/shade/latest
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-86be9a1b-a3b1-48c8-98a3-13a6272965a1
location_href: 00005073-python-shade/python-shade-1.33.0-1.src.rpm
checksum_type: sha256
description:
    shade has been superceded by `openstacksdk`_ and no longer takes new
    features. The existing code will continue to be maintained indefinitely
    for bugfixes as necessary, but improvements will be deferred to
    `openstacksdk`_. Please update your applications to use `openstacksdk`_
    directly.
  shade is a simple client library for interacting with OpenStack clouds. The
  key word here is *simple*. Clouds can do many many many things - but there are
  probably only about 10 of them that most people care about with any
  regularity. If you want to do complicated things, you should probably use
  the lower level client libraries - or even the REST API directly. However,
  if what you want is to be able to write an application that talks to clouds
  no matter what crazy choices the deployer has made in an attempt to be
  more hipster than their self-entitled narcissist peers, then shade is for you.
  shade started its life as some code inside of ansible. ansible has a bunch
  of different OpenStack related modules, and there was a ton of duplicated
  code. Eventually, between refactoring that duplication into an internal
  library, and adding logic and features that the OpenStack Infra team had
  developed to run client applications at scale, it turned out that we'd written
  nine-tenths of what we'd need to have a standalone library.


pkgId: 945822f37aa0888c6394eab2415e3ac50361aa3085a3daef57be21ab688a4bf7
name: python-shadowsocks
arch: src
version: 2.8.2
epoch: 0
release: 1
summary: A fast tunnel proxy that help you get through firewalls
url: https://github.com/shadowsocks/shadowsocks
rpm_license: http://www.apache.org/licenses/LICENSE-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a74d02e5-c524-45e0-9782-81969bb665c2
location_href: 00005074-python-shadowsocks/python-shadowsocks-2.8.2-1.src.rpm
checksum_type: sha256
description:
  |PyPI version| |Build Status| |Coverage Status|
  A fast tunnel proxy that helps you bypass firewalls.


pkgId: 333320293da45482c4bb9d2d996b4d8161e463280778e8f1a5bed87330fcbac2
name: python-sharepoint
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: Module and command-line utility to get data out of SharePoint
url: https://github.com/ox-it/python-sharepoint
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-29c98b28-3623-4888-8a33-21106d41e9cd
location_href: 00013165-python-sharepoint/python-sharepoint-0.4.2-1.src.rpm
checksum_type: sha256
description:
  A Python library and command-line utility for gettting data out of SharePoint.
  If you're more a Perl person, you might also want to try `SharePerltopus
  <https://github.com/cgutteridge/SharePerltopus>`_.


pkgId: 4d8dfb5dc8f415fcbd58fb4c1397d5e1b30570994873def4cd6335148e70aa3c
name: python-shellescape
arch: src
version: 3.8.1
epoch: 0
release: 1
url: https://github.com/chrissimpkins/shellescape
rpm_license: MIT license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d4d218e2-4a4c-4460-b3b7-428b21b352bd
location_href: 00009776-python-shellescape/python-shellescape-3.8.1-1.src.rpm
checksum_type: sha256
summary:
  Shell escape a string to safely use it as a token in a shell command (backport of cPython shlex.quote for Python versions 2.x & < 3.3)

description:
  The shellescape Python module defines the `shellescape.quote()` function that returns a shell-escaped version of a Python string.  This is a backport of the `shlex.quote()` function from Python 3.8 that makes it accessible to users of Python 3 versions < 3.3 and all Python 2.x versions.




  *From the Python documentation*:

  Return a shell-escaped version of the string s. The returned value is a string that can safely be used as one token in a shell command line, for cases where you cannot use a list.

  This idiom would be unsafe:

  ```python
  >>> filename = 'somefile; rm -rf ~'
  >>> command = 'ls -l {}'.format(filename)
  >>> print(command)  # executed by a shell: boom!
  ls -l somefile; rm -rf ~
  ```

  `quote()` lets you plug the security hole:

  ```python
  >>> command = 'ls -l {}'.format(quote(filename))
  >>> print(command)
  ls -l 'somefile; rm -rf ~'
  >>> remote_command = 'ssh home {}'.format(quote(command))
  >>> print(remote_command)
  ssh home 'ls -l '"'"'somefile; rm -rf ~'"'"''
  ```

  The quoting is compatible with UNIX shells and with `shlex.split()`:

  ```python
  >>> remote_command = split(remote_command)
  >>> remote_command
  ['ssh', 'home', "ls -l 'somefile; rm -rf ~'"]
  >>> command = split(remote_command[-1])
  >>> command
  ['ls', '-l', 'somefile; rm -rf ~']
  ```




  Include `shellescape` in your project setup.py file `install_requires` dependency definition list:

  ```python
  setup(
      ...
      install_requires=['shellescape'],
      ...
  )
  ```

  Then import the `quote` function into your module(s) and use it as needed:

  ```python



  from shellescape import quote

  filename = "somefile; rm -rf ~"
  escaped_shell_command = 'ls -l {}'.format(quote(filename))
  ```



  [LICENSE](https://github.com/chrissimpkins/shellescape/blob/master/docs/LICENSE)


pkgId: bd88450a48f5d7015dbd099ad3bd887991baebc989603238a63054e489e4eca5
name: python-shelly
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Standalone tools to make the shell better.
url: http://bitbucket.org/larsyencken/shelly/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f6763160-e242-422d-a356-0783658f5562
location_href: 00005078-python-shelly/python-shelly-0.2.1-1.src.rpm
checksum_type: sha256
description:
  Shelly makes processing line-by-line data in the shell easier, by providing
  access to useful functional programming primitives and interactive tools.


pkgId: 56bfdbd21836897c827a870f38c2818cbeaf1dc23167123eb0b2ebbda5597b61
name: python-shodan
arch: src
version: 1.28.0
epoch: 0
release: 1
summary: Python library and command-line utility for Shodan (https://developer.shodan.io)
url: https://github.com/achillean/shodan-python
rpm_license: None
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8e395833-2ded-4e4f-8c68-a9c02513256b
location_href: 00005083-python-shodan/python-shodan-1.28.0-1.src.rpm
checksum_type: sha256
description:
  Shodan is a search engine for Internet-connected devices. Google lets you search for websites,
  Shodan lets you search for devices. This library provides developers easy access to all of the
  data stored in Shodan in order to automate tasks and integrate into existing tools.


pkgId: 9727eea8e22e0e0846882e66bf54787dcfcda0f3e276195c3ced170e71566e5b
name: python-shortuuid
arch: src
version: 1.0.11
epoch: 0
release: 1
summary: A generator library for concise, unambiguous and URL-safe UUIDs.
url: https://github.com/skorokithakis/shortuuid/
rpm_license: License :: OSI Approved :: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1e461860-11fc-4221-a703-63b63c7f1468
location_href: 00005084-python-shortuuid/python-shortuuid-1.0.11-1.src.rpm
checksum_type: sha256
description:
  `shortuuid` is a simple python library that generates concise, unambiguous, URL-safe
  UUIDs.
  Often, one needs to use non-sequential IDs in places where users will see them, but the
  IDs must be as concise and easy to use as possible.  `shortuuid` solves this problem by
  generating uuids using Python's built-in `uuid` module and then translating them to
  base57 using lowercase and uppercase letters and digits, and removing similar-looking
  characters such as l, 1, I, O and 0.
  [![image](https://travis-ci.org/skorokithakis/shortuuid.svg?branch=master)](https://travis-ci.org/skorokithakis/shortuuid)


pkgId: 29457b31a02b190b9f1931ce843b079c88b40a646aa9cab71aa955f47f7940f6
name: python-shrub.py
arch: src
version: 3.0.4
epoch: 0
release: 1
summary: Library for creating evergreen configurations
url: https://github.com/evergreen-ci/shrub.py
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-973234b9-86dc-4d58-a73e-3927fd0272e3
location_href: 00009946-python-shrub-py/python-shrub.py-3.0.4-1.src.rpm
checksum_type: sha256
description:
  A python based Evergreen project config generation library

  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/shrub.py)
  [![PyPI version](https://badge.fury.io/py/shrub.py.svg)](https://pypi.org/project/shrub.py/)



  Based on [shrub](https://github.com/evergreen-ci/shrub/), shrub.py is a library for programatically
  building Evergreen project configurations described [here](https://github.com/evergreen-ci/evergreen/wiki/Project-Files).



  The following snippet will create a set of parallel tasks reported under a single display task. It
  would generate json used by ```generate.tasks```:

  ```
  from shrub.v2 import ShrubProject, Task, BuildVariant

  n_tasks = 10
  def define_task(index):
      name = f"task_name_{index}"

      return Task(
          name,
          [
              FunctionCall("do setup"),
              FunctionCall(
                  "run test generator",
                  {"parameter_1": "value 1", "parameter_2": "value 2"}
              ),
              FunctionCall("run tests")
          ],
      ).dependency("compile")

  tasks = {define_task(i) for i in range(n_tasks)}
  variant = BuildVariant("linux-64").display_task("test_suite", tasks)
  project = ShrubProject({variant})

  project.json()
  ```



  ```
  poetry run pytest
  ```


pkgId: dddf754528f052934e20ab9b97f347aa1bc1b395029beb2da238459ec4d0a3d8
name: python-shtab
arch: src
version: 1.6.1
epoch: 0
release: 1
summary: Automagic shell tab completion for Python CLI applications
url: https://github.com/iterative/shtab
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-09e58553-2e46-4844-b82d-30f862cddf40
location_href: 00010670-python-shtab/python-shtab-1.6.1-1.src.rpm
checksum_type: sha256
description:
  |Tests| |Coverage| |Conda| |PyPI|
  - What: Automatically generate shell tab completion scripts for Python CLI apps
  - Why: Speed & correctness. Alternatives like
    `argcomplete <https://pypi.org/project/argcomplete>`_ and
    `pyzshcomplete <https://pypi.org/project/pyzshcomplete>`_ are slow and have
    side-effects
  - How: ``shtab`` processes an ``argparse.ArgumentParser`` object to generate a
    tab completion script for your shell


pkgId: 397cd1f7ddb2d79d025f18ae54b34fe1a775774764329e5dbfb14166a32be472
name: python-shutilwhich
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: shutil.which for those not using Python 3.3 yet.
url: http://github.com/mbr/shutilwhich
rpm_license: PSF
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6ef72b0b-16b7-4ac8-913f-2cfef0f7ecf3
location_href: 00011780-python-shutilwhich/python-shutilwhich-1.1.0-1.src.rpm
checksum_type: sha256
description:
  First, install the package: ``pip install shutilwhich``
  Importing the package::
    import shutilwhich
  will monkey-patch the ``shutil`` package, so from that point on you can simply
  import the ``which`` function::
    from shutil import which
  To keep things a little more concise, you can also import ``which`` directly
  from ``shutilwhich``::
    from shutilwhich import which
  This will still monkeypatch the ``shutil`` module. On Python 3.3 and above, the
  module never do anything but return the stdlib ``shutil.which`` function.


pkgId: 50225f9152e469d6fd1c8c9ae169ca40dd7663f0fb530d66993a0bcea9a660da
name: python-sieve
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: XML Comparison Utils
url: http://github.com/ralphbean/sieve
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-548995a8-22f8-40aa-96ce-cf56336cc0ea
location_href: 00005086-python-sieve/python-sieve-0.1.9-1.src.rpm
checksum_type: sha256
description:
  +----------+-----------+
  | Branch   | Status    |
  +==========+===========+
  | master   | |master|  |
  +----------+-----------+
  | develop  | |develop| |
  +----------+-----------+


pkgId: 99ce00cd50e33a26c285f16f5ea835d26aab717790f42c8b168d246931f7233a
name: python-sievelib
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: Client-side SIEVE library
url: https://github.com/tonioo/sievelib
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e9d405de-14e9-4ae6-9fd0-f6fc86f25242
location_href: 00005087-python-sievelib/python-sievelib-1.2.1-1.src.rpm
checksum_type: sha256
description:
  |travis| |codecov| |latest-version|
  Client-side Sieve and Managesieve library written in Python.
  * Sieve : An Email Filtering Language
    (`RFC 5228 <http://tools.ietf.org/html/rfc5228>`_)
  * ManageSieve : A Protocol for Remotely Managing Sieve Scripts
    (`RFC 5804 <http://tools.ietf.org/html/rfc5804>`_)


pkgId: 87761a78d2c07e168b1403964ba78383b0d8df9ed694db09e79110f7ff168cb5
name: python-simple-crypt
arch: src
version: 4.1.7
epoch: 0
release: 1
summary: Simple, secure encryption and decryption for Python 2.7 and 3
url: https://github.com/andrewcooke/simple-crypt
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b1eb1732-0781-4bd0-911b-2e61ce66d49a
location_href: 00011591-python-simple-crypt/python-simple-crypt-4.1.7-1.src.rpm
checksum_type: sha256
description:
  Simple Crypt encrypts and decrypts data.  It has two functions, ``encrypt``
  and ``decrypt``::
      from simplecrypt import encrypt, decrypt
      ciphertext = encrypt('password', plaintext)
      plaintext = decrypt('password', ciphertext)
  That's it.  You can see the implementation on
  `github <https://github.com/andrewcooke/simple-crypt/blob/master/src/simplecrypt/__init__.py>`_.


pkgId: 5d1d0a19804ead6c1e6da16aafae5cd71a97f532807cbb8fce15bf6dc786bad9
name: python-simple-ddl-parser
arch: src
version: 0.30.0
epoch: 0
release: 1
url: https://github.com/xnuinside/simple-ddl-parser
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5681f722-4165-41e5-912e-74cf4098a406
location_href: 00010490-python-simple-ddl-parser/python-simple-ddl-parser-0.30.0-1.src.rpm
checksum_type: sha256
summary:
  Simple DDL Parser to parse SQL & dialects like HQL, TSQL (MSSQL), Oracle, AWS Redshift, Snowflake, MySQL, PostgreSQL, etc ddl files to json/python dict with full information about columns: types, defaults, primary keys, etc.; sequences, alters, custom types & other entities from ddl.

description:
  Build with ply (lex & yacc in python). A lot of samples in 'tests/.
  Is it Stable?
  ^^^^^^^^^^^^^
  Yes, library already has about 7000+ downloads per day  - https://pypistats.org/packages/simple-ddl-parser..
  As maintainer, I guarantee that any backward incompatible changes will not be done in patch or minor version. But! Pay attention that sometimes output in keywords can be changed in minor version because of fixing wrong behaviour in past. For example, previously 'auto_increment' was a part of column type, but later it became a separate column property. So, please read for minor versions changedlog.
  However, in process of adding support for new statements & features I see that output can be structured more optimal way and I hope to release version ``1.0.*`` with more struct output result. But, it will not be soon, first of all, I want to add support for so much statements as I can. So I don't think make sense to expect version 1.0.* before, for example, version ``0.26.0`` :)
  How does it work?
  ^^^^^^^^^^^^^^^^^
  Parser supports:
  * SQL
  * HQL (Hive)
  * MSSQL dialec
  * Oracle dialect
  * MySQL dialect
  * PostgreSQL dialect
  * BigQuery
  * Redshift
  * Snowflake
  * SparkSQL
  * IBM DB2 dialect
  You can check dialects sections after ``Supported Statements`` section to get more information that statements from dialects already supported by parser. If you need to add more statements or new dialects - feel free to open the issue.
  Feel free to open Issue with DDL sample
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  Pay attentions that I'm adding functional tests for all supported statement, so if you see that your statement is failed and you didn't see it in the test 99,9% that I did n't have sample with such SQL statement - so feel free to open the issue and I will add support for it.
  **If you need some statement, that not supported by parser yet**\ : please provide DDL example & information about that is it SQL dialect or DB.
  Types that are used in your DB does not matter, so parser must also work successfuly to any DDL for SQL DB. Parser is NOT case sensitive, it did not expect that all queries will be in upper case or lower case. So you can write statements like this:
         Alter Table Persons ADD CONSTRAINT CHK_PersonAge CHECK (Age>=18 AND City='Sandnes');
  It will be parsed as is without errors.
  If you have samples that cause an error - please open the issue (but don't forget to add ddl example), I will be glad to fix it.
  A lot of statements and output result you can find in tests on the github - https://github.com/xnuinside/simple-ddl-parser/tree/main/tests .
  How to install
  ^^^^^^^^^^^^^^
         pip install simple-ddl-parser


pkgId: 4d096984db81ffc4217876c654884f0008a8a3a775c5b6d5413894c3970f8dec
name: python-simple-salesforce
arch: src
version: 1.12.3
epoch: 0
release: 1
summary: A basic Salesforce.com REST API client.
url: https://github.com/simple-salesforce/simple-salesforce
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f08450c3-dc1d-4c06-80db-fd2ac99bb000
location_href: 00009217-python-simple-salesforce/python-simple-salesforce-1.12.3-1.src.rpm
checksum_type: sha256
description:
  You can find out more regarding the format of the results in the `Official Salesforce.com REST API Documentation`_


pkgId: 351e0632370ac1dcf5be82f3e2a65eed19f39c61db25e794df0882a58eef60d8
name: python-simpleaudio
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: Simple, asynchronous audio playback for Python 3.
url: https://github.com/hamiltron/py-simple-audio
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8ffbef95-98db-471f-80c7-a3c0543ce0df
location_href: 00005091-python-simpleaudio/python-simpleaudio-1.0.4-1.src.rpm
checksum_type: sha256
description:
  The simplaudio package provides cross-platform, dependency-free audio playback
  capability for Python 3 on OSX, Windows, and Linux.
  MIT Licensed.


pkgId: acdc552594dec2008ea18b584e737501d71ce5a8596584d7933ece06b782ccf1
name: python-simpleeval
arch: src
version: 0.9.13
epoch: 0
release: 1
summary: A simple, safe single expression evaluator library.
url: https://github.com/danthedeckie/simpleeval
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c7db1a2c-0f36-4e94-83c1-9da7a3c09b04
location_href: 00005093-python-simpleeval/python-simpleeval-0.9.13-1.src.rpm
checksum_type: sha256
description:
  A single file library for easily adding evaluatable expressions into
  python projects.  Say you want to allow a user to set an alarm volume, which
  could depend on the time of day, alarm level, how many previous alarms had gone
  off, and if there is music playing at the time.
  Or if you want to allow simple formulae in a web application, but don't want to
  give full eval() access, or don't want to run in javascript on the client side.
  It's deliberately trying to stay simple to use and not have millions of features,
  pull it in from PyPI (pip or easy_install), or even just a single file you can dump
  into a project.
  Internally, it's using the amazing python ``ast`` module to parse the
  expression, which allows very fine control of what is and isn't allowed.  It
  should be completely safe in terms of what operations can be performed by the
  expression.
  The only issue I know to be aware of is that you can create an expression which
  takes a long time to evaluate, or which evaluating requires an awful lot of
  memory, which leaves the potential for DOS attacks.  There is basic protection
  against this, and you can lock it down further if you desire. (see the
  Operators_ section below)
  You should be aware of this when deploying in a public setting.
  The defaults are pretty locked down and basic, and it's easy to add
  whatever extra specific functionality you need (your own functions,
  variable/name lookup, etc).


pkgId: 0ffa3355c18ade82a6617f3c915ca53e812b6331c3ac05c88aac1681ce1f73fe
name: python-simplegeneric
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Simple generic functions (similar to Python's own len(), pickle.dump(), etc.)
url: http://cheeseshop.python.org/pypi/simplegeneric
rpm_license: ZPL 2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-557d9f71-f1b7-4567-a8dc-1071b9fe0b92
location_href: 00009572-python-simplegeneric/python-simplegeneric-0.8.1-1.src.rpm
checksum_type: sha256
description:
  Defining and using a generic function is straightforward::
      >>> from simplegeneric import generic
      >>> @generic
      >>> @move.when_type(int)
      >>> @move.when_type(str)
      >>> zig = object()
      >>> @move.when_object(zig)
      >>> move(2101, "war")
      In AD 2101, war was beginning.
      >>> move("gentlemen", "base")
      How are you gentlemen!!
      All your base are belong to us.
      >>> move(zig, "doing")
      You know what you doing.
      For great justice!
      >>> move(27.0, 56.2)
      what you say?!


pkgId: f2eabbeed1864d5a3b67ca8c3eadb31e36a9e5c5f21a044b03fa7a6ecb3655cc
name: python-simplejson
arch: src
version: 3.19.1
epoch: 0
release: 1
summary: Simple, fast, extensible JSON encoder/decoder for Python
url: https://github.com/simplejson/simplejson
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c4a3e45c-443e-429c-8ee9-4497b848f91d
location_href: 00009055-python-simplejson/python-simplejson-3.19.1-1.src.rpm
checksum_type: sha256
description:
  simplejson is a simple, fast, complete, correct and extensible
  JSON <http://json.org> encoder and decoder for Python 3.3+
  with legacy support for Python 2.5+.  It is pure Python code
  with no dependencies, but includes an optional C extension
  for a serious speed boost.
  The latest documentation for simplejson can be read online here:
  https://simplejson.readthedocs.io/
  simplejson is the externally maintained development version of the
  json library included with Python (since 2.6). This version is tested
  with the latest Python 3.8 and maintains backwards compatibility
  with Python 3.3+ and the legacy Python 2.5 - Python 2.7 releases.
  The encoder can be specialized to provide serialization in any kind of
  situation, without any special support by the objects to be serialized
  (somewhat like pickle). This is best done with the ``default`` kwarg
  to dumps.
  The decoder can handle incoming JSON strings of any specified encoding
  (UTF-8 by default). It can also be specialized to post-process JSON
  objects with the ``object_hook`` or ``object_pairs_hook`` kwargs. This
  is particularly useful for implementing protocols such as JSON-RPC
  that have a richer type system than JSON itself.
  For those of you that have legacy systems to maintain, there is a
  very old fork of simplejson in the `python2.2`_ branch that supports
  Python 2.2. This is based on a very old version of simplejson,
  is not maintained, and should only be used as a last resort.


pkgId: b896a2c6d9786ddfa47b721152685916c2dc3605140292012ba9f0e7c3d895fb
name: python-simplejson-debuginfo
arch: x86_64
version: 3.19.1
epoch: 0
release: 1
summary: Debug information for package python-simplejson
url: https://github.com/simplejson/simplejson
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-c4a3e45c-443e-429c-8ee9-4497b848f91d
rpm_sourcerpm: python-simplejson-3.19.1-1.src.rpm
location_href: 00009055-python-simplejson/python-simplejson-debuginfo-3.19.1-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-simplejson.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 1a09467531ea8b916d1160c1d18d37e530285ce20af3c5d9b2c30dcdb82e5036
name: python-simplejson-debugsource
arch: x86_64
version: 3.19.1
epoch: 0
release: 1
summary: Debug sources for package python-simplejson
url: https://github.com/simplejson/simplejson
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-c4a3e45c-443e-429c-8ee9-4497b848f91d
rpm_sourcerpm: python-simplejson-3.19.1-1.src.rpm
location_href: 00009055-python-simplejson/python-simplejson-debugsource-3.19.1-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-simplejson.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: e7c595c08ec50bd16c347248a6d6fa2fe05c20675906815dfd80aa436eaaf168
name: python-simplepam
arch: src
version: 0.1.5
epoch: 0
release: 1
url: https://github.com/leonnnn/python3-simplepam
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f6391a2b-9401-4374-aca1-d6ee67db76b3
location_href: 00005095-python-simplepam/python-simplepam-0.1.5-1.src.rpm
checksum_type: sha256
summary:
  An interface to the Pluggable Authentication Modules (PAM) library on linux, written in pure python (using ctypes)

description:
  An interface to the Pluggable Authentication Modules (PAM) library on
  linux, written in pure python (using ctypes)


pkgId: 236e2cf335e1fb1f3d712819c3ed2c082680c3d4659e598b8b469997c9e5f946
name: python-simpletransformers
arch: src
version: 0.63.9
epoch: 0
release: 1
summary: An easy-to-use wrapper library for the Transformers library.
url: https://github.com/ThilinaRajapakse/simpletransformers/
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-133698c3-b0b1-46a8-a8ef-d62692e4a102
location_href: 00012860-python-simpletransformers/python-simpletransformers-0.63.9-1.src.rpm
checksum_type: sha256
description:
  For a list of pretrained models, see [Hugging Face docs](https://huggingface.co/pytorch-transformers/pretrained_models.html).
  The `model_types` available for each task can be found under their respective section. Any pretrained model of that type
  found in the Hugging Face docs should work. To use any of them set the correct `model_type` and `model_name` in the `args`


pkgId: 3573ab6c629a5bb0a3e7365bbcfc8cad24d7abf0a06e65a84438fc15cfe5d5c5
name: python-simplevisor
arch: src
version: 1.3
epoch: 0
release: 1
summary: Simple daemon supervisor
url: https://github.com/cern-mig/python-simplevisor
rpm_license: ASL 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-995cd592-2734-4407-85f5-2fea947efd6e
location_href: 00005098-python-simplevisor/python-simplevisor-1.3-1.src.rpm
checksum_type: sha256
description:
  Simplevisor is a simple daemons supervisor, it is inspired by
  Erlang OTP and it can supervise hierarchies of services.


pkgId: 0bc2e4246187594e21226245857e197d37dc47bfc60cda3a0dbac64780e251bd
name: python-simpy
arch: src
version: 4.0.1
epoch: 0
release: 1
summary: Event discrete, process based simulation for Python.
url: https://simpy.readthedocs.io
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a02c3252-102d-4aa7-a779-e381ecbe8b02
location_href: 00005100-python-simpy/python-simpy-4.0.1-1.src.rpm
checksum_type: sha256
description:
  SimPy is a process-based discrete-event simulation framework based on standard
  Python. Processes in SimPy are defined by Python `generator`__ functions and
  can, for example, be used to model active components like customers, vehicles or
  agents.  SimPy also provides various types of shared resources to model
  limited capacity congestion points (like servers, checkout counters and
  tunnels).
  Simulations can be performed “as fast as possible”, in real time (wall clock
  time) or by manually stepping through the events.
  Though it is theoretically possible to do continuous simulations with SimPy, it
  has no features that help you with that. Also, SimPy is not really required for
  simulations with a fixed step size and where your processes don’t interact with
  each other or with shared resources.
  The `documentation`__ contains a `tutorial`__, `several guides`__ explaining key
  concepts, a number of `examples`__ and the `API reference`__.
  SimPy is released under the MIT License. Simulation model developers are
  encouraged to share their SimPy modeling techniques with the SimPy community.
  Please post a message to the `SimPy mailing list`__.
  There is an introductory talk that explains SimPy’s concepts and provides some
  examples: `watch the video`__ or `get the slides`__.
  __ http://docs.python.org/3/glossary.html#term-generator
  __ https://simpy.readthedocs.io/en/latest/
  __ https://simpy.readthedocs.io/en/latest/simpy_intro/index.html
  __ https://simpy.readthedocs.io/en/latest/topical_guides/index.html
  __ https://simpy.readthedocs.io/en/latest/examples/index.html
  __ https://simpy.readthedocs.io/en/latest/api_reference/index.html
  __ https://groups.google.com/forum/#!forum/python-simpy
  __ https://www.youtube.com/watch?v=Bk91DoAEcjY
  __ http://stefan.sofa-rockers.org/downloads/simpy-ep14.pdf


pkgId: b4a486be9126f6acfc41da5288ca743045da631699ed62d6f8d12dc10f343628
name: python-singleton-decorator
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: A testable singleton decorator
url: https://github.com/Kemaweyan/singleton_decorator
rpm_license: GPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b23f07db-43ff-4901-822c-6e2a1626c3b8
location_href: 00010798-python-singleton-decorator/python-singleton-decorator-1.0.0-1.src.rpm
checksum_type: sha256
description:
  A testable singleton decorator allows easily create a singleton objects
  just adding a decorator to class definition but also allows easily write
  unit tests for those classes.


pkgId: b79daa02568d6d1da7389c6283a918d7c332d5b4b7f22c651782656ae60ab3fb
name: python-siosocks
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: sans-io socks proxy client/server with couple io backends
url: https://github.com/pohmelie/siosocks
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c1ff50da-59d7-44db-bbeb-7a385892a5d9
location_href: 00005101-python-siosocks/python-siosocks-0.3.0-1.src.rpm
checksum_type: sha256
description:
  asyncio | + | +
  trio | + | +
  socket | | +
  Feel free to make it bigger :wink:

  End user implementations mimic «parent» library api.

  - asyncio: [`open_connection`](https://docs.python.org/3/library/asyncio-stream.html#asyncio.open_connection)
  - trio: [`open_tcp_stream`](https://trio.readthedocs.io/en/stable/reference-io.html#trio.open_tcp_stream)
  Extra keyword-only arguments:
  - `socks_host`: string
  - `socks_port`: integer
  - `socks_version`: integer (4 or 5)
  - `username`: optional string (default: `None`)
  - `password`: optional string (default: `None`)
  - `encoding`: optional string (default: `"utf-8"`)
  - `socks4_extras`: optional dictionary
  - `socks5_extras`: optional dictionary
  Extras:
  - socks4
      - `user_id`: string (default: `""`)
  - socks5
      - None at this moment, added for uniform api

  End user implementations mimic «parent» library server request handlers.
  - asyncio: [`start_server`](https://docs.python.org/3/library/asyncio-stream.html#asyncio.start_server)
  - trio: [`serve_tcp`](https://trio.readthedocs.io/en/stable/reference-io.html#trio.serve_tcp)
  - socketserver: [`ThreadingTCPServer`](https://docs.python.org/3/library/socketserver.html#socketserver.ThreadingTCPServer)
  You should use [`partial`](https://docs.python.org/3/library/functools.html#functools.partial) to bind socks specific arguments:
  - `allowed_versions`: set of integers (default: `{4, 5}`)
  - `username`: optional string (default: `None`)
  - `password`: optional string (default: `None`)
  - `strict_security_policy`: boolean, if `True` exception will be raised if authentication required and 4 is in allowed versions set (default: `True`)
  - `encoding`: optional string (default: `"utf-8"`)
  Nothing to say more. Typical usage can be found at [`__main__.py`](https://github.com/pohmelie/siosocks/blob/master/siosocks/__main__.py)


  This section will use `asyncio` as backend, since it is main target/reason for `siosocks`

  ``` python
  import asyncio
  from siosocks.io.asyncio import open_connection
  HOST = "api.ipify.org"
  REQ = """GET /?format=json HTTP/1.1
  Host: api.ipify.org
  User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:67.0) Gecko/20100101 Firefox/67.0
  Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
  Accept-Language: en,en-US;q=0.7,ru;q=0.3
  Accept-Encoding: gzip, deflate
  DNT: 1
  Connection: keep-alive
  Upgrade-Insecure-Requests: 1
  Cache-Control: max-age=0
  """
  async def main():
      
      r, w = await open_connection(HOST, 80, socks_host="localhost", socks_port=9050, socks_version=5)
      w.write(REQ.replace("\n", "\r\n").encode())
      await w.drain()
      print(await r.read(8192))
      w.close()
  loop = asyncio.get_event_loop()
  loop.run_until_complete(main())
  ```

  ``` python
  import socket
  import asyncio
  import contextlib
  from siosocks.io.asyncio import socks_server_handler
  loop = asyncio.get_event_loop()
  server = loop.run_until_complete(asyncio.start_server(socks_server_handler, port=1080))
  addresses = []
  for sock in server.sockets:
      if sock.family in (socket.AF_INET, socket.AF_INET6):
          host, port, *_ = sock.getsockname()
          addresses.append(f"{host}:{port}")
  print(f"Socks4/5 proxy serving on {', '.join(addresses)}")
  with contextlib.suppress(KeyboardInterrupt):
      loop.run_forever()
  ```
  But if you just want one-shot socks server then try:
  ``` bash
  python -m siosocks
  ```
  This will start socks 4, 5 server on all interfaces on 1080 port. For more information try `--help`
  ``` bash
  python -m siosocks --help
  usage: siosocks [-h] [--backend {asyncio,socketserver,trio}] [--host HOST]
                  [--port PORT] [--family {ipv4,ipv6,auto}] [--socks SOCKS]
                  [--username USERNAME] [--password PASSWORD]
                  [--encoding ENCODING] [--no-strict] [-v]
  Socks proxy server
  optional arguments:
    -h, --help            show this help message and exit
    --backend {asyncio,socketserver,trio}
                          Socks server backend [default: asyncio]
    --host HOST           Socks server host [default: None]
    --port PORT           Socks server port [default: 1080]
    --family {ipv4,ipv6,auto}
                          Socket family [default: auto]
    --socks SOCKS         Socks protocol version [default: []]
    --username USERNAME   Socks auth username [default: None]
    --password PASSWORD   Socks auth password [default: None]
    --encoding ENCODING   String encoding [default: utf-8]
    --no-strict           Allow multiversion socks server, when socks5 used with
                          username/password auth [default: False]
    -v, --version         Show siosocks version
  ```

  `siosocks` have unified exception for all types of socks-related errors:
  ``` python
  import asyncio
  from siosocks.exceptions import SocksException
  from siosocks.io.asyncio import open_connection
  async def main():
      try:
          r, w = await open_connection("127.0.0.1", 80, socks_host="localhost", socks_port=9050, socks_version=5)
      except SocksException:
      else:
          
          
  loop = asyncio.get_event_loop()
  loop.run_until_complete(main())
  ```

  Shadowsocks-like [client/server](https://github.com/pohmelie/siosocks/blob/master/examples/shadowsocks-like.py). Shadowsocks-like built on top of socks5 and encryption. It have «client», which is actually socks server and «server». So, precisely there are two servers: client side and server side. Purpose of shadowsocks is to encrypt data between «incoming» and «outgoing» servers. In common this looks like:
  ```
  client (non-encrypted socks) «incoming» socks server (encrypted socks) «outgoing» socks server (non-socks connection) target server
  ```
  Example above use Caesar cipher for simplicity (and security of course).

  - [ ] add more backends (average)
  - [ ] speed up `passthrough` implementation (seems hard)
  - [ ] add client redirection


pkgId: fed3b05ad4f97c83f875597994243ca8af1376a912c7d54d22a5d7603e4e44a5
name: python-sip-debuginfo
arch: x86_64
version: 6.7.8
epoch: 0
release: 1
summary: Debug information for package python-sip
url: https://www.riverbankcomputing.com/software/sip/
rpm_license: SIP
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-3e590fc0-a2de-4675-be52-5c210e54b066
rpm_sourcerpm: python-sip-6.7.8-1.src.rpm
location_href: 00011936-python-sip/python-sip-debuginfo-6.7.8-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-sip.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 1c2809364bb6d2bff980c6e1364538c90a1dab9d169cef1e86b66ff579958805
name: python-sip-debugsource
arch: x86_64
version: 6.7.8
epoch: 0
release: 1
summary: Debug sources for package python-sip
url: https://www.riverbankcomputing.com/software/sip/
rpm_license: SIP
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-3e590fc0-a2de-4675-be52-5c210e54b066
rpm_sourcerpm: python-sip-6.7.8-1.src.rpm
location_href: 00011936-python-sip/python-sip-debugsource-6.7.8-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-sip.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 181c5c6e3a0d6127808dbf4cd2941489dc4365660bd3926fabc8a08d891643af
name: python-siphash
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: siphash - python siphash implementation
url: http://github.com/majek/pysiphash#readme
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-da638a76-56c3-4e3b-9516-389ce4972a14
location_href: 00005103-python-siphash/python-siphash-0.0.1-1.src.rpm
checksum_type: sha256
description:
  A Python implementation of [SipHash](https://131002.net/siphash/), a
  fast short-input PRF.
  Extract from the description:
  ```
  SipHash is a family of pseudorandom functions (a.k.a. keyed hash
  functions) optimized for speed on short messages.
  Target applications include network traffic authentication and defense
  against hash-flooding DoS attacks.
  SipHash is secure, fast, and simple (for real):
  * SipHash is simpler and faster than previous cryptographic algorithms
    (e.g. MACs based on universal hashing)
  * SipHash is competitive in performance with insecure
    non-cryptographic algorithms (e.g. MurmurHash)
  * We propose that hash tables switch to SipHash as a hash
    function. Users of SipHash already include OpenDNS, Perl 5, Ruby, or
    Rust.
  ```


pkgId: 34dd02732e9c005693d15a3e56feb88297bf6bae31e5fb0d8cf055be45215f5d
name: python-sipvicious
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: SIPVicious suite is a set of tools that can be used to audit SIP based VoIP systems.
url: https://github.com/EnableSecurity/sipvicious
rpm_license: GPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b493f3f7-8a56-42c3-9ff6-471b0c2c044d
location_href: 00005104-python-sipvicious/python-sipvicious-0.3.4-1.src.rpm
checksum_type: sha256
description:
  ![SIPVicious mascot](https://repository-images.githubusercontent.com/32133566/55b41300-12d9-11eb-89d8-58f60930e3fa)

  SIPVicious OSS is a set of security tools that can be used to audit SIP based VoIP systems. Specifically, it allows you to find SIP servers, enumerate SIP extensions and finally, crack their password.

  To get started read the following:

  - [Getting started on the Wiki](https://github.com/enablesecurity/sipvicious/wiki/Getting-Started)
  - Communication Breakdown blog: [Attacking a real VoIP System with SIPVicious OSS](https://www.rtcsec.com/2020/06/02-attacking-voip-system-with-sipvicious/).

  For usage help make use of `-h` or `--help` switch.



  If you are looking for a professional grade toolset to test your RTC systems, please consider [SIPVicious PRO](https://www.sipvicious.pro).




  The SIPVicious OSS toolset consists of the following tools:

  - svmap
  - svwar
  - svcrack
  - svreport
  - svcrash



  	this is a sip scanner. When launched against
  	ranges of ip address space, it will identify any SIP servers
  	which it finds on the way. Also has the option to scan hosts
  	on ranges of ports.

  	Usage: <https://github.com/EnableSecurity/sipvicious/wiki/SVMap-Usage>



  	identifies working extension lines on a PBX. A working
  	extension is one that can be registered.
  	Also tells you if the extension line requires authentication or not.

  	Usage: <https://github.com/EnableSecurity/sipvicious/wiki/SVWar-Usage>



  	a password cracker making use of digest authentication.
  	It is able to crack passwords on both registrar servers and proxy
  	servers. Current cracking modes are either numeric ranges or
  	words from dictionary files.

  	Usage: <https://github.com/EnableSecurity/sipvicious/wiki/SVCrack-Usage>



  	able to manage sessions created by the rest of the tools
  	and export to pdf, xml, csv and plain text.

  	Usage: <https://github.com/EnableSecurity/sipvicious/wiki/SVReport-Usage>



  	responds to svwar and svcrack SIP messages with a message that
  	causes old versions to crash.

  	Usage: <https://github.com/EnableSecurity/sipvicious/wiki/SVCrash-FAQ>




  Please refer to the [installation documentation](https://github.com/EnableSecurity/sipvicious/wiki/Basics#installation).



  Check out the [wiki](https://github.com/enablesecurity/sipvicious/wiki) for documentation.


pkgId: 8713193ac85b51a71581271e27686a7f60f4ac24d8754b08e1ae1b633bd34b41
name: python-siuba
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: A package for quick, scrappy analyses with pandas and SQL
url: https://github.com/machow/siuba
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-723a141f-c538-447d-908e-09555c361e58
location_href: 00014076-python-siuba/python-siuba-0.4.2-1.src.rpm
checksum_type: sha256
description:
  *scrappy data analysis, with seamless support for pandas and SQL*
  [![CI](https://github.com/machow/siuba/workflows/CI/badge.svg)](https://github.com/machow/siuba/actions?query=workflow%3ACI+branch%3Amain)
  [![Documentation Status](https://img.shields.io/badge/docs-siuba.org-blue.svg)](https://siuba.org)
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/machow/siuba/master)
  <img width="30%" align="right" src="./docs/siuba_small.svg">
  siuba ([小巴](http://www.cantonese.sheik.co.uk/dictionary/words/9139/)) is a port of [dplyr](https://github.com/tidyverse/dplyr) and other R libraries. It supports a tabular data analysis workflow centered on 5 common actions:
  * `select()` - keep certain columns of data.
  * `filter()` - keep certain rows of data.
  * `mutate()` - create or modify an existing column of data.
  * `summarize()` - reduce one or more columns down to a single number.
  * `arrange()` - reorder the rows of data.
  These actions can be preceded by a `group_by()`, which causes them to be applied individually to grouped rows of data. Moreover, many SQL concepts, such as `distinct()`, `count()`, and joins are implemented.
  Inputs to these functions can be a pandas `DataFrame` or SQL connection (currently postgres, redshift, or sqlite).
  For more on the rationale behind tools like dplyr, see this [tidyverse paper](https://tidyverse.tidyverse.org/articles/paper.html).
  For examples of siuba in action, see the [siuba guide](https://siuba.org/guide).


pkgId: 0e91ab8a15ce3ba06a748f0ac45889e9dd7084a6d04d96247ef7610627468cb7
name: python-six
arch: src
version: 1.16.0
epoch: 0
release: 1
summary: Python 2 and 3 compatibility utilities
url: https://github.com/benjaminp/six
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d5b7197c-58ca-4d24-8fb4-fb65fa7ad6d4
location_href: 00008879-python-six/python-six-1.16.0-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://img.shields.io/pypi/v/six.svg
     :target: https://pypi.org/project/six/
     :alt: six on PyPI

  .. image:: https://travis-ci.org/benjaminp/six.svg?branch=master
     :target: https://travis-ci.org/benjaminp/six
     :alt: six on TravisCI

  .. image:: https://readthedocs.org/projects/six/badge/?version=latest
     :target: https://six.readthedocs.io/
     :alt: six's documentation on Read the Docs

  .. image:: https://img.shields.io/badge/license-MIT-green.svg
     :target: https://github.com/benjaminp/six/blob/master/LICENSE
     :alt: MIT License badge

  Six is a Python 2 and 3 compatibility library.  It provides utility functions
  for smoothing over the differences between the Python versions with the goal of
  writing Python code that is compatible on both Python versions.  See the
  documentation for more information on what is provided.

  Six supports Python 2.7 and 3.3+.  It is contained in only one Python
  file, so it can be easily copied into your project. (The copyright and license
  notice must be retained.)

  Online documentation is at https://six.readthedocs.io/.

  Bugs can be reported to https://github.com/benjaminp/six.  The code can also
  be found there.


pkgId: 8183234d205456b5b62846089d0b9286c2e3db16f8a93a1cb1f1faebbacfa766
name: python-skl2onnx
arch: src
version: 1.14.0
epoch: 0
release: 1
summary: Convert scikit-learn models to ONNX
url: https://github.com/onnx/sklearn-onnx
rpm_license: Apache License v2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ef0b10b3-94c8-4238-a146-e06751767caf
location_href: 00010859-python-skl2onnx/python-skl2onnx-1.14.0-1.src.rpm
checksum_type: sha256
description:
  *sklearn-onnx* converts [scikit-learn](https://scikit-learn.org/stable/) models to [ONNX](https://github.com/onnx/onnx).
  Once in the ONNX format, you can use tools like [ONNX Runtime](https://github.com/Microsoft/onnxruntime) for high performance scoring.
  All converters are tested with [onnxruntime](https://onnxruntime.ai/).


  Full documentation including tutorials is available at [https://onnx.ai/sklearn-onnx/](https://onnx.ai/sklearn-onnx/).
  [Supported scikit-learn Models](https://onnx.ai/sklearn-onnx/supported.html)
  Last supported opset is 15.

  You may also find answers in [existing issues](https://github.com/onnx/sklearn-onnx/issues?utf8=%E2%9C%93&q=is%3Aissue)
  or submit a new one.


  You can install from [PyPi](https://pypi.org/project/skl2onnx/):
  ```
  pip install skl2onnx
  ```
  Or you can install from the source with the latest changes.
  ```
  pip install git+https://github.com/onnx/sklearn-onnx.git
  ```


  We welcome contributions in the form of feedback, ideas, or code.


  [Apache License v2.0](LICENSE)


pkgId: 3b76a1488d11e32b7b66a14bf92f0878c22021717486c7eff8a869a527b5733e
name: python-sklearn-nature-inspired-algorithms
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: Search using nature inspired algorithms over specified parameter values for an sklearn estimator.
url: https://github.com/timzatko/Sklearn-Nature-Inspired-Algorithms
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9e3c6945-4f69-479f-9c88-6395f6f042a9
checksum_type: sha256
description:
  [![CI](https://github.com/timzatko/Sklearn-Nature-Inspired-Algorithms/workflows/CI/badge.svg?branch=master)](https://github.com/timzatko/Sklearn-Nature-Inspired-Algorithms/actions?query=workflow:CI+branch:master)
  [![Maintainability](https://api.codeclimate.com/v1/badges/ed99e5c765bf5c95d716/maintainability)](https://codeclimate.com/github/timzatko/Sklearn-Nature-Inspired-Algorithms/maintainability)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/sklearn-nature-inspired-algorithms)
  [![PyPI version](https://badge.fury.io/py/sklearn-nature-inspired-algorithms.svg)](https://pypi.org/project/sklearn-nature-inspired-algorithms/)
  [![PyPI downloads](https://img.shields.io/pypi/dm/sklearn-nature-inspired-algorithms)](https://pypi.org/project/sklearn-nature-inspired-algorithms/)
  [![Fedora package](https://img.shields.io/fedora/v/python3-sklearn-nature-inspired-algorithms?color=blue&label=Fedora%20Linux&logo=fedora)](https://src.fedoraproject.org/rpms/python-sklearn-nature-inspired-algorithms)

  Nature-inspired algorithms for hyper-parameter tuning of [scikit-learn](https://github.com/scikit-learn/scikit-learn) models. This package uses algorithms implementation from [NiaPy](https://github.com/NiaOrg/NiaPy).



  ```shell script
  $ pip install sklearn-nature-inspired-algorithms
  ```

  To install this package on Fedora, run:

  ```sh
  $ dnf install python3-sklearn-nature-inspired-algorithms
  ```



  The usage is similar to using sklearn's `GridSearchCV`. Refer to the [documentation](https://sklearn-nature-inspired-algorithms.readthedocs.io/en/stable/) for more detailed guides and more examples.

  ```python
  from sklearn_nature_inspired_algorithms.model_selection import NatureInspiredSearchCV
  from sklearn.ensemble import RandomForestClassifier

  param_grid = {
      'n_estimators': range(20, 100, 20),
      'max_depth': range(2, 40, 2),
      'min_samples_split': range(2, 20, 2),
      'max_features': ["auto", "sqrt", "log2"],
  }

  clf = RandomForestClassifier(random_state=42)

  nia_search = NatureInspiredSearchCV(
      clf,
      param_grid,
      algorithm='hba', # hybrid bat algorithm
      population_size=50,
      max_n_gen=100,
      max_stagnating_gen=10,
      runs=3,
      random_state=None, # or any number if you want same results on each run
  )

  nia_search.fit(X_train, y_train)



  new_clf = RandomForestClassifier(**nia_search.best_params_, random_state=42)
  ```

  Also you plot the search process with _line plot_ or _violin plot_.

  ```python
  from sklearn_nature_inspired_algorithms.helpers import score_by_generation_lineplot, score_by_generation_violinplot


  score_by_generation_lineplot(nia_search, metric='max')


  score_by_generation_violinplot(nia_search, run=0)
  ```

  Jupyter notebooks with full examples are available in [here](examples/notebooks).



  If you do not want to use any of the pre-defined algorithm configurations, you can use any algorithm from the  [NiaPy](https://github.com/NiaOrg/NiaPy) collection.
  This will allow you to have more control of the algorithm behavior.
  Refer to their [documentation](https://niapy.readthedocs.io/en/latest/) and [examples](https://github.com/NiaOrg/NiaPy/tree/master/examples) for the usage.

  __Note:__ Use version >2.x.x of NiaPy package

  ```python
  from niapy.algorithms.basic import GeneticAlgorithm

  algorithm = GeneticAlgorithm() # when custom algorithm is provided random_state is ignored
  algorithm.set_parameters(NP=50, Ts=5, Mr=0.25)

  nia_search = NatureInspiredSearchCV(
      clf,
      param_grid,
      algorithm=algorithm,
      population_size=50,
      max_n_gen=100,
      max_stagnating_gen=20,
      runs=3,
  )

  nia_search.fit(X_train, y_train)
  ```



  Detailed information on the contribution guidelines are in the [CONTRIBUTING.md](./CONTRIBUTING.md).

location_href:
  00005105-python-sklearn-nature-inspired-algorithms/python-sklearn-nature-inspired-algorithms-0.11.0-1.src.rpm


pkgId: 0e72803d3bce797936f137f33f29f684a19c85cc3e56d665da1ecad135dbe265
name: python-slack-webhook
arch: src
version: 1.0.7
epoch: 0
release: 1
url: https://github.com/10mohi6/slack-webhook-python
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-63c7f58e-d755-4a75-8222-af198bc105d8
location_href: 00011617-python-slack-webhook/python-slack-webhook-1.0.7-1.src.rpm
checksum_type: sha256
summary:
  slack-webhook is a python client library for slack api         Incoming Webhooks on Python 3.6 and above.

description:
  [![PyPI](https://img.shields.io/pypi/v/slack-webhook)](https://pypi.org/project/slack-webhook/)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![codecov](https://codecov.io/gh/10mohi6/slack-webhook-python/branch/master/graph/badge.svg)](https://codecov.io/gh/10mohi6/slack-webhook-python)
  [![Build Status](https://travis-ci.com/10mohi6/slack-webhook-python.svg?branch=master)](https://travis-ci.com/10mohi6/slack-webhook-python)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/slack-webhook)](https://pypi.org/project/slack-webhook/)
  [![Downloads](https://pepy.tech/badge/slack-webhook)](https://pepy.tech/project/slack-webhook)

  slack-webhook is a python client library for slack api Incoming Webhooks on Python 3.6 and above.




      $ pip install slack-webhook




  ```python
  from slack_webhook import Slack

  slack = Slack(url='https://hooks.slack.com/services/T00/B00/XXX')
  slack.post(text="Hello, world.")
  ```


  ```python
  from slack_webhook import Slack

  slack = Slack(url='https://hooks.slack.com/services/T00/B00/XXX')
  slack.post(text="Robert DeSoto added a new task",
      attachments = [{
          "fallback": "Plan a vacation",
          "author_name": "Owner: rdesoto",
          "title": "Plan a vacation",
          "text": "I've been working too hard, it's time for a break.",
          "actions": [
              {
                  "name": "action",
                  "type": "button",
                  "text": "Complete this task",
                  "style": "",
                  "value": "complete"
              },
              {
                  "name": "tags_list",
                  "type": "select",
                  "text": "Add a tag...",
                  "data_source": "static",
                  "options": [
                      {
                          "text": "Launch Blocking",
                          "value": "launch-blocking"
                      },
                      {
                          "text": "Enhancement",
                          "value": "enhancement"
                      },
                      {
                          "text": "Bug",
                          "value": "bug"
                      }
                  ]
              }
          ]
      }]
  )
  ```



  For help getting started with Incoming Webhooks, view our online [documentation](https://api.slack.com/incoming-webhooks).




  1. Fork it
  2. Create your feature branch (`git checkout -b my-new-feature`)
  3. Commit your changes (`git commit -am 'Add some feature'`)
  4. Push to the branch (`git push origin my-new-feature`)
  5. Create new Pull Request


pkgId: 8d86716a113577ce67ad0d477b3cc7543a4da2bcf64c49747c292c1572bf9343
name: python-slackclient
arch: src
version: 2.9.4
epoch: 0
release: 1
url: https://github.com/slackapi/python-slack-sdk
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9c1e375f-86c5-4c33-8424-3bd047e248d8
location_href: 00005106-python-slackclient/python-slackclient-2.9.4-1.src.rpm
checksum_type: sha256
summary:
  Slack API clients for Web API and RTM API (Legacy) - Please use https://pypi.org/project/slack-sdk/ instead.

description:
  This library requires Python 3.6 and above. If you require Python 2, please use our [SlackClient - v1.x][slackclientv1]. If you're unsure how to check what version of Python you're on, you can check it using the following:
  > **Note:** You may need to use `python3` before your commands to ensure you use the correct Python path. e.g. `python3 --version`
  ```bash
  python --version
  -- or --
  python3 --version
  ```

  We recommend using [PyPI][pypi] to install the Slack Developer Kit for Python.
  ```bash
  $ pip3 install slackclient
  ```


pkgId: fda3733ab0d580d2685706b144354fb8eb073194d74e7569c0d27f7107c8d178
name: python-slicer
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: A small package for big slicing.
url: https://github.com/interpretml/slicer
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c7d60159-6068-469b-9913-1362c074047b
location_href: 00009266-python-slicer/python-slicer-0.0.7-1.src.rpm
checksum_type: sha256
description:
  ![License](https://img.shields.io/github/license/interpretml/slicer.svg?style=flat-square)
  ![Python Version](https://img.shields.io/pypi/pyversions/slicer.svg?style=flat-square)
  ![Package Version](https://img.shields.io/pypi/v/slicer.svg?style=flat-square)
  ![Build Status](https://img.shields.io/azure-devops/build/ms/interpret/405/master?style=flat-square)
  ![Coverage](https://img.shields.io/azure-devops/coverage/ms/interpret/405/master.svg?style=flat-square)
  ![Maintenance](https://img.shields.io/maintenance/yes/2020.svg?style=flat-square)

  *(Equal Contribution) Samuel Jenkins & Harsha Nori & Scott Lundberg*

  **slicer** wraps tensor-like objects and provides a uniform slicing interface via `__getitem__`.

  <br/>
  It supports many data types including:

  &nbsp;&nbsp;
  [numpy](https://github.com/numpy/numpy) |
  [pandas](https://github.com/pandas-dev/pandas) |
  [scipy](https://docs.scipy.org/doc/scipy/reference/sparse.html) |
  [pytorch](https://github.com/pytorch/pytorch) |
  [list](https://github.com/python/cpython) |
  [tuple](https://github.com/python/cpython) |
  [dict](https://github.com/python/cpython)

  And enables upgraded slicing functionality on its objects:
  ```python

  S(df)[:, ["Age", "Income"]]


  S(nested_list)[..., :5]
  ```

  It can also simultaneously slice many objects at once:
  ```python

  S(first=df, second=ar)[0, :]
  ```

  This package has **0** dependencies. Not even one.



  Python 3.6+ | Linux, Mac, Windows
  ```sh
  pip install slicer
  ```



  Basic anonymous slicing:
  ```python
  from slicer import Slicer as S
  li = [[1, 2, 3], [4, 5, 6]]
  S(li)[:, 0:2].o

  di = {'x': [1, 2, 3], 'y': [4, 5, 6]}
  S(di)[:, 0:2].o

  ```

  Basic named slicing:
  ```python
  import pandas as pd
  import numpy as np
  df = pd.DataFrame({'A': [1, 3], 'B': [2, 4]})
  ar = np.array([[5, 6], [7, 8]])
  sliced = S(first=df, second=ar)[0, :]
  sliced.first



  sliced.second

  ```

  Real example:
  ```python
  from slicer import Slicer as S
  from slicer import Alias as A

  data = [[1, 2], [3, 4]]
  values = [[5, 6], [7, 8]]
  identifiers = ["id1", "id1"]
  instance_names = ["r1", "r2"]
  feature_names = ["f1", "f2"]
  full_name = "A"

  slicer = S(
      data=data,
      values=values,
      
      
      identifiers=A(identifiers, 0),
      instance_names=A(instance_names, 0),
      feature_names=A(feature_names, 1),
      full_name=full_name,
  )

  sliced = slicer[:, 1]  # Tensor-like parallel slicing on all objects
  assert sliced.data == [2, 4]
  assert sliced.instance_names == ["r1", "r2"]
  assert sliced.feature_names == "f2"
  assert sliced.values == [6, 8]

  sliced = slicer["r1", "f2"]  # Example use of aliasing
  assert sliced.data == 2
  assert sliced.feature_names == "f2"
  assert sliced.instance_names == "r1"
  assert sliced.values == 6
  ```


  Raise an issue on GitHub, or contact us at interpret@microsoft.com


pkgId: a5919e95c332364c6c4c86ddfc55309d0ea6e281120a863efdd791ba830e6735
name: python-slixmpp
arch: src
version: 1.8.3
epoch: 0
release: 1
summary: Slixmpp is an elegant Python library for XMPP (aka Jabber).
url: https://lab.louiz.org/poezio/slixmpp
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3eac901d-05cc-4f26-9296-1bdd6e434b2d
location_href: 00005110-python-slixmpp/python-slixmpp-1.8.3-1.src.rpm
checksum_type: sha256
description:
  Slixmpp can make use of cython to improve performance on critical modules.
  To do that, **cython3** is necessary along with **libidn** headers.
  Otherwise, no compilation is needed. Building is done by running setup.py::
      python3 setup.py build_ext --inplace


pkgId: 61d773b05657f041180e224bd53e4e287c9d40c73df8f0cbe6ad289b5dc1c71d
name: python-smbprotocol
arch: src
version: 1.10.1
epoch: 0
release: 1
summary: Interact with a server using the SMB 2/3 Protocol
url: https://pypi.org/project/smbprotocol/
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8a3d72de-156b-4346-8910-98800a0b6288
location_href: 00010516-python-smbprotocol/python-smbprotocol-1.10.1-1.src.rpm
checksum_type: sha256
description:
  SMBv2 and v3 Client for Python.


  [![Test workflow](https://github.com/jborean93/smbprotocol/actions/workflows/ci.yml/badge.svg)](https://github.com/jborean93/smbprotocol/actions/workflows/ci.yml)
  [![codecov](https://codecov.io/gh/jborean93/smbprotocol/branch/master/graph/badge.svg)](https://codecov.io/gh/jborean93/smbprotocol)
  [![PyPI version](https://badge.fury.io/py/smbprotocol.svg)](https://badge.fury.io/py/smbprotocol)
  [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/jborean93/smbprotocol/blob/master/LICENSE)

  SMB is a network file sharing protocol and has numerous iterations over the
  years. This library implements the SMBv2 and SMBv3 protocol based on the
  [MS-SMB2](https://msdn.microsoft.com/en-us/library/cc246482.aspx) document.




  * Negotiation of the SMB 2.0.2 protocol to SMB 3.1.1 (Windows 10/Server 2016)
  * Authentication with both NTLM and Kerberos
  * Message signing
  * Message encryption (SMB 3.x.x+)
  * Connect to a Tree/Share
  * Opening of files, pipes and directories
  * Set create contexts when opening files
  * Read and writing of files and pipes
  * Sending IOCTL commands
  * Sending of multiple messages in one packet (compounding)
  * Experimental support for both standalone and DFS server shares

  This is definitely not feature complete as SMB is quite a complex protocol, see
  backlog for features that would be nice to have in this library.




  * Python 3.7+
  * For Kerberos auth on Linux
      * [python-gssapi](https://github.com/pythongssapi/python-gssapi)
      * [pykrb5](https://github.com/jborean93/pykrb5)

  To use Kerberos authentication on Linux, further dependencies are required, to install these dependencies run

  ```bash

  sudo apt-get install gcc python-dev libkrb5-dev
  pip install smbprotocol[kerberos]


  sudo yum install gcc python-devel krb5-devel krb5-workstation python-devel
  pip install smbprotocol[kerberos]
  ```

  Kerberos auth with Windows should just work out of the box with the `pyspnego` library but on Linux, the
  `python-gssapi` library must be installed and `smbprotocol` requires a particular GSSAPI extension to be available to
  work. This extension should be installed on the majority of MIT or Heimdal Kerberos installs but that is not a
  guarantee. To verify that Kerberos is available on Linux you can run the following check in a Python console:

  ```python
  try:
      from gssapi.raw import inquire_sec_context_by_oid
      print("python-gssapi extension is available")
  except ImportError as exc:
      print("python-gssapi extension is not available: %s" % str(exc))
  ```

  If it isn't available, then either a newer version of the system's gssapi implementation needs to be setup and
  python-gssapi compiled against that newer version. In the absence of this extension, only NTLM auth is used.




  To install smbprotocol, simply run

  ```bash
  pip install smbprotocol


  pip install smbprotocol[kerberos]
  ```

  This will download the required packages that are used in this package and get
  your Python environment ready to go.




  One of the first steps as part of the SMB protocol is to negotiate the dialect
  used and other features that are available. Currently smbprotocol supports
  the following dialects;

  * `2.0.0`: Added with Server 2008/Windows Vista
  * `2.1.0`: Added with Server 2008 R2/Windows 7
  * `3.0.0`: Added with Server 2012/Windows 8
  * `3.0.2`: Added with Server 2012 R2/Windows 8.1
  * `3.1.1`: Added with Server 2016/Windows10

  Each dialect adds in more features to the protocol where some are minor but
  some are major. One major changes is in Dialect 3.x where it added message
  encryption. Message encryption is set to True by default and needs to be
  overridden when creating a Session object for the older dialects.

  By default, the negotiation process will use the latest dialect that is
  supported by the server but this can be overridden if required. When this is
  done by the following code

  ```python
  import uuid

  from smbprotocol.connection import Connection, Dialects

  connection = Connection(uuid.uuid4(), "server", 445)
  connection.connect(Dialects.SMB_3_0_2)
  ```

  While you shouldn't want to downgrade to an earlier version, this does allow
  you to set a minimum dialect version if required.




  There are 2 different APIs you can use with this library.

  * `smbprotocol`: Low level interface that can do whatever you want but quite verbose
  * `smbclient`: Higher level interface that implements the builtin `os` and `os.path` file system functions but for SMB support

  The `examples` folder contains some examples of both the high and low level
  interface but for everyday user's it is recommended to use `smbclient` as it
  is a lot simpler.



  The higher level interface `smbclient` is designed to make this library easier
  for people to use for simple and common use cases. It is designed to replicate
  the builtin `os` and `os.path` filesystem functions like `os.open()`,
  `os.stat()`, and `os.path.exists()`. It is also designed to handle connections
  to a DFS target unlike `smbprotocol`.

  A connection made by `smbclient` is kept in a pool and re-used for future
  requests to the same server until the Python process exists. This makes
  authentication simple and only required for the first call to the server. Any
  DFS referrals are also cached in that Python process. This optimises any
  future requests to that same DFS namespace.

  The functions in `smbclient` have a global config object that can be used to
  set any connection defaults to use for any future connections. It can also be
  used to specify any domain based DFS settings for more advanced setups. It is
  recommended to use `ClientConfig()` to set any global credentials like so:

  ```python
  import smbclient

  smbclient.ClientConfig(username='user', password='password')
  ```

  The `ClientConfig` is a singleton and any future instanciations of that
  object will just update the keys being set. You can set the following keys on
  the `ClientConfig`:

  * `client_guid`: The client GUID to identify the client to the server on a new connection
  * `username`: The default username to use when creating a new SMB session if explicit credentials weren't set
  * `password`: The default password to use for authentication
  * `domain_controller`: The domain controller hostname. This is useful for environments with DFS servers as it is used to identify the DFS domain information automatically
  * `skip_dfs`: Whether to skip doing any DFS resolution, useful if there is a bug or you don't want to waste any roundtrip requesting referrals
  * `auth_protocol`: The authentication protocol to use; `negotiate` (default), `kerberos`, or `ntlm`
  * `require_secure_negotiate`: Control whether the client validates the negotiation info when connecting to a share (default: `True`).
      * More information can be found on [SMB3 Secure Dialect Negotiation](https://docs.microsoft.com/en-us/archive/blogs/openspecification/smb3-secure-dialect-negotiation)

  As well as setting the default credentials on the `ClientConfig` you can also
  specify the credentials and other connection parameters on each `smbclient`
  function or when registering a new server. These functions accept the
  following kwargs:

  * `username`: The username used to connect to the share
  * `password`: The password used to connect to the share
  * `port`: Override the default port (`445`) to connect to
  * `encrypt`: Whether to force encryption on the connection, requires SMBv3 or newer on the remote server (default: `False`)
  * `connection_timeout`: Override the connection timeout in seconds (default: `60`)

  If using Kerberos authentication and a Kerberos ticket has already set by
  `kinit` then `smbclient` will automatically use those credentials without
  having to be explicitly set. If no ticket has been retrieved or you wish to use
  different credentials then set the default credentials on the `ClientConfig`
  or specify `username` and `password` on the first request to the server.

  For example I only need to set the credentials on the first request to create
  the directory and not for the subsequent file creation in that dir.

  ```python
  import smbclient


  smbclient.ClientConfig(username='user', password='pass')


  smbclient.register_session("server", username="user", password="pass")

  smbclient.mkdir(r"\\server\share\directory", username="user", password="pass")

  with smbclient.open_file(r"\\server\share\directory\file.txt", mode="w") as fd:
      fd.write(u"file contents")
  ```

  If you wish to reset the cache you can either start a new Python process or
  call `smbclient.reset_connection_cache()` to close all the connections that
  have been cached by the client.




  This library makes use of the builtin Python logging facilities. Log messages
  are logged to the `smbprotocol` named logger as well as `smbprotocol.*` where
  `*` is each python script in the `smbprotocol` directory.

  These logs are really useful when debugging issues as they give you a more
  step by step snapshot of what it is doing and what may be going wrong. The
  debug side will also print out a human readable string of each SMB packet that
  is sent out from the client so it can get very verbose.




  To this module, you need to install some pre-requisites first. This can be done
  by running;

  ```bash
  pip install -r requirements-test.txt


  pip install tox
  ```

  From there to run the basic tests run;

  ```bash
  py.test -v --pep8 --cov smbprotocol --cov-report term-missing


  tox
  ```

  There are extra tests that only run when certain environment variables are set.
  To run these tests set the following variables;

  * `SMB_USER`: The username to authenticate with
  * `SMB_PASSWORD`: The password to authenticate with
  * `SMB_SERVER`: The IP or hostname of the server to authenticate with
  * `SMB_PORT`: The port the SMB server is listening on, default is `445`
  * `SMB_SHARE`: The name of the share to connect to, a share with this name must exist as well as a share with the name`$SMB_SHARE-encrypted` must also exist that forces encryption

  From here running `tox` or `py.test` with these environment variables set will
  activate the integration tests.

  This requires either Windows 10 or Server 2016 as they support Dialect 3.1.1
  which is required by the tests.

  If you don't have access to a Windows host, you can use Docker to setup a
  Samba container and use that as part of the tests. To do so run the following
  bash commands;

  ```bash
  source ./build_helpers/lib.sh

  lib::setup::smb_server
  ```

  This command will also set the required `SMB_*` env vars used in testing.




  Here is a list of features that I would like to incorporate, PRs are welcome
  if you want to implement them yourself;

  * Multiple channel support to speed up large data transfers
  * Lots and lots more...

rpm_license:
  MIT License  Copyright (c) 2017 Jordan Borean, Red Hat  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: 8ab66109486822c44107fb3b5b4eeba4051d4a5e2a23fff8828001a0fcd776c1
name: python-smbus2
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: smbus2 is a drop-in replacement for smbus-cffi/smbus-python in pure Python
url: https://github.com/kplindegaard/smbus2
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9c4c5fe3-9be8-40a5-a2c7-bb9e27f9bdcf
location_href: 00013647-python-smbus2/python-smbus2-0.4.2-1.src.rpm
checksum_type: sha256
description:
  A drop-in replacement for smbus-cffi/smbus-python in pure Python

  [![Build Status](https://github.com/kplindegaard/smbus2/actions/workflows/python-build-test.yml/badge.svg?branch=master)](https://github.com/kplindegaard/smbus2/actions/workflows/python-build-test.yml)
  [![Documentation Status](https://readthedocs.org/projects/smbus2/badge/?version=latest)](http://smbus2.readthedocs.io/en/latest/?badge=latest)
  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=kplindegaard_smbus2&metric=alert_status)](https://sonarcloud.io/dashboard?id=kplindegaard_smbus2)

  ![Python Verions](https://img.shields.io/pypi/pyversions/smbus2.svg)
  [![PyPi Version](https://img.shields.io/pypi/v/smbus2.svg)](https://pypi.org/project/smbus2/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/smbus2)](https://pypi.org/project/smbus2/)



  smbus2 is (yet another) pure Python implementation of of the [python-smbus](http://www.lm-sensors.org/browser/i2c-tools/trunk/py-smbus/) package.

  It was designed from the ground up with two goals in mind:

  1. It should be a drop-in replacement of smbus. The syntax shall be the same.
  2. Use the inherent i2c structs and unions to a greater extent than other pure Python implementations like [pysmbus](https://github.com/bjornt/pysmbus) does. By doing so, it will be more feature complete and easier to extend.

  Currently supported features are:

  * Get i2c capabilities (I2C_FUNCS)
  * SMBus Packet Error Checking (PEC) support
  * read_byte
  * write_byte
  * read_byte_data
  * write_byte_data
  * read_word_data
  * write_word_data
  * read_i2c_block_data
  * write_i2c_block_data
  * write_quick
  * process_call
  * read_block_data
  * write_block_data
  * block_process_call
  * i2c_rdwr - *combined write/read transactions with repeated start*

  It is developed on Python 2.7 but works without any modifications in Python 3.X too.

  More information about updates and general changes are recorded in the [change log](https://github.com/kplindegaard/smbus2/blob/master/CHANGELOG.md).



  smbus2 installs next to smbus as the package, so it's not really a 100% replacement. You must change the module name.



  ```python
  from smbus2 import SMBus


  bus = SMBus(1)
  b = bus.read_byte_data(80, 0)
  print(b)
  bus.close()
  ```



  This is the very same example but safer to use since the smbus will be closed automatically when exiting the with block.

  ```python
  from smbus2 import SMBus

  with SMBus(1) as bus:
      b = bus.read_byte_data(80, 0)
      print(b)
  ```



  Same example with Packet Error Checking enabled.

  ```python
  from smbus2 import SMBus

  with SMBus(1) as bus:
      bus.pec = 1  # Enable PEC
      b = bus.read_byte_data(80, 0)
      print(b)
  ```



  You can read up to 32 bytes at once.

  ```python
  from smbus2 import SMBus

  with SMBus(1) as bus:
      
      block = bus.read_i2c_block_data(80, 0, 16)
      
      print(block)
  ```



  ```python
  from smbus2 import SMBus

  with SMBus(1) as bus:
      
      data = 45
      bus.write_byte_data(80, 0, data)
  ```



  It is possible to write 32 bytes at the time, but I have found that error-prone. Write less and add a delay in between if you run into trouble.

  ```python
  from smbus2 import SMBus

  with SMBus(1) as bus:
      
      data = [1, 2, 3, 4, 5, 6, 7, 8]
      bus.write_i2c_block_data(80, 0, data)
  ```



  Starting with v0.2, the smbus2 library also has support for combined read and write transactions. *i2c_rdwr* is not really a SMBus feature but comes in handy when the master needs to:

  1. read or write bulks of data larger than SMBus' 32 bytes limit.
  1. write some data and then read from the slave with a repeated start and no stop bit between.

  Each operation is represented by a *i2c_msg* message object.




  ```python
  from smbus2 import SMBus, i2c_msg

  with SMBus(1) as bus:
      
      msg = i2c_msg.read(80, 64)
      bus.i2c_rdwr(msg)

      
      msg = i2c_msg.write(80, [65])
      bus.i2c_rdwr(msg)

      
      msg = i2c_msg.write(80, [65, 66, 67, 68])
      bus.i2c_rdwr(msg)
  ```



  To perform dual operations just add more i2c_msg instances to the bus call:

  ```python
  from smbus2 import SMBus, i2c_msg


  write = i2c_msg.write(80, [40, 50])
  read = i2c_msg.read(80, 2)
  with SMBus(1) as bus:
      bus.i2c_rdwr(write, read)
  ```



  All data is contained in the i2c_msg instances. Here are some data access alternatives.

  ```python

  msg = i2c_msg.write(60, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
  data = list(msg)  # data = [1, 2, 3, ...]
  print(len(data))  # => 10


  for value in msg:
      print(value)


  for k in range(msg.len):
      print(msg.buf[k])
  ```



  From [PyPi](https://pypi.org/) with `pip`:

  ```
  pip install smbus2
  ```

  From [conda-forge](https://anaconda.org/conda-forge) using `conda`:

  ```
  conda install -c conda-forge smbus2
  ```

  Installation from source code is straight forward:

  ```
  python setup.py install
  ```


pkgId: a5a53d41b295263a33d7954f73289b3c84b49bdca919fad0c18cb5e5b58b247f
name: python-smmap
arch: src
version: 5.0.0
epoch: 0
release: 1
summary: A pure Python implementation of a sliding window memory map manager
url: https://github.com/gitpython-developers/smmap
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7208bf8b-d8ed-4f4e-924e-a3a493715b54
location_href: 00005118-python-smmap/python-smmap-5.0.0-1.src.rpm
checksum_type: sha256
description:
  When reading from many possibly large files in a fashion similar to random access, it is usually the fastest and most efficient to use memory maps.

  Although memory maps have many advantages, they represent a very limited system resource as every map uses one file descriptor, whose amount is limited per process. On 32 bit systems, the amount of memory you can have mapped at a time is naturally limited to theoretical 4GB of memory, which may not be enough for some applications.




  * **System resources (file-handles) are likely to be leaked!** This is due to the library authors reliance on a deterministic `__del__()` destructor.
  * The memory access is read-only by design.




  ![Python package](https://github.com/gitpython-developers/smmap/workflows/Python%20package/badge.svg)

  Smmap wraps an interface around mmap and tracks the mapped files as well as the amount of clients who use it. If the system runs out of resources, or if a memory limit is reached, it will automatically unload unused maps to allow continued operation.

  To allow processing large files even on 32 bit systems, it allows only portions of the file to be mapped. Once the user reads beyond the mapped region, smmap will automatically map the next required region, unloading unused regions using a LRU algorithm.

  Although the library can be used most efficiently with its native interface, a Buffer implementation is provided to hide these details behind a simple string-like interface.

  For performance critical 64 bit applications, a simplified version of memory mapping is provided which always maps the whole file, but still provides the benefit of unloading unused mappings on demand.





  * Python 3.6+
  * OSX, Windows or Linux

  The package was tested on all of the previously mentioned configurations.



  [![Documentation Status](https://readthedocs.org/projects/smmap/badge/?version=latest)](https://readthedocs.org/projects/smmap/?badge=latest)

  Its easiest to install smmap using the [pip](http://www.pip-installer.org/en/latest) program:

  ```bash
  $ pip install smmap
  ```

  As the command will install smmap in your respective python distribution, you will most likely need root permissions to authorize the required changes.

  If you have downloaded the source archive, the package can be installed by running the `setup.py` script:

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

  It is advised to have a look at the **Usage Guide** for a brief introduction on the different database implementations.





  The project is home on github at https://github.com/gitpython-developers/smmap .

  The latest source can be cloned from github as well:

  * git://github.com/gitpython-developers/smmap.git


  For support, please use the git-python mailing list:

  * http://groups.google.com/group/git-python


  Issues can be filed on github:

  * https://github.com/gitpython-developers/smmap/issues

  A link to the pypi page related to this repository:

  * https://pypi.org/project/smmap/




  *smmap* is licensed under the New BSD License.


pkgId: 1114dd1f1180fff296104f09e2fc4012a0c1489c16470c0566b7d2e5ed67737d
name: python-smtpapi
arch: src
version: 0.4.12
epoch: 0
release: 1
summary: Simple wrapper to use SendGrid SMTP API
url: https://github.com/sendgrid/smtpapi-python/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f8a2d8a9-0013-412d-8756-606859c41ac5
location_href: 00012700-python-smtpapi/python-smtpapi-0.4.12-1.src.rpm
checksum_type: sha256
description:
  **The default branch name for this repository has been changed to `main` as of 07/27/2020.**
  All the updates to this module are documented in our `CHANGELOG`_.


pkgId: 1532ab0f6994382fdb780cc1e6afec8d7fd54854a45a887b06a75d40e902805d
name: python-snack
arch: src
version: 0.0.3
epoch: 0
release: 1
description: Quick and dirty visualization of large-scale datasets via concept embeddings
url: http://vision.cornell.edu/se3/projects/concept-embeddings/
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-01f41d28-c71f-4664-b590-27e656d57c2b
location_href: 00005119-python-snack/python-snack-0.0.3-1.src.rpm
checksum_type: sha256
summary:
  Stochastic Neighbor and Crowd Kernel (SNaCK) embeddings: Quick and dirty visualization of large-scale datasets via concept embeddings


pkgId: fca6ae24770c97d7152aa9d113359f066a1d7f94ad2c5a2849bc2557f4e1f076
name: python-snallygaster
arch: src
version: 0.0.12
epoch: 0
release: 1
summary: Tool to scan for secret files on HTTP servers
url: https://github.com/hannob/snallygaster
rpm_license: CC0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6868b289-011f-4975-ab8c-7bc748044c02
location_href: 00005120-python-snallygaster/python-snallygaster-0.0.12-1.src.rpm
checksum_type: sha256
description:
  snallygaster is a tool that looks for files accessible on web servers that shouldn't be public
  and can pose a security risk.
  Typical examples include publicly accessible git repositories, backup files potentially containing
  passwords or database dumps. In addition, it contains a few checks for other security vulnerabilities.
  As an introduction to these kinds of issues you may want to watch this talk:
  * [Attacking with HTTP Requests](https://www.youtube.com/watch?v=Bppr9rbmwz4)
  See the [TESTS.md](TESTS.md) file for an overview of all tests and links to further information
  about the issues.


pkgId: ab2697f9e10704f79b1a341dfea769c1c434f3887eeba899fc27b556d271f895
name: python-snappy
arch: src
version: 3.0.3
epoch: 0
release: 1
summary: Studying the topology and geometry of 3-manifolds, with a focus on hyperbolic structures.
url: http://snappy.computop.org
rpm_license: GPLv2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-488eb033-e27d-42bb-9723-608a994b1e6c
location_href: 00005121-python-snappy/python-snappy-3.0.3-1.src.rpm
checksum_type: sha256
description:
  SnapPy is a package for studying the topology and geometry of
  3-manifolds, with a focus on hyperbolic structures.  It is based on
  the SnapPea kernel written by `Jeff Weeks
  <http://www.geometrygames.org>`_.
  Complete documentation is available on the web including the `main
  page <http://snappy.computop.org>`_ and an `installation guide
  <http://snappy.computop.org/installing.html>`_.  You can also browse
  the `source code <https://github.com/3-manifolds/SnapPy>`_.


pkgId: 112a3e99e01c3c4a2d1af450c945812d49bd3e3760b07977d4839bf8114a604a
name: python-snapshottest
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Snapshot testing for pytest, unittest, Django, and Nose
url: https://github.com/syrusakbary/snapshottest
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-63ff97af-fd8f-4873-9fd3-1e8683e0b0ea
location_href: 00010100-python-snapshottest/python-snapshottest-0.6.0-1.src.rpm
checksum_type: sha256
description:
  [travis-image]: https://img.shields.io/travis/syrusakbary/snapshottest.svg?style=flat
  [travis-url]: https://travis-ci.org/syrusakbary/snapshottest
  [pypi-image]: https://img.shields.io/pypi/v/snapshottest.svg?style=flat
  [pypi-url]: https://pypi.python.org/pypi/snapshottest


  Snapshot testing is a way to test your APIs without writing actual test cases.

  1. A snapshot is a single state of your API, saved in a file.
  2. You have a set of snapshots for your API endpoints.
  3. Once you add a new feature, you can generate *automatically* new snapshots for the updated API.



      $ pip install snapshottest




  ```python
  from snapshottest import TestCase

  class APITestCase(TestCase):
      def test_api_me(self):
          """Testing the API for /me"""
          my_api_response = api.client.get('/me')
          self.assertMatchSnapshot(my_api_response)

          
          my_gpg_response = api.client.get('/me?gpg_key')
          self.assertMatchSnapshot(my_gpg_response, 'gpg_response')
  ```

  If you want to update the snapshots automatically you can use the `nosetests --snapshot-update`.

  Check the [Unittest example](https://github.com/syrusakbary/snapshottest/tree/master/examples/unittest).



  ```python
  def test_mything(snapshot):
      """Testing the API for /me"""
      my_api_response = api.client.get('/me')
      snapshot.assert_match(my_api_response)

      
      my_gpg_response = api.client.get('/me?gpg_key')
      snapshot.assert_match(my_gpg_response, 'gpg_response')
  ```

  If you want to update the snapshots automatically you can use the `--snapshot-update` config.

  Check the [Pytest example](https://github.com/syrusakbary/snapshottest/tree/master/examples/pytest).


  Add to your settings:
  ```python
  TEST_RUNNER = 'snapshottest.django.TestRunner'
  ```
  To create your snapshottest:
  ```python
  from snapshottest.django import TestCase

  class APITestCase(TestCase):
      def test_api_me(self):
          """Testing the API for /me"""
          my_api_response = api.client.get('/me')
          self.assertMatchSnapshot(my_api_response)
  ```
  If you want to update the snapshots automatically you can use the `python manage.py test --snapshot-update`.
  Check the [Django example](https://github.com/syrusakbary/snapshottest/tree/master/examples/django_project).



  Set the environment variable `ANSI_COLORS_DISABLED` (to any value), e.g.

      ANSI_COLORS_DISABLED=1 pytest




  After cloning this repo and configuring a virtualenv for snapshottest (optional, but highly recommended), ensure dependencies are installed by running:

  ```sh
  make install
  ```

  After developing, the full test suite can be evaluated by running:

  ```sh
  make lint

  make test
  ```



  This package is heavily inspired in [jest snapshot testing](https://facebook.github.io/jest/docs/snapshot-testing.html).



  > Most of this content is taken from the [Jest snapshot blogpost](https://facebook.github.io/jest/blog/2016/07/27/jest-14.html).

  We want to make it as frictionless as possible to write good tests that are useful.
  We observed that when engineers are provided with ready-to-use tools, they end up writing more tests, which in turn results in stable and healthy code bases.

  However engineers frequently spend more time writing a test than the component itself. As a result many people stopped writing tests altogether which eventually led to instabilities.

  A typical snapshot test case for a mobile app renders a UI component, takes a screenshot, then compares it to a reference image stored alongside the test. The test will fail if the two images do not match: either the change is unexpected, or the screenshot needs to be updated to the new version of the UI component.




  A similar approach can be taken when it comes to testing your APIs.
  Instead of rendering the graphical UI, which would require building the entire app, you can use a test renderer to quickly generate a serializable value for your API response.




  [MIT License](https://github.com/syrusakbary/snapshottest/blob/master/LICENSE)

  [![coveralls][coveralls-image]][coveralls-url]

  [coveralls-image]: https://coveralls.io/repos/syrusakbary/snapshottest/badge.svg?branch=master&service=github
  [coveralls-url]: https://coveralls.io/github/syrusakbary/snapshottest?branch=master


pkgId: 01c2b7a77281c85513195ac6f33fc5233332696aa309f85a535851634b9d0501
name: python-snorkel
arch: src
version: 0.9.9
epoch: 0
release: 1
summary: A system for quickly generating training data with weak supervision
url: https://snorkel.org
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-38a3b5a9-a670-4ce6-ab79-160996c740d4
location_href: 00012847-python-snorkel/python-snorkel-0.9.9-1.src.rpm
checksum_type: sha256
description:
  <img src="figs/logo_01.png" width="150"/>

  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/snorkel)
  ![PyPI](https://img.shields.io/pypi/v/snorkel)
  ![Conda](https://img.shields.io/conda/v/conda-forge/snorkel)
  [![CircleCI](https://circleci.com/gh/snorkel-team/snorkel/tree/master.svg?style=svg)](https://circleci.com/gh/snorkel-team/snorkel/tree/master)
  [![docs](https://readthedocs.org/projects/snorkel/badge/?version=master)](https://snorkel.readthedocs.io/en/master)
  [![coverage](https://codecov.io/gh/snorkel-team/snorkel/branch/master/graph/badge.svg)](https://codecov.io/gh/snorkel-team/snorkel/branch/master)
  [![license](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![Join the community on Spectrum](https://withspectrum.github.io/badge/badge.svg)](https://spectrum.chat/snorkel)

  ***Programmatically Build and Manage Training Data***



  **The Snorkel team is now focusing their efforts on Snorkel Flow, an end-to-end AI application development platform based on the core ideas behind Snorkel—you can check it out [here](https://snorkel.ai) or [join us](www.snorkel.ai/careers) in building it!**

  The [Snorkel project](https://snorkel.ai/how-to-use-snorkel-to-build-ai-applications/) started at Stanford in 2015 with a simple technical bet: that it would increasingly be the **training data**, not the models, algorithms, or infrastructure, that decided whether a machine learning project succeeded or failed. Given this premise, we set out to explore the radical idea that you could bring mathematical and systems structure to the messy and often entirely manual process of training data creation and management, starting by empowering users to **programmatically label, build, and manage** training data.

  To say that the Snorkel project succeeded and expanded beyond what we had ever expected would be an understatement. The basic goals of a research repo like Snorkel are to provide a minimum viable framework for testing and validating hypotheses. Four years later, we’ve been fortunate to do not just this, but to develop and deploy early versions of Snorkel in partnership with some of the world’s leading organizations like [Google](https://ai.googleblog.com/2019/03/harnessing-organizational-knowledge-for.html), [Intel](https://dl.acm.org/doi/abs/10.1145/3329486.3329492), [Stanford Medicine](https://www.cell.com/patterns/fulltext/S2666-3899(20)30019-2), and many more; author over [thirty-six peer-reviewed publications](https://snorkel.ai/technology.html) on our findings around Snorkel and related innovations in weak supervision modeling, data augmentation, multi-task learning, and more; be included in courses at top-tier universities; support production deployments in systems that you’ve likely used in the last few hours; and work with an amazing community of researchers and practitioners from industry, medicine, government, academia, and beyond.

  However, we realized increasingly–from conversations with users in weekly office hours, workshops, online discussions, and industry partners–that the Snorkel project was just the very first step. The ideas behind Snorkel change not just how you label training data, but so much of the entire lifecycle and pipeline of building, deploying, and managing ML: how users inject their knowledge; how models are constructed, trained, inspected, versioned, and monitored; how entire pipelines are developed iteratively; and how the full set of stakeholders in any ML deployment, from subject matter experts to ML engineers, are incorporated into the process.

  Over the last year, we have been building the platform to support this broader vision: [Snorkel Flow](https://snorkel.ai/snorkel-flow-platform/), an end-to-end machine learning platform for developing and deploying AI applications. Snorkel Flow incorporates many of the concepts of the Snorkel project with a range of newer techniques around weak supervision modeling, data augmentation, multi-task learning, data slicing and structuring, monitoring and analysis, and more, all of which integrate in a way that is greater than the sum of its parts–and that we believe makes ML truly faster, more flexible, and more practical than ever before.

  Moving forward, we will be focusing our efforts on Snorkel Flow. We are extremely grateful for all of you that have contributed to the Snorkel project, and are excited for you to check out our next chapter [here](https://snorkel.ai).



  * [Snorkel website](https://snorkel.org)
  * [Snorkel tutorials](https://github.com/snorkel-team/snorkel-tutorials)
  * [Snorkel documentation](https://snorkel.readthedocs.io/)
  * [Snorkel community forum](https://spectrum.chat/snorkel)
  * [Snorkel mailing list](https://groups.google.com/forum/#!forum/snorkel-ml)
  * [Snorkel Twitter](https://twitter.com/SnorkelAI)


  The quickest way to familiarize yourself with the Snorkel library is to walk through the [Get Started](https://snorkel.org/get-started/) page on the Snorkel website, followed by the full-length tutorials in the [Snorkel tutorials](https://github.com/snorkel-team/snorkel-tutorials) repository.
  These tutorials demonstrate a variety of tasks, domains, labeling techniques, and integrations that can serve as templates as you apply Snorkel to your own applications.




  Snorkel requires Python 3.6 or later. To install Snorkel, we recommend using `pip`:

  ```bash
  pip install snorkel
  ```

  or `conda`:

  ```bash
  conda install snorkel -c conda-forge
  ```

  For information on installing from source and contributing to Snorkel, see our
  [contributing guidelines](./CONTRIBUTING.md).

  <details><summary><b>Details on installing with <tt>conda</tt></b></summary>
  <p>

  The following example commands give some more color on installing with `conda`.
  These commands assume that your `conda` installation is Python 3.6,
  and that you want to use a virtual environment called `snorkel-env`.

  ```bash

  conda create --yes -n snorkel-env python=3.6
  conda activate snorkel-env


  conda install pytorch==1.1.0 -c pytorch
  conda install snorkel==0.9.0 -c conda-forge
  ```

  </p>
  </details>

  <details><summary><b>A quick note for Windows users</b></summary>
  <p>

  If you're using Windows, we highly recommend using Docker
  (you can find an example in our
  [tutorials repo](https://github.com/snorkel-team/snorkel-tutorials/blob/master/Dockerfile))
  or the [Linux subsystem](https://docs.microsoft.com/en-us/windows/wsl/faq).
  We've done limited testing on Windows, so if you want to contribute instructions
  or improvements, feel free to open a PR!

  </p>
  </details>




  We use [GitHub Issues](https://github.com/snorkel-team/snorkel/issues) for posting bugs and feature requests — anything code-related.
  Just make sure you search for related issues first and use our Issues templates.
  We may ask for contributions if a prompt fix doesn't fit into the immediate roadmap of the core development team.


  We welcome contributions from the Snorkel community!
  This is likely the fastest way to get a change you'd like to see into the library.

  Small contributions can be made directly in a pull request (PR).
  If you would like to contribute a larger feature, we recommend first creating an issue with a proposed design for discussion.
  For ideas about what to work on, we've labeled specific issues as [`help wanted`](https://github.com/snorkel-team/snorkel/issues?utf8=%E2%9C%93&q=is%3Aopen+is%3Aissue+label%3A%22help+wanted%22+).

  To set up a development environment for contributing back to Snorkel, see our [contributing guidelines](./CONTRIBUTING.md).
  All PRs must pass the continuous integration tests and receive approval from a member of the Snorkel development team before they will be merged.


  For broader Q&A, discussions about using Snorkel, tutorial requests, etc., use the [Snorkel community forum](https://spectrum.chat/snorkel) hosted on Spectrum.
  We hope this will be a venue for you to interact with other Snorkel users — please don't be shy about posting!


  To stay up-to-date on Snorkel-related announcements (e.g. version releases, upcoming workshops), subscribe to the [Snorkel mailing list](https://groups.google.com/forum/#!forum/snorkel-ml). We promise to respect your inboxes — communication will be sparse!


  Follow us on Twitter [@SnorkelAI](https://twitter.com/SnorkelAI).


pkgId: 1e0b1439346f8375baa49ce97d1ba24535acd49ecec7f3c314b13b99aac5f706
name: python-snowballstemmer
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: This package provides 29 stemmers for 28 languages generated from Snowball algorithms.
url: https://github.com/snowballstem/snowball
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b8bcc883-098f-43d5-b8c6-93a9350c7868
location_href: 00009155-python-snowballstemmer/python-snowballstemmer-2.2.0-1.src.rpm
checksum_type: sha256
description:
  Python 3 (>= 3.3) is supported.  We no longer actively support Python 2 as
  the Python developers stopped supporting it at the start of 2020.  Snowball
  2.1.0 was the last release to officially support Python 2.


pkgId: e882d263629867e596b4d3427a040aff53e4e97914e2341bdecd7b9e570a86e5
name: python-snowflake-sqlalchemy
arch: src
version: 1.4.7
epoch: 0
release: 1
summary: Snowflake SQLAlchemy Dialect
url: https://www.snowflake.com/
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-242fa03c-c937-4251-9683-41fac301c0a2
location_href: 00009279-python-snowflake-sqlalchemy/python-snowflake-sqlalchemy-1.4.7-1.src.rpm
checksum_type: sha256
description:
  This package includes the Snowflake SQLAlchemy, which supports Snowsql dialects for SQLAlchemy
  <http://www.sqlalchemy.org/>

  Snowflake Documentation is available at:
  <https://docs.snowflake.net/>

  Source code is also available at:
  <https://github.com/snowflakedb/snowflake-sqlalchemy>



  - v1.4.7(Mar 22, 2023)

    - Re-applied the application name of driver connection `SnowflakeConnection` to `SnowflakeSQLAlchemy`.
    - `SnowflakeDialect.get_columns` now throws a `NoSuchTableError` exception when the specified table doesn't exist, instead of the more vague `KeyError`.
    - Fixed a bug that dialect can not be created with empty host name.
    - Fixed a bug that `sqlalchemy.func.now` is not rendered correctly.

  - v1.4.6(Feb 8, 2023)

    - Bumped snowflake-connector-python dependency to newest version which supports Python 3.11.
    - Reverted the change of application name introduced in v1.4.5 until support gets added.

  - v1.4.5(Dec 7, 2022)

    - Updated the application name of driver connection `SnowflakeConnection` to `SnowflakeSQLAlchemy`.

  - v1.4.4(Nov 16, 2022)

    - Fixed a bug that percent signs in a non-compiled statement should not be interpolated with emtpy sequence when executed.

  - v1.4.3(Oct 17, 2022)

    - Fixed a bug that `SnowflakeDialect.normalize_name` and `SnowflakeDialect.denormalize_name` could not handle empty string.
    - Fixed a compatibility issue to vendor function `sqlalchemy.engine.url._rfc_1738_quote` as it is removed from SQLAlchemy v1.4.42.

  - v1.4.2(Sep 19, 2022)

    - Improved performance by standardizing string interpolations to f-strings.
    - Improved reliability by always using context managers.

  - v1.4.1(Aug 18, 2022)

    - snowflake-sqlalchemy is now SQLAlchemy 2.0 compatible.
    - Fixed a bug that `DATE` should not be removed from `SnowflakeDialect.ischema_names`.
    - Fixed breaking changes introduced in release 1.4.0 that:
      - changed the behavior of processing numeric, datetime and timestamp values returned from service.
      - changed the sequence order of primary/foreign keys in list returned by `inspect.get_foreign_keys` and `inspect.get_pk_constraint`.

  - v1.4.0(July 20, 2022)

    - Added support for `regexp_match`, `regexp_replace` in `sqlalchemy.sql.expression.ColumnOperators`.
    - Added support for Identity Column.
    - Added support for handling literals value of sql type `Date`, `DateTime`, `Time`, `Float` and `Numeric`, and converting the values into corresponding Python objects.
    - Added support for `get_sequence_names` in `SnowflakeDialect`.
    - Fixed a bug where insert with autoincrement failed due to incompatible column type affinity #124.
    - Fixed a bug when creating a column with sequence, default value was set incorrectly.
    - Fixed a bug that identifier having percents in a compiled statement was not interpolated.
    - Fixed a bug when visiting sequence value from another schema, the sequence name is not formatted with the schema name.
    - Fixed a bug where the sequence order of columns were not maintained when retrieving primary keys and foreign keys for a table.

  - v1.3.4(April 27,2022)

    - Fixed a bug where identifier max length was set to the wrong value and added relevant schema introspection
    - Add support for geography type
    - Fixed a bug where foreign key's referred schema was set incorrectly
    - Disabled new SQLAlchemy option for statement caching until support gets added

  - v1.3.3(December 19,2021)

    - Fixed an issue where quote arguments were stripped from identifiers.

  - v1.3.2 (September 14,2021)

    - Fixed a breaking change introduced in SQLAlchemy 1.4 that changed the behavior of returns_unicode_strings.

  - v1.3.1 (July 23,2021)

    - Raising minimum version of SQLAlchemy to match used features.

  - v1.2.5 (July 20,2021)

    - Various custom command bug fixes and additions.

  - v1.2.4 (October 05,2020)

    - Fixed an issue where inspector would not properly switch to table wide column retrieving when schema wide column retrieving was taking too long to respond.

  - v1.2.3 (March 30, 2020)

    - Update tox.ini
    - Add external stage to COPY INTO custom command.
    - Bumped pandas to newest versions

  - v1.2.2 (March 9, 2020)

    - Allow get_table_comment to fetch view comments too

  - v1.2.1 (February 18,2020)

    - Add driver property to SnowflakeDialect #140
    - Suppress deprecation warning by fixing import

  - v1.2.0 (January 27, 2020)

    - Fix typo in README Connection Parameters #141
    - Fix sqlalchemy and possibly python-connector warnings
    - Fix handling of empty table comments #137
    - Fix handling spaces in connection string passwords #149

  - v1.1.18 (January 6,2020)

    - Set current schema in connection string containing special characters
    - Calling str on custom_types throws Exception

  - v1.1.17 (December 2,2019)

    - Comments not created when creating new table #118
    - SQLAlchemy Column Metadata Cache not working
    - Timestamp DDL renders wrong when precision value passed
    - Fixed special character handling in snowflake-sqlalchemy from URL string
    - Added development optional dependencies to Python packages

  - v1.1.16 (October 21,2019)

    - Fix SQLAlchemy not working with global url

  - v1.1.15 (September 30, 2019)

    - Incorrect SQL generated for INSERT with CTE
    - Type Synonyms not exported to top-level module #109

  - v1.1.14 (August 12, 2019)

    - Fix CSVFormatter class has `FIELD_DELIMETER` spelled incorrectly

  - v1.1.13 (May 20,2019)

    - CopyInto's maxfilesize method expects a bool instead of an int
    - CopyInto statement doesn't compile correctly when the source is storage and the destination is a table

  - v1.1.12 (April 8,2019)

    - Add ability to inspect column comments
    - Restricting index creation checking to only SnowflakeDialect tables

  - v1.1.11 (March 25, 2019)

    - Remove relative reference to connector from SQLAlchemy dialect

  - v1.1.10 (February 22, 2019)

    - Separated base.py file into smaller files and fixed import statements
    - Prevent creating tables with indexes in SQLAlchemy
    - Add tox support

  - v1.1.9 (February 11, 2019)

    - Fix an issue in v1.1.8

  - v1.1.8 (February 8, 2019)

    - Fixed a dependency

  - v1.1.7 (February 8, 2019)

    - Added Upsert in sql-alchemy
    - CopyIntoS3 command in SQLAlchemy

  - v1.1.6 (January 3, 2019)

    - Fixed 'module' object is not callable in csvsql

  - v1.1.5 (December 19, 2018)

    - Added multivalue_support feature flag
    - Deprecate get_primary_keys

  - v1.1.4 (November 13, 2018)

    - Fixed lable/alias by honoring quote_name.

  - v1.1.3 (October 30, 2018)

    - SQLAlchemy 1.2 multi table support.
    - TIMESTAMP_LTZ, TIMESTAMP_NTZ and TIMESTAMP_TZ support.
    - Fixed relative import issue in SQLAlchemy

  - v1.1.2 (June 7, 2018)

    - Removes username restriction for OAuth

  - v1.1.1 (May 17, 2018)

    - Made password as optional parameter for SSO support
    - Fixed paramstyl=qmark mode where the data are bound in the server instead of client side
    - Fixed multipart schema support. Now db.schema can be specified in the schema parameters.
    - Added ``region`` parameter support to ``URL`` utility method.

  - v1.1.0 (February 1, 2018)

    - Updated doc including ``role`` example.
    - Fixed the return value of ``get_pk_constraint`` and ``get_primary_keys``. Those applications that depend on the old behaviors must update codes. Issue #38 (@nrth)
    - Updated doc including a note about ``open`` and ``close`` connections.

  - v1.0.9 (January 4, 2018)

    - Fixed foreign key names that should be normalized. Issue #24 (@cladden)
    - Set the default schema Issue #25 (@cladden)
    - Improved performance by caching current database and schema for inspector. Issue #30 (@cladden)

  - v1.0.8 (December 21, 2017)

    - Added ``get_schema_names`` method to Snowflake SQLAlchemy dialect. PR #20(andrewsali)
    - Fixed the column metadata including length for string/varchar and precision and scale for numeric data type. Issue #22(@cladden)

  - v1.0.7 (May 18, 2017)

    - Fixed COPY command transaction issue. PR #16(Pangstar) and Issue #17(Pangstar)

  - v1.0.6 (April 20, 2017)

    - Fixed account with subdomain issue. Issue #15(Pangstar)

  - v1.0.5 (April 13, 2017)

    - Added ``snowflake_clusterby`` option support to ``Table`` object so that the user can create a table with clustering keys

  - v1.0.4 (March 9, 2017)

    - Added SQLAlchemy 1.1 support

  - v1.0.3 (October 20, 2016)

    - Added ``VARIANT``, ``OBJECT`` and ``ARRAY`` data type supports for fetch

  - v1.0.2 (July 5, 2016)

    - Fixed the development status in classifiers. 5 - Production/Stable

  - v1.0.1 (July 4, 2016)

    - Fixed URL method in case of including warehouse without database.

  - v1.0.0 (June 28, 2016)

    - General Availability


pkgId: 71a43b6a05654f5c6dee1c13eb1ac779b841d3c2e065fce3c0161a33982da742
name: python-social-auth-app-django
arch: src
version: 5.2.0
epoch: 0
release: 1
summary: Python Social Authentication, Django integration.
url: https://github.com/python-social-auth/social-app-django
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4656968a-e327-471b-ac92-9ee77c0309ae
location_href: 00009972-python-social-auth-app-django/python-social-auth-app-django-5.2.0-1.src.rpm
checksum_type: sha256
description:
  ![Build Status](https://github.com/python-social-auth/social-app-django/workflows/Flake8/badge.svg)
  ![Build Status](https://github.com/python-social-auth/social-app-django/workflows/Tests/badge.svg)
  [![PyPI version](https://badge.fury.io/py/social-auth-app-django.svg)](https://badge.fury.io/py/social-auth-app-django)
  [![Donate](https://img.shields.io/badge/Donate-PayPal-orange.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=matiasaguirre%40gmail%2ecom&lc=US&item_name=Python%20Social%20Auth&no_note=0&currency_code=USD&bn=PP%2dDonationsBF%3abtn_donate_SM%2egif%3aNonHostedGuest)

  Python Social Auth is an easy to setup social authentication/registration
  mechanism with support for several frameworks and auth providers.



  This is the [Django](https://www.djangoproject.com/) component of the
  [python-social-auth ecosystem](https://github.com/python-social-auth/social-core),
  it implements the needed functionality to integrate
  [social-auth-core](https://github.com/python-social-auth/social-core)
  in a Django based project.



  This project will focus on the currently supported Django releases as
  stated on the [Django Project Supported Versions table](https://www.djangoproject.com/download/#supported-versions).

  Backward compatibility with unsupported versions won't be enforced.



  Project documentation is available at https://python-social-auth.readthedocs.org/.



  ```shell
  $ pip install social-auth-app-django
  ```



  See the [CONTRIBUTING.md](CONTRIBUTING.md) document for details.



  This project follows [Semantic Versioning 2.0.0](http://semver.org/spec/v2.0.0.html).



  This project follows the BSD license. See the [LICENSE](LICENSE) for details.



  This project is maintained on my spare time, consider donating to keep
  it improving.

  [![Donate](https://img.shields.io/badge/Donate-PayPal-orange.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=matiasaguirre%40gmail%2ecom&lc=US&item_name=Python%20Social%20Auth&no_note=0&currency_code=USD&bn=PP%2dDonationsBF%3abtn_donate_SM%2egif%3aNonHostedGuest)


pkgId: cc92cc81fab27f0857f23ee0e18c590e044162d7586754e4d20c1d8ed56cdf0b
name: python-social-auth-core
arch: src
version: 4.3.0
epoch: 0
release: 1
summary: Python social authentication made simple.
url: https://github.com/python-social-auth/social-core
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1565a19f-463d-45cc-81bd-eceb1fb776ad
location_href: 00005125-python-social-auth-core/python-social-auth-core-4.3.0-1.src.rpm
checksum_type: sha256
description:
  > ## THIS PROJECT IS OPEN FOR MAINTAINERS
  > Development on the python-social-auth projects has been stagnated for a while,
  > #445 was open a long time ago to discuss this matter and a plan (failed) was
  > presented to fix the situation. For that reason, I'm opening the organization to
  > new maintainers that will have the proper permissions to unstuck development.
  >
  > Those willing to join, contact me by email with the subject `[PSA Maintainer]
  > <your name>` and please let me know what motivates you to join in such role.


  ![Build Status](https://github.com/python-social-auth/social-core/workflows/Flake8/badge.svg)
  ![Build Status](https://github.com/python-social-auth/social-core/workflows/Tests/badge.svg)
  [![Build Status](https://travis-ci.org/python-social-auth/social-core.svg?branch=master)](https://travis-ci.org/python-social-auth/social-core)
  [![PyPI version](https://badge.fury.io/py/social-auth-core.svg)](https://badge.fury.io/py/social-auth-core)
  [![Donate](https://img.shields.io/badge/Donate-PayPal-orange.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=matiasaguirre%40gmail%2ecom&lc=US&item_name=Python%20Social%20Auth&no_note=0&currency_code=USD&bn=PP%2dDonationsBF%3abtn_donate_SM%2egif%3aNonHostedGuest)

  Python Social Auth is an easy to setup social authentication/registration
  mechanism with support for several frameworks and auth providers.



  This is the core component of the python-social-auth ecosystem, it
  implements the common interface to define new authentication backends
  to third parties services, implement integrations with web frameworks
  and storage solutions.



  Project documentation is available at http://python-social-auth.readthedocs.org/.



  ```shell
  $ pip install social-auth-core
  ```



  See the [CONTRIBUTING.md](CONTRIBUTING.md) document for details.



  This project follows [Semantic Versioning 2.0.0](http://semver.org/spec/v2.0.0.html).



  This project follows the BSD license. See the [LICENSE](LICENSE) for details.



  This project is maintained on my spare time, consider donating to keep
  it improving.

  [![Donate](https://img.shields.io/badge/Donate-PayPal-orange.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=matiasaguirre%40gmail%2ecom&lc=US&item_name=Python%20Social%20Auth&no_note=0&currency_code=USD&bn=PP%2dDonationsBF%3abtn_donate_SM%2egif%3aNonHostedGuest)


pkgId: c9f70411d67480473dbb1c6b12e063249aa800fc286fde5c6bca17e3810cdd41
name: python-socialscan
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Open-source intelligence tool for checking email address and username usage on online platforms
url: https://github.com/iojw/socialscan
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c8ab4c86-785b-4f7e-a956-6261419e0944
location_href: 00005128-python-socialscan/python-socialscan-2.0.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/iojw/socialscan.svg?token=4yLRbSuqAQqrjanbzeXs&branch=master)](https://travis-ci.com/iojw/socialscan)
  [![Downloads](https://pepy.tech/badge/socialscan)](https://pepy.tech/project/socialscan/)
  [![MPL 2.0 license](https://img.shields.io/badge/License-MPL%202.0-blue.svg)](https://www.mozilla.org/en-US/MPL/2.0/)
  [![Python 3.6+](https://img.shields.io/badge/python-3.6+-green.svg)](https://www.python.org/downloads/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  socialscan offers **accurate** and **fast** checks for email address and username usage on online platforms.

  Given an email address or username, socialscan returns whether it is available, taken or invalid on online platforms.

  Features that differentiate socialscan from similar tools (e.g. knowem.com, Namechk, and Sherlock):

  1. **100% accuracy**: socialscan's query method eliminates the false positives and negatives that often occur in similar tools, ensuring that results are always accurate.

  2. **Speed**: socialscan uses [asyncio](https://docs.python.org/3/library/asyncio.html) along with [aiohttp](https://aiohttp.readthedocs.io/en/stable/) to conduct all queries concurrently, providing fast searches even with bulk queries involving hundreds of usernames and email addresses. On a test computer with average specs and Internet speed, 100 queries were executed in ~4 seconds.

  3. **Library / CLI**: socialscan can be executed through a CLI, or imported as a Python library to be used with existing code.

  4. **Email support**: socialscan supports queries for both email addresses and usernames.

  The following platforms are currently supported:

  |           | Username | Email |
  |:---------:|:--------:|:--------:|
  | Instagram |     ✔️    |   ✔️   |
  | Twitter   |     ✔️    |   ✔️   |
  |  GitHub   |     ✔️    |   ✔️   |
  |   Tumblr  |     ✔️    |   ✔️   |
  |  Lastfm   |     ✔️    |   ✔️   |
  |  Snapchat |     ✔️    |        |
  | GitLab    |     ✔️    |        |
  | Reddit    |     ✔️    |        |
  |  Yahoo    |     ✔️    |        |
  | Pinterest |            |   ✔️  |
  |  Firefox  |            |   ✔️  |

  ![](https://github.com/iojw/socialscan/raw/master/demo/demo.gif)
  ![](https://github.com/iojw/socialscan/raw/master/demo/demo100.gif)



  Other similar tools check username availability by requesting the profile page of the username in question and based on information like the HTTP status code or error text on the requested page, determine whether a username is already taken. This is a naive approach that fails in the following cases:

  - Reserved keywords: Most platforms have a set of keywords that they don't allow to be used in usernames
  (A simple test: try checking reserved words like 'admin' or 'home' or 'root' and see if other services mark them as available)

  - Deleted/banned accounts: Deleted/banned account usernames tend to be unavailable even though the profile pages might not exist

  Therefore, these tools tend to come up with false positives and negatives. This method of checking is also dependent on platforms having web-based profile pages and cannot be extended to email addresses.

  socialscan aims to plug these gaps by directly querying the registration servers of the platforms instead, retrieving the appropriate CSRF tokens, headers, and cookies.




  ```
  > pip install socialscan
  ```


  ```
  > git clone https://github.com/iojw/socialscan.git
  > cd socialscan
  > pip install .
  ```


  ```
  usage: socialscan [list of usernames/email addresses to check]

  optional arguments:
    -h, --help            show this help message and exit
    --platforms [platform [platform ...]], -p [platform [platform ...]]
                          list of platforms to query (default: all platforms)
    --view-by {platform,query}
                          view results sorted by platform or by query (default:
                          query)
    --available-only, -a  only print usernames/email addresses that are
                          available and not in use
    --cache-tokens, -c    cache tokens for platforms requiring more than one
                          HTTP request (Snapchat, GitHub, Instagram. Lastfm &
                          Tumblr), reducing total number of requests sent
    --input input.txt, -i input.txt
                          file containg list of queries to execute
    --proxy-list proxy_list.txt
                          file containing list of HTTP proxy servers to execute
                          queries with
    --verbose, -v         show query responses as they are received
    --show-urls           display profile URLs for usernames on supported platforms
                          (profiles may not exist if usernames are reserved or belong to deleted/banned accounts)
    --json json.txt       output results in JSON format to the specified file
    --version             show program's version number and exit
  ```


  socialscan can also be imported into existing code and used as a library.

  v1.0.0 introduces the async method `execute_queries` and the corresponding synchronous wrapper `sync_execute_queries` that takes a list of queries and optional list of platforms and proxies, executing all queries concurrently. The method then returns a list of results in the same order.

  ```python
  from socialscan.util import Platforms, sync_execute_queries

  queries = ["username1", "email2@gmail.com", "mail42@me.com"]
  platforms = [Platforms.GITHUB, Platforms.LASTFM]
  results = sync_execute_queries(queries, platforms)
  for result in results:
      print(f"{result.query} on {result.platform}: {result.message} (Success: {result.success}, Valid: {result.valid}, Available: {result.available})")
  ```
  Output:
  ```
  username1 on GitHub: Username is already taken (Success: True, Valid: True, Available: False)
  username1 on Lastfm: Sorry, this username isn't available. (Success: True, Valid: True, Available: False)
  email2@gmail.com on GitHub: Available (Success: True, Valid: True, Available: True)
  email2@gmail.com on Lastfm: Sorry, that email address is already registered to another account. (Success: True, Valid: True, Available: False)
  mail42@me.com on GitHub: Available (Success: True, Valid: True, Available: True)
  mail42@me.com on Lastfm: Looking good! (Success: True, Valid: True, Available: True)
  ```


  For bulk queries with the `--input` option, place one username/email on each line in the .txt file:
  ```
  username1
  email2@mail.com
  username3
  ```



  If you find this tool useful and would like to support its continued development, you can donate here. Thank you for your support.

  [![Donate Via PayPal](https://www.paypal.com/en_US/i/btn/btn_donate_LG.gif)](https://paypal.me/isaacong)

  BTC: bc1qwrnukyc6xh9aygu5ps2geh8stmvagsj5u4v7j6
  ETH: 0x45a0F91666391078eA521A6123559E49DAb1275f


  Errors, suggestions or want a site added? [Submit an issue](https://github.com/iojw/socialscan/issues).

  PRs are always welcome 🙂

  Please ensure that the code is formatted with `black` using the config in `pyproject.toml` before submitting a PR.


  MPL 2.0


pkgId: 472a57effe737d996ca09463661665a8852e0eed6c876d962332dbc2631adb6c
name: python-socketIO-client
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: A socket.io client library
url: https://github.com/invisibleroads/socketIO-client
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-21c90628-1b48-4257-902c-3f147f7f04cf
location_href: 00011485-python-socketio-client/python-socketIO-client-0.7.2-1.src.rpm
checksum_type: sha256
description:
  Here is a `socket.io <http://socket.io>`_ client library for Python.  You can use it to write test code for your socket.io server.
  Please note that this version implements `socket.io protocol 1.x <https://github.com/automattic/socket.io-protocol>`_, which is not backwards compatible.  If you want to communicate using `socket.io protocol 0.9 <https://github.com/learnboost/socket.io-spec>`_ (which is compatible with `gevent-socketio <https://github.com/abourget/gevent-socketio>`_), please use `socketIO-client 0.5.7.2 <https://pypi.python.org/pypi/socketIO-client/0.5.7.2>`_.


pkgId: 2fb29d2785719f0ec314998708699137dc117f40a949e267c70fa6aa7dfc69f0
name: python-sockjs-tornado
arch: src
version: 1.0.7
epoch: 0
release: 1
summary: SockJS python server implementation on top of Tornado framework
url: http://github.com/mrjoes/sockjs-tornado/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5443afdb-7794-4fcf-a660-02fcfd6d5ed4
location_href: 00005130-python-sockjs-tornado/python-sockjs-tornado-1.0.7-1.src.rpm
checksum_type: sha256
description:
  SockJS-tornado is a Python server side counterpart of `SockJS-client browser library <https://github.com/sockjs/sockjs-client>`_
  running on top of `Tornado <http://tornadoweb.org>`_ framework.
  Simplified echo SockJS server could look more or less like::
      from tornado import web, ioloop
      from sockjs.tornado import SockJSRouter, SockJSConnection
      class EchoConnection(SockJSConnection):
          def on_message(self, msg):
              self.send(msg)
      if __name__ == '__main__':
          EchoRouter = SockJSRouter(EchoConnection, '/echo')
          app = web.Application(EchoRouter.urls)
          app.listen(9999)
          ioloop.IOLoop.instance().start()
  (Take look at `examples <https://github.com/MrJoes/sockjs-tornado/tree/master/examples>`_ for a complete version).
  Subscribe to `SockJS mailing list <https://groups.google.com/forum/#!forum/sockjs>`_ for discussions and support.


pkgId: a867a280e60a3d666a3058c1c19f404da9f7742a469ec4551b86549b25994209
name: python-soco
arch: src
version: 0.29.1
epoch: 0
release: 1
summary: SoCo (Sonos Controller) is a simple library to control Sonos speakers.
url: https://github.com/SoCo/SoCo
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d9bdc6df-c253-42b9-bb09-358ab301444b
location_href: 00005132-python-soco/python-soco-0.29.1-1.src.rpm
checksum_type: sha256
description:
  SoCo (Sonos Controller) is a Python library that allows you to
  control `Sonos speakers`_ programmatically. It was originally created at `Music
  Hack Day Sydney`_ by `Rahim Sonawalla`_ and is now developed by a `team of
  people`_ at its `GitHub repository`_
  For more background on the project, please see Rahim's `blog post
  <http://www.hirahim.com/blog/2012/04/29/dissecting-the-sonos-controller/>`_.
  Visit the `SoCo documentation`_ for a more detailed overview of the functionailty.


pkgId: 141a484bc3f0f8b21b7d78aedb863a8abb595a83c70b3dc74431f3d852b78906
name: python-solrq
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: Python Solr query utility
url: https://github.com/swistakm/solrq
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-98fe3d2d-df54-4152-b7ae-e2ce9df82868
location_href: 00012437-python-solrq/python-solrq-1.1.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/swistakm/solrq.svg?branch=master)](https://travis-ci.org/swistakm/solrq)
  [![Coverage Status](https://coveralls.io/repos/swistakm/solrq/badge.svg)](https://coveralls.io/r/swistakm/solrq)
  [![Documentation Status](https://readthedocs.org/projects/solrq/badge/?version=latest)](https://readthedocs.org/projects/solrq/?badge=latest)


  `solrq` is a Python Solr query utility. It helps making query strings for Solr
  and also helps with escaping reserved characters. `solrq` is has no external
  dependencies and is compatibile with `python3.7`, `python3,8`, `python3.9`, `python3.10`, `python3.11`, `pypy` and `pypy3`.
  It might be compatibile with other python releases/implentations but this has
  not been tested yet or is no longer tested (e.g `python3.2` or `python2.7`).

      pip install solrq

  And you're ready to go!




  Everything in `solrq` is about `Q()` object. Drop into python repl and just
  feed it with bunch of field and search terms to see how it works:

  ```python
  >>> from solrq import Q
  >>> # note: all terms in single Q object are implicitely joined with 'AND'
  >>> query = Q(type="animal", species="dog")
  >>> query
  <Q: type:animal AND species:dog>

  >>> # ohh, forgot about cats?
  >>> query | Q(type="animal", species="cat")
  <Q: (type:animal AND species:dog) OR (type:animal AND species:cat)>

  >>># more a cat lover? Let's give them a boost boost
  >>> Q(type="animal") & (Q(species="cat")^2 | Q(species="dog"))
  <Q: type:animal AND ((species:cat^2) OR species:dog)>
  ```

  But what to do with this `Q`? Simply pass it to your Solr library of choice,
  like [pysolr](https://github.com/toastdriven/pysolr) or
  [mysolr](https://github.com/RedTuna/mysolr). Most of python Solr libraries
  expect simple string as a query parameter and do not bother with escaping
  of reserved characters so you must take care of that by yourself. This is why
  `solrq` integrates so easily. Here is an example how you can use it with
  [pysolr](https://github.com/toastdriven/pysolr):

  ```python
  from solrq import Q
  import pysolr

  solr = Solr("<your solr url>")


  solr.search(Q(text="easy as f***"))


  solr.search(str(Q(text="easy as f***")))
  ```



  Full reference can be found in [API reference documentation page](http://solrq.readthedocs.org/en/latest/api-reference.html)
  but here is a short reference.



  Use python `^` operator:

  ```python
  >>> Q(text='cat') ^ 2
  <Q: text:cat^2>
  ```



  Use python `&` operator:

  ```python
  >>> Q(text='cat') & Q(text='dog')
  <Q: text:cat AND text:dog>
  ```



  Use python `|` operator:

  ```python
  >>> Q(text='cat') | Q(text='dog')
  <Q: text:cat OR text:dog>
  ```



  Use python `~` operator:

  ```python
  >>> ~ Q(text='cat')
  <Q: !text:cat>
  ```



  Use `solrq.Range` wrapper:

  ```python
  >>> from solrq import Range
  >>> Q(age=Range(18, 25))
  <Q: age:[18 TO 25]>
  ```



  Use `solrq.Proximity` wrapper:

  ```python
  >>> from solrq import Proximity
  >>> Q(age=Proximity("cat dogs", 5))
  <Q: age:"cat\ dogs"~5>
  ```



  All raw string values are treated as unsafe by default and will be escaped to
  ensure that final query string will not be broken by some rougue search value.
  This of course can be disabled if you know what you're doing using
  `Value` wrapper:

  ```python
  >>> from solrq import Q, Value
  >>> Q(type='foo bar[]')
  <Q: type:foo\ bar\[\]>
  >>> Q(type=Value('foo bar[]', safe=True))
  <Q: type:foo bar[]>
  ```



  Simply as:

  ```python
  >>> from datetime import datetime, timedelta
  >>> Q(date=datetime(1970, 1, 1))
  <Q: date:"1970-01-01T00:00:00Z">
  >>> # note that timedeltas has any sense mostly with ranges
  >>> Q(delta=timedelta(days=1))
  <Q: delta:NOW+1DAYS+0SECONDS+0MILLISECONDS>
  ```



  If you need to use wildcards in field names just use dict and unpack it inside
  of `Q()` instead of using keyword arguments:

  ```python
      >>> Q(**{"*_t": "text_to_search"})
      <Q: *_t:text_to_search>
  ```



  Any contribution is welcome. Issues, suggestions, pull requests - whatever.
  There are no strict contribution guidelines beyond PEP-8 and sanity.
  Code style is checked with flakes8 and any PR that has failed build
  will not be merged.

  One thing: if you submit a PR please do not rebase it later unless you
  are asked for that explicitely. Reviewing pull requests that suddenly had
  their history rewritten just drives me crazy.



  Tests are run using tox. Simply install it and run:

      pip install tox
      tox

  And that's all.


pkgId: 2fe3e9584f88b40e53537c5f50c551b0f720fc560f39870ba6e5e1c4aae16299
name: python-sops
arch: src
version: 1.18
epoch: 0
release: 1
summary: Secrets OPerationS (sops) is an editor of encrypted files
url: https://github.com/mozilla/sops
rpm_license: MPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2399b220-ad88-4961-9b8c-b00cdc28c879
location_href: 00010855-python-sops/python-sops-1.18-1.src.rpm
checksum_type: sha256
description:
  This is the Python version of SOPS that is no longer maintained. We fix the occasional bug, but all improvements happen in the Go version of SOPS, over in the Master branch. You have been warned!
  **sop** is an editor of encrypted files that supports YAML, JSON and BINARY formats and encrypts with AWS KMS and PGP (via GnuPG). Watch `the demo <https://www.youtube.com/watch?v=YTEVyLXFiq0>`_.
  **Questions?** ping "ulfr" in `#security` on `irc.mozilla.org <https://wiki.mozilla.org/IRC>`_
  (use a web client like `mibbit <https://chat.mibbit.com>`_ ).


pkgId: 312d56fa30d6b69a42ae147098826867bb7af504654133d5db9b3b96622ca6a2
name: python-sorl-thumbnail
arch: src
version: 12.9.0
epoch: 0
release: 1
summary: Thumbnails for Django
url: https://github.com/jazzband/sorl-thumbnail
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-681b10ce-0ce9-42e3-905a-84b2a73e527f
location_href: 00011344-python-sorl-thumbnail/python-sorl-thumbnail-12.9.0-1.src.rpm
checksum_type: sha256
description:
  - Support for Django 3.2, 4.0 and 4.1 following the `Django supported versions policy`_
  - Python 3 support
  - Storage support
  - Pluggable Engine support for `Pillow`_, `ImageMagick`_, `PIL`_, `Wand`_, `pgmagick`_, and `vipsthumbnail`_
  - Pluggable Key Value Store support (cached db, redis, and dynamodb by AWS)
  - Pluggable Backend support
  - Admin integration with possibility to delete
  - Dummy generation (placeholders)
  - Flexible, simple syntax, generates no html
  - ImageField for model that deletes thumbnails (only compatible with django 1.2.5 or less)
  - CSS style cropping options
  - Back smart cropping, and remove borders from the images when cropping
  - Margin calculation for vertical positioning
  - Alternative resolutions versions of a thumbnail
  Read more in `the documentation (latest version) <https://sorl-thumbnail.readthedocs.io/>`_


pkgId: 0d71d9ce1787a023d47f820e3ee39d230631a0feeb061530cddc53bcc8693c11
name: python-sortedcontainers
arch: src
version: 2.4.0
epoch: 0
release: 1
summary: Sorted Containers -- Sorted List, Sorted Dict, Sorted Set
url: http://www.grantjenks.com/docs/sortedcontainers/
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-de141bbd-f824-45cd-8432-4b86ca6e96c6
location_href: 00009080-python-sortedcontainers/python-sortedcontainers-2.4.0-1.src.rpm
checksum_type: sha256
description:
  `Sorted Containers`_ is an Apache2 licensed `sorted collections library`_,
  written in pure-Python, and fast as C-extensions.
  Python's standard library is great until you need a sorted collections
  type. Many will attest that you can get really far without one, but the moment
  you **really need** a sorted list, sorted dict, or sorted set, you're faced
  with a dozen different implementations, most using C-extensions without great
  documentation and benchmarking.
  In Python, we can do better. And we can do it in pure-Python!
      >>> from sortedcontainers import SortedList
      >>> sl = SortedList(['e', 'a', 'c', 'd', 'b'])
      >>> sl
      SortedList(['a', 'b', 'c', 'd', 'e'])
      >>> sl *= 10_000_000
      >>> sl.count('c')
      10000000
      >>> sl[-3:]
      ['e', 'e', 'e']
      >>> from sortedcontainers import SortedDict
      >>> sd = SortedDict({'c': 3, 'a': 1, 'b': 2})
      >>> sd
      SortedDict({'a': 1, 'b': 2, 'c': 3})
      >>> sd.popitem(index=-1)
      ('c', 3)
      >>> from sortedcontainers import SortedSet
      >>> ss = SortedSet('abracadabra')
      >>> ss
      SortedSet(['a', 'b', 'c', 'd', 'r'])
      >>> ss.bisect_left('c')
      2
  All of the operations shown above run in faster than linear time. The above
  demo also takes nearly a gigabyte of memory to run. When the sorted list is
  multiplied by ten million, it stores ten million references to each of "a"
  through "e". Each reference requires eight bytes in the sorted
  container. That's pretty hard to beat as it's the cost of a pointer to each
  object. It's also 66% less overhead than a typical binary tree implementation
  (e.g. Red-Black Tree, AVL-Tree, AA-Tree, Splay-Tree, Treap, etc.) for which
  every node must also store two pointers to children nodes.
  `Sorted Containers`_ takes all of the work out of Python sorted collections -
  making your deployment and use of Python easy. There's no need to install a C
  compiler or pre-build and distribute custom extensions. Performance is a
  feature and testing has 100% coverage with unit tests and hours of stress.


pkgId: e7c1da7e20b892ef30ab1e2b17f93beef2659955a8a438d960d7bb5740a100da
name: python-spacy-legacy
arch: src
version: 3.0.12
epoch: 0
release: 1
summary: Legacy registered functions for spaCy backwards compatibility
url: https://spacy.io
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-562e0508-5661-4069-ac65-901731639b15
location_href: 00009419-python-spacy-legacy/python-spacy-legacy-3.0.12-1.src.rpm
checksum_type: sha256
description:
  <a href="https://explosion.ai"><img src="https://explosion.ai/assets/img/logo.svg" width="125" height="125" align="right" /></a>



  This package includes outdated registered functions for [spaCy](https://spacy.io) v3.x, for example model architectures, pipeline components and utilities. It's **installed automatically** as a dependency of spaCy, and allows us to provide backwards compatibility, while keeping the core library tidy and up to date. All of this happens under the hood, so you typically shouldn't have to care about this package.

  [![Azure Pipelines](https://img.shields.io/azure-devops/build/explosion-ai/public/21/master.svg?logo=azure-pipelines&style=flat-square&label=build)](https://dev.azure.com/explosion-ai/public/_build?definitionId=21)
  [![pypi Version](https://img.shields.io/pypi/v/spacy-legacy.svg?style=flat-square&logo=pypi&logoColor=white)](https://pypi.org/project/spacy-legacy/)




  Whenever a new backwards-incompatible version of a registered function is available, e.g. `spacy.Tok2Vec.v1` &rarr; `spacy.Tok2Vec.v2`, the legacy version is moved to `spacy-legacy`, and exposed via [entry points](setup.cfg). This means that it will still be available if your config files use it, even though the core library only includes the latest version.

  Legacy functions are exposed with the prefix `spacy-legacy`, e.g. `spacy-legacy.Tok2Vec.v1`. When spaCy resolves your config and a function is not available in the core library, e.g. `spacy.Tok2Vec.v1`, it will check if there's a legacy function available and fall back to that. You can also explicitly refer to legacy functions in your config, to indicate that a newer version is available.


pkgId: ce520cf18c7c81cfd35822e7a97a3eb7a171da2bf95d198a389ec380d20fa7b1
name: python-spacy-loggers
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: Logging utilities for SpaCy
url: https://github.com/explosion/spacy-loggers
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b6e01bd0-8890-4ac6-b306-ab399491b79d
location_href: 00009871-python-spacy-loggers/python-spacy-loggers-1.0.4-1.src.rpm
checksum_type: sha256
description:
  <a href="https://explosion.ai"><img src="https://explosion.ai/assets/img/logo.svg" width="125" height="125" align="right" /></a>



  [![PyPi Version](https://img.shields.io/pypi/v/spacy-loggers.svg?style=flat-square&logo=pypi&logoColor=white)](https://pypi.python.org/pypi/spacy-loggers)

  Starting with spaCy v3.2, alternate loggers are moved into a separate package
  so that they can be added and updated independently from the core spaCy
  library.

  `spacy-loggers` currently provides loggers for:

  - [Weights & Biases](https://www.wandb.com)
  - [MLflow](https://www.mlflow.org/)
  - [ClearML](https://www.clear.ml/)

  If you'd like to add a new logger or logging option, please submit a PR to this
  repo!



  `spacy-loggers` should be installed automatically with spaCy v3.2+, so you
  usually don't need to install it separately. You can install it with `pip` or
  from the conda channel `conda-forge`:

  ```bash
  pip install spacy-loggers
  ```

  ```bash
  conda install -c conda-forge spacy-loggers
  ```







  This logger requires `wandb` to be installed and configured:

  ```bash
  pip install wandb
  wandb login
  ```



  `spacy.WandbLogger.v4` is a logger that sends the results of each training step
  to the dashboard of the [Weights & Biases](https://www.wandb.com/) tool. To use
  this logger, Weights & Biases should be installed, and you should be logged in.
  The logger will send the full config file to W&B, as well as various system
  information such as memory utilization, network traffic, disk IO, GPU
  statistics, etc. This will also include information such as your hostname and
  operating system, as well as the location of your Python executable.

  **Note** that by default, the full (interpolated)
  [training config](https://spacy.io/usage/training#config) is sent over to the
  W&B dashboard. If you prefer to **exclude certain information** such as path
  names, you can list those fields in "dot notation" in the
  `remove_config_values` parameter. These fields will then be removed from the
  config before uploading, but will otherwise remain in the config file stored
  on your local system.



  ```ini
  [training.logger]
  @loggers = "spacy.WandbLogger.v4"
  project_name = "monitor_spacy_training"
  remove_config_values = ["paths.train", "paths.dev", "corpora.train.path", "corpora.dev.path"]
  log_dataset_dir = "corpus"
  model_log_interval = 1000
  ```

  | Name                   | Type            | Description                                                                                                                                                                                                                     |
  | ---------------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  | `project_name`         | `str`           | The name of the project in the Weights & Biases interface. The project will be created automatically if it doesn't exist yet.                                                                                                   |
  | `remove_config_values` | `List[str]`     | A list of values to exclude from the config before it is uploaded to W&B (default: `[]`).                                                                                                                                       |
  | `model_log_interval`   | `Optional[int]` | Steps to wait between logging model checkpoints to the W&B dasboard (default: `None`). Added in `spacy.WandbLogger.v2`.                                                                                                         |
  | `log_dataset_dir`      | `Optional[str]` | Directory containing the dataset to be logged and versioned as a W&B artifact (default: `None`). Added in `spacy.WandbLogger.v2`.                                                                                               |
  | `run_name`             | `Optional[str]` | The name of the run. If you don't specify a run name, the name will be created by the `wandb` library (default: `None`). Added in `spacy.WandbLogger.v3`.                                                                       |
  | `entity`               | `Optional[str]` | An entity is a username or team name where you're sending runs. If you don't specify an entity, the run will be sent to your default entity, which is usually your username (default: `None`). Added in `spacy.WandbLogger.v3`. |
  | `log_best_dir`         | `Optional[str]` | Directory containing the best trained model as saved by spaCy (by default in `training/model-best`), to be logged and versioned as a W&B artifact (default: `None`). Added in `spacy.WandbLogger.v4`.                           |
  | `log_latest_dir`       | `Optional[str]` | Directory containing the latest trained model as saved by spaCy (by default in `training/model-latest`), to be logged and versioned as a W&B artifact (default: `None`). Added in `spacy.WandbLogger.v4`.                       |





  This logger requires `mlflow` to be installed and configured:

  ```bash
  pip install mlflow
  ```



  `spacy.MLflowLogger.v1` is a logger that tracks the results of each training step
  using the [MLflow](https://www.mlflow.org/) tool. To use
  this logger, MLflow should be installed. At the beginning of each model training
  operation, the logger will initialize a new MLflow run and set it as the active
  run under which metrics and parameters wil be logged. The logger will then log
  the entire config file as parameters of the active run. After each training step,
  the following actions are performed:

  - The final score is logged under the metric `score`.
  - Individual component scores are logged under their default names.
  - Loss values of different components are logged with the `loss_` prefix.
  - If the final score is higher than the previous best score (for the current run),
    the model artifact is additionally uploaded to MLflow. This action is only performed
    if the `output_path` argument is provided during the training pipeline initialization phase.

  By default, the tracking API writes data into files in a local `./mlruns` directory.

  **Note** that by default, the full (interpolated)
  [training config](https://spacy.io/usage/training#config) is sent over to
  MLflow. If you prefer to **exclude certain information** such as path
  names, you can list those fields in "dot notation" in the
  `remove_config_values` parameter. These fields will then be removed from the
  config before uploading, but will otherwise remain in the config file stored
  on your local system.



  ```ini
  [training.logger]
  @loggers = "spacy.MLflowLogger.v1"
  experiment_id = "1"
  run_name = "with_fast_alignments"
  nested = False
  remove_config_values = ["paths.train", "paths.dev", "corpora.train.path", "corpora.dev.path"]
  ```

  | Name                   | Type                       | Description                                                                                                                                                                                                             |
  | ---------------------- | -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  | `run_id`               | `Optional[str]`            | Unique ID of an existing MLflow run to which parameters and metrics are logged. Can be omitted if `experiment_id` and `run_id` are provided (default: `None`).                                                          |
  | `experiment_id`        | `Optional[str]`            | ID of an existing experiment under which to create the current run. Only applicable when `run_id` is `None` (default: `None`).                                                                                          |
  | `run_name`             | `Optional[str]`            | Name of new run. Only applicable when `run_id` is `None` (default: `None`).                                                                                                                                             |
  | `nested`               | `bool`                     | Controls whether run is nested in parent run. `True` creates a nested run (default: `False`).                                                                                                                           |
  | `tags`                 | `Optional[Dict[str, Any]]` | A dictionary of string keys and values to set as tags on the run. If a run is being resumed, these tags are set on the resumed run. If a new run is being created, these tags are set on the new run (default: `None`). |
  | `remove_config_values` | `List[str]`                | A list of values to exclude from the config before it is uploaded to MLflow (default: `[]`).                                                                                                                            |





  This logger requires `clearml` to be installed and configured:

  ```bash
  pip install clearml
  clearml-init
  ```



  `spacy.ClearMLLogger.v1` is a logger that tracks the results of each training step
  using the [ClearML](https://www.clear.ml/) tool. To use
  this logger, ClearML should be installed and you should have initialized (using the command above).
  The logger will send all the gathered information to your ClearML server, either [the hosted free tier](https://app.clear.ml)
  or the open source [self-hosted server](https://github.com/allegroai/clearml-server). This logger captures the following information, all of which is visible in the ClearML web UI:

  - The full spaCy config file contents.
  - Code information such as git repository, commit ID and uncommitted changes.
  - Full console output.
  - Miscellaneous info such as time, python version and hardware information.
  - Output scalars:
      - The final score is logged under the scalar `score`.
      - Individual component scores are grouped together on one scalar plot (filterable using the web UI).
      - Loss values of different components are logged with the `loss_` prefix.

  In addition to the above, the following artifacts can also be optionally captured:

  - Best model directory (zipped).
  - Latest model directory (zipped).
  - Dataset used to train.
  	- Versioned using ClearML Data and linked to under Configuration -> User Properties on the web UI.


  **Note** that by default, the full (interpolated)
  [training config](https://spacy.io/usage/training#config) is sent over to
  ClearML. If you prefer to **exclude certain information** such as path
  names, you can list those fields in "dot notation" in the
  `remove_config_values` parameter. These fields will then be removed from the
  config before uploading, but will otherwise remain in the config file stored
  on your local system.



  ```ini
  [training.logger]
  @loggers = "spacy.ClearMLLogger.v1"
  project_name = "Hello ClearML!"
  task_name = "My spaCy Task"
  model_log_interval = 1000
  log_best_dir = training/model-best
  log_latest_dir = training/model-last
  log_dataset_dir = corpus
  remove_config_values = ["paths.train", "paths.dev", "corpora.train.path", "corpora.dev.path"]
  ```

  | Name                   | Type            | Description                                                                                                                                                                                                                     |
  | ---------------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  | `project_name`         | `str`           | The name of the project in the ClearML interface. The project will be created automatically if it doesn't exist yet.                                                                                                            |
  | `task_name`            | `str`           | The name of the ClearML task. A task is an experiment that lives inside a project. Can be non-unique.                                                                                                                           |
  | `remove_config_values` | `List[str]`     | A list of values to exclude from the config before it is uploaded to ClearML (default: `[]`).                                                                                                                                   |
  | `model_log_interval`   | `Optional[int]` | Steps to wait between logging model checkpoints to the ClearML dasboard (default: `None`). Will have no effect without also setting `log_best_dir` or `log_latest_dir`.                                                         |
  | `log_best_dir`         | `Optional[str]` | Directory containing the best trained model as saved by spaCy (by default in `training/model-best`), to be logged and versioned as a ClearML artifact (default: `None`)                                                         |
  | `log_latest_dir`       | `Optional[str]` | Directory containing the latest trained model as saved by spaCy (by default in `training/model-last`), to be logged and versioned as a ClearML artifact (default: `None`)                                                       |
  | `log_dataset_dir`      | `Optional[str]` | Directory containing the dataset to be logged and versioned as a [ClearML Dataset](https://clear.ml/docs/latest/docs/clearml_data/clearml_data/) (default: `None`).                                                             |


pkgId: ba556ae7bad1311d56b440b0d0d8624e960c6fb50bc8ec3fe13a6e3b4ee320f9
name: python-spanishconjugator
arch: src
version: 2.3.4608
epoch: 0
release: 1
summary: A python library to conjugate spanish words with parameters tense, mood and pronoun
url: https://github.com/Benedict-Carling/spanish-conjugator
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-94fdc7b4-8c1f-487c-8f19-b7322fb340ec
location_href: 00011650-python-spanishconjugator/python-spanishconjugator-2.3.4608-1.src.rpm
checksum_type: sha256
description:
  ![GitHub Workflow Status](https://img.shields.io/github/workflow/status/Imperial-iGEM/DJANGO-Assembly-Methods/Django%20CI)
  ![GitHub repo size](https://img.shields.io/github/repo-size/Benedict-Carling/spanish-conjugator)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/spanishconjugator)
  ![GitHub top language](https://img.shields.io/github/languages/top/Benedict-Carling/spanish-conjugator)
  ![GitHub](https://img.shields.io/github/license/Benedict-Carling/spanish-conjugator)
  ![PyPI](https://img.shields.io/pypi/v/spanishconjugator)


  A class Conjugator containing a function conjugate which conjugates spanish verbs by tense, mood and pronoun.


  `pip install spanishconjugator`


  Example python usage; the `conjugate` function of the `Conjugator` Class takes 4 parameters being root-verb, tense, mood, pronoun respectively

  ```python
  from spanishconjugator import Conjugator
  imperfect_conjugation = Conjugator().conjugate('hablar','imperfect','indicative','yo')
  print(imperfect_conjugation)
  >>> hablaba
  ```


  All pronouns are implemented
  ```yo, tu, usted, nosotros, vosotros, ustedes```

  All moods currently implemented are
  ```indicative, conditional```

  All tenses currently implemented are
  ```present, imperfect, preterite, future, present_perfect, past_anterior, future_perfect, conditional_simple```

  Exaple usage of different moods/tenses with hablar and yo



  ```python
  Conjugator().conjugate('hablar','present','indicative','yo')
  >>> hablo
  ```

  In case of indicative present, 4th param pronoun is optional.
  ```python
  from spanishconjugator import Conjugator
  present_indicative_conjugation = Conjugator().conjugate('hablar','present','indicative')
  print(present_indicative_conjugation)
  >>> {'el/ella/usted': 'habla', 'ellos/ellas/ustedes': 'hablan', 'tu': 'hablas', 'vosotros': 'hablÃ¡is', 'yo': 'hablo', 'nosotros': 'hablamos'}
  ```



  ```python
  Conjugator().conjugate('hablar','imperfect','indicative','yo')
  >>> hablaba
  ```


  ```python
  Conjugator().conjugate('hablar','preterite','indicative','yo')
  >>> hablé
  ```


  ```python
  Conjugator().conjugate('hablar','future','indicative','yo')
  >>> hablaré
  ```


  ```python
  Conjugator().conjugate('hablar','present_perfect','indicative','yo')
  >>> he hablado
  ```


  ```python
  Conjugator().conjugate('hablar','past_anterior','indicative','yo')
  >>> hube hablado
  ```


  ```python
  Conjugator().conjugate('hablar','future_perfect','indicative','yo')
  >>> habré hablado
  ```


  ```python
  Conjugator().conjugate('hablar','simple_conditional','conditional','yo')
  >>> hablaría
  ```


  ```python
  Conjugator().conjugate('hablar','perfect','conditional','yo')
  >>> habría hablado
  ```


  ```python
  Conjugator().conjugate('hablar','affirmative','imperative','tu')
  >>> habla
  ```


  ```python
  Conjugator().conjugate('hablar','negative','imperative','tu')
  >>> hables
  ```


  ```python
  Conjugator().conjugate('hablar','present','subjunctive','yo')
  >>> hable
  ```


  ```python
  Conjugator().conjugate('hablar','imperfect','subjunctive','yo')
  >>> hablara
  ```


  ```python
  Conjugator().conjugate('hablar','imperfect_se','subjunctive','yo')
  >>> hablase
  ```


  ```python
  Conjugator().conjugate('hablar','future','subjunctive','yo')
  >>> hablare
  ```


  if you would like to help develop spanishconjugator, follow succeeding code

  Whilst in command line create a folder in which you would like to work (name only reccommended)

  `$ mkdir spanish_conjugator_enviroment`

  change directory into the enviroment you have just made

  `$ cd spanish_conjugator_enviroment`

  install virtualenv

  `$ pip install virtualenv`

  create a virtual enviroment from path of python3

  `$ virtualenv -p $(which python3) my_venv`

  activate virtual enviroment

  `$ source my_venv/bin/activate`

  > tip: once you want to disactivate your virtual enviroment simply run `$ deactivate`

  Clone Spanish-Conjugator

  `$ git clone https://github.com/Benedict-Carling/spanish-conjugator.git`

  Install developer dependencies for unit test e.g pytest and for other library tools

  `pip install -e .[dev]`



  We have chosen to use the library pytest for our unit test
  At this point in the developing guide you can check the code works by running it against out current unit tests located in the `/tests` folder

  `$ pytest`

  output should show the different tenses implemented should pass their unit tests as below.(27/08/2020)
  ![alt text](https://github.com/Benedict-Carling/spanish-conjugator/blob/master/images/pytest.png?raw=true)



  To submit code to this repositry please fork and submit a pull request 🚀


  Check out the Javascript npm version of the library if you are working in a node or browser enviroment

  https://github.com/Benedict-Carling/spanish-conjugatorjs


pkgId: cac7229d49ac9db78d0e719ac2746fb6cc4f874da0ec57baa3da6c24efb84baf
name: python-spark-nlp
arch: src
version: 4.3.2
epoch: 0
release: 1
url: https://github.com/JohnSnowLabs/spark-nlp
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dd71c3de-34d5-477f-95ff-54fdbba730d3
location_href: 00009534-python-spark-nlp/python-spark-nlp-4.3.2-1.src.rpm
checksum_type: sha256
summary:
  John Snow Labs Spark NLP is a natural language processing library built on top of Apache Spark ML. It provides simple, performant & accurate NLP annotations for machine learning pipelines, that scale easily in a distributed environment.

description:
  <p align="center">
      <a href="https://github.com/JohnSnowLabs/spark-nlp/actions" alt="build">
          <img src="https://github.com/JohnSnowLabs/spark-nlp/workflows/build/badge.svg" /></a>
      <a href="https://github.com/JohnSnowLabs/spark-nlp/releases" alt="Current Release Version">
          <img src="https://img.shields.io/github/v/release/JohnSnowLabs/spark-nlp.svg?style=flat-square&logo=github" /></a>
      <a href="https://search.maven.org/artifact/com.johnsnowlabs.nlp/spark-nlp_2.12" alt="Maven Central">
          <img src="https://maven-badges.herokuapp.com/maven-central/com.johnsnowlabs.nlp/spark-nlp_2.12/badge.svg" /></a>
      <a href="https://badge.fury.io/py/spark-nlp" alt="PyPI version">
          <img src="https://badge.fury.io/py/spark-nlp.svg" /></a>
      <a href="https://anaconda.org/JohnSnowLabs/spark-nlp" alt="Anaconda-Cloud">
          <img src="https://anaconda.org/johnsnowlabs/spark-nlp/badges/version.svg" /></a>
      <a href="https://github.com/JohnSnowLabs/spark-nlp/blob/master/LICENSE" alt="License">
          <img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg" /></a>
      <a href="https://pypi.org/project/spark-nlp/" alt="PyPi downloads">
          <img src="https://static.pepy.tech/personalized-badge/spark-nlp?period=total&units=international_system&left_color=grey&right_color=orange&left_text=pip%20downloads" /></a>
  </p>

  Spark NLP is a state-of-the-art Natural Language Processing library built on top of Apache Spark. It provides **simple
  **, **performant** & **accurate** NLP annotations for machine learning pipelines that **scale** easily in a distributed
  environment.
  Spark NLP comes with **11000+** pretrained **pipelines** and **models** in more than **200+** languages.
  It also offers tasks such as **Tokenization**, **Word Segmentation**, **Part-of-Speech Tagging**, Word and Sentence **Embeddings**, **Named Entity Recognition**, **Dependency Parsing**, **Spell Checking**, **Text Classification**, **Sentiment Analysis**, **Token Classification**, **Machine Translation** (+180 languages), **Summarization**, **Question Answering**, **Table Question Answering**, **Text Generation**, **Image Classification**, **Automatic Speech Recognition
  **, and many more [NLP tasks](#features).

  **Spark NLP** is the only open-source NLP library in **production** that offers state-of-the-art transformers such as **BERT**, **CamemBERT**, **ALBERT**, **ELECTRA**, **XLNet**, **DistilBERT**, **RoBERTa**, **DeBERTa**, **XLM-RoBERTa**, **Longformer**, **ELMO**, **Universal Sentence Encoder**, **Google T5**, **MarianMT**, **GPT2**, and **Vision Transformers (ViT)** not only to **Python** and **R**, but also to **JVM** ecosystem (**Java**, **Scala**, and **Kotlin**) at **scale** by extending **Apache Spark** natively.



  Take a look at our official Spark NLP page: [http://nlp.johnsnowlabs.com/](http://nlp.johnsnowlabs.com/) for user
  documentation and examples



  - [Slack](https://join.slack.com/t/spark-nlp/shared_invite/zt-198dipu77-L3UWNe_AJ8xqDk0ivmih5Q) For live discussion with the Spark NLP community and the team
  - [GitHub](https://github.com/JohnSnowLabs/spark-nlp) Bug reports, feature requests, and contributions
  - [Discussions](https://github.com/JohnSnowLabs/spark-nlp/discussions) Engage with other community members, share ideas,
    and show off how you use Spark NLP!
  - [Medium](https://medium.com/spark-nlp) Spark NLP articles
  - [YouTube](https://www.youtube.com/channel/UCmFOjlpYEhxf_wJUDuz6xxQ/videos) Spark NLP video tutorials



  - [Features](#features)
  - [Requirements](#requirements)
  - [Quick Start](#quick-start)
  - [Apache Spark Support](#apache-spark-support)
  - [Scala & Python Support](#scala-and-python-support)
  - [Databricks Support](#databricks-support)
  - [EMR Support](#emr-support)
  - [Using Spark NLP](#usage)
      - [Packages Cheatsheet](#packages-cheatsheet)
      - [Spark Packages](#spark-packages)
      - [Scala](#scala)
          - [Maven](#maven)
          - [SBT](#sbt)
      - [Python](#python)
          - [Pip/Conda](#pipconda)
      - [Compiled JARs](#compiled-jars)
      - [Apache Zeppelin](#apache-zeppelin)
      - [Jupyter Notebook](#jupyter-notebook-python)
      - [Google Colab Notebook](#google-colab-notebook)
      - [Kaggle Kernel](#kaggle-kernel)
      - [Databricks Cluster](#databricks-cluster)
      - [EMR Cluster](#emr-cluster)
      - [GCP Dataproc](#gcp-dataproc)
      - [Spark NLP Configuration](#spark-nlp-configuration)
  - [Pipelines & Models](#pipelines-and-models)
      - [Pipelines](#pipelines)
      - [Models](#models)
  - [Offline](#offline)
  - [Examples](#examples)
  - [FAQ](#faq)
  - [Citation](#citation)
  - [Contributing](#contributing)



  - Tokenization
  - Trainable Word Segmentation
  - Stop Words Removal
  - Token Normalizer
  - Document Normalizer
  - Stemmer
  - Lemmatizer
  - NGrams
  - Regex Matching
  - Text Matching
  - Chunking
  - Date Matcher
  - Sentence Detector
  - Deep Sentence Detector (Deep learning)
  - Dependency parsing (Labeled/unlabeled)
  - SpanBertCorefModel (Coreference Resolution)
  - Part-of-speech tagging
  - Sentiment Detection (ML models)
  - Spell Checker (ML and DL models)
  - Word Embeddings (GloVe and Word2Vec)
  - Doc2Vec (based on Word2Vec)
  - BERT Embeddings (TF Hub & HuggingFace models)
  - DistilBERT Embeddings (HuggingFace models)
  - CamemBERT Embeddings (HuggingFace models)
  - RoBERTa Embeddings (HuggingFace models)
  - DeBERTa Embeddings (HuggingFace v2 & v3 models)
  - XLM-RoBERTa Embeddings (HuggingFace models)
  - Longformer Embeddings (HuggingFace models)
  - ALBERT Embeddings (TF Hub & HuggingFace models)
  - XLNet Embeddings
  - ELMO Embeddings (TF Hub models)
  - Universal Sentence Encoder (TF Hub models)
  - BERT Sentence Embeddings (TF Hub & HuggingFace models)
  - RoBerta Sentence Embeddings (HuggingFace models)
  - XLM-RoBerta Sentence Embeddings (HuggingFace models)
  - Sentence Embeddings
  - Chunk Embeddings
  - Unsupervised keywords extraction
  - Language Detection & Identification (up to 375 languages)
  - Multi-class Sentiment analysis (Deep learning)
  - Multi-label Sentiment analysis (Deep learning)
  - Multi-class Text Classification (Deep learning)
  - BERT for Token & Sequence Classification
  - DistilBERT for Token & Sequence Classification
  - CamemBERT for Token & Sequence Classification
  - ALBERT for Token & Sequence Classification
  - RoBERTa for Token & Sequence Classification
  - DeBERTa for Token & Sequence Classification
  - XLM-RoBERTa for Token & Sequence Classification
  - XLNet for Token & Sequence Classification
  - Longformer for Token & Sequence Classification
  - BERT for Token & Sequence Classification
  - BERT for Question Answering
  - CamemBERT for Question Answering
  - DistilBERT for Question Answering
  - ALBERT for Question Answering
  - RoBERTa for Question Answering
  - DeBERTa for Question Answering
  - XLM-RoBERTa for Question Answering
  - Longformer for Question Answering
  - Table Question Answering (TAPAS)
  - Zero-Shot NER Model
  - Neural Machine Translation (MarianMT)
  - Text-To-Text Transfer Transformer (Google T5)
  - Generative Pre-trained Transformer 2 (OpenAI GPT2)
  - Vision Transformer (ViT)
  - Swin Image Classification
  - Automatic Speech Recognition (Wav2Vec2)
  - Automatic Speech Recognition (HuBERT)
  - Named entity recognition (Deep learning)
  - Easy TensorFlow integration
  - GPU Support
  - Full integration with Spark ML functions
  - +9400 pre-trained models in +200 languages!
  - +3200 pre-trained pipelines in +200 languages!
  - Multi-lingual NER models: Arabic, Bengali, Chinese, Danish, Dutch, English, Finnish, French, German, Hebrew, Italian,
    Japanese, Korean, Norwegian, Persian, Polish, Portuguese, Russian, Spanish, Swedish, Urdu, and more.



  To use Spark NLP you need the following requirements:

  - Java 8 and 11
  - Apache Spark 3.3.x, 3.2.x, 3.1.x, 3.0.x

  **GPU (optional):**

  Spark NLP 4.3.2 is built with TensorFlow 2.7.1 and the following NVIDIA® software are only required for GPU support:

  - NVIDIA® GPU drivers version 450.80.02 or higher
  - CUDA® Toolkit 11.2
  - cuDNN SDK 8.1.0



  This is a quick example of how to use Spark NLP pre-trained pipeline in Python and PySpark:

  ```sh
  $ java -version

  $ conda create -n sparknlp python=3.7 -y
  $ conda activate sparknlp

  $ pip install spark-nlp==4.3.2 pyspark==3.3.1
  ```

  In Python console or Jupyter `Python3` kernel:

  ```python

  from sparknlp.base import *
  from sparknlp.annotator import *
  from sparknlp.pretrained import PretrainedPipeline
  import sparknlp






  spark = sparknlp.start()


  pipeline = PretrainedPipeline('explain_document_dl', lang='en')


  text = """
  The Mona Lisa is a 16th century oil painting created by Leonardo.
  It's held at the Louvre in Paris.
  """


  result = pipeline.annotate(text)


  list(result.keys())
  Output: ['entities', 'stem', 'checked', 'lemma', 'document',
           'pos', 'token', 'ner', 'embeddings', 'sentence']


  result['entities']
  Output: ['Mona Lisa', 'Leonardo', 'Louvre', 'Paris']
  ```

  For more examples, you can visit our dedicated [examples](https://github.com/JohnSnowLabs/spark-nlp/tree/master/examples) to showcase all Spark NLP use cases!



  Spark NLP *4.3.2* has been built on top of Apache Spark 3.2 while fully supports Apache Spark 3.0.x, 3.1.x, 3.2.x, and
  3.3.x:

  | Spark NLP | Apache Spark 2.3.x | Apache Spark 2.4.x | Apache Spark 3.0.x | Apache Spark 3.1.x | Apache Spark 3.2.x | Apache Spark 3.3.x |
  |-----------|--------------------|--------------------|--------------------|--------------------|--------------------|--------------------|
  | 4.3.x     | NO                 | NO                 | YES                | YES                | YES                | YES                |
  | 4.2.x     | NO                 | NO                 | YES                | YES                | YES                | YES                |
  | 4.1.x     | NO                 | NO                 | YES                | YES                | YES                | YES                |
  | 4.0.x     | NO                 | NO                 | YES                | YES                | YES                | YES                |
  | 3.4.x     | YES                | YES                | YES                | YES                | Partially          | N/A                |
  | 3.3.x     | YES                | YES                | YES                | YES                | NO                 | NO                 |
  | 3.2.x     | YES                | YES                | YES                | YES                | NO                 | NO                 |
  | 3.1.x     | YES                | YES                | YES                | YES                | NO                 | NO                 |
  | 3.0.x     | YES                | YES                | YES                | YES                | NO                 | NO                 |
  | 2.7.x     | YES                | YES                | NO                 | NO                 | NO                 | NO                 |

  NOTE: Starting 4.0.0 release, the default `spark-nlp` and `spark-nlp-gpu` packages are based on Scala 2.12.15 and Apache
  Spark 3.2 by default.

  Find out more about `Spark NLP` versions from our [release notes](https://github.com/JohnSnowLabs/spark-nlp/releases).



  | Spark NLP | Python 3.6 | Python 3.7 | Python 3.8 | Python 3.9 | Scala 2.11 | Scala 2.12 |
  |-----------|------------|------------|------------|------------|------------|------------|
  | 4.3.x     | YES        | YES        | YES        | YES        | NO         | YES        |
  | 4.2.x     | YES        | YES        | YES        | YES        | NO         | YES        |
  | 4.1.x     | YES        | YES        | YES        | YES        | NO         | YES        |
  | 4.0.x     | YES        | YES        | YES        | YES        | NO         | YES        |
  | 3.4.x     | YES        | YES        | YES        | YES        | YES        | YES        |
  | 3.3.x     | YES        | YES        | YES        | NO         | YES        | YES        |
  | 3.2.x     | YES        | YES        | YES        | NO         | YES        | YES        |
  | 3.1.x     | YES        | YES        | YES        | NO         | YES        | YES        |
  | 3.0.x     | YES        | YES        | YES        | NO         | YES        | YES        |
  | 2.7.x     | YES        | YES        | NO         | NO         | YES        | NO         |



  Spark NLP 4.3.2 has been tested and is compatible with the following runtimes:

  **CPU:**

  - 7.3
  - 7.3 ML
  - 9.1
  - 9.1 ML
  - 10.1
  - 10.1 ML
  - 10.2
  - 10.2 ML
  - 10.3
  - 10.3 ML
  - 10.4
  - 10.4 ML
  - 10.5
  - 10.5 ML
  - 11.0
  - 11.0 ML
  - 11.1
  - 11.1 ML
  - 11.2
  - 11.2 ML
  - 11.3
  - 11.3 ML

  **GPU:**

  - 9.1 ML & GPU
  - 10.1 ML & GPU
  - 10.2 ML & GPU
  - 10.3 ML & GPU
  - 10.4 ML & GPU
  - 10.5 ML & GPU
  - 11.0 ML & GPU
  - 11.1 ML & GPU
  - 11.2 ML & GPU
  - 11.3 ML & GPU

  NOTE: Spark NLP 4.x is based on TensorFlow 2.7.x which is compatible with CUDA11 and cuDNN 8.0.2. The only Databricks
  runtimes supporting CUDA 11 are 9.x and above as listed under GPU.



  Spark NLP 4.3.2 has been tested and is compatible with the following EMR releases:

  - emr-6.2.0
  - emr-6.3.0
  - emr-6.3.1
  - emr-6.4.0
  - emr-6.5.0
  - emr-6.6.0
  - emr-6.7.0

  Full list of [Amazon EMR 6.x releases](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-release-6x.html)

  NOTE: The EMR 6.1.0 and 6.1.1 are not supported.





  This is a cheatsheet for corresponding Spark NLP Maven package to Apache Spark / PySpark major version:

  | Apache Spark    | Spark NLP on CPU   | Spark NLP on GPU           | Spark NLP on AArch64 (linux)   | Spark NLP on Apple Silicon           |
  |-----------------|--------------------|----------------------------|--------------------------------|--------------------------------------|
  | 3.0/3.1/3.2/3.3 | `spark-nlp`        | `spark-nlp-gpu`            | `spark-nlp-aarch64`            | `spark-nlp-silicon`                  |
  | Start Function  | `sparknlp.start()` | `sparknlp.start(gpu=True)` | `sparknlp.start(aarch64=True)` | `sparknlp.start(apple_silicon=True)` |

  NOTE: `M1/M2` and `AArch64` are under `experimental` support. Access and support to these architectures are limited by the
  community and we had to build most of the dependencies by ourselves to make them compatible. We support these two
  architectures, however, they may not work in some environments.





  Spark NLP supports all major releases of Apache Spark 3.0.x, Apache Spark 3.1.x, Apache Spark 3.2.x, and Apache Spark
  3.3.x.



  ```sh


  spark-shell --packages com.johnsnowlabs.nlp:spark-nlp_2.12:4.3.2

  pyspark --packages com.johnsnowlabs.nlp:spark-nlp_2.12:4.3.2

  spark-submit --packages com.johnsnowlabs.nlp:spark-nlp_2.12:4.3.2
  ```

  The `spark-nlp` has been published to
  the [Maven Repository](https://mvnrepository.com/artifact/com.johnsnowlabs.nlp/spark-nlp).

  ```sh


  spark-shell --packages com.johnsnowlabs.nlp:spark-nlp-gpu_2.12:4.3.2

  pyspark --packages com.johnsnowlabs.nlp:spark-nlp-gpu_2.12:4.3.2

  spark-submit --packages com.johnsnowlabs.nlp:spark-nlp-gpu_2.12:4.3.2

  ```

  The `spark-nlp-gpu` has been published to
  the [Maven Repository](https://mvnrepository.com/artifact/com.johnsnowlabs.nlp/spark-nlp-gpu).

  ```sh


  spark-shell --packages com.johnsnowlabs.nlp:spark-nlp-aarch64_2.12:4.3.2

  pyspark --packages com.johnsnowlabs.nlp:spark-nlp-aarch64_2.12:4.3.2

  spark-submit --packages com.johnsnowlabs.nlp:spark-nlp-aarch64_2.12:4.3.2

  ```

  The `spark-nlp-aarch64` has been published to
  the [Maven Repository](https://mvnrepository.com/artifact/com.johnsnowlabs.nlp/spark-nlp-aarch64).

  ```sh


  spark-shell --packages com.johnsnowlabs.nlp:spark-nlp-silicon_2.12:4.3.2

  pyspark --packages com.johnsnowlabs.nlp:spark-nlp-silicon_2.12:4.3.2

  spark-submit --packages com.johnsnowlabs.nlp:spark-nlp-silicon_2.12:4.3.2

  ```

  The `spark-nlp-silicon` has been published to
  the [Maven Repository](https://mvnrepository.com/artifact/com.johnsnowlabs.nlp/spark-nlp-silicon).

  **NOTE**: In case you are using large pretrained models like UniversalSentenceEncoder, you need to have the following
  set in your SparkSession:

  ```sh
  spark-shell \
    --driver-memory 16g \
    --conf spark.kryoserializer.buffer.max=2000M \
    --packages com.johnsnowlabs.nlp:spark-nlp_2.12:4.3.2
  ```



  Spark NLP supports Scala 2.12.15 if you are using Apache Spark 3.0.x, 3.1.x, 3.2.x, and 3.3.x versions. Our packages are
  deployed to Maven central. To add any of our packages as a dependency in your application you can follow these
  coordinates:



  **spark-nlp** on Apache Spark 3.0.x, 3.1.x, 3.2.x, and 3.3.x:

  ```xml
  <!-- https://mvnrepository.com/artifact/com.johnsnowlabs.nlp/spark-nlp -->
  <dependency>
      <groupId>com.johnsnowlabs.nlp</groupId>
      <artifactId>spark-nlp_2.12</artifactId>
      <version>4.3.2</version>
  </dependency>
  ```

  **spark-nlp-gpu:**

  ```xml
  <!-- https://mvnrepository.com/artifact/com.johnsnowlabs.nlp/spark-nlp-gpu -->
  <dependency>
      <groupId>com.johnsnowlabs.nlp</groupId>
      <artifactId>spark-nlp-gpu_2.12</artifactId>
      <version>4.3.2</version>
  </dependency>
  ```

  **spark-nlp-aarch64:**

  ```xml
  <!-- https://mvnrepository.com/artifact/com.johnsnowlabs.nlp/spark-nlp-aarch64 -->
  <dependency>
      <groupId>com.johnsnowlabs.nlp</groupId>
      <artifactId>spark-nlp-aarch64_2.12</artifactId>
      <version>4.3.2</version>
  </dependency>
  ```

  **spark-nlp-silicon:**

  ```xml
  <!-- https://mvnrepository.com/artifact/com.johnsnowlabs.nlp/spark-nlp-silicon -->
  <dependency>
      <groupId>com.johnsnowlabs.nlp</groupId>
      <artifactId>spark-nlp-silicon_2.12</artifactId>
      <version>4.3.2</version>
  </dependency>
  ```



  **spark-nlp** on Apache Spark 3.0.x, 3.1.x, 3.2.x, and 3.3.x:

  ```sbtshell
  // https://mvnrepository.com/artifact/com.johnsnowlabs.nlp/spark-nlp
  libraryDependencies += "com.johnsnowlabs.nlp" % "spark-nlp" % "4.3.2"
  ```

  **spark-nlp-gpu:**

  ```sbtshell
  // https://mvnrepository.com/artifact/com.johnsnowlabs.nlp/spark-nlp-gpu
  libraryDependencies += "com.johnsnowlabs.nlp" % "spark-nlp-gpu" % "4.3.2"
  ```

  **spark-nlp-aarch64:**

  ```sbtshell
  // https://mvnrepository.com/artifact/com.johnsnowlabs.nlp/spark-nlp-aarch64
  libraryDependencies += "com.johnsnowlabs.nlp" % "spark-nlp-aarch64" % "4.3.2"
  ```

  **spark-nlp-silicon:**

  ```sbtshell
  // https://mvnrepository.com/artifact/com.johnsnowlabs.nlp/spark-nlp-silicon
  libraryDependencies += "com.johnsnowlabs.nlp" % "spark-nlp-silicon" % "4.3.2"
  ```

  Maven
  Central: [https://mvnrepository.com/artifact/com.johnsnowlabs.nlp](https://mvnrepository.com/artifact/com.johnsnowlabs.nlp)

  If you are interested, there is a simple SBT project for Spark NLP to guide you on how to use it in your
  projects [Spark NLP SBT Starter](https://github.com/maziyarpanahi/spark-nlp-starter)



  Spark NLP supports Python 3.6.x and above depending on your major PySpark version.





  If you installed pyspark through pip/conda, you can install `spark-nlp` through the same channel.

  Pip:

  ```bash
  pip install spark-nlp==4.3.2
  ```

  Conda:

  ```bash
  conda install -c johnsnowlabs spark-nlp
  ```

  PyPI [spark-nlp package](https://pypi.org/project/spark-nlp/) /
  Anaconda [spark-nlp package](https://anaconda.org/JohnSnowLabs/spark-nlp)

  Then you'll have to create a SparkSession either from Spark NLP:

  ```python
  import sparknlp

  spark = sparknlp.start()
  ```

  or manually:

  ```python
  spark = SparkSession.builder
      .appName("Spark NLP")
      .master("local[*]")
      .config("spark.driver.memory", "16G")
      .config("spark.driver.maxResultSize", "0")
      .config("spark.kryoserializer.buffer.max", "2000M")
      .config("spark.jars.packages", "com.johnsnowlabs.nlp:spark-nlp_2.12:4.3.2")
      .getOrCreate()
  ```

  If using local jars, you can use `spark.jars` instead for comma-delimited jar files. For cluster setups, of course,
  you'll have to put the jars in a reachable location for all driver and executor nodes.

  **Quick example:**

  ```python
  import sparknlp
  from sparknlp.pretrained import PretrainedPipeline



  spark = sparknlp.start()

  sparknlp.version()
  spark.version



  pipeline = PretrainedPipeline('recognize_entities_dl', 'en')
  result = pipeline.annotate('The Mona Lisa is a 16th century oil painting created by Leonardo')
  ```







  - FAT-JAR for CPU on Apache Spark 3.0.x, 3.1.x, 3.2.x, and 3.3.x

  ```bash
  sbt assembly
  ```

  - FAT-JAR for GPU on Apache Spark 3.0.x, 3.1.x, 3.2.x, and 3.3.x

  ```bash
  sbt -Dis_gpu=true assembly
  ```

  - FAT-JAR for M! on Apache Spark 3.0.x, 3.1.x, 3.2.x, and 3.3.x

  ```bash
  sbt -Dis_silicon=true assembly
  ```



  If for some reason you need to use the JAR, you can either download the Fat JARs provided here or download it
  from [Maven Central](https://mvnrepository.com/artifact/com.johnsnowlabs.nlp).

  To add JARs to spark programs use the `--jars` option:

  ```sh
  spark-shell --jars spark-nlp.jar
  ```

  The preferred way to use the library when running spark programs is using the `--packages` option as specified in
  the `spark-packages` section.



  Use either one of the following options

  - Add the following Maven Coordinates to the interpreter's library list

  ```bash
  com.johnsnowlabs.nlp:spark-nlp_2.12:4.3.2
  ```

  - Add a path to pre-built jar from [here](#compiled-jars) in the interpreter's library list making sure the jar is
    available to driver path



  Apart from the previous step, install the python module through pip

  ```bash
  pip install spark-nlp==4.3.2
  ```

  Or you can install `spark-nlp` from inside Zeppelin by using Conda:

  ```bash
  python.conda install -c johnsnowlabs spark-nlp
  ```

  Configure Zeppelin properly, use cells with %spark.pyspark or any interpreter name you chose.

  Finally, in Zeppelin interpreter settings, make sure you set properly zeppelin.python to the python you want to use and
  install the pip library with (e.g. `python3`).

  An alternative option would be to set `SPARK_SUBMIT_OPTIONS` (zeppelin-env.sh) and make sure `--packages` is there as
  shown earlier since it includes both scala and python side installation.



  **Recommended:**

  The easiest way to get this done on Linux and macOS is to simply install `spark-nlp` and `pyspark` PyPI packages and
  launch the Jupyter from the same Python environment:

  ```sh
  $ conda create -n sparknlp python=3.8 -y
  $ conda activate sparknlp

  $ pip install spark-nlp==4.3.2 pyspark==3.3.1 jupyter
  $ jupyter notebook
  ```

  Then you can use `python3` kernel to run your code with creating SparkSession via `spark = sparknlp.start()`.

  **Optional:**

  If you are in different operating systems and require to make Jupyter Notebook run by using pyspark, you can follow
  these steps:

  ```bash
  export SPARK_HOME=/path/to/your/spark/folder
  export PYSPARK_PYTHON=python3
  export PYSPARK_DRIVER_PYTHON=jupyter
  export PYSPARK_DRIVER_PYTHON_OPTS=notebook

  pyspark --packages com.johnsnowlabs.nlp:spark-nlp_2.12:4.3.2
  ```

  Alternatively, you can mix in using `--jars` option for pyspark + `pip install spark-nlp`

  If not using pyspark at all, you'll have to run the instructions
  pointed [here](#python-without-explicit-Pyspark-installation)



  Google Colab is perhaps the easiest way to get started with spark-nlp. It requires no installation or setup other than
  having a Google account.

  Run the following code in Google Colab notebook and start using spark-nlp right away.

  ```sh

  !wget https://setup.johnsnowlabs.com/colab.sh -O - | bash
  ```

  This script comes with the two options to define `pyspark` and `spark-nlp` versions via options:

  ```sh




  !wget https://setup.johnsnowlabs.com/colab.sh -O - | bash /dev/stdin -p 3.2.3 -s 4.3.2
  ```

  [Spark NLP quick start on Google Colab](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/quick_start_google_colab.ipynb)
  is a live demo on Google Colab that performs named entity recognitions and sentiment analysis by using Spark NLP
  pretrained pipelines.



  Run the following code in Kaggle Kernel and start using spark-nlp right away.

  ```sh

  !wget https://setup.johnsnowlabs.com/kaggle.sh -O - | bash
  ```

  This script comes with the two options to define `pyspark` and `spark-nlp` versions via options:

  ```sh




  !wget https://setup.johnsnowlabs.com/colab.sh -O - | bash /dev/stdin -p 3.2.3 -s 4.3.2
  ```

  [Spark NLP quick start on Kaggle Kernel](https://www.kaggle.com/mozzie/spark-nlp-named-entity-recognition) is a live
  demo on Kaggle Kernel that performs named entity recognitions by using Spark NLP pretrained pipeline.



  1. Create a cluster if you don't have one already

  2. On a new cluster or existing one you need to add the following to the `Advanced Options -> Spark` tab:

      ```bash
      spark.kryoserializer.buffer.max 2000M
      spark.serializer org.apache.spark.serializer.KryoSerializer
      ```

  3. In `Libraries` tab inside your cluster you need to follow these steps:

     3.1. Install New -> PyPI -> `spark-nlp==4.3.2` -> Install

     3.2. Install New -> Maven -> Coordinates -> `com.johnsnowlabs.nlp:spark-nlp_2.12:4.3.2` -> Install

  4. Now you can attach your notebook to the cluster and use Spark NLP!

  NOTE: Databricks' runtimes support different Apache Spark major releases. Please make sure you choose the correct Spark
  NLP Maven package name (Maven Coordinate) for your runtime from
  our [Packages Cheatsheet](https://github.com/JohnSnowLabs/spark-nlp#packages-cheatsheet)



  To launch EMR clusters with Apache Spark/PySpark and Spark NLP correctly you need to have bootstrap and software
  configuration.

  A sample of your bootstrap script

  ```.sh

  set -x -e

  echo -e 'export PYSPARK_PYTHON=/usr/bin/python3
  export HADOOP_CONF_DIR=/etc/hadoop/conf
  export SPARK_JARS_DIR=/usr/lib/spark/jars
  export SPARK_HOME=/usr/lib/spark' >> $HOME/.bashrc && source $HOME/.bashrc

  sudo python3 -m pip install awscli boto spark-nlp

  set +x
  exit 0

  ```

  A sample of your software configuration in JSON on S3 (must be public access):

  ```.json
  [{
    "Classification": "spark-env",
    "Configurations": [{
      "Classification": "export",
      "Properties": {
        "PYSPARK_PYTHON": "/usr/bin/python3"
      }
    }]
  },
  {
    "Classification": "spark-defaults",
      "Properties": {
        "spark.yarn.stagingDir": "hdfs:///tmp",
        "spark.yarn.preserve.staging.files": "true",
        "spark.kryoserializer.buffer.max": "2000M",
        "spark.serializer": "org.apache.spark.serializer.KryoSerializer",
        "spark.driver.maxResultSize": "0",
        "spark.jars.packages": "com.johnsnowlabs.nlp:spark-nlp_2.12:4.3.2"
      }
  }]
  ```

  A sample of AWS CLI to launch EMR cluster:

  ```.sh
  aws emr create-cluster \
  --name "Spark NLP 4.3.2" \
  --release-label emr-6.2.0 \
  --applications Name=Hadoop Name=Spark Name=Hive \
  --instance-type m4.4xlarge \
  --instance-count 3 \
  --use-default-roles \
  --log-uri "s3://<S3_BUCKET>/" \
  --bootstrap-actions Path=s3://<S3_BUCKET>/emr-bootstrap.sh,Name=custome \
  --configurations "https://<public_access>/sparknlp-config.json" \
  --ec2-attributes KeyName=<your_ssh_key>,EmrManagedMasterSecurityGroup=<security_group_with_ssh>,EmrManagedSlaveSecurityGroup=<security_group_with_ssh> \
  --profile <aws_profile_credentials>
  ```



  1. Create a cluster if you don't have one already as follows.

  At gcloud shell:

  ```bash
  gcloud services enable dataproc.googleapis.com \
    compute.googleapis.com \
    storage-component.googleapis.com \
    bigquery.googleapis.com \
    bigquerystorage.googleapis.com
  ```

  ```bash
  REGION=<region>
  ```

  ```bash
  BUCKET_NAME=<bucket_name>
  gsutil mb -c standard -l ${REGION} gs://${BUCKET_NAME}
  ```

  ```bash
  REGION=<region>
  ZONE=<zone>
  CLUSTER_NAME=<cluster_name>
  BUCKET_NAME=<bucket_name>
  ```

  You can set image-version, master-machine-type, worker-machine-type,
  master-boot-disk-size, worker-boot-disk-size, num-workers as your needs.
  If you use the previous image-version from 2.0, you should also add ANACONDA to optional-components.
  And, you should enable gateway.
  Don't forget to set the maven coordinates for the jar in properties.

  ```bash
  gcloud dataproc clusters create ${CLUSTER_NAME} \
    --region=${REGION} \
    --zone=${ZONE} \
    --image-version=2.0 \
    --master-machine-type=n1-standard-4 \
    --worker-machine-type=n1-standard-2 \
    --master-boot-disk-size=128GB \
    --worker-boot-disk-size=128GB \
    --num-workers=2 \
    --bucket=${BUCKET_NAME} \
    --optional-components=JUPYTER \
    --enable-component-gateway \
    --metadata 'PIP_PACKAGES=spark-nlp spark-nlp-display google-cloud-bigquery google-cloud-storage' \
    --initialization-actions gs://goog-dataproc-initialization-actions-${REGION}/python/pip-install.sh \
    --properties spark:spark.serializer=org.apache.spark.serializer.KryoSerializer,spark:spark.driver.maxResultSize=0,spark:spark.kryoserializer.buffer.max=2000M,spark:spark.jars.packages=com.johnsnowlabs.nlp:spark-nlp_2.12:4.3.2
  ```

  2. On an existing one, you need to install spark-nlp and spark-nlp-display packages from PyPI.

  3. Now, you can attach your notebook to the cluster and use the Spark NLP!



  You can change the following Spark NLP configurations via Spark Configuration:

  | Property Name                                          | Default              | Meaning                                                                                                                                                                                                                                                                            |
  |--------------------------------------------------------|----------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | `spark.jsl.settings.pretrained.cache_folder`           | `~/cache_pretrained` | The location to download and extract pretrained `Models` and `Pipelines`. By default, it will be in User's Home directory under `cache_pretrained` directory                                                                                                                       |
  | `spark.jsl.settings.storage.cluster_tmp_dir`           | `hadoop.tmp.dir`     | The location to use on a cluster for temporarily files such as unpacking indexes for WordEmbeddings. By default, this locations is the location of `hadoop.tmp.dir` set via Hadoop configuration for Apache Spark. NOTE: `S3` is not supported and it must be local, HDFS, or DBFS |
  | `spark.jsl.settings.annotator.log_folder`              | `~/annotator_logs`   | The location to save logs from annotators during training such as `NerDLApproach`, `ClassifierDLApproach`, `SentimentDLApproach`, `MultiClassifierDLApproach`, etc. By default, it will be in User's Home directory under `annotator_logs` directory                               |
  | `spark.jsl.settings.aws.credentials.access_key_id`     | `None`               | Your AWS access key to use your S3 bucket to store log files of training models or access tensorflow graphs used in `NerDLApproach`                                                                                                                                                |
  | `spark.jsl.settings.aws.credentials.secret_access_key` | `None`               | Your AWS secret access key to use your S3 bucket to store log files of training models or access tensorflow graphs used in `NerDLApproach`                                                                                                                                         |
  | `spark.jsl.settings.aws.credentials.session_token`     | `None`               | Your AWS MFA session token to use your S3 bucket to store log files of training models or access tensorflow graphs used in `NerDLApproach`                                                                                                                                         |
  | `spark.jsl.settings.aws.s3_bucket`                     | `None`               | Your AWS S3 bucket to store log files of training models or access tensorflow graphs used in `NerDLApproach`                                                                                                                                                                       |
  | `spark.jsl.settings.aws.region`                        | `None`               | Your AWS region to use your S3 bucket to store log files of training models or access tensorflow graphs used in `NerDLApproach`                                                                                                                                                    |



  **SparkSession:**

  You can use `.config()` during SparkSession creation to set Spark NLP configurations.

  ```python
  from pyspark.sql import SparkSession

  spark = SparkSession.builder
      .master("local[*]")
      .config("spark.driver.memory", "16G")
      .config("spark.driver.maxResultSize", "0")
      .config("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
      .config("spark.kryoserializer.buffer.max", "2000m")
      .config("spark.jsl.settings.pretrained.cache_folder", "sample_data/pretrained")
      .config("spark.jsl.settings.storage.cluster_tmp_dir", "sample_data/storage")
      .config("spark.jars.packages", "com.johnsnowlabs.nlp:spark-nlp_2.12:4.3.2")
      .getOrCreate()
  ```

  **spark-shell:**

  ```sh
  spark-shell \
    --driver-memory 16g \
    --conf spark.driver.maxResultSize=0 \
    --conf spark.serializer=org.apache.spark.serializer.KryoSerializer
    --conf spark.kryoserializer.buffer.max=2000M \
    --conf spark.jsl.settings.pretrained.cache_folder="sample_data/pretrained" \
    --conf spark.jsl.settings.storage.cluster_tmp_dir="sample_data/storage" \
    --packages com.johnsnowlabs.nlp:spark-nlp_2.12:4.3.2
  ```

  **pyspark:**

  ```sh
  pyspark \
    --driver-memory 16g \
    --conf spark.driver.maxResultSize=0 \
    --conf spark.serializer=org.apache.spark.serializer.KryoSerializer
    --conf spark.kryoserializer.buffer.max=2000M \
    --conf spark.jsl.settings.pretrained.cache_folder="sample_data/pretrained" \
    --conf spark.jsl.settings.storage.cluster_tmp_dir="sample_data/storage" \
    --packages com.johnsnowlabs.nlp:spark-nlp_2.12:4.3.2
  ```

  **Databricks:**

  On a new cluster or existing one you need to add the following to the `Advanced Options -> Spark` tab:

  ```bash
  spark.kryoserializer.buffer.max 2000M
  spark.serializer org.apache.spark.serializer.KryoSerializer
  spark.jsl.settings.pretrained.cache_folder dbfs:/PATH_TO_CACHE
  spark.jsl.settings.storage.cluster_tmp_dir dbfs:/PATH_TO_STORAGE
  spark.jsl.settings.annotator.log_folder dbfs:/PATH_TO_LOGS
  ```

  NOTE: If this is an existing cluster, after adding new configs or changing existing properties you need to restart it.



  In Spark NLP we can define S3 locations to:

  - Export log files of training models
  - Store tensorflow graphs used in `NerDLApproach`

  **Logging:**

  To configure S3 path for logging while training models. We need to set up AWS credentials as well as an S3 path

  ```bash
  spark.conf.set("spark.jsl.settings.annotator.log_folder", "s3://my/s3/path/logs")
  spark.conf.set("spark.jsl.settings.aws.credentials.access_key_id", "MY_KEY_ID")
  spark.conf.set("spark.jsl.settings.aws.credentials.secret_access_key", "MY_SECRET_ACCESS_KEY")
  spark.conf.set("spark.jsl.settings.aws.s3_bucket", "my.bucket")
  spark.conf.set("spark.jsl.settings.aws.region", "my-region")
  ```

  Now you can check the log on your S3 path defined in *spark.jsl.settings.annotator.log_folder* property.
  Make sure to use the prefix *s3://*, otherwise it will use the default configuration.

  **Tensorflow Graphs:**

  To reference S3 location for downloading graphs. We need to set up AWS credentials

  ```bash
  spark.conf.set("spark.jsl.settings.aws.credentials.access_key_id", "MY_KEY_ID")
  spark.conf.set("spark.jsl.settings.aws.credentials.secret_access_key", "MY_SECRET_ACCESS_KEY")
  spark.conf.set("spark.jsl.settings.aws.region", "my-region")
  ```

  **MFA Configuration:**

  In case your AWS account is configured with MFA. You will need first to get temporal credentials and add session token
  to the configuration as shown in the examples below
  For logging:

  ```bash
  spark.conf.set("spark.jsl.settings.aws.credentials.session_token", "MY_TOKEN")
  ```

  An example of a bash script that gets temporal AWS credentials can be
  found [here](https://github.com/JohnSnowLabs/spark-nlp/blob/master/scripts/aws_tmp_credentials.sh)
  This script requires three arguments:

  ```bash
  ./aws_tmp_credentials.sh iam_user duration serial_number
  ```





  **Quick example:**

  ```scala
  import com.johnsnowlabs.nlp.pretrained.PretrainedPipeline
  import com.johnsnowlabs.nlp.SparkNLP

  SparkNLP.version()

  val testData = spark.createDataFrame(Seq(
    (1, "Google has announced the release of a beta version of the popular TensorFlow machine learning library"),
    (2, "Donald John Trump (born June 14, 1946) is the 45th and current president of the United States")
  )).toDF("id", "text")

  val pipeline = PretrainedPipeline("explain_document_dl", lang = "en")

  val annotation = pipeline.transform(testData)

  annotation.show()
  /*
  import com.johnsnowlabs.nlp.pretrained.PretrainedPipeline
  import com.johnsnowlabs.nlp.SparkNLP
  2.5.0
  testData: org.apache.spark.sql.DataFrame = [id: int, text: string]
  pipeline: com.johnsnowlabs.nlp.pretrained.PretrainedPipeline = PretrainedPipeline(explain_document_dl,en,public/models)
  annotation: org.apache.spark.sql.DataFrame = [id: int, text: string ... 10 more fields]
  +---+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+
  | id|                text|            document|               token|            sentence|             checked|               lemma|                stem|                 pos|          embeddings|                 ner|            entities|
  +---+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+
  |  1|Google has announ...|[[document, 0, 10...|[[token, 0, 5, Go...|[[document, 0, 10...|[[token, 0, 5, Go...|[[token, 0, 5, Go...|[[token, 0, 5, go...|[[pos, 0, 5, NNP,...|[[word_embeddings...|[[named_entity, 0...|[[chunk, 0, 5, Go...|
  |  2|The Paris metro w...|[[document, 0, 11...|[[token, 0, 2, Th...|[[document, 0, 11...|[[token, 0, 2, Th...|[[token, 0, 2, Th...|[[token, 0, 2, th...|[[pos, 0, 2, DT, ...|[[word_embeddings...|[[named_entity, 0...|[[chunk, 4, 8, Pa...|
  +---+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+
  */

  annotation.select("entities.result").show(false)

  /*
  +----------------------------------+
  |result                            |
  +----------------------------------+
  |[Google, TensorFlow]              |
  |[Donald John Trump, United States]|
  +----------------------------------+
  */
  ```



  There are functions in Spark NLP that will list all the available Pipelines
  of a particular language for you:

  ```scala
  import com.johnsnowlabs.nlp.pretrained.ResourceDownloader

  ResourceDownloader.showPublicPipelines(lang = "en")
  /*
  +--------------------------------------------+------+---------+
  | Pipeline                                   | lang | version |
  +--------------------------------------------+------+---------+
  | dependency_parse                           |  en  | 2.0.2   |
  | analyze_sentiment_ml                       |  en  | 2.0.2   |
  | check_spelling                             |  en  | 2.1.0   |
  | match_datetime                             |  en  | 2.1.0   |
                                 ...
  | explain_document_ml                        |  en  | 3.1.3   |
  +--------------------------------------------+------+---------+
  */
  ```

  Or if we want to check for a particular version:

  ```scala
  import com.johnsnowlabs.nlp.pretrained.ResourceDownloader

  ResourceDownloader.showPublicPipelines(lang = "en", version = "3.1.0")
  /*
  +---------------------------------------+------+---------+
  | Pipeline                              | lang | version |
  +---------------------------------------+------+---------+
  | dependency_parse                      |  en  | 2.0.2   |
                                 ...
  | clean_slang                           |  en  | 3.0.0   |
  | clean_pattern                         |  en  | 3.0.0   |
  | check_spelling                        |  en  | 3.0.0   |
  | dependency_parse                      |  en  | 3.0.0   |
  +---------------------------------------+------+---------+
  */
  ```





  **Some selected languages:
  ** `Afrikaans, Arabic, Armenian, Basque, Bengali, Breton, Bulgarian, Catalan, Czech, Dutch, English, Esperanto, Finnish, French, Galician, German, Greek, Hausa, Hebrew, Hindi, Hungarian, Indonesian, Irish, Italian, Japanese, Latin, Latvian, Marathi, Norwegian, Persian, Polish, Portuguese, Romanian, Russian, Slovak, Slovenian, Somali, Southern Sotho, Spanish, Swahili, Swedish, Tswana, Turkish, Ukrainian, Zulu`

  **Quick online example:**

  ```python

  ner_dl = NerDLModel.pretrained('ner_dl')

  ner_bert = NerDLModel.pretrained('ner_dl_bert')
  ```

  ```scala
  // load French POS tagger model trained by Universal Dependencies
  val french_pos = PerceptronModel.pretrained("pos_ud_gsd", lang = "fr")
  // load Italian LemmatizerModel
  val italian_lemma = LemmatizerModel.pretrained("lemma_dxc", lang = "it")
  ````

  **Quick offline example:**

  - Loading `PerceptronModel` annotator model inside Spark NLP Pipeline

  ```scala
  val french_pos = PerceptronModel.load("/tmp/pos_ud_gsd_fr_2.0.2_2.4_1556531457346/")
    .setInputCols("document", "token")
    .setOutputCol("pos")
  ```



  There are functions in Spark NLP that will list all the available Models
  of a particular Annotator and language for you:

  ```scala
  import com.johnsnowlabs.nlp.pretrained.ResourceDownloader

  ResourceDownloader.showPublicModels(annotator = "NerDLModel", lang = "en")
  /*
  +---------------------------------------------+------+---------+
  | Model                                       | lang | version |
  +---------------------------------------------+------+---------+
  | onto_100                                    |  en  | 2.1.0   |
  | onto_300                                    |  en  | 2.1.0   |
  | ner_dl_bert                                 |  en  | 2.2.0   |
  | onto_100                                    |  en  | 2.4.0   |
  | ner_conll_elmo                              |  en  | 3.2.2   |
  +---------------------------------------------+------+---------+
  */
  ```

  Or if we want to check for a particular version:

  ```scala
  import com.johnsnowlabs.nlp.pretrained.ResourceDownloader

  ResourceDownloader.showPublicModels(annotator = "NerDLModel", lang = "en", version = "3.1.0")
  /*
  +----------------------------+------+---------+
  | Model                      | lang | version |
  +----------------------------+------+---------+
  | onto_100                   |  en  | 2.1.0   |
  | ner_aspect_based_sentiment |  en  | 2.6.2   |
  | ner_weibo_glove_840B_300d  |  en  | 2.6.2   |
  | nerdl_atis_840b_300d       |  en  | 2.7.1   |
  | nerdl_snips_100d           |  en  | 2.7.3   |
  +----------------------------+------+---------+
  */
  ```

  And to see a list of available annotators, you can use:

  ```scala
  import com.johnsnowlabs.nlp.pretrained.ResourceDownloader

  ResourceDownloader.showAvailableAnnotators()
  /*
  AlbertEmbeddings
  AlbertForTokenClassification
  AssertionDLModel
  ...
  XlmRoBertaSentenceEmbeddings
  XlnetEmbeddings
  */
  ```





  Spark NLP library and all the pre-trained models/pipelines can be used entirely offline with no access to the Internet.
  If you are behind a proxy or a firewall with no access to the Maven repository (to download packages) or/and no access
  to S3 (to automatically download models and pipelines), you can simply follow the instructions to have Spark NLP without
  any limitations offline:

  - Instead of using the Maven package, you need to load our Fat JAR
  - Instead of using PretrainedPipeline for pretrained pipelines or the `.pretrained()` function to download pretrained
    models, you will need to manually download your pipeline/model from [Models Hub](https://nlp.johnsnowlabs.com/models),
    extract it, and load it.

  Example of `SparkSession` with Fat JAR to have Spark NLP offline:

  ```python
  spark = SparkSession.builder
      .appName("Spark NLP")
      .master("local[*]")
      .config("spark.driver.memory", "16G")
      .config("spark.driver.maxResultSize", "0")
      .config("spark.kryoserializer.buffer.max", "2000M")
      .config("spark.jars", "/tmp/spark-nlp-assembly-4.3.2.jar")
      .getOrCreate()
  ```

  - You can download provided Fat JARs from each [release notes](https://github.com/JohnSnowLabs/spark-nlp/releases),
    please pay attention to pick the one that suits your environment depending on the device (CPU/GPU) and Apache Spark
    version (3.0.x, 3.1.x, 3.2.x, and 3.3.x)
  - If you are local, you can load the Fat JAR from your local FileSystem, however, if you are in a cluster setup you need
    to put the Fat JAR on a distributed FileSystem such as HDFS, DBFS, S3, etc. (
    i.e., `hdfs:///tmp/spark-nlp-assembly-4.3.2.jar`)

  Example of using pretrained Models and Pipelines in offline:

  ```python



  french_pos = PerceptronModel.load("/tmp/pos_ud_gsd_fr_2.0.2_2.4_1556531457346/")
      .setInputCols("document", "token")
      .setOutputCol("pos")





  PipelineModel.load("/tmp/explain_document_dl_en_2.0.2_2.4_1556530585689/")
  ```

  - Since you are downloading and loading models/pipelines manually, this means Spark NLP is not downloading the most
    recent and compatible models/pipelines for you. Choosing the right model/pipeline is on you
  - If you are local, you can load the model/pipeline from your local FileSystem, however, if you are in a cluster setup
    you need to put the model/pipeline on a distributed FileSystem such as HDFS, DBFS, S3, etc. (
    i.e., `hdfs:///tmp/explain_document_dl_en_2.0.2_2.4_1556530585689/`)



  Need more **examples**? Check out our dedicated [Spark NLP Examples](https://github.com/JohnSnowLabs/spark-nlp/tree/master/examples)
  repository to showcase all Spark NLP use cases!

  Also, don't forget to check [Spark NLP in Action](https://nlp.johnsnowlabs.com/demo) built by Streamlit.





  [Check our Articles and Videos page here](https://nlp.johnsnowlabs.com/learn)



  We have published a [paper](https://www.sciencedirect.com/science/article/pii/S2665963821000063) that you can cite for
  the Spark NLP library:

  ```bibtex
  @article{KOCAMAN2021100058,
      title = {Spark NLP: Natural language understanding at scale},
      journal = {Software Impacts},
      pages = {100058},
      year = {2021},
      issn = {2665-9638},
      doi = {https://doi.org/10.1016/j.simpa.2021.100058},
      url = {https://www.sciencedirect.com/science/article/pii/S2665963.2.300063},
      author = {Veysel Kocaman and David Talby},
      keywords = {Spark, Natural language processing, Deep learning, Tensorflow, Cluster},
      abstract = {Spark NLP is a Natural Language Processing (NLP) library built on top of Apache Spark ML. It provides simple, performant & accurate NLP annotations for machine learning pipelines that can scale easily in a distributed environment. Spark NLP comes with 1100+ pretrained pipelines and models in more than 192+ languages. It supports nearly all the NLP tasks and modules that can be used seamlessly in a cluster. Downloaded more than 2.7 million times and experiencing 9x growth since January 2020, Spark NLP is used by 54% of healthcare organizations as the world’s most widely used NLP library in the enterprise.}
      }
  }
  ```



  We appreciate any sort of contributions:

  - ideas
  - feedback
  - documentation
  - bug reports
  - NLP training and testing corpora
  - Development and testing

  Clone the repo and submit your pull-requests! Or directly create issues in this repo.



  [http://johnsnowlabs.com](http://johnsnowlabs.com)


pkgId: fba2b2e536a475059da29372dcaf7c9146ff90d4d539588f2884ca2115c3f813
name: python-spark-nlp-display
arch: src
version: 4.4
epoch: 0
release: 1
summary: Visualization package for Spark NLP
url: http://nlp.johnsnowlabs.com
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d0de4d51-e8ea-438d-b61e-c5c315cd8b53
location_href: 00011691-python-spark-nlp-display/python-spark-nlp-display-4.4-1.src.rpm
checksum_type: sha256
description:
  A library for the simple visualization of different types of Spark NLP annotations.


  - Dependency Parser
  - Named Entity Recognition
  - Entity Resolution
  - Relation Extraction
  - Assertion Status


  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp-display/blob/main/tutorials/Spark_NLP_Display.ipynb)

  https://github.com/JohnSnowLabs/spark-nlp-display/blob/main/tutorials/Spark_NLP_Display.ipynb


  - spark-nlp
  - ipython
  - svgwrite
  - pandas
  - numpy


  ```bash
  pip install spark-nlp-display
  ```





  ```python
  from sparknlp_display import NerVisualizer

  ner_vis = NerVisualizer()


  ner_vis.set_label_colors({'LOC':'#800080', 'PER':'#77b5fe'}) #set label colors by specifying hex codes

  pipeline_result = ner_light_pipeline.fullAnnotate(text) ##light pipeline


  vis_html = ner_vis.display(pipeline_result[0], #should be the results of a single example, not the complete dataframe
                      label_col='entities', #specify the entity column
                      document_col='document', #specify the document column (default: 'document')
                      labels=['PER'], #only allow these labels to be displayed. (default: [] - all labels will be displayed)
                      return_html=True)

  displayHTML(vis_html)
  ```
  ![title](https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp-display/main/assets/ner_viz.png)



  To save the visualization as html, provide the export file path: `save_path='./export.html'` for each visualizer.



  ```python
  from sparknlp_display import DependencyParserVisualizer

  dependency_vis = DependencyParserVisualizer()

  pipeline_result = dp_pipeline.fullAnnotate(text)


  dependency_vis.display(pipeline_result[0], #should be the results of a single example, not the complete dataframe.
                         pos_col = 'pos', #specify the pos column
                         dependency_col = 'dependency', #specify the dependency column
                         dependency_type_col = 'dependency_type', #specify the dependency type column
                         save_path='./export.html' # optional - to save viz as html. (default: None)
                         )
  ```

  ![title](https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp-display/main/assets/dp_viz.png)



  ```python
  from sparknlp_display import NerVisualizer

  ner_vis = NerVisualizer()

  pipeline_result = ner_light_pipeline.fullAnnotate(text)


  ner_vis.display(pipeline_result[0], #should be the results of a single example, not the complete dataframe
                      label_col='entities', #specify the entity column
                      document_col='document', #specify the document column (default: 'document')
                      labels=['PER'], #only allow these labels to be displayed. (default: [] - all labels will be displayed)
                      save_path='./export.html' # optional - to save viz as html. (default: None)
                      )


  ner_vis.set_label_colors({'LOC':'#800080', 'PER':'#77b5fe'}) #set label colors by specifying hex codes

  ```

  ![title](https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp-display/main/assets/ner_viz.png)



  ```python
  from sparknlp_display import EntityResolverVisualizer

  er_vis = EntityResolverVisualizer()

  pipeline_result = er_light_pipeline.fullAnnotate(text)

  er_vis.display(pipeline_result[0], #should be the results of a single example, not the complete dataframe
                 label_col='entities', #specify the ner result column
                 resolution_col = 'resolution',
                 document_col='document', #specify the document column (default: 'document')
                 save_path='./export.html' # optional - to save viz as html. (default: None)
                 )


  er_vis.set_label_colors({'TREATMENT':'#800080', 'PROBLEM':'#77b5fe'}) #set label colors by specifying hex codes

  ```

  ![title](https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp-display/main/assets/er_viz.png)


  ```python
  from sparknlp_display import RelationExtractionVisualizer

  re_vis = RelationExtractionVisualizer()

  pipeline_result = re_light_pipeline.fullAnnotate(text)

  re_vis.display(pipeline_result[0], #should be the results of a single example, not the complete dataframe
                 relation_col = 'relations', #specify relations column
                 document_col = 'document', #specify document column
                 show_relations=True, #display relation names on arrows (default: True)
                 save_path='./export.html' # optional - to save viz as html. (default: None)
                 )

  ```

  ![title](https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp-display/main/assets/re_viz.png)


  ```python
  from sparknlp_display import AssertionVisualizer

  assertion_vis = AssertionVisualizer()

  pipeline_result = ner_assertion_light_pipeline.fullAnnotate(text)

  assertion_vis.display(pipeline_result[0],
                        label_col = 'entities', #specify the ner result column
                        assertion_col = 'assertion', #specify assertion column
                        document_col = 'document', #specify the document column (default: 'document')
                        save_path='./export.html' # optional - to save viz as html. (default: None)
                        )


  assertion_vis.set_label_colors({'TREATMENT':'#008080', 'problem':'#800080'}) #set label colors by specifying hex codes

  ```

  ![title](https://raw.githubusercontent.com/JohnSnowLabs/spark-nlp-display/main/assets/assertion_viz.png)


pkgId: 2728e2745f1bd8687f1b9578b0c04e8f118efe3271894e6ca71ece3ed4cbb250
name: python-spark-sklearn
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Integration tools for running scikit-learn on Spark
url: https://github.com/databricks/spark-sklearn
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a2b6c879-3c27-4761-91d7-782ff630237d
location_href: 00010287-python-spark-sklearn/python-spark-sklearn-0.3.0-1.src.rpm
checksum_type: sha256
description:
  This package contains some tools to integrate the `Spark computing framework <https://spark.apache.org/>`_
  with the popular `scikit-learn machine library <https://scikit-learn.org/stable/>`_. Among other things, it can:
  - train and evaluate multiple scikit-learn models in parallel. It is a distributed analog to the
    `multicore implementation <https://pythonhosted.org/joblib/parallel.html>`_ included by default in ``scikit-learn``
  - convert Spark's Dataframes seamlessly into numpy ``ndarray`` or sparse matrices
  - (experimental) distribute Scipy's sparse matrices as a dataset of sparse vectors
  It focuses on problems that have a small amount of data and that can be run in parallel.
  For small datasets, it distributes the search for estimator parameters (``GridSearchCV`` in scikit-learn),
  using Spark. For datasets that do not fit in memory, we recommend using the `distributed implementation in
  `Spark MLlib <https://spark.apache.org/docs/latest/api/python/pyspark.mllib.html>`_.
  This package distributes simple tasks like grid-search cross-validation.
  It does not distribute individual learning algorithms (unlike Spark MLlib).


pkgId: 39b64c0018c9d3e3743425820fac2059a29ec02ebbf09641b55f5d0f0e0bca8a
name: python-sparkaid
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Utils for working with Spark
url: https://github.com/lvhuyen/SparkAid
rpm_license: GNU Lesser General Public License v3 or later (LGPLv3+)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-435160c8-8353-48bd-b341-b709b0fd43fd
location_href: 00010926-python-sparkaid/python-sparkaid-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Sample DataFrame:
      from pyspark.sql import Row
      from pyspark.sql.functions import col
      df_struct = spark.createDataFrame([Row(structA=Row(field1=10, field2=1.5),
                                             structB=Row(field3="one",field4=False))])
  	df_struct.printSchema()
  	root
  	 |-- structA: struct (nullable = true)
  	 |    |-- field1: long (nullable = true)
  	 |    |-- field2: double (nullable = true)
  	 |-- structB: struct (nullable = true)
  	 |    |-- field3: string (nullable = true)
  	 |    |-- field4: boolean (nullable = true)
  Spark allows selecting nested columns by using the dot `.` notation:
  	df_struct.select("structA.*", "structB.field3").printSchema()
  	root
       |-- field1: long (nullable = true)
       |-- field2: double (nullable = true)
       |-- field3: string (nullable = true)
  Please note here that the current Spark implementation (2.4.3 or below) doesn't keep the outer layer fieldname (e.g: structA) in the output dataframe

  To select only some elements from an ArrayType column, either *`getItem()`* or using brackets (as selecting elements from a legacy array: `[]` in Python `()` in Scala)  would do the trick:
  	df_array = spark.createDataFrame([Row(arrayA=[1,2,3,4,5],fieldB="foo")])
  	df_array.select(col("arrayA").getItem(0).alias("element0"), col("arrayA")[4].alias("element5"), col("fieldB")).show()
  	+--------+--------+------+
      |element0|element5|fieldB|
      +--------+--------+------+
      |       1|       5|   foo|
      +--------+--------+------+

  Elements from a MapType column can be selected the same way as in the case of ArrayType, but using the key instead of index number. The dot notation (`.`) could also be used instead of `getItem()` or brackets:
      df_map = spark.createDataFrame([Row(mapA={2: "TWO", 3: "THREE", 0: "ZERO"}, fieldB="foo")])
      df_map.select(col("mapA")[3].alias("element3"), col("mapA").getItem(2).alias("element2"), col("mapA.0").alias("element0"), col("mapA").getItem(1).alias("element1")).show()
  	+--------+--------+--------+--------+
      |element3|element2|element0|element1|
      +--------+--------+--------+--------+
      |   THREE|     TWO|    ZERO|    null|
      +--------+--------+--------+--------+

  As Spark DataFrame.select() supports passing an array of columns to be selected, to fully unflatten a multi-layer nested dataframe, a recursive call would do the trick.
  Here is a detailed discussion on StackOverFlow on how to do this:
  https://stackoverflow.com/questions/37471346/automatically-and-elegantly-flatten-dataframe-in-spark-sql

  	df_nested = spark.createDataFrame([
  	    Row(
  	        arrayA=[
  	            Row(childStructB=Row(field1=1, field2="foo")),
  	            Row(childStructB=Row(field1=2, field2="bar"))
  	        ]
  	    )])
  	df_nested.printSchema()
  	root
       |-- arrayA: array (nullable = true)
       |    |-- element: struct (containsNull = true)
       |    |    |-- childStructB: struct (nullable = true)
       |    |    |    |-- field1: long (nullable = true)
       |    |    |    |-- field2: string (nullable = true)
      df_nested.show(1, False)
      +------------------------+
      |arrayA                  |
      +------------------------+
      |[[[1, foo]], [[2, bar]]]|
      +------------------------+
  Selecting *field1* or *field2* can be done as with normal structs (not nested inside an array), by using that dot `.` annotation. The result would be of the type `ArrayType[ChildFieldType]`, which has been **_vertically sliced_** from the original array
  	df_child = df_nested.select("arrayA.childStructB.field1", "arrayA.childStructB.field2")
  	df_child.printSchema()
  	root
       |-- field1: array (nullable = true)
       |    |-- element: long (containsNull = true)
       |-- field2: array (nullable = true)
       |    |-- element: string (containsNull = true)
      df_child.show()
      +------+----------+
      |field1|    field2|
      +------+----------+
      |[1, 2]|[foo, bar]|
      +------+----------+

  As each MapType column has two components, the keys and the values, selecting nested column inside a MapType column is not straight forward - we cannot just use that `.` to take the nested fields as that has already been used for denoting the key.
      df_map_nested = spark.createDataFrame([Row(mapA={"2": Row(type_name="Arabic number", equivalent=2), "THREE": Row(type_name="English Text", equivalent=3)}, fieldB="foo")])
      df_map_nested.select(col("mapA.type_name"), col("mapA.THREE.type_name")).show()
      +---------+------------+
      |type_name|   type_name|
      +---------+------------+
      |     null|English Text|
      +---------+------------+
  A solution for this is to use the builtin function `map_values()` which has been introduced since Spark 2.3. Note the type of the result column: ArrayType
      from pyspark.sql.functions import map_values
      result = df_map_nested.select(map_values("mapA")["type_name"], col("mapA.THREE.type_name"))
      result.show(2,False)
      result.printSchema()
      +-----------------------------+------------+
      |map_values(mapA).type_name   |type_name   |
      +-----------------------------+------------+
      |[Arabic number, English Text]|English Text|
      +-----------------------------+------------+
      root
       |-- map_values(mapA).type_name: array (nullable = true)
       |    |-- element: string (containsNull = true)
       |-- type_name: string (nullable = true)

  The above steps would work well for most of dataframes. The only dataframes that it fails (as of Spark 2.4.3 or lower) are the ones with a StructType nested inside MORE THAN ONE layers of ArrayType.
  Like this one:
  	df_nested_B = spark.createDataFrame([
          Row(
              arrayA=[[
                  Row(childStructB=Row(field1=1, field2="foo")),
                  Row(childStructB=Row(field1=2, field2="bar"))
              ]]
          )])
      df_nested_B.printSchema()
      root
       |-- arrayA: array (nullable = true)
       |    |-- element: array (containsNull = true)
       |    |    |-- element: struct (containsNull = true)
       |    |    |    |-- childStructB: struct (nullable = true)
       |    |    |    |    |-- field1: long (nullable = true)
       |    |    |    |    |-- field2: string (nullable = true)
  Or this one
  	df_nested_C = spark.createDataFrame([
          Row(
              arrayA=[
                  Row(childStructB=Row(childArrayC=[Row(field1=1, field2="foo")])),
                  Row(childStructB=Row(childArrayC=[Row(field1=2, field2="bar")])),
              ]
          )])
      df_nested_C.printSchema()
      root
       |-- arrayA: array (nullable = true)
       |    |-- element: struct (containsNull = true)
       |    |    |-- childStructB: struct (nullable = true)
       |    |    |    |-- childArrayC: array (nullable = true)
       |    |    |    |    |-- element: struct (containsNull = true)
       |    |    |    |    |    |-- field1: long (nullable = true)
       |    |    |    |    |    |-- field2: string (nullable = true)
  Selecting `arrayA.childStructB.field1` from `df_nested_B` fails with the error message: `AnalysisException: No such struct field field1 in childStructB`.<br>
  While selecting `arrayA.childStructB.childArrayC.field1` from `df_nested_C` throws the `AnalysisException`: `cannot resolve 'arrayA.childStructB.childArrayC['field1']' due to data type mismatch: argument 2 requires integral type, however, ''field1'' is of string type.`

  With the introduction of the SQL function `transform` in Spark 2.4, the error above can be solved by applying `transform` on every layer of the array.
  A comprehensive implementation of a flatten function can be found in the Python package `sparkaid`:
  	from sparkaid import flatten
  	flatten(df_nested_B).printSchema()
  	root
  	 |-- arrayA__childStructB_field1: array (nullable = true)
  	 |    |-- element: array (containsNull = true)
  	 |    |    |-- element: long (containsNull = true)
  	 |-- arrayA__childStructB_field2: array (nullable = true)
  	 |    |-- element: array (containsNull = true)
  	 |    |    |-- element: string (containsNull = true)
  <p>
  	flatten(df_nested_B).show()
  	+---------------------------+---------------------------+
      |arrayA__childStructB_field1|arrayA__childStructB_field2|
      +---------------------------+---------------------------+
      |                   [[1, 2]]|               [[foo, bar]]|
      +---------------------------+---------------------------+
  <p>
      flatten(df_nested_C).printSchema()
      root
       |-- arrayA_childStructB_childArrayC_field1: array (nullable = true)
       |    |-- element: array (containsNull = true)
       |    |    |-- element: long (containsNull = true)
       |-- arrayA_childStructB_childArrayC_field2: array (nullable = true)
       |    |-- element: array (containsNull = true)
       |    |    |-- element: string (containsNull = true)
  []: https://spark.apache.org/docs/2.4.0/api/java/org/apache/spark/sql/functions.html#flatten-org.apache.spark.sql.Column


pkgId: 709c917bdb0f33cde13b76f2abbcffc5e3f1f198f43ff1f604fcae54ddfcb2d5
name: python-sparkly
arch: src
version: 2.8.2
epoch: 0
release: 1
summary: Helpers & syntax sugar for PySpark.
url: https://github.com/Tubular/sparkly
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dac0b259-182f-4066-a67b-c078ed5d11e8
location_href: 00012384-python-sparkly/python-sparkly-2.8.2-1.src.rpm
checksum_type: sha256
description:
  |Sparkly PyPi Version| |Sparkly Build Status| |Documentation Status|
  Helpers & syntax sugar for PySpark. There are several features to make your life easier:
  - Definition of spark packages, external jars, UDFs and spark options within your code;
  - Simplified reader/writer api for Cassandra, Elastic, MySQL, Kafka;
  - Testing framework for spark applications.
  More details could be found in `the official
  documentation <https://sparkly.readthedocs.org>`__.


pkgId: a9e77979f87ef1d6749f22a796582275ee5dde9e65b98e5371c54b24722e7ce0
name: python-sparkmeasure
arch: src
version: 0.21.1
epoch: 0
release: 1
summary: Python API for sparkMeasure, a tool for performance troubleshooting of Apache Spark workloads
url: https://github.com/lucacanali/sparkMeasure
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-83cae88b-be74-4a23-9d24-564e943d417c
location_href: 00010658-python-sparkmeasure/python-sparkmeasure-0.21.1-1.src.rpm
checksum_type: sha256
description:
  SparkMeasure is a tool for performance troubleshooting of Apache Spark workloads.
  It simplifies the collection and analysis of Spark performance metrics. The bulk of sparkMeasure is written in Scala.
  This package contains the Python API for sparkMeasure and is intended to work in conjunction with PySpark.
  Use from python command line or in Jupyter notebook environments, or as a tool to instrument Python code running Spark workloads.
  **[Link to sparkMeasure GitHub page and documentation](https://github.com/lucacanali/sparkMeasure)**


pkgId: b83cd207896957e899c234ec67a9957833137a3bee865c927af0fbbf6d9d7ab0
name: python-sparknlp
arch: src
version: 1.0.0
epoch: 0
release: 1
url: http://nlp.johnsnowlabs.com
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0667a4c6-03eb-4075-b00c-be2447d41823
location_href: 00014041-python-sparknlp/python-sparknlp-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  John Snow Labs Spark NLP is a natural language processing library built on top of Apache Spark ML. It provides simple, performant & accurate NLP annotations for machine learning pipelines, that scale easily in a distributed environment.

description:
  The correct URL for Spark NLP PyPI package: [https://pypi.org/project/spark-nlp/](https://pypi.org/project/spark-nlp/).


pkgId: 15ad9d399084b8ec3e8b29b6a7555540e0072a4a897784481f44751a6a325b1e
name: python-sparse
arch: src
version: 0.14.0
epoch: 0
release: 1
summary: Sparse n-dimensional arrays
url: https://github.com/pydata/sparse/
rpm_license: BSD 3-Clause License (Revised)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7cbac3aa-cdb7-41b1-b108-5b6a5a595bb9
location_href: 00011890-python-sparse/python-sparse-0.14.0-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Docs Status| |Coverage|
  This library provides multi-dimensional sparse arrays.
  * `Documentation <http://sparse.pydata.org/>`_
  * `Contributing <https://github.com/pydata/sparse/blob/master/docs/contributing.rst>`_
  * `Bug Reports/Feature Requests <https://github.com/pydata/sparse/issues>`_


pkgId: ca51efe23c7e03a49d4b8e0194cf24d1fd78ffd47ec61ccef8a1920cbc07d36a
name: python-spdx
arch: src
version: 2.5.1
epoch: 0
release: 1
summary: SPDX license list database
url: https://github.com/bbqsrc/spdx-python
rpm_license: CC0-1.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8ac65ba8-ec6e-453e-91ed-e7e1e36094bb
location_href: 00005135-python-spdx/python-spdx-2.5.1-1.src.rpm
checksum_type: sha256
description:
  A Python module incorporating an interface to the SPDX license database.
  This library serves purely as a holder for the database that can be
  found on `the SPDX website <https://spdx.org/licenses/>`__.
  To more easily query this database or detect licenses, consider using
  something like
  `spdx-lookup <https://pypi.python.org/pypi/spdx-lookup>`__.


pkgId: 60e34ed574fdfa7b317ab4b300e814eda32ffda38056187406dc3e4968a9c790
name: python-speaklater
arch: src
version: 1.3
epoch: 0
release: 1
summary: implements a lazy string for python useful for use with gettext
url: http://github.com/mitsuhiko/speaklater
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9b8f9d5e-f6db-4979-ab6f-701917768811
location_href: 00005137-python-speaklater/python-speaklater-1.3-1.src.rpm
checksum_type: sha256
description:
  speaklater
  ~~~~~~~~~~

  A module that provides lazy strings for translations.  Basically you
  get an object that appears to be a string but changes the value every
  time the value is evaluated based on a callable you provide.

  For example you can have a global `lazy_gettext` function that returns
  a lazy string with the value of the current set language.

  Example:

  >>> from speaklater import make_lazy_string
  >>> sval = u'Hello World'
  >>> string = make_lazy_string(lambda: sval)

  This lazy string will evaluate to the value of the `sval` variable.

  >>> string
  lu'Hello World'
  >>> unicode(string)
  u'Hello World'
  >>> string.upper()
  u'HELLO WORLD'

  If you change the value, the lazy string will change as well:

  >>> sval = u'Hallo Welt'
  >>> string.upper()
  u'HALLO WELT'

  This is especially handy when combined with a thread local and gettext
  translations or dicts of translatable strings:

  >>> from speaklater import make_lazy_gettext
  >>> from threading import local
  >>> l = local()
  >>> l.translations = {u'Yes': 'Ja'}
  >>> lazy_gettext = make_lazy_gettext(lambda: l.translations.get)
  >>> yes = lazy_gettext(u'Yes')
  >>> print yes
  Ja
  >>> l.translations[u'Yes'] = u'Si'
  >>> print yes
  Si

  Lazy strings are no real strings so if you pass this sort of string to
  a function that performs an instance check, it will fail.  In that case
  you have to explicitly convert it with `unicode` and/or `string` depending
  on what string type the lazy string encapsulates.

  To check if a string is lazy, you can use the `is_lazy_string` function:

  >>> from speaklater import is_lazy_string
  >>> is_lazy_string(u'yes')
  False
  >>> is_lazy_string(yes)
  True

  New in version 1.2: It's now also possible to pass keyword arguments to
  the callback used with `make_lazy_string`.


pkgId: 1e6248d9f6a4bc427ee0747bd67572ae1b1ed40e7f88926764124339488d350a
name: python-spglib-debuginfo
arch: x86_64
version: 2.0.2
epoch: 0
release: 1
summary: Debug information for package python-spglib
url: http://spglib.github.io/spglib/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-13362b31-8760-4b0c-97d3-44385de4d0ea
rpm_sourcerpm: python-spglib-2.0.2-1.src.rpm
location_href: 00005141-python-spglib/python-spglib-debuginfo-2.0.2-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-spglib.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: ba9b309ba1fcaa33148048010f6b9b025028e8f7d357cf3e9bbe207ce168b505
name: python-spglib-debugsource
arch: x86_64
version: 2.0.2
epoch: 0
release: 1
summary: Debug sources for package python-spglib
url: http://spglib.github.io/spglib/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-13362b31-8760-4b0c-97d3-44385de4d0ea
rpm_sourcerpm: python-spglib-2.0.2-1.src.rpm
location_href: 00005141-python-spglib/python-spglib-debugsource-2.0.2-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-spglib.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: abf9b7468e4d00039451205cba4aaae3e8ea761f2aa9fd487793e79de04390b9
name: python-sphinx-ansible-theme
arch: src
version: 0.10.1
epoch: 0
release: 1
summary: Ansible Sphinx Theme
url: https://pypi.org/project/sphinx-ansible-theme/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a14b693f-db5b-4519-b19a-770bcc1f2c02
location_href: 00005159-python-sphinx_ansible_theme/python-sphinx-ansible-theme-0.10.1-1.src.rpm
checksum_type: sha256
description:
  A reusable Ansible Sphinx Theme.
  Demo-site at https://sphinx-ansible-theme.readthedocs.io/en/latest/
  Logos in ``sphinx_ansible_theme/static/images/``
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  The Ansible logos are taken from `the official Ansible Community logo download page <https://www.ansible.com/logos>`_. The files are slightly modified as follows:
  * The SVG logos' bounding boxes are modified from ``0 0 300 300`` to ``30 30 240 240``.
  * The PNG files are rescaled to 180x180 using ImageMagick as follows:
      convert Ansible-Mark-Large-RGB-Black.png -resize 180x180 Ansible-Mark-RGB_Black.png
      convert Ansible-Mark-Large-RGB-White.png -resize 180x180 Ansible-Mark-RGB_White.png


pkgId: 2dc7b7d2499708db76e0b014bba84b28accf8fbb706f6e21af0196be2ab7d5e2
name: python-sphinx-argparse
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: A sphinx extension that automatically documents argparse commands and options
url: https://github.com/ashb/sphinx-argparse
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-12c923f2-9498-4a16-9a69-592eb5491a42
location_href: 00005142-python-sphinx-argparse/python-sphinx-argparse-0.4.0-1.src.rpm
checksum_type: sha256
description:
  A sphinx extension that automatically documents argparse commands and options.
  For installation and usage details see the [documentation](http://sphinx-argparse.readthedocs.org/en/latest/). The changelog is also [found there](http://sphinx-argparse.readthedocs.org/en/latest/changelog.html).
  This project used to live at [alex-rudakov/sphinx-argparse](https://github.com/alex-rudakov/sphinx-argparse/) that the original maintainer disappears so I have taken over the project under this new home.


pkgId: 328e7c9c5780c9a2f9fd095be85872f34dc3f486a47ce1ce22822fbc8a846c57
name: python-sphinx-autoapi
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Sphinx API documentation generator
url: http://github.com/readthedocs/sphinx-autoapi
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d5b8dd7c-f952-4112-86c1-19d71b2f4cd8
location_href: 00011852-python-sphinx-autoapi/python-sphinx-autoapi-2.1.0-1.src.rpm
checksum_type: sha256
description:
  Sphinx AutoAPI provides "autodoc" style documentation for multiple programming languages
  without needing to load, run, or import the project being documented.
  In contrast to the traditional `Sphinx autodoc <https://www.sphinx-doc.org/en/master/usage/extensions/autodoc.html>`_,
  which is Python-only and uses code imports,
  AutoAPI finds and generates documentation by parsing source code.


pkgId: c7c9b260f15382a2857255cb65640884b4c667f7392c6009537c77f68c9c69dd
name: python-sphinx-autobuild
arch: src
version: 2021.3.14
epoch: 0
release: 1
summary: Rebuild Sphinx documentation on changes, with live-reload in the browser.
url: https://github.com/executablebooks/sphinx-autobuild
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cf34d625-a02a-470a-94aa-cc46a029424d
location_href: 00010732-python-sphinx-autobuild/python-sphinx-autobuild-2021.3.14-1.src.rpm
checksum_type: sha256
description:
  Rebuild Sphinx documentation on changes, with live-reload in the browser.

  <p align="center">

  ![preview screenshot](./docs/_static/demo.png)

  </p>



  sphinx-autobuild is available on [PyPI](https://pypi.org/p/sphinx-autobuild/). It can be installed using pip:

  ```
  pip install sphinx-autobuild
  ```



  To build a classical Sphinx documentation set, run:

  ```
  sphinx-autobuild docs docs/_build/html
  ```

  This will start a server at http://127.0.0.1:8000 and start watching for changes in the `docs/` directory. When a change is detected in `docs/`, the documentation is rebuilt and any open browser windows are reloaded automatically. `KeyboardInterrupt` (<kbd>ctrl</kbd>+<kbd>c</kbd>) will stop the server.



  sphinx-autobuild accepts the same arguments as `sphinx-build` (these get passed to sphinx-build on each build). It also has a few additional options, which can seen by running `sphinx-autobuild --help`:

  ```sh-session
  $ sphinx-autobuild --help
  usage: sphinx-autobuild [-h] [--port PORT] [--host HOST] [--re-ignore RE_IGNORE] [--ignore IGNORE] [--no-initial] [--open-browser]
                          [--delay DELAY] [--watch DIR] [--pre-build COMMAND] [--version]
                          sourcedir outdir [filenames [filenames ...]]

  positional arguments:
    sourcedir             source directory
    outdir                output directory for built documentation
    filenames             specific files to rebuild on each run (default: None)

  optional arguments:
    -h, --help            show this help message and exit
    --port PORT           port to serve documentation on. 0 means find and use a free port (default: 8000)
    --host HOST           hostname to serve documentation on (default: 127.0.0.1)
    --re-ignore RE_IGNORE
                          regular expression for files to ignore, when watching for changes (default: [])
    --ignore IGNORE       glob expression for files to ignore, when watching for changes (default: [])
    --no-initial          skip the initial build (default: False)
    --open-browser        open the browser after building documentation (default: False)
    --delay DELAY         how long to wait before opening the browser (default: 5)
    --watch DIR           additional directories to watch (default: [])
    --pre-build COMMAND   additional command(s) to run prior to building the documentation (default: [])
    --version             show program's version number and exit

  sphinx's arguments:
    The following arguments are forwarded as-is to Sphinx. Please look at `sphinx --help` for more information.
      -b=builder, -a, -E, -d=path, -j=N, -c=path, -C, -D=setting=value, -t=tag, -A=name=value, -n, -v, -q, -Q, -w=file, -W, -T, -N, -P
  ```



  > FYI: Sphinx is planning to [move away from using `Makefile`](https://github.com/sphinx-doc/sphinx/issues/5618#issuecomment-502415633).

  To use sphinx-autobuild with the Makefile generated by Sphinx, add the following to the end of the Makefile:

  ```make
  livehtml:
  	sphinx-autobuild "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
  ```

  `make livehtml` will now invoke sphinx-autobuild.

  > If you generated the `Makefile` with an older version of sphinx, this syntax might not work for you. Consider [updating to the newer `Makefile`](https://github.com/sphinx-doc/sphinx/blob/af62fa61e6cbd88d0798963211e73e5ba0d55e6d/sphinx/templates/quickstart/Makefile.new_t) structure.



  sphinx-autobuild can open the homepage of the generated documentation in your default browser. Passing `--open-browser` will enable this behaviour.



  sphinx-autobuild asks the operating system for a free port number and use that for its server. Passing `--port=0` will enable this behaviour.





  When working on a Sphinx HTML theme, add the source directory of the theme as a watch directory. It is also recommended to disable Sphinx's incremental builds by passing the `-a` option to sphinx-autobuild.

  ```
  sphinx-autobuild -a docs docs/_build/html --watch path/to/theme
  ```

  This results in slower builds, but it ensures that all pages are built from the same state of the HTML theme. It also works around a [known issue in Sphinx](#user-content-relevant-sphinx-bugs) which causes significant problems during theme development.



  When working on multiple Sphinx documentation projects simultaneously, it is required to use different output directories for each project. It is also recommended to use `--port=0` and `--open-browser` to avoid needing to manually manage ports and opening browser windows (which can get tedious quickly).

  ```
  sphinx-autobuild --port=0 --open-browser pikachu/docs pikachu/docs/_build/html &
  sphinx-autobuild --port=0 --open-browser magickarp/docs magickarp/docs/_build/html &
  ```



  Sphinx does not [detect changes in non-document files in incremental mode](https://github.com/GaretJax/sphinx-autobuild/issues/34), like theme files, static files and source code used with autodoc.

  At the time of writing, the only known workaround is to instruct Sphinx to rebuild the relevant pages. This can be done by disabling incremental mode (with `-a`) or passing relevant `filenames` in addition to source and output directory in the CLI.



  This project stands on the shoulders of giants like [Sphinx], [LiveReload] and [python-livereload], without whom this project would not be possible.

  Many thanks to everyone who has [contributed code](https://github.com/GaretJax/sphinx-autobuild/graphs/contributors) as well as participated in [discussions on the issue tracker](https://github.com/GaretJax/sphinx-autobuild/issues). This project is better thanks to your contribution. :smile:

  [Sphinx]: https://sphinx-doc.org/
  [LiveReload]: https://livereload.com/
  [python-livereload]: https://github.com/lepture/python-livereload


pkgId: fb2c643b7cda2ff398745bcdc3fd07f7181393bb3638e78f53dfb8a3754c1a32
name: python-sphinx-copybutton
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: Add a copy button to each of your code cells.
url: https://github.com/executablebooks/sphinx-copybutton
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c3e4a1f5-beae-42df-956c-52d5d6623bf4
location_href: 00005145-python-sphinx-copybutton/python-sphinx-copybutton-0.5.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/sphinx-copybutton.svg)](https://pypi.org/project/sphinx_copybutton/) | [![Conda Version](https://img.shields.io/conda/vn/conda-forge/sphinx-copybutton.svg)](https://anaconda.org/conda-forge/sphinx-copybutton) | [![Documentation](https://readthedocs.org/projects/sphinx-copybutton/badge/?version=latest)](https://sphinx-copybutton.readthedocs.io/en/latest/?badge=latest)

  A small sphinx extension to add a "copy" button to code blocks.

  See [the sphinx-copybutton documentation](https://sphinx-copybutton.readthedocs.io/en/latest/) for more details!

  ![Copy Button Demo](https://user-images.githubusercontent.com/1839645/150200219-73663c59-08fd-4185-b157-62f3769c02ac.gif)



  You can install `sphinx-copybutton` with `pip`:

  ```bash
  pip install sphinx-copybutton
  ```

  Or with `conda` via `conda-forge`:

  ```bash
  conda install -c conda-forge sphinx-copybutton
  ```




  In your `conf.py` configuration file, add `sphinx_copybutton` to your extensions list.
  E.g.:

  ```python
  extensions = [
      ...
      'sphinx_copybutton'
      ...
  ]
  ```

  When you build your site, your code blocks should now have little copy buttons to their
  right. Clicking the button will copy the code inside!



  If you'd like to customize the look of the copy buttons, you can over-write any of the
  CSS rules specified in the Sphinx-CopyButton CSS file ([link](sphinx_copybutton/_static/copybutton.css))



  Development should principally adhere to the [EBP Developer Conventions](https://github.com/executablebooks/.github/blob/master/CONTRIBUTING.md)

  Sphinx-Copybutton is [hosted on the pypi repository](https://pypi.org/project/sphinx-copybutton/).
  After a release - following the [EBP release instructions](https://github.com/executablebooks/.github/blob/master/CONTRIBUTING.md#releases-and-change-logs) - confirm that the new version of Sphinx-Copybutton [is posted to pypi](https://pypi.org/project/sphinx-copybutton/).



  Many thanks to the excellent [clipboard.js library](https://clipboardjs.com/) for the lightweight javascript code that powers the copy button!


pkgId: 3598e1d61b894a7840367c026d4afa232f62a7cb60c530aa3065051459d14226
name: python-sphinx-epytext
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: Sphinx "epytext" extension.
url: https://github.com/jayvdb/sphinx-epytext
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4a630656-6f0b-46f7-84e8-1b6d2683874e
location_href: 00005146-python-sphinx-epytext/python-sphinx-epytext-0.0.4-1.src.rpm
checksum_type: sha256
description:
  sphinx-epytext provides basic support for epytext docstrings
  <http://epydoc.sourceforge.net/epytext.html>
  in Sphinx autodoc <http://sphinx-doc.org/ext/autodoc.html>.
  It connects to the 'autodoc-process-docstring' hook of Sphinx, to perform the following:
  - Replaces '@' with ':' for epydoc fields. <http://epydoc.sourceforge.net/fields.html>
  - Replaces L{..} and C{..} with :py:obj:`..`
  - Removes U{..} from around links


pkgId: 63e6b6f23cd4ea4fee58f3f62f1c91a27c5af93a15f720e3f74e8e382733cbe7
name: python-sphinx-gallery
arch: src
version: 0.12.0
epoch: 0
release: 1
url: https://sphinx-gallery.github.io
rpm_license: 3-clause BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ca00a746-4283-4648-a102-db0a75a933b9
location_href: 00005147-python-sphinx-gallery/python-sphinx-gallery-0.12.0-1.src.rpm
checksum_type: sha256
summary:
  A `Sphinx <https://www.sphinx-doc.org/en/master/>`_ extension that builds an HTML gallery of examples from any set of Python scripts.


pkgId: 6a4aafb92718d19d89aa43d9a3c9e183467aa43043a9b1843b4ca6dc9a75a1c1
name: python-sphinx-kr-theme
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: The third-part package of kennethreitz/kr-sphinx-themes.
url: https://github.com/tonyseek/sphinx-kr-theme
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d9dc092b-18da-406d-8a66-84814ced603a
location_href: 00005151-python-sphinx-kr-theme/python-sphinx-kr-theme-0.2.1-1.src.rpm
checksum_type: sha256
description:
  This is the third-part package of Kenneth Reitz's krTheme_. You will not have
  to copy the theme files into VCS or register it as submodule anymore.


pkgId: a95d197b10bfa0f1c6b585252795e219fd7f04f4cc075c979f1bbb1baf0e8c41
name: python-sphinx-last-updated-by-git
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: Get the "last updated" time for each Sphinx page from Git
url: https://github.com/mgeier/sphinx-last-updated-by-git/
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1fb8ed5c-e137-4571-b215-7f22e61c8555
location_href: 00005152-python-sphinx-last-updated-by-git/python-sphinx-last-updated-by-git-0.3.4-1.src.rpm
checksum_type: sha256
description:
  This is a little Sphinx_ extension that does exactly that.
  It also checks for included files and other dependencies and
  uses their "last updated" time if it's more recent.
  For each file, the "author date" of the Git commit where it was last changed
  is taken to be its "last updated" time.  Uncommitted changes are ignored.
  If a page doesn't have a source file, its last_updated_ time is set to ``None``.
  The default value for html_last_updated_fmt_ is changed
  from ``None`` to the empty string.
  Usage
      
      
      
  Options
      * If a source file is not tracked by Git (e.g. because it has been
        auto-generated on demand by autosummary_generate_) but its dependencies
        are, the last_updated_ time is taken from them.  If you don't want this
        to happen, use ``git_untracked_check_dependencies = False``.
      * If a source file is not tracked by Git, its HTML page doesn't get a
        source link.  If you do want those pages to have a sourcelink, set
        ``git_untracked_show_sourcelink = True``.  Of course, in this case
        html_copy_source_ and html_show_sourcelink_ must also be ``True``, and
        the theme you are using must support source links in the first place.
      * By default, timestamps are displayed using the local time zone.
        You can specify a datetime.timezone_ object (or any ``tzinfo`` subclass
        instance) with the configuration option ``git_last_updated_timezone``.
        You can also use any string recognized by babel_,
        e.g.  ``git_last_updated_timezone = 'NZ'``.
      * By default, the "last updated" timestamp is added as an HTML ``<meta>``
        tag.  This can be disabled by setting the configuration option
        ``git_last_updated_metatags`` to ``False``.
      * Files can be excluded from the last updated date calculation by passing
        a list of exclusion patterns to the configuration option
        ``git_exclude_patterns``.
        These patterns are checked on both source files and dependencies
        and are treated the same way as Sphinx's exclude_patterns_.
      * Individual commits can be excluded from the last updated date
        calculation by passing a list of commit hashes to the configuration
        option ``git_exclude_commits``.
  Caveats
      * When using a "Git shallow clone" (with the ``--depth`` option),
        the "last updated" commit for a long-unchanged file
        might not have been checked out.
        In this case, the last_updated_ time is set to ``None``
        (and a warning is shown during the build).
        This might happen on https://readthedocs.org/
        because they use shallow clones by default.
        The ``DONT_SHALLOW_CLONE`` `feature flag`_ should fix this.
        If you want to get rid of the warning, use this in your ``conf.py``::
            suppress_warnings = ['git.too_shallow']
      * When a project on https://readthedocs.org/ using their default theme
        ``sphinx_rtd_theme`` was created before October 20th 2020,
        the date will not be displayed in the footer.
        One work-around is to enable the (undocumented) `feature flag`_
        ``USE_SPHINX_LATEST``.
        Another work-around is to override the defaults
        by means of a ``requirements.txt`` file containing something like this::
            sphinx>=2
            sphinx_rtd_theme>=0.5
        See also `issue #1`_.
      * Starting with Sphinx version 5.0, there has been a
        (most likely unintentional) change in how dependencies are determined.
        This may lead to spurious dependencies which means that some
        "last changed" dates might be wrong.
        This will hopefully be fixed in a future Sphinx version.
        In the meantime, Sphinx version 4.5.0  (with docutils 0.17.1)
        can be used.
        See also `issue #40`_.
  License
      BSD-2-Clause (same as Sphinx itself),
      for more information take a look at the ``LICENSE`` file.
  Similar stuff
      | https://github.com/jdillard/sphinx-gitstamp
      | https://github.com/OddBloke/sphinx-git
      | https://github.com/MestreLion/git-tools (``git-restore-mtime``)
      | https://github.com/TYPO3-Documentation/sphinxcontrib-gitloginfo
      templating.html#last_updated
      configuration.html#confval-exclude_patterns
      usage/extensions/autosummary.html#confval-autosummary_generate
      usage/configuration.html#confval-html_copy_source
      usage/configuration.html#confval-html_show_sourcelink
      usage/configuration.html#confval-html_last_updated_fmt
      datetime.html#timezone-objects
      guides/feature-flags.html


pkgId: a2c3806482a51671fbd183d8559828e6ab7d6db47fbd6c1ea5e4db3b562fad72
name: python-sphinx-last-updated-by-git-help
arch: noarch
version: 0.3.4
epoch: 0
release: 1
summary: Development documents and examples for sphinx-last-updated-by-git
url: https://github.com/mgeier/sphinx-last-updated-by-git/
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1fb8ed5c-e137-4571-b215-7f22e61c8555
rpm_sourcerpm: python-sphinx-last-updated-by-git-0.3.4-1.src.rpm
checksum_type: sha256
description:
  This is a little Sphinx_ extension that does exactly that.
  It also checks for included files and other dependencies and
  uses their "last updated" time if it's more recent.
  For each file, the "author date" of the Git commit where it was last changed
  is taken to be its "last updated" time.  Uncommitted changes are ignored.
  If a page doesn't have a source file, its last_updated_ time is set to ``None``.
  The default value for html_last_updated_fmt_ is changed
  from ``None`` to the empty string.
  Usage
      
      
      
  Options
      * If a source file is not tracked by Git (e.g. because it has been
        auto-generated on demand by autosummary_generate_) but its dependencies
        are, the last_updated_ time is taken from them.  If you don't want this
        to happen, use ``git_untracked_check_dependencies = False``.
      * If a source file is not tracked by Git, its HTML page doesn't get a
        source link.  If you do want those pages to have a sourcelink, set
        ``git_untracked_show_sourcelink = True``.  Of course, in this case
        html_copy_source_ and html_show_sourcelink_ must also be ``True``, and
        the theme you are using must support source links in the first place.
      * By default, timestamps are displayed using the local time zone.
        You can specify a datetime.timezone_ object (or any ``tzinfo`` subclass
        instance) with the configuration option ``git_last_updated_timezone``.
        You can also use any string recognized by babel_,
        e.g.  ``git_last_updated_timezone = 'NZ'``.
      * By default, the "last updated" timestamp is added as an HTML ``<meta>``
        tag.  This can be disabled by setting the configuration option
        ``git_last_updated_metatags`` to ``False``.
      * Files can be excluded from the last updated date calculation by passing
        a list of exclusion patterns to the configuration option
        ``git_exclude_patterns``.
        These patterns are checked on both source files and dependencies
        and are treated the same way as Sphinx's exclude_patterns_.
      * Individual commits can be excluded from the last updated date
        calculation by passing a list of commit hashes to the configuration
        option ``git_exclude_commits``.
  Caveats
      * When using a "Git shallow clone" (with the ``--depth`` option),
        the "last updated" commit for a long-unchanged file
        might not have been checked out.
        In this case, the last_updated_ time is set to ``None``
        (and a warning is shown during the build).
        This might happen on https://readthedocs.org/
        because they use shallow clones by default.
        The ``DONT_SHALLOW_CLONE`` `feature flag`_ should fix this.
        If you want to get rid of the warning, use this in your ``conf.py``::
            suppress_warnings = ['git.too_shallow']
      * When a project on https://readthedocs.org/ using their default theme
        ``sphinx_rtd_theme`` was created before October 20th 2020,
        the date will not be displayed in the footer.
        One work-around is to enable the (undocumented) `feature flag`_
        ``USE_SPHINX_LATEST``.
        Another work-around is to override the defaults
        by means of a ``requirements.txt`` file containing something like this::
            sphinx>=2
            sphinx_rtd_theme>=0.5
        See also `issue #1`_.
      * Starting with Sphinx version 5.0, there has been a
        (most likely unintentional) change in how dependencies are determined.
        This may lead to spurious dependencies which means that some
        "last changed" dates might be wrong.
        This will hopefully be fixed in a future Sphinx version.
        In the meantime, Sphinx version 4.5.0  (with docutils 0.17.1)
        can be used.
        See also `issue #40`_.
  License
      BSD-2-Clause (same as Sphinx itself),
      for more information take a look at the ``LICENSE`` file.
  Similar stuff
      | https://github.com/jdillard/sphinx-gitstamp
      | https://github.com/OddBloke/sphinx-git
      | https://github.com/MestreLion/git-tools (``git-restore-mtime``)
      | https://github.com/TYPO3-Documentation/sphinxcontrib-gitloginfo
      templating.html#last_updated
      configuration.html#confval-exclude_patterns
      usage/extensions/autosummary.html#confval-autosummary_generate
      usage/configuration.html#confval-html_copy_source
      usage/configuration.html#confval-html_show_sourcelink
      usage/configuration.html#confval-html_last_updated_fmt
      datetime.html#timezone-objects
      guides/feature-flags.html

location_href:
  00005152-python-sphinx-last-updated-by-git/python-sphinx-last-updated-by-git-help-0.3.4-1.noarch.rpm


pkgId: dc676d7ad1e24d926dd02ed268ad7f9e6d8f2cdc5dd70fb18afe1dfdf750ebde
name: python-sphinx-last-updated-by-git-help
arch: noarch
version: 0.3.4
epoch: 0
release: 1
summary: Development documents and examples for sphinx-last-updated-by-git
url: https://github.com/mgeier/sphinx-last-updated-by-git/
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3152963d-f823-4751-90a0-868b60035669
rpm_sourcerpm: python-sphinx-last-updated-by-git-0.3.4-1.src.rpm
checksum_type: sha256
description:
[cell repeats an earlier one in this file: 4460 characters]

location_href:
  00008478-python-sphinx-last-updated-by-git/python-sphinx-last-updated-by-git-help-0.3.4-1.noarch.rpm


pkgId: 31e51d08444abe590722e796ccaca35dc0ddb5de25e4202e02a70d72ea84b57a
name: python-sphinx-press-theme
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: A Sphinx-doc theme based on Vuepress
url: https://schettino72.github.io/sphinx_press_site/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-941260c7-df84-41de-9cfe-7c9e1a6a02fe
location_href: 00005155-python-sphinx-press-theme/python-sphinx-press-theme-0.8.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/sphinx_press_theme.svg)](https://pypi.python.org/pypi/sphinx_press_theme)

  Please help me keep this project alive [![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/A0A23ZL4A)


  A modern responsive theme for python's [Sphinx](http://www.sphinx-doc.org) documentation generator.

  See it in action on Press Theme own [website](https://schettino72.github.io/sphinx_press_site/)


  This theme is based on [VuePress](https://vuepress.vuejs.org/).
  It uses [Vue.js](https://vuejs.org/) & [Stylus](http://stylus-lang.com/) managed by
  [vite](http://vitejs.dev/).



  **Press** theme is still in **BETA**.
  Contributions are welcome.



  First install the theme:

  ```
  $ pip install sphinx_press_theme
  ```

  Sphinx version compatibility

  |Sphinx |Press Theme|
  |-------|-----------|
  |4.X    | latest    |
  |3.X    | 0.6.1     |
  |2.X    | 0.5.1     |




  On Sphinx project's ``conf.py``: set the theme name to ``press``.

  ```
  html_theme = "press"
  ```

  See details on [configuration](https://schettino72.github.io/sphinx_press_site/configuration.html).




  First build web assets:

  ```
  cd ui
  yarn build
  ```

  Sphinx theme has a soft link to built assets...
  Install theme locally with `pip install -e .`.

  `docs` folder contains theme's own documentantion.

  ```
  cd docs
  make clean html
  ```



  Set version on:

  - `setup.py`
  - `sphinx_press_theme/__init__.py`
  - `sphinx_press_theme/theme.conf`
  - `docs/source/conf.py`




  To update website:

  ```
  cd ../press_site
  rsync -rvi ../sphinx_press_theme/docs/build/html/ .
  git add --all
  ```


pkgId: 1c4ff495a5e0ebc866c1541c33e19af4ddfbce947fb9f040a7c60c17a6bca03b
name: python-sphinx-removed-in
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: versionremoved and removed-in directives for Sphinx
url: https://github.com/MrSenko/sphinx-removed-in
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e0cf7e4c-35b4-47ee-9b74-a175b1e3f27c
location_href: 00005156-python-sphinx-removed-in/python-sphinx-removed-in-0.2.1-1.src.rpm
checksum_type: sha256
description:
  This is a Sphinx extension which recognizes the ``.. versionremoved::`` and
  ``.. removed-in::`` directives. These are missing from Sphinx'es
  `core markup <http://www.sphinx-doc.org/en/stable/markup/para.html>`_.


pkgId: acee6a7ccc2aec52df4df80c986227f7a9cf6e101dba78793d2ea4f5663a7538
name: python-sphinx-selective-exclude
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: Sphinx eager ".. only::" directive and other selective rendition extensions
url: https://github.com/pfalcon/sphinx_selective_exclude
rpm_license: MIT license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-634f3a40-7aea-4294-9356-b0f1c82cdfac
location_href: 00005160-python-sphinx_selective_exclude/python-sphinx-selective-exclude-1.0.3-1.src.rpm
checksum_type: sha256
description:
  Project home page: https://github.com/pfalcon/sphinx_selective_exclude
  The implementation of ".. only::" directive in Sphinx documentation
  generation tool is known to violate principles of least user surprise
  and user expectations in general. Instead of excluding content early
  in the pipeline (pre-processor style), Sphinx defers exclusion until
  output phase, and what's the worst, various stages processing ignore
  "only" blocks and their exclusion status, so they may leak unexpected
  information into ToC, indexes, etc.
  There's multiple issues submitted upstream on this matter:
  * https://github.com/sphinx-doc/sphinx/issues/2150
  * https://github.com/sphinx-doc/sphinx/issues/1717
  * https://github.com/sphinx-doc/sphinx/issues/1488
  * etc.
  They are largely ignored by Sphinx maintainers.
  This projects tries to rectify situation on users' side. It actually
  changes the way Sphinx processes "only" directive, but does this
  without forking the project, and instead is made as a standard
  Sphinx extension, which a user may add to their documentation config.
  Unlike normal extensions, extensions provided in this package
  monkey-patch Sphinx core to work in a way expected by users.


pkgId: d41224b44c0bf3a3f0801d8eba55cda8709990830107f3653b9406c7c549aa3c
name: python-sphinxcontrib-asyncio
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: sphinx extension to support coroutines in markup
url: https://github.com/aio-libs/sphinxcontrib-asyncio
rpm_license: Apache 2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-483ef289-7341-4d7b-a029-8757083da7a2
location_href: 00005165-python-sphinxcontrib-asyncio/python-sphinxcontrib-asyncio-0.3.0-1.src.rpm
checksum_type: sha256
description:
  Sphinx extension for adding asyncio-specific markups
  Read docs https://sphinxcontrib-asyncio.readthedocs.io/en/latest/ for more details


pkgId: 182caf894807fc36912f53ced793cc30e9179fde3cb4bd1d4154cc2f76ed7af7
name: python-sphinxcontrib-autoprogram
arch: src
version: 0.1.8
epoch: 0
release: 1
summary: Documenting CLI programs
url: https://github.com/sphinx-contrib/autoprogram
rpm_license: 2-Clause BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6c3f3838-ac2c-4a01-a754-dd727f753aff
location_href: 00005166-python-sphinxcontrib-autoprogram/python-sphinxcontrib-autoprogram-0.1.8-1.src.rpm
checksum_type: sha256
description:
  This contrib extension, ``sphinxcontrib.autoprogram``, provides an automated
  way to document CLI programs.  It scans ``argparse.ArgumentParser`` object,
  and then expands it into a set of ``.. program::`` and ``.. option::``
  directives.
  Install using ``pip``:
     $ pip install sphinxcontrib-autoprogram
  You can find the documentation from the following URL:
  https://sphinxcontrib-autoprogram.readthedocs.io/


pkgId: 1fc27bcb6aeaa24432b7c628650bb925374ce8106243da5321f1a7213ff08636
name: python-sphinxcontrib-bibtex
arch: src
version: 2.5.0
epoch: 0
release: 1
summary: Sphinx extension for BibTeX style citations.
url: https://github.com/mcmtroffaes/sphinxcontrib-bibtex
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e6a13458-25a3-4990-837e-5ef8214f4e63
location_href: 00005167-python-sphinxcontrib-bibtex/python-sphinxcontrib-bibtex-2.5.0-1.src.rpm
checksum_type: sha256
description:
  The bibtex extension allows `BibTeX <http://www.bibtex.org/>`_
  citations to be inserted into documentation generated by
  `Sphinx <https://www.sphinx-doc.org/en/master/>`_, via
  a ``bibliography`` directive,
  along with ``:cite:p:`` and ``:cite:t:`` roles.
  These work similarly to LaTeX's ``thebibliography`` environment
  and the ``\citet`` and ``\citep`` commands.
  For formatting, the extension relies on
  `pybtex <https://pybtex.org/>`_
  written by Andrey Golovizin.
  The extension is inspired by Matthew Brett's
  `bibstuff.sphinxext.bibref <https://github.com/matthew-brett/bibstuff>`_
  and Weston Nielson's
  `sphinx-natbib <https://github.com/mcmtroffaes/sphinxcontrib-bibtex/blob/develop/test/natbib.py>`_.
  * Download: https://pypi.org/project/sphinxcontrib-bibtex/#files
  * Documentation: https://sphinxcontrib-bibtex.readthedocs.io/en/latest/
  * Development: https://github.com/mcmtroffaes/sphinxcontrib-bibtex/


pkgId: c08b84ce22af2a9e02677383d4892f43f41d497bcd788a5f944c3390b643a620
name: python-sphinxcontrib-httpdomain
arch: src
version: 1.8.1
epoch: 0
release: 1
summary: Sphinx domain for documenting HTTP APIs
url: https://github.com/sphinx-contrib/httpdomain
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2bf449ff-3fdb-49ab-9805-8e2f898562fc
location_href: 00005171-python-sphinxcontrib-httpdomain/python-sphinxcontrib-httpdomain-1.8.1-1.src.rpm
checksum_type: sha256
description:
  This contrib extension, ``sphinxcontrib.httpdomain``, provides a Sphinx
  domain for describing HTTP APIs.
  You can find the documentation from the following URL:
  https://sphinxcontrib-httpdomain.readthedocs.io/


pkgId: a4fd23102586d25cf4c2720864ed4bcfee32d5e6de851050268c95fb12fa690a
name: python-sphinxcontrib-issuetracker
arch: src
version: 0.11
epoch: 0
release: 1
summary: Sphinx integration with different issuetrackers
url: http://sphinxcontrib-issuetracker.readthedocs.org/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-244edeb3-f88a-4432-838e-0a25adf1f8b2
location_href: 00005173-python-sphinxcontrib-issuetracker/python-sphinxcontrib-issuetracker-0.11-1.src.rpm
checksum_type: sha256
description:
  This extension can be installed from the `Python Package Index`_::
     pip install sphinxcontrib-issuetracker
  This extension requires Sphinx 1.1 and Pythonn 2.6 or Python 3.1.


pkgId: 7e4eb5e1139eb8e2d7c9e2790bc1a6102f8598e38c74cdda9f619c470cb74c44
name: python-sphinxcontrib-napoleon
arch: src
version: 0.7
epoch: 0
release: 1
summary: Sphinx "napoleon" extension.
url: https://sphinxcontrib-napoleon.readthedocs.io
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-15471d04-af08-40a1-8271-f624027606f5
location_href: 00011345-python-sphinxcontrib-napoleon/python-sphinxcontrib-napoleon-0.7-1.src.rpm
checksum_type: sha256
description:
     Sphinx under `sphinx.ext.napoleon`. The `sphinxcontrib.napoleon` extension
     will continue to work with Sphinx <= 1.2.
  Are you tired of writing docstrings that look like this::
         instance is destructed
  `ReStructuredText`_ is great, but it creates visually dense, hard to read
  `docstrings`_. Compare the jumble above to the same thing rewritten
  according to the `Google Python Style Guide`_::
      Args:
          path (str): The path of the file to wrap
          field_storage (FileStorage): The :class:`FileStorage` instance to wrap
          temporary (bool): Whether or not to delete the file when the File
             instance is destructed
      Returns:
          BufferedFileStorage: A buffered writable file descriptor
  Much more legible, no?
  Napoleon is a `Sphinx extension`_ that enables Sphinx to parse both `NumPy`_
  and `Google`_ style docstrings - the style recommended by `Khan Academy`_.
  Napoleon is a pre-processor that parses `NumPy`_ and `Google`_ style
  docstrings and converts them to reStructuredText before Sphinx attempts to
  parse them. This happens in an intermediate step while Sphinx is processing
  the documentation, so it doesn't modify any of the docstrings in your actual
  source code files.
     http://google.github.io/styleguide/pyguide.html
     http://google.github.io/styleguide/pyguide.html#Comments
     https://github.com/numpy/numpy/blob/master/doc/HOWTO_DOCUMENT.rst.txt
     https://sites.google.com/a/khanacademy.org/forge/for-developers/styleguide/python#TOC-Docstrings


pkgId: 2e8705edb942e076612d518a4b031fedf79565aa7b53be0455be28f3d589ca35
name: python-sphinxcontrib-phpdomain
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: Sphinx extension to enable documenting PHP code
url: https://github.com/markstory/sphinxcontrib-phpdomain
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9da33297-7c93-43cb-b9ab-d087457c135b
location_href: 00008502-python-sphinxcontrib-phpdomain/python-sphinxcontrib-phpdomain-0.11.0-1.src.rpm
checksum_type: sha256
description:
  This package provides a Sphinx extension for documenting PHP projects.

  PHP Domain supports following objects:

  * Global variable
  * Global function
  * Constants
  * Namespaces

      * Functions
      * Class

  * Class

      * Class constant
      * Instance methods
      * Static methods
      * Properties

  * Enums


pkgId: cb9410721634a88dda1dff49683a160ced727f1cab794439cd81d27db83c6258
name: python-sphinxcontrib-phpdomain
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: Sphinx extension to enable documenting PHP code
url: https://github.com/markstory/sphinxcontrib-phpdomain
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ff02cc0e-8a11-4321-9c62-7f40c1d5b281
location_href: 00005176-python-sphinxcontrib-phpdomain/python-sphinxcontrib-phpdomain-0.9.0-1.src.rpm
checksum_type: sha256
description:
  This package contains the phpdomain Sphinx extension.

  This extension provides a PHP domain for sphinx


pkgId: a9ab9cc7ba41651e48ce87c6311261f326fbb5657389df42aa20b67b219aa36b
name: python-sphinxcontrib-programoutput-help
arch: noarch
version: 0.17
epoch: 0
release: 1
summary: Development documents and examples for sphinxcontrib-programoutput
url: https://sphinxcontrib-programoutput.readthedocs.org/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ceac8547-4a83-42d3-976e-e6eb32c69730
rpm_sourcerpm: python-sphinxcontrib-programoutput-0.17-1.src.rpm
checksum_type: sha256
location_href:
  00005177-python-sphinxcontrib-programoutput/python-sphinxcontrib-programoutput-help-0.17-1.noarch.rpm


pkgId: 48da995fc85966b3ee3055574f871949ad58398f7c9ef2f1c7fd6a3da12a39a1
name: python-sphinxcontrib-programoutput-help
arch: noarch
version: 0.17
epoch: 0
release: 1
summary: Development documents and examples for sphinxcontrib-programoutput
url: https://sphinxcontrib-programoutput.readthedocs.org/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8bd84640-3d2c-443e-9da3-6ae49c19f182
rpm_sourcerpm: python-sphinxcontrib-programoutput-0.17-1.src.rpm
checksum_type: sha256
location_href:
  00008503-python-sphinxcontrib-programoutput/python-sphinxcontrib-programoutput-help-0.17-1.noarch.rpm


pkgId: 58d1c5f13d229d2fe29e4a83f0d5896c78e901a6beb216ff59d307a8fce36255
name: python-sphinxcontrib-serializinghtml
arch: src
version: 1.1.5
epoch: 0
release: 1
url: http://sphinx-doc.org/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4217389d-67e9-4955-9f41-2eb40bd4cb24
location_href: 00009236-python-sphinxcontrib-serializinghtml/python-sphinxcontrib-serializinghtml-1.1.5-1.src.rpm
checksum_type: sha256
summary:
  sphinxcontrib-serializinghtml is a sphinx extension which outputs "serialized" HTML files (json and pickle).

description:
  sphinxcontrib-serializinghtml is a sphinx extension which outputs
  "serialized" HTML files (json and pickle).


pkgId: d88fe01a3b9a6c3f0c597f25562ece3dabd340f27431cf27ec1f330bc477b715
name: python-sphinxcontrib-serializinghtml-help
arch: noarch
version: 1.1.5
epoch: 0
release: 1
summary: Development documents and examples for sphinxcontrib-serializinghtml
url: http://sphinx-doc.org/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4217389d-67e9-4955-9f41-2eb40bd4cb24
rpm_sourcerpm: python-sphinxcontrib-serializinghtml-1.1.5-1.src.rpm
checksum_type: sha256
description:
  sphinxcontrib-serializinghtml is a sphinx extension which outputs
  "serialized" HTML files (json and pickle).

location_href:
  00009236-python-sphinxcontrib-serializinghtml/python-sphinxcontrib-serializinghtml-help-1.1.5-1.noarch.rpm


pkgId: ea985d98e69078aa1f9cf55d6c36a50041bd43352f0e459c3bf4d48103f476b0
name: python-sphinxcontrib-svg2pdfconverter
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: Sphinx SVG to PDF converter extension
url: https://github.com/missinglinkelectronics/sphinxcontrib-svg2pdfconverter
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2af7c6f8-5b94-48e3-a375-a94476809c32
checksum_type: sha256
description:
  Just install via ``pip``:
     $ pip install sphinxcontrib-svg2pdfconverter
  You can choose between Inkscape, libRSVG and CairoSVG by adding
  ``sphinxcontrib.inkscapeconverter``, ``sphinxcontrib.rsvgconverter`` or
  ``sphinxcontrib.cairosvgconverter`` to the ``extensions`` list in your
  ``conf.py``.
  Make sure to have either ``inkscape`` or the ``rsvg-convert`` command available
  in your systems ``PATH`` and, if necessary, adapt the
  ``inkscape_converter_bin`` or ``rsvg_converter_bin`` config value respectively.
  CairoSVG requires additional dependencies to be installed with:
     $ pip install sphinxcontrib-svg2pdfconverter[CairoSVG]
  CairoSVG and its dependencies may require additional tools during the
  installation depending on the OS you are using; see the `CairoSVG documentation
  <https://cairosvg.org/documentation/#installation>`_ for further details.

location_href:
  00012263-python-sphinxcontrib-svg2pdfconverter/python-sphinxcontrib-svg2pdfconverter-1.2.2-1.src.rpm


pkgId: cdc0438a38fc86c14d253d7dc6611e726b227daf63b5430a72f801a904949bdf
name: python-sphinxcontrib-svg2pdfconverter-help
arch: noarch
version: 1.2.2
epoch: 0
release: 1
summary: Development documents and examples for sphinxcontrib-svg2pdfconverter
url: https://github.com/missinglinkelectronics/sphinxcontrib-svg2pdfconverter
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2af7c6f8-5b94-48e3-a375-a94476809c32
rpm_sourcerpm: python-sphinxcontrib-svg2pdfconverter-1.2.2-1.src.rpm
checksum_type: sha256
description:
  Just install via ``pip``:
     $ pip install sphinxcontrib-svg2pdfconverter
  You can choose between Inkscape, libRSVG and CairoSVG by adding
  ``sphinxcontrib.inkscapeconverter``, ``sphinxcontrib.rsvgconverter`` or
  ``sphinxcontrib.cairosvgconverter`` to the ``extensions`` list in your
  ``conf.py``.
  Make sure to have either ``inkscape`` or the ``rsvg-convert`` command available
  in your systems ``PATH`` and, if necessary, adapt the
  ``inkscape_converter_bin`` or ``rsvg_converter_bin`` config value respectively.
  CairoSVG requires additional dependencies to be installed with:
     $ pip install sphinxcontrib-svg2pdfconverter[CairoSVG]
  CairoSVG and its dependencies may require additional tools during the
  installation depending on the OS you are using; see the `CairoSVG documentation
  <https://cairosvg.org/documentation/#installation>`_ for further details.

location_href:
  00012263-python-sphinxcontrib-svg2pdfconverter/python-sphinxcontrib-svg2pdfconverter-help-1.2.2-1.noarch.rpm


pkgId: 13c7a89637dda830253c6f8d7a02f6e3638a7d13a888001a00e2d8f71e077211
name: python-sphinxcontrib-trio
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: Make Sphinx better at documenting Python functions and methods
url: https://github.com/python-trio/sphinxcontrib-trio
rpm_license: MIT -or- Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-022f29f7-f223-4c3b-9b5c-fe5c7179639d
location_href: 00005181-python-sphinxcontrib-trio/python-sphinxcontrib-trio-1.1.2-1.src.rpm
checksum_type: sha256
description:
  This sphinx extension helps you document Python code that uses
  async/await, or abstract methods, or context managers, or generators,
  or ... you get the idea. It works by making sphinx's regular
  directives for documenting Python functions and methods smarter and
  more powerful. The name is because it was originally written for the
  `Trio <https://trio.readthedocs.io>`__ project, and I'm not very
  creative. But don't be put off – there's nothing Trio- or
  async-specific about this extension; any Python project can
  benefit. (Though projects using async/await probably benefit the most,
  since sphinx's built-in tools are especially inadequate in this case.)


pkgId: f70313070c72c5fda7fd8f1b5222bd2a08e61e094fe452d7a5429d5a62d6fcc3
name: python-sphinxcontrib-websupport
arch: src
version: 1.2.4
epoch: 0
release: 1
summary: Sphinx API for Web Apps
url: http://sphinx-doc.org/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fca25baa-10c6-4f74-8e0f-1cff503d0dc7
location_href: 00009938-python-sphinxcontrib-websupport/python-sphinxcontrib-websupport-1.2.4-1.src.rpm
checksum_type: sha256
description:
  sphinxcontrib-websupport provides a Python API to easily integrate Sphinx
  documentation into your Web application.


pkgId: 2565518f04d5a7e76b5d4c487e519790e204ffdc875e864b4e49a08978e1bf3e
name: python-sphinxcontrib_github_alt
arch: src
version: 1.2
epoch: 0
release: 1
summary: Link to GitHub issues, pull requests, commits and users from Sphinx docs.
url: https://github.com/jupyter/sphinxcontrib_github_alt
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-809cb408-e980-4ff9-a57e-1710efbbb70d
location_href: 00005170-python-sphinxcontrib-github-alt/python-sphinxcontrib_github_alt-1.2-1.src.rpm
checksum_type: sha256
description:
  Link to GitHub issues, pull requests, commits and users for a particular project.

  To use this extension, add it to the ``extensions`` list in ``conf.py``,
  and set the variable ``github_project_url``:

  .. code-block:: python

      extensions = [...
                    'sphinxcontrib_github_alt',
                   ]

      github_project_url = "https://github.com/ipython/ipython"

  Then use these roles in your documentation:

  .. code-block:: rst

      * :ghissue:`12` - link to issue #12
      * :ghpull:`35` - link to pull request #35
      * :ghcommit:`3a1cb54` - link to commit
      * :ghuser:`ipython` - link to a user or organisation


  It's called 'alt' because `sphinxcontrib-github
  <https://pypi.python.org/pypi/sphinxcontrib-github/>`__ already exists. IPython
  & Jupyter projects have been using the syntax defined in this extension for some
  time before we made it into its own package, so we didn't want to switch to
  ``sphinxcontrib-github``.


pkgId: 7b4352b8423632d2e9b471c54cc7d0517e41e28ed97da1b4bddd9d634626dd7b
name: python-sphinxext-opengraph
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Sphinx Extension to enable OGP support
url: https://github.com/wpilibsuite/sphinxext-opengraph
rpm_license: LICENSE.md
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c3e04c55-0b66-4c43-81fe-b0e9ccc7c991
location_href: 00014232-python-sphinxext-opengraph/python-sphinxext-opengraph-0.8.1-1.src.rpm
checksum_type: sha256
description:
  ```

  Additionally, you can use field lists to add any arbitrary Open Graph tag not supported by the extension. The syntax for arbitrary tags is the same with `:og:tag: content`. For example:
  ```rst


pkgId: ad87eed58fd80e922db96b1e5eff16c9f5e23b86fdd2ecd702c602fc7fedc93d
name: python-sphinxtesters
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: Utilities for testing Sphinx extensions
url: http://github.com/matthew-brett/sphinxtesters
rpm_license: BSD license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-49a03ccb-9dd7-4d45-80a9-408e66acf12c
location_href: 00005183-python-sphinxtesters/python-sphinxtesters-0.2.3-1.src.rpm
checksum_type: sha256
description:
  Sphinxtesters - utilities for testing Sphinx extensions


  .. shared-text-body

  **********
  Quickstart
  **********

  If you have a directory containing a sphinx project, test that it builds with
  something like:

  .. code:: python

      class TestMyProject(SourcesBuilder):

          page_source_template = 'path/to/sphinx_dir'

          def test_basic_build(self):
              
              doctree = self.get_doctree('a_page')
              
              html = self.get_built_file('a_page.html')
              

  You can try adding other page content by using the ``rst_sources`` dictionary:

  .. code:: python

      class TestChangedProject(SourcesBuilder):

          page_source_template = 'path/to/sphinx_dir'
          rst_sources = {'a_page': """Replacement text for page""",
                         'b_page': """An entirely new page"""}

          def test_basic_build(self):
              a_doctree = self.get_doctree('a_page')
              b_doctree = self.get_doctree('b_page')
              

  Set the text of the ``conf.py`` file with the ``conf_source`` attribute:

  .. code:: python

      class TestConfeddProject(SourcesBuilder):

          page_source_template = 'path/to/sphinx_dir'
          rst_sources = {'a_page': """Replacement text for page""",
                         'b_page': """An entirely new page"""}
          conf_source = """ # This overwrites existing conf.py """

          def test_basic_build(self):
              a_doctree = self.get_doctree('a_page')
              b_doctree = self.get_doctree('b_page')
              

  You don't need to set ``page_source_template``; if you don't, you start with a
  fresh project, where the only pages are the ones you specify in
  ``rst_sources``.

  .. code:: python

      class TestFreshProject(SourcesBuilder):

          rst_sources = {'a_page': """A new page""",
                         'b_page': """Another new page"""}
          conf_source = """ # Stuff for the conf.py file """

          def test_basic_build(self):
              a_doctree = self.get_doctree('a_page')
              b_doctree = self.get_doctree('b_page')
              

  See the tests for examples of using Sphinxtesters for testing builds of Sphinx
  projects.

  ************
  Installation
  ************

  ::

      pip install sphinxtesters

  ****
  Code
  ****

  See https://github.com/matthew-brett/sphinxtesters

  Released under the BSD two-clause license - see the file ``LICENSE`` in the
  source distribution.

  `travis-ci <https://travis-ci.org/matthew-brett/sphinxtesters>`_ kindly tests the
  code automatically under Python versions 2.7, and 3.3 through 3.6.

  The latest released version is at https://pypi.python.org/pypi/sphinxtesters

  *****
  Tests
  *****

  * Install ``sphinxtesters``
  * Install the pytest_ testing framework::

      pip install pytest

  * Run the tests with::

      pytest sphinxtesters

  *******
  Support
  *******

  Please put up issues on the `sphinxtesters issue tracker`_.

  .. standalone-references

  .. |sphinxtesters-documentation| replace:: `sphinxtesters documentation`_
  .. _sphinxtesters documentation:
      https://matthew-brett.github.com/sphinxtesters/sphinxtesters.html
  .. _documentation: https://matthew-brett.github.com/sphinxtesters
  .. _pandoc: http://pandoc.org
  .. _jupyter: jupyter.org
  .. _homebrew: brew.sh
  .. _sphinx: http://sphinx-doc.org
  .. _rest: http://docutils.sourceforge.net/rst.html
  .. _sphinxtesters issue tracker: https://github.com/matthew-brett/sphinxtesters/issues
  .. _pytest: https://pytest.org
  .. _mock: https://github.com/testing-cabal/mock


pkgId: e1df0fe39ab7464869eeda49f738abfaf85bc029b53304980d88aa422ffdfc99
name: python-spiceypy
arch: src
version: 5.1.2
epoch: 0
release: 1
summary: A Python Wrapper for the NAIF CSPICE Toolkit
url: https://github.com/AndrewAnnex/SpiceyPy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9f688b21-976f-4b9a-9a9f-1dbded3fb082
location_href: 00013552-python-spiceypy/python-spiceypy-5.1.2-1.src.rpm
checksum_type: sha256
description:
  SpiceyPy is a Python wrapper for the NAIF C SPICE Toolkit (N66), written using ctypes.
  +------------------------+-------------------+--------+-----------------+------------+--------------+
  | Continuous Integration | Code Coverage     | Docs   | Chat            |  Citation  |  Code Style  |
  +========================+===================+========+=================+============+==============+
  | |Github Build Status|  | |Coverage Status| | |Docs| | |Join the chat| | |JOSS|     |  |Black|     |
  +------------------------+-------------------+--------+-----------------+------------+--------------+


pkgId: 8b4e7d29a5ef77e64da74d999fc4ac04d2c0327c46d39b39f956e4a3bfefa7ed
name: python-spiceypy-debuginfo
arch: x86_64
version: 5.1.2
epoch: 0
release: 1
summary: Debug information for package python-spiceypy
url: https://github.com/AndrewAnnex/SpiceyPy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-9f688b21-976f-4b9a-9a9f-1dbded3fb082
rpm_sourcerpm: python-spiceypy-5.1.2-1.src.rpm
location_href: 00013552-python-spiceypy/python-spiceypy-debuginfo-5.1.2-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-spiceypy.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: b00fbec74816504e9d3fdb58de4edce275c0ab77c4297fd70b6bd8cdd3fadb74
name: python-spiceypy-debugsource
arch: x86_64
version: 5.1.2
epoch: 0
release: 1
summary: Debug sources for package python-spiceypy
url: https://github.com/AndrewAnnex/SpiceyPy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-9f688b21-976f-4b9a-9a9f-1dbded3fb082
rpm_sourcerpm: python-spiceypy-5.1.2-1.src.rpm
location_href: 00013552-python-spiceypy/python-spiceypy-debugsource-5.1.2-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-spiceypy.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 4bf3a4c51eed5c34baa21d633826973958988f51f4a83e0a4da70f5f04ee9fb1
name: python-spidev
arch: src
version: 3.6
epoch: 0
release: 1
summary: Python bindings for Linux SPI access through spidev
url: http://github.com/doceme/py-spidev
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-031713b8-b9d3-4f9e-a25a-ba4cd3ffe332
location_href: 00005185-python-spidev/python-spidev-3.6-1.src.rpm
checksum_type: sha256
description:
  This project contains a python module for interfacing with SPI devices from user space via the spidev linux kernel driver.
  All code is MIT licensed unless explicitly stated otherwise.


pkgId: 5773104b3a13176b6a38c86bd3d957ed62bd726610b5cea3f0bbae4444f7210d
name: python-spikeinterface
arch: src
version: 0.97.1
epoch: 0
release: 1
summary: Python toolkit for analysis, visualization, and comparison of spike sorting output
url: https://pypi.org/project/spikeinterface/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8080b47b-feb4-433b-8597-23a3dd87fb51
location_href: 00012490-python-spikeinterface/python-spikeinterface-0.97.1-1.src.rpm
checksum_type: sha256
description:
  <table>
  <tr>
    <td>Latest Release</td>
    <td>
      <a href="https://pypi.org/project/spikeinterface/">
      <img src="https://img.shields.io/pypi/v/spikeinterface.svg" alt="latest release" />
      </a>
    </td>
  </tr>
  <tr>
    <td>Documentation</td>
    <td>
      <a href="https://spikeinterface.readthedocs.io/">
      <img src="https://readthedocs.org/projects/spikeinterface/badge/?version=latest" alt="latest documentation" />
      </a>
    </td>
  </tr>
  <tr>
    <td>License</td>
    <td>
      <a href="https://github.com/SpikeInterface/spikeinterface/blob/master/LICENSE">
      <img src="https://img.shields.io/pypi/l/spikeinterface.svg" alt="license" />
      </a>
  </td>
  </tr>
  <tr>
    <td>Build Status</td>
    <td>
      <a href="https://github.com/SpikeInterface/spikeinterface/actions/workflows/full-test.yml/badge.svg">
      <img src="https://github.com/SpikeInterface/spikeinterface/actions/workflows/full-test.yml/badge.svg" alt="travis build status" />
      </a>
    </td>
  </tr>
  <tr>
  	<td>Codecov</td>
  	<td>
  		<a href="https://codecov.io/github/spikeinterface/spikeinterface">
  		<img src="https://codecov.io/gh/spikeinterface/spikeinterface/branch/master/graphs/badge.svg" alt="codecov" />
  		</a>
  	</td>
  </tr>
  </table>

  [![Twitter](https://img.shields.io/badge/@spikeinterface-%231DA1F2.svg?style=for-the-badge&logo=Twitter&logoColor=white)](https://twitter.com/spikeinterface) [![Mastodon](https://img.shields.io/badge/-@spikeinterface-%232B90D9?style=for-the-badge&logo=mastodon&logoColor=white)](https://fosstodon.org/@spikeinterface)


  SpikeInterface is a Python framework designed to unify preexisting spike sorting technologies into a single code base.

  Please [Star](https://github.com/SpikeInterface/spikeinterface/stargazers) the project to support us and [Watch](https://github.com/SpikeInterface/spikeinterface/subscription) to always stay up-to-date!


  With SpikeInterface, users can:

  - read/write many extracellular file formats.
  - pre-process extracellular recordings.
  - run many popular, semi-automatic spike sorters (also in Docker/Singularity containers).
  - post-process sorted datasets.
  - compare and benchmark spike sorting outputs.
  - compute quality metrics to validate and curate spike sorting outputs.
  - visualize recordings and spike sorting outputs in several ways (matplotlib, sortingview, in jupyter)
  - export report and export to phy
  - offer a powerful Qt-based viewer in separate package [spikeinterface-gui](https://github.com/SpikeInterface/spikeinterface-gui)
  - have some powerful sorting components to build your own sorter.




  Detailed documentation for spikeinterface can be found [here](https://spikeinterface.readthedocs.io/en/latest).

  Several tutorials to get started can be found in [spiketutorials](https://github.com/SpikeInterface/spiketutorials).

  There are also some useful notebooks [on our blog](https://spikeinterface.github.io) that cover advanced benchmarking
  and sorting components.

  You can also have a look at the [spikeinterface-gui](https://github.com/SpikeInterface/spikeinterface-gui).




  You can install the new `spikeinterface` version with pip:

  ```bash
  pip install spikeinterface[full]
  ```

  The `[full]` option installs all the extra dependencies for all the different sub-modules.

  To install all interactive widget backends, you can use:

  ```bash
   pip install spikeinterface[full,widgets]
  ```


  To get the latest updates, you can install `spikeinterface` from sources:

  ```bash
  git clone https://github.com/SpikeInterface/spikeinterface.git
  cd spikeinterface
  pip install -e .
  cd ..
  ```




  If you find SpikeInterface useful in your research, please cite:

  ```bibtex
  @article{buccino2020spikeinterface,
    title={SpikeInterface, a unified framework for spike sorting},
    author={Buccino, Alessio Paolo and Hurwitz, Cole Lincoln and Garcia, Samuel and Magland, Jeremy and Siegle, Joshua H and Hurwitz, Roger and Hennig, Matthias H},
    journal={Elife},
    volume={9},
    pages={e61834},
    year={2020},
    publisher={eLife Sciences Publications Limited}
  }
  ```


pkgId: 4893fb04de55b19024160131839e735ed620b3b2d1970d77fc025b224136bd47
name: python-spotify_tensorflow
arch: src
version: 0.7.7
epoch: 0
release: 1
summary: Spotify-specific helpers for TensorFlow
url: https://github.com/spotify/spotify-tensorflow
rpm_license: Apache-2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-589f45e7-16fd-4074-ac16-dc8244d2c526
location_href: 00010765-python-spotify-tensorflow/python-spotify_tensorflow-0.7.7-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://img.shields.io/circleci/project/github/spotify/spotify-tensorflow/master.svg)](https://circleci.com/gh/spotify/spotify-tensorflow)
  [![Coverage](https://img.shields.io/codecov/c/github/spotify/spotify-tensorflow/master.svg?style=flat)](https://codecov.io/github/spotify/spotify-tensorflow?branch=master)
  [![GitHub license](https://img.shields.io/github/license/spotify/spotify-tensorflow.svg)](./LICENSE)
  [![PyPI version](https://badge.fury.io/py/spotify_tensorflow.svg)](https://badge.fury.io/py/spotify_tensorflow)



  Provide Spotify specific TensorFlow helpers.



   * tf.data integration with [Featran](https://github.com/spotify/featran)
   * common Dataset API to read:
     * TFRecord datasets as tf.Tensor
     * TFRecord datasets as Pandas DataFrame
     * TFRecord datasets as python dict
   * tf.Graph freezing utilities
   * TensorFlow integration with [Luigi](https://github.com/spotify/luigi)



  Check examples in the [examples directory](https://github.com/spotify/spotify-tensorflow/tree/master/examples),
  currently they include:

   * sklearn training via Pandas DataFrame dataset
   * XGBoost training via tf.Example dataset
   * TensorFlow training via tf.Example dataset

  To run the examples:

  ```sh
  $ pip install -e .[examples]
  $ bin/run-examples
  ```



  This project uses `tox`.

  ```sh
  $ pip install tox
  ```

  To see all `testenv`'s:

  ```sh
  $ tox -l
  mypy
  lint
  examples-py27
  examples-py35
  test-py27
  test-py35
  upload-coverage
  license
  ```

  To run the tests:

  ```
  tox -e test
  ```

  To release:

  ```
  git commit --allow-empty -m "Release x.y.z"
  git tag x.y.z
  git push --tags  origin master
  ```

  Then upload to pypi:

  ```
  python setup.py sdist upload -r pypi
  ```


pkgId: 35cf1c861ab7cf435641cab93c483aedc1a04ec6206e3cab3bc0afbd948fbf78
name: python-spotinst-agent-2
arch: src
version: 2.0.10
epoch: 0
release: 1
url: https://github.com/spotinst/spotinst-spectrum-agent
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-20bc8501-bf2f-4b05-862c-bf722e2933f1
location_href: 00011215-python-spotinst-agent-2/python-spotinst-agent-2-2.0.10-1.src.rpm
checksum_type: sha256
summary:
  Spectrum instance spotinst-agent that is able to run remote scripts, collect data, deploy applications and more.

description:
  Spotinst Agent executor provides a mechanism to run remote shutdown scripts on machine using polling architecture.
  Note:
  The agent must have token to communicate with spotinst API.
  The credentials ini that holds the token file must be located at: '/root/.spotinst/credentials'


pkgId: d36a66cee5dbd4515c54e01b7abc2ec4af599d83adb6e9034f76eeea1e292b67
name: python-spotinst-sdk
arch: src
version: 1.0.56
epoch: 0
release: 1
summary: A Python SDK for Spotinst
url: https://github.com/spotinst/spotinst-sdk-python
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b728a057-46ae-49c4-826f-143f3bcf4804
location_href: 00011050-python-spotinst-sdk/python-spotinst-sdk-1.0.56-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/spotinst/spotinst-sdk-python.svg?branch=master)](https://travis-ci.org/spotinst/spotinst-sdk-python)
  [![Coverage Status](https://coveralls.io/repos/github/spotinst/spotinst-sdk-python/badge.svg?branch=master)](https://coveralls.io/github/spotinst/spotinst-sdk-python?branch=master)
  [![Python 2.7](https://img.shields.io/badge/python-2.7-blue.svg)](https://www.python.org/downloads/release/python-270/)
  [![Python 3.6](https://img.shields.io/badge/python-3.6-blue.svg)](https://www.python.org/downloads/release/python-360/)



  The official Spotinst SDK for the Python programming language.



  Version 2 for the Spotinst Python SDK will be moving from the `v2` branch to the `master` branch very soon. The current `master` will move to it's own `v1` branch and eventually be deprecated. Version 2 introduces some breaking changes from v1 and will require updates when switching over. Luckily this process should be easy and is completely explained on the [v2 branch in this repository](https://github.com/spotinst/spotinst-sdk-python/tree/v2). Both `v1` and `v2` will be released as `spotinst-sdk` and `spotinst-sdk2` respectively, to prevent any auto version upgrades.



  - [Installation](#installation)
  - [Authentication](#authentication)
  - [Documentation](#documentation)
  - [Getting Help](#getting-help)
  - [Community](#community)
  - [License](#license)



  ```bash
  pip install --upgrade spotinst-sdk
  ```



  The mechanism in which the SDK looks for credentials is to search through a list of possible locations and stop as soon as it finds credentials. The order in which the SDK searches for credentials is:

  1. Passing credentials as parameters when creating a `SpotinstClient` object:

  ```python
  session = SpotinstClient(auth_token='foo', account_id='bar')
  ```

  2. Environment variables:

  ```sh
  export SPOTINST_TOKEN=foo
  export SPOTINST_ACCOUNT=bar
  ```

  3. Shared credentials file:

  - The shared credentials file has a default location of `~/.spotinst/credentials`. This file is an INI formatted file with section names corresponding to profiles. With each section, two configuration variables can be specified: `token`, `account`. These are the only supported values in the shared credential file.

  - Below is a minimal example of the shared credentials file:

  ```ini
  [default]
  token   = foo
  account = bar
  ```

  - The shared credentials file also supports the concept of profiles. Profiles represent logical groups of configuration. The shared credential file can have multiple profiles:

  ```ini
  [default]
  token   = foo
  account = bar

  [dev]
  token   = foo2
  account = bar2

  [prod]
  token   = foo3
  account = bar3
  ```

  - You can configure your Spot credentials using the `spotctl configure` command. For more information, see the `spotctl` [Getting Started](https://github.com/spotinst/spotctl#getting-started).

  - To maintain compatibility with previous SDK versions, the file can also be in YAML format:

  ```yaml
  default:
    token: foo
    account: bar

  dev:
    token: foo2
    account: bar2

  prod:
    token: foo3
    account: bar3
  ```

  - You can change the location of the credentials file and the profile used by setting the `SPOTINST_SHARED_CREDENTIALS_FILE` and/or `SPOTINST_PROFILE` environment variables:

  ```sh
  export SPOTINST_SHARED_CREDENTIALS_FILE=/path/to/credentials_file
  export SPOTINST_PROFILE=dev
  ```

  - Passing the credentials file location and the profile used as parameters when creating a `SpotinstClient` object:

  ```python
  session = SpotinstClient(credentials_file='/path/to/credentials_file', profile='dev')
  ```



  For a comprehensive documentation, check out the [API documentation](https://help.spot.io/).

  - [Endpoints](docs/endpoints)
  - [Classes](docs/classes)
  - [Examples](docs/examples)



  We use GitHub issues for tracking bugs and feature requests. Please use these community resources for getting help:

  - Ask a question on [Stack Overflow](https://stackoverflow.com/) and tag it with [spotinst-sdk-python](https://stackoverflow.com/questions/tagged/spotinst-sdk-python/).
  - Join our Spotinst community on [Slack](http://slack.spot.io/).
  - Open an [issue](https://github.com/spotinst/spotinst-sdk-python/issues/new/).



  - [Slack](http://slack.spot.io/)
  - [Twitter](https://twitter.com/spot_hq/)



  Code is licensed under the [Apache License 2.0](LICENSE). See [NOTICE.md](NOTICE.md) for complete details, including software and third-party licenses and permissions.


pkgId: a3a314cf139d6533c818727797d03f13dabd76169187689ed0a147a5ee015e33
name: python-spotipy
arch: src
version: 2.23.0
epoch: 0
release: 1
summary: A light weight Python library for the Spotify Web API
url: https://spotipy.readthedocs.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1b390ab3-b7af-4c02-b213-56b5339f6d94
location_href: 00010408-python-spotipy/python-spotipy-2.23.0-1.src.rpm
checksum_type: sha256
description:
  ![Tests](https://github.com/plamere/spotipy/workflows/Tests/badge.svg?branch=master) [![Documentation Status](https://readthedocs.org/projects/spotipy/badge/?version=latest)](https://spotipy.readthedocs.io/en/latest/?badge=latest)



  Spotipy's full documentation is online at [Spotipy Documentation](http://spotipy.readthedocs.org/).



  ```bash
  pip install spotipy
  ```

  alternatively, for Windows users

  ```bash
  py -m pip install spotipy
  ```

  or upgrade

  ```bash
  pip install spotipy --upgrade
  ```



  A full set of examples can be found in the [online documentation](http://spotipy.readthedocs.org/) and in the [Spotipy examples directory](https://github.com/plamere/spotipy/tree/master/examples).

  To get started, install spotipy and create an app on https://developers.spotify.com/.
  Add your new ID and SECRET to your environment:



  ```python
  import spotipy
  from spotipy.oauth2 import SpotifyClientCredentials

  sp = spotipy.Spotify(auth_manager=SpotifyClientCredentials(client_id="YOUR_APP_CLIENT_ID",
                                                             client_secret="YOUR_APP_CLIENT_SECRET"))

  results = sp.search(q='weezer', limit=20)
  for idx, track in enumerate(results['tracks']['items']):
      print(idx, track['name'])
  ```



  A redirect URI must be added to your application at [My Dashboard](https://developer.spotify.com/dashboard/applications) to access user authenticated features.

  ```python
  import spotipy
  from spotipy.oauth2 import SpotifyOAuth

  sp = spotipy.Spotify(auth_manager=SpotifyOAuth(client_id="YOUR_APP_CLIENT_ID",
                                                 client_secret="YOUR_APP_CLIENT_SECRET",
                                                 redirect_uri="YOUR_APP_REDIRECT_URI",
                                                 scope="user-library-read"))

  results = sp.current_user_saved_tracks()
  for idx, item in enumerate(results['items']):
      track = item['track']
      print(idx, track['artists'][0]['name'], " – ", track['name'])
  ```



  For common questions please check our [FAQ](FAQ.md).

  You can ask questions about Spotipy on
  [Stack Overflow](http://stackoverflow.com/questions/ask).
  Don’t forget to add the *Spotipy* tag, and any other relevant tags as well, before posting.

  If you have suggestions, bugs or other issues specific to this library,
  file them [here](https://github.com/plamere/spotipy/issues).
  Or just send a pull request.


pkgId: 32088b00a45dc1ac6652b42a119d40d7aaeac61dc2176f58b172d2da33d0bb84
name: python-spur
arch: src
version: 0.3.22
epoch: 0
release: 1
summary: Run commands and manipulate files locally or over SSH using the same interface
url: http://github.com/mwilliamson/spur.py
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-da143365-aa45-4243-a0dd-98441d86fac8
location_href: 00005187-python-spur/python-spur-0.3.22-1.src.rpm
checksum_type: sha256
description:
  To run echo locally:
      import spur
      shell = spur.LocalShell()
      result = shell.run(["echo", "-n", "hello"])
      print(result.output) # prints hello
  Executing the same command over SSH uses the same interface -- the only
  difference is how the shell is created:
      import spur
      shell = spur.SshShell(hostname="localhost", username="bob", password="password1")
      with shell:
          result = shell.run(["echo", "-n", "hello"])
      print(result.output) # prints hello


pkgId: 5adb18b94b6a7ba25b12cc8e9d8a48aec8e3c8a47ca8cfed81ddeadef016f5de
name: python-spyking-circus
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Fast spike sorting by template matching
url: http://spyking-circus.rtfd.org
rpm_license: License :: OSI Approved :: CeCILL-2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0f0a4461-ede2-40e1-ba38-9c635f644234
location_href: 00005190-python-spyking-circus/python-spyking-circus-1.1.0-1.src.rpm
checksum_type: sha256
description:
  *A fast and scalable solution for spike sorting of large-scale extracellular recordings*
  SpyKING CIRCUS is a python code to allow fast spike sorting on multi channel recordings.
  A publication on the algorithm can be found at https://elifesciences.org/articles/34518
  It has been tested on datasets coming from *in vitro* retina
  with 252 electrodes MEA, from *in vivo* hippocampus with tetrodes, *in vivo* and *in vitro* cortex
  data with 30 and up to 4225 channels, with good results. Synthetic tests on these data show
  that cells firing at more than 0.5Hz can be detected, and their spikes recovered with error
  rates at around 1%, even resolving overlapping spikes and synchronous firing. It seems to
  be compatible with optogenetic stimulation, based on experimental data obtained in the retina.
  SpyKING CIRCUS is currently still under development. Please do not hesitate to report issues with the issue tracker
  * Documentation can be found at http://spyking-circus.rtfd.org
  * A Google group can be found at http://groups.google.com/forum/#!forum/spyking-circus-users
  * A bug tracker can be found at https://github.com/spyking-circus/spyking-circus/issues
  * Open source ground-truth datasets used in the paper https://zenodo.org/record/1205233#.WrTFtXXwaV4


pkgId: 0e2d9a68b36b607987fbf29ab371642f473d0b604e8c137b0f2efe94f659e8a0
name: python-spyne
arch: src
version: 2.14.0
epoch: 0
release: 1
url: http://spyne.io
rpm_license: LGPL-2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2248eb2a-1abe-41c7-b309-ab2170b73e11
location_href: 00012812-python-spyne/python-spyne-2.14.0-1.src.rpm
checksum_type: sha256
summary:
  A transport and architecture agnostic rpc library that focuses on exposing public services with a well-defined API.


pkgId: 44217359749c7e95b0c2b928f6f323d7daad14b8bbae8d764937078eda2d4b22
name: python-sqlacodegen
arch: src
version: 2.3.0.post1
epoch: 0
release: 1
summary: Automatic model code generator for SQLAlchemy
url: https://pypi.org/project/sqlacodegen/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-10f7a500-86ec-47e5-ad77-78361e07f7ee
location_href: 00005192-python-sqlacodegen/python-sqlacodegen-2.3.0.post1-1.src.rpm
checksum_type: sha256
description:
  * Supports SQLAlchemy 0.8.x - 1.3.x
  * Produces declarative code that almost looks like it was hand written
  * Produces `PEP 8`_ compliant code
  * Accurately determines relationships, including many-to-many, one-to-one
  * Automatically detects joined table inheritance
  * Excellent test coverage


pkgId: e25a107bbbfce9405d06ae0d133de69406afe0302add2c8a369372f8c330508e
name: python-sqlakeyset
arch: src
version: 2.0.1681021882
epoch: 0
release: 1
summary: offset-free paging for sqlalchemy
url: https://github.com/djrobstep/sqlakeyset
rpm_license: Unlicense
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6ed9330c-2bc5-4537-a740-30efa02a2e8c
location_href: 00012517-python-sqlakeyset/python-sqlakeyset-2.0.1681021882-1.src.rpm
checksum_type: sha256
description:
  sqlakeyset implements keyset-based paging for SQLAlchemy (both ORM and core). **Now with full SQLAlchemy 2 support and type hints!**
  This library is tested with PostgreSQL, MariaDB/MySQL and SQLite. It should work with many other SQLAlchemy-supported databases, too; but caveat emptor - you should verify the results are correct.
  **Notice:** In accordance with Python end-of-life dates, we've stopped supporting Python versions earlier than 3.7. If you really need it, the latest version to support Python 2 is 0.1.1559103842 and Python 3.4 is 1.0.1679209451, but you'll miss out on all the latest features and bugfixes from the latest version. You should be upgrading anyway!


pkgId: 144622b6dd18dfb408f9b41f92836fac6ff078bc89a1baadc31c0815a4aa912b
name: python-sqlalchemy-aurora-data-api
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: An AWS Aurora Serverless Data API dialect for SQLAlchemy
url: https://github.com/chanzuckerberg/sqlalchemy-aurora-data-api
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1d7b2ad4-e3b5-484e-b92c-b64b5802979b
location_href: 00013954-python-sqlalchemy-aurora-data-api/python-sqlalchemy-aurora-data-api-0.4.1-1.src.rpm
checksum_type: sha256
description:
  This package provides a `SQLAlchemy <https://www.sqlalchemy.org>`_
  `dialect <https://docs.sqlalchemy.org/en/13/dialects/>`_ for accessing PostgreSQL and MySQL databases via the
  `AWS Aurora Data API <https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/data-api.html>`_.


pkgId: 5a9c620b50b687d811142adb27c4f77296cef1c9f78ac6f7db5057e95c775185
name: python-sqlalchemy-aurora-data-api-help
arch: noarch
version: 0.4.1
epoch: 0
release: 1
summary: Development documents and examples for sqlalchemy-aurora-data-api
url: https://github.com/chanzuckerberg/sqlalchemy-aurora-data-api
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1d7b2ad4-e3b5-484e-b92c-b64b5802979b
rpm_sourcerpm: python-sqlalchemy-aurora-data-api-0.4.1-1.src.rpm
checksum_type: sha256
description:
  This package provides a `SQLAlchemy <https://www.sqlalchemy.org>`_
  `dialect <https://docs.sqlalchemy.org/en/13/dialects/>`_ for accessing PostgreSQL and MySQL databases via the
  `AWS Aurora Data API <https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/data-api.html>`_.

location_href:
  00013954-python-sqlalchemy-aurora-data-api/python-sqlalchemy-aurora-data-api-help-0.4.1-1.noarch.rpm


pkgId: a1e60cf83cad260546cad387432b98754dfb17f8781248714352426db5b84b1f
name: python-sqlalchemy-cockroachdb
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: CockroachDB dialect for SQLAlchemy
url: https://github.com/cockroachdb/sqlalchemy-cockroachdb
rpm_license: http://www.apache.org/licenses/LICENSE-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-06dfbccb-4ba1-4992-8bd7-89574eb77a73
location_href: 00010096-python-sqlalchemy-cockroachdb/python-sqlalchemy-cockroachdb-2.0.0-1.src.rpm
checksum_type: sha256
description:
  For psycopg2 support you must install either:

  * [psycopg2](https://pypi.org/project/psycopg2/), which has some
    [prerequisites](https://www.psycopg.org/docs/install.html#prerequisites) of
    its own.

  * [psycopg2-binary](https://pypi.org/project/psycopg2-binary/)

  (The binary package is a practical choice for development and testing but in
  production it is advised to use the package built from sources.)

  Or, for asyncpg support (⚠️ experimental 🏗) you must install

  * [asyncpg](https://pypi.org/project/asyncpg/)



  Use `pip` to install the latest version.

  `pip install sqlalchemy-cockroachdb`

  NOTE: This version of the dialect requires SQLAlchemy 2.0 or later. To work with
  earlier versions of SQLAlchemy you'll need to install an earlier version of this
  dialect.

  `pip install sqlalchemy-cockroachdb<2.0.0`

  Use a `cockroachdb` connection string when creating the `Engine`. For example,
  to connect to an insecure, local CockroachDB cluster using psycopg2:

  ```
  from sqlalchemy import create_engine
  engine = create_engine('cockroachdb://root@localhost:26257/defaultdb?sslmode=disable')
  ```

  or

  ```
  from sqlalchemy import create_engine
  engine = create_engine('cockroachdb+psycopg2://root@localhost:26257/defaultdb?sslmode=disable')
  ```

  To connect using asyncpg (⚠️ experimental 🏗):

  ```
  from sqlalchemy import create_async_engine
  engine = create_async_engine('cockroachdb+asyncpg://root@localhost:26257/defaultdb')
  ```



  See [CHANGES.md](https://github.com/cockroachdb/sqlalchemy-cockroachdb/blob/master/CHANGES.md)


pkgId: 76640f6742d361cce06a2ff88af979c3ffeb42b4539c0ace7c200361dcf61e3b
name: python-sqlalchemy-filters
arch: src
version: 0.12.0
epoch: 0
release: 1
summary: A library to filter SQLAlchemy queries.
url: https://github.com/juliotrigo/sqlalchemy-filters
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9ca8de1d-2543-45f8-9b73-14cb56fd0feb
location_href: 00005194-python-sqlalchemy-filters/python-sqlalchemy-filters-0.12.0-1.src.rpm
checksum_type: sha256
description:
      Filter, sort and paginate SQLAlchemy query objects. Ideal for
      exposing these actions over a REST API.


pkgId: 0ae5c6f0289896c20b0d71342041feacb27178e65b897470de96180a3e7db554
name: python-sqlalchemy-migrate
arch: src
version: 0.13.0
epoch: 0
release: 1
summary: Database schema migration for SQLAlchemy
url: http://www.openstack.org/
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d9f9d584-b06b-4c72-b627-6ac920ef4c26
location_href: 00010716-python-sqlalchemy-migrate/python-sqlalchemy-migrate-0.13.0-1.src.rpm
checksum_type: sha256
description:
  Fork from http://code.google.com/p/sqlalchemy-migrate/ to get it working with
  SQLAlchemy 0.8.
  Inspired by Ruby on Rails' migrations, Migrate provides a way to deal with
  database schema changes in `SQLAlchemy <http://sqlalchemy.org>`_ projects.
  Migrate extends SQLAlchemy to have database changeset handling. It provides a
  database change repository mechanism which can be used from the command line as
  well as from inside python code.


pkgId: 7144239b7dca4211d5c5258136fd068ca886f8563d85ee738fcd25ce14004806
name: python-sqlalchemy-stubs
arch: src
version: 0.4
epoch: 0
release: 1
summary: SQLAlchemy stubs and mypy plugin
url: https://github.com/dropbox/sqlalchemy-stubs
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9a24789b-d571-4438-9aa8-5b4e561229b5
location_href: 00010140-python-sqlalchemy-stubs/python-sqlalchemy-stubs-0.4-1.src.rpm
checksum_type: sha256
description:
  This package contains type stubs and mypy plugin to provide more precise
  static types and type inference for SQLAlchemy framework. SQLAlchemy uses
  dynamic Python features that are hard to understand by static type checkers,
  this is why the plugin is needed in addition to type stubs.

  Currently, some basic use cases like inferring model field types are supported.
  The final goal is to be able to get precise types for most common patterns.



  ```
  pip install sqlalchemy-stubs
  ```

  Important: you need to enable the plugin in your mypy config file:
  ```
  [mypy]
  plugins = sqlmypy
  ```


pkgId: 6266bc254a4cf0017696dd60b49cb72a0ab6f304050b63bf8a5e6b7a95b7c634
name: python-sqlparams
arch: src
version: 5.1.0
epoch: 0
release: 1
summary: Convert between various DB API 2.0 parameter styles.
url: https://pypi.org/project/sqlparams/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-622cca3e-f891-4359-86fc-af973998a9e9
location_href: 00011922-python-sqlparams/python-sqlparams-5.1.0-1.src.rpm
checksum_type: sha256
description:
  *sqlparams* is a utility package for converting between various SQL
  parameter styles. This can simplify the use of SQL parameters in queries by
  allowing the use of named parameters where only ordinal are supported. Some
  `Python DB API 2.0`_ compliant modules only support the ordinal *qmark* or
  *format* style parameters (e.g., `pyodbc`_ only supports *qmark*). This
  package provides a helper class, `SQLParams`_, that is used to convert
  from any parameter style (*qmark*, *numeric*, *named*, *format*, *pyformat*;
  and the non-standard *numeric_dollar* and *named_dollar*), and have them
  safely converted to the desired parameter style.


pkgId: addc8c6347679df7332cb6400d6598de2ad675edcf67f6a23082579d04578ae2
name: python-sqlparse
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: A non-validating SQL parser.
url: https://github.com/andialbrecht/sqlparse
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-18110f69-0aa4-4b6c-86c9-dbb45ee26d68
location_href: 00005198-python-sqlparse/python-sqlparse-0.4.3-1.src.rpm
checksum_type: sha256
description:
  |buildstatus|_
  |coverage|_
  |docs|_
  |packageversion|_
  sqlparse is a non-validating SQL parser for Python.
  It provides support for parsing, splitting and formatting SQL statements.
  The module is compatible with Python 3.5+ and released under the terms of the
  `New BSD license <https://opensource.org/licenses/BSD-3-Clause>`_.
  Visit the project page at https://github.com/andialbrecht/sqlparse for
  further information about this project.


pkgId: bd0c6c3ae9ec6468e878cb616beaa5efbaa7331a464a555f567c70e9720a1f4c
name: python-ssdeep
arch: src
version: 3.4
epoch: 0
release: 1
summary: Python wrapper for the ssdeep library
url: http://github.com/DinoTools/python-ssdeep
rpm_license: LGPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-82642fe5-085a-436c-a51a-530992484347
location_href: 00005199-python-ssdeep/python-ssdeep-3.4-1.src.rpm
checksum_type: sha256
description:
  This is a straightforward Python wrapper for `ssdeep by Jesse Kornblum`_, which is a library for computing context
  triggered piecewise hashes (CTPH). Also called fuzzy hashes, CTPH can match inputs that have homologies. Such inputs
  have sequences of identical bytes in the same order, although bytes in between these sequences may be different in both
  content and length.


pkgId: 93c78e6ab45b85bfe56958f9dce7cf435da938de5837c38cb40f40868f7d124c
name: python-ssdp
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Python asyncio library for Simple Service Discovery Protocol (SSDP).
url: https://pypi.org/project/ssdp/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-67c396cc-e86b-4d14-8d47-5c3a84d41b0b
location_href: 00005201-python-ssdp/python-ssdp-1.1.1-1.src.rpm
checksum_type: sha256
description:
  Python asyncio library for Simple Service Discovery Protocol (SSDP).

  SSDP is a UPnP substandard. For more information see:
  https://en.wikipedia.org/wiki/Simple_Service_Discovery_Protocol



  ```bash
  python3 -m pip install ssdp
  ```



  ```python
  import asyncio
  import socket

  import ssdp


  class MyProtocol(ssdp.SimpleServiceDiscoveryProtocol):

      def response_received(self, response, addr):
          print(response, addr)

      def request_received(self, request, addr):
          print(request, addr)


  loop = asyncio.get_event_loop()
  connect = loop.create_datagram_endpoint(MyProtocol, family=socket.AF_INET)
  transport, protocol = loop.run_until_complete(connect)

  notify = ssdp.SSDPRequest('NOTIFY')
  notify.sendto(transport, (MyProtocol.MULTICAST_ADDRESS, 1982))

  try:
      loop.run_forever()
  except KeyboardInterrupt:
      pass

  transport.close()
  loop.close()
  ```



  The `examples <examples/>`\_ directory contains examples on how to use
  this library.


pkgId: f3fb25b3bcf33d0ad1fcb733aeea85a4ef6542fb368da749cec0a0835fa4f26c
name: python-ssh2-python
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Bindings for libssh2 C library
url: https://github.com/ParallelSSH/ssh2-python
rpm_license: LGPLv2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ddf18578-61ca-4069-9b52-f0739c8e8cfc
location_href: 00005204-python-ssh2-python/python-ssh2-python-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Super fast SSH2 protocol library. ``ssh2-python`` provides Python bindings for `libssh2`_.
  Installation
  ______________
  Binary wheel packages are provided for Linux, OSX and Windows, all Python versions. Wheel packages have **no dependencies**.
  ``pip`` may need to be updated to be able to install binary wheel packages - ``pip install -U pip``.
     pip install ssh2-python
  For from source installation instructions, including building against system provided libssh2, `see documentation <https://ssh2-python.readthedocs.io/en/latest/installation.html#installation-from-source>`_.
  Who Should Use This
  ___________________
  Most developers will want to use the `high level clients <https://parallel-ssh.readthedocs.io/en/latest/quickstart.html#single-host-client>`_
  in `parallel-ssh <https://github.com/ParallelSSH/parallel-ssh>`_
  based on this library.
  This library provides bindings to the low-level libssh2 C-API. It is *not* high level, nor easy to use. A *lot* of code
  would need to be written to use this library that is already provided by `parallel-ssh`.
  Use `parallel-ssh <https://github.com/ParallelSSH/parallel-ssh>`_ unless *really* sure using a C-API is what is wanted.
  API Feature Set
  ________________
  At this time all of the `libssh2`_ API has been implemented up to the libssh2 version in the repository. Please report any missing implementation.
  Complete example scripts for various operations can be found in the `examples directory`_.
  In addition, as ``ssh2-python`` is a thin wrapper of ``libssh2`` with Python semantics, `its code examples <https://libssh2.org/examples/>`_ can be ported straight over to Python with only minimal changes.
  Examples
  _____________
  See `examples directory <https://github.com/ParallelSSH/ssh2-python/tree/master/examples>`_  for complete examples.
  Again, most developers will want to use `parallel-ssh <https://github.com/ParallelSSH/parallel-ssh>`_ rather than this
  library directly.


pkgId: 44164de2d52847b5e34da0a8010a6ce2bb915809487a0abb03095e52b93b0129
name: python-sslyze
arch: src
version: 5.1.3
epoch: 0
release: 1
summary: Fast and powerful SSL/TLS scanning library.
url: https://github.com/nabla-c0d3/sslyze
rpm_license: AGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d6ba7414-2c18-42a7-b9c7-b2f72a676090
location_href: 00012075-python-sslyze/python-sslyze-5.1.3-1.src.rpm
checksum_type: sha256
description:
  ![Run Tests](https://github.com/nabla-c0d3/sslyze/workflows/Run%20Tests/badge.svg)
  [![Downloads](https://pepy.tech/badge/sslyze/month)](https://pepy.tech/project/sslyze)
  [![PyPI version](https://img.shields.io/pypi/v/sslyze.svg)](https://pypi.org/project/sslyze/)
  [![Python version](https://img.shields.io/pypi/pyversions/sslyze.svg)](https://pypi.org/project/sslyze/)
  SSLyze is a fast and powerful SSL/TLS scanning tool and Python library.
  SSLyze can analyze the SSL/TLS configuration of a server by connecting to it, in order to ensure that it uses strong
  encryption settings (certificate, cipher suites, elliptic curves, etc.), and that it is not vulnerable to known TLS
  attacks (Heartbleed, ROBOT, OpenSSL CCS injection, etc.).


pkgId: 01042f4eed5d765e88d142a2b47ff76b6f69fc0d95b11e731f7e14810f7fab5c
name: python-ssm-parameter-store
arch: src
version: 19.11.0
epoch: 0
release: 1
summary: Simple Python wrapper for getting values from AWS Systems Manager Parameter Store
url: http://github.com/christippett/ssm-parameter-store
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b330df5e-2fe6-4cdd-a15e-dced34b5b4b3
location_href: 00011414-python-ssm-parameter-store/python-ssm-parameter-store-19.11.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/ssm-parameter-store.svg)](https://pypi.python.org/pypi/ssm-parameter-store)
  [![Build status](https://img.shields.io/travis/christippett/ssm-parameter-store.svg)](https://travis-ci.org/christippett/ssm-parameter-store)
  [![Coverage](https://img.shields.io/coveralls/github/christippett/ssm-parameter-store.svg)](https://coveralls.io/github/christippett/ssm-parameter-store?branch=master)
  [![Python versions](https://img.shields.io/pypi/pyversions/ssm-parameter-store.svg)](https://pypi.python.org/pypi/ssm-parameter-store)
  [![Github license](https://img.shields.io/github/license/christippett/ssm-parameter-store.svg)](https://github.com/christippett/ssm-parameter-store)


pkgId: b59bea5264b7b82609a9611c19b047da20622bc7cfb955be9cdda038c71157d7
name: python-sss
arch: src
version: 1.2
epoch: 0
release: 1
url: https://bitbucket.org/brunobord/sss/
rpm_license: WTFPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c744abdf-073a-448e-ace5-b042739d39ee
location_href: 00005206-python-sss/python-sss-1.2-1.src.rpm
checksum_type: sha256
summary:
  Simple Scrum System is a basic Django-based Scrum-like project manager. It takes advantage of the automagic admin contrib site.


pkgId: 134f8a4ec78c7d53c7647627d385c017fafe2cba52dec1590a225797910c3576
name: python-stackprinter
arch: src
version: 0.2.10
epoch: 0
release: 1
summary: Debug-friendly stack traces, with variable values and semantic highlighting
url: https://github.com/cknd/stackprinter
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1c7e2655-0044-486c-92bc-776025603927
location_href: 00005209-python-stackprinter/python-stackprinter-0.2.10-1.src.rpm
checksum_type: sha256
description:
  <img src="https://raw.githubusercontent.com/cknd/stackprinter/master/darkbg.png" width="500">

  [![build](https://github.com/cknd/stackprinter/actions/workflows/build.yml/badge.svg?branch=master)](https://github.com/cknd/stackprinter/actions/workflows/build.yml)



  This is a more helpful version of Python's built-in exception message: It shows more code context and the current values of nearby variables. That answers many of the questions I'd ask an interactive debugger: Where in the code was the crash, what's in the relevant variables, and why was _that_ function called with _those_ arguments. It either prints to the console or gives you a string for logging.

  ```bash
  pip3 install stackprinter
  ```

  ```
  Traceback (most recent call last):
    File "demo.py", line 12, in <module>
      dangerous_function(somelist + anotherlist)
    File "demo.py", line 6, in dangerous_function
      return sorted(blub, key=lambda xs: sum(xs))
    File "demo.py", line 6, in <lambda>
      return sorted(blub, key=lambda xs: sum(xs))
  TypeError: unsupported operand type(s) for +: 'int' and 'str'
  ```


  ```
  File demo.py, line 12, in <module>
      9        somelist = [[1,2], [3,4]]
      10       anotherlist = [['5', 6]]
      11       spam = numpy.zeros((3,3))
  --> 12       dangerous_function(somelist + anotherlist)
      13   except:
      ..................................................
       somelist = [[1, 2, ], [3, 4, ], ]
       anotherlist = [['5', 6, ], ]
       spam = 3x3 array([[0. 0. 0.]
                         [0. 0. 0.]
                         [0. 0. 0.]])
      ..................................................

  File demo.py, line 6, in dangerous_function
      5    def dangerous_function(blub):
  --> 6        return sorted(blub, key=lambda xs: sum(xs))
      ..................................................
       blub = [[1, 2, ], [3, 4, ], ['5', 6, ], ]
      ..................................................

  File demo.py, line 6, in <lambda>
      3
      4
      5    def dangerous_function(blub):
  --> 6        return sorted(blub, key=lambda xs: sum(xs))
      7
      ..................................................
       xs = ['5', 6, ]
      ..................................................

  TypeError: unsupported operand type(s) for +: 'int' and 'str'
  ```
  I rarely use this locally instead of a real debugger, but it helps me sleep when my code runs somewhere where the only debug tool is a log file (though it's not a fully-grown [error monitoring system](https://sentry.io/welcome/)).

  By default, it tries to be somewhat polite about screen space, showing only a few source lines & the function header, and only the variables _that appear in those lines_, and using only (?) 500 characters per variable. You can [configure](https://github.com/cknd/stackprinter/blob/master/stackprinter/__init__.py#L28-L149) exactly how verbose things should be.

  It outputs plain text normally, which is good for log files. There's also a color mode for some reason 🌈, with a few different color schemes for light and dark backgrounds. (The colors [track different variables](https://medium.com/@brianwill/making-semantic-highlighting-useful-9aeac92411df) instead of the language syntax.)

  <img src="https://raw.githubusercontent.com/cknd/stackprinter/master/notebook.png" width="500">




  To replace the default python crash printout, call `set_excepthook()` somewhere once. Afterwards, any uncaught exception will be printed with an extended traceback (to stderr, by default). You could also [make this permanent for your python installation](#making-it-stick).

  ```python
  import stackprinter
  stackprinter.set_excepthook(style='darkbg2')  # for jupyter notebooks try style='lightbg'
  ```

  For more control, call [`show()`](https://github.com/cknd/stackprinter/blob/master/stackprinter/__init__.py#L166-L183) or [`format()`](https://github.com/cknd/stackprinter/blob/master/stackprinter/__init__.py#L28-L149) inside an `except` block. `show()` prints to stderr, `format()` returns a string, for custom logging.

  ```python
  try:
      something()
  except:
      
      stackprinter.show()

      
      logger.error(stackprinter.format())
  ```
  Or pass specific exceptions explicitly:
  ```python
  try:
      something()
  except RuntimeError as exc:
      tb = stackprinter.format(exc)
      logger.error('The front fell off.\n' + tb)
  ```



  `format()`, `show()` and `set_excepthook()` accept a common set of keyword args. They allow you to tweak the formatting, hide certain variables by name, skip variables in calls within certain files, and some other stuff.

  ```python
  try:
      something()
  except RuntimeError as exc:
      stackprinter.show(exc, suppressed_vars=[r".*secret.*"],
                             suppressed_paths=[r"lib/python.*/site-packages/boringstuff"],
                             truncate_vals=9001,
                             style="darkbg2")
  ```
  For all the options [see the docstring of `format()`](https://github.com/cknd/stackprinter/blob/master/stackprinter/__init__.py#L28-L149).



  With a bit of extra plumbing you can log errors like this via the normal `logging` methods, without having to import `stackprinter` at the site of the logging call. So you can continue to write nice and simple error handlers like so...

  ```python
  logger = logging.getLogger()
  try:
      nothing = {}
      dangerous_function(nothing.get("something"))
  except:
      logger.exception('My hovercraft is full of eels.')
  ```
  ...but still get annotated tracebacks in the resulting log.
  ```
  2022-04-02 16:16:40,905 ERROR: My hovercraft is full of eels.
    ┆ File "demo_logging.py", line 56, in <module>
    ┆     54   try:
    ┆     55       nothing = {}
    ┆ --> 56       dangerous_function(nothing.get("something"))
    ┆     57   except:
    ┆     ..................................................
    ┆      nothing = {}
    ┆     ..................................................
    ┆
    ┆ File "demo_logging.py", line 52, in dangerous_function
    ┆     51   def dangerous_function(something):
    ┆ --> 52       return something + 1
    ┆     ..................................................
    ┆      something = None
    ┆     ..................................................
    ┆
    ┆ TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'
  ```

  You can get this by adding a [custom formatter](https://docs.python.org/3/howto/logging-cookbook.html#customized-exception-formatting) to the logger before using it:

  ```python
  import logging
  import stackprinter

  class VerboseExceptionFormatter(logging.Formatter):
      def formatException(self, exc_info):
          msg = stackprinter.format(exc_info)
          lines = msg.split('\n')
          lines_indented = ["  ┆ " + line + "\n" for line in lines]
          msg_indented = "".join(lines_indented)
          return msg_indented

  def configure_logger(logger_name=None):
      fmt = 's s: s'
      formatter = VerboseExceptionFormatter(fmt)

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

      logger = logging.getLogger(logger_name)
      logger.addHandler(handler)

  configure_logger("some_logger")
  ```
  See [demo_logging.py](https://github.com/cknd/stackprinter/blob/master/demo_logging.py) for a runnable example.


  To see your own thread's current call stack, call `show` or `format` anywhere outside of exception handling.

  ```python
  stackprinter.show() # or format()
  ```


  To inspect the call stack of any other running thread:

  ```python
  thread = threading.Thread(target=something)
  thread.start()

  stackprinter.show(thread) # or format(thread)
  ```



  To permanently replace the crash message for your python installation, you *could* put a file `sitecustomize.py` into the `site-packages` directory under one of the paths revealed by `python -c "import site; print(site.PREFIXES)"`, with contents like this:

  ```python
      
      import stackprinter
      stackprinter.set_excepthook(style='darkbg2')
  ```

  That would give you colorful tracebacks automatically every time, even in the REPL.

  (You could do a similar thing for IPython, [but they have their own method](https://ipython.readthedocs.io/en/stable/interactive/tutorial.html?highlight=startup#configuration), where the file goes into `~/.ipython/profile_default/startup` instead, and also I don't want to talk about what this module does to set an excepthook under IPython.)



  For now, the documentation consists only of some fairly detailed docstrings, [e.g. those of `format()`](https://github.com/cknd/stackprinter/blob/master/stackprinter/__init__.py#L28-L149)



  This displays variable values as they are _at the time of formatting_. In
  multi-threaded programs, variables can change while we're busy walking
  the stack & printing them. So, if nothing seems to make sense, consider that
  your exception and the traceback messages are from slightly different times.
  Sadly, there is no responsible way to freeze all other threads as soon
  as we want to inspect some thread's call stack (...or is there?)



  Basically, this is a frame formatter. For each [frame on the call stack](https://en.wikipedia.org/wiki/Call_stack), it grabs the source code to find out which source lines reference which variables. Then it displays code and variables in the neighbourhood of the last executed line.

  Since this already requires a map of where each variable occurs in the code, it was difficult not to also implement the whole semantic highlighting color thing seen in the screenshots. The colors are ANSI escape codes now, but it should be fairly straightforward™ to render the underlying data without any 1980ies terminal technology. Say, a foldable and clickable HTML page with downloadable pickled variables. For now you'll have to pipe the ANSI strings through [ansi2html](https://github.com/ralphbean/ansi2html/) or something.

  The format and everything is inspired by the excellent [`ultratb`](https://ipython.readthedocs.io/en/stable/api/generated/IPython.core.ultratb.html) in IPython. One day I'd like to contribute the whole "find out which variables in `locals` and `globals` are nearby in the source and print only those" machine over there, after trimming its complexity a bit.



  More for curiosity than anything else, you can watch a piece of code execute step-by-step, printing a trace of all calls & returns 'live' as they are happening. Slows everything down though, of course.
  ```python
  with stackprinter.TracePrinter(style='darkbg2'):
      dosomething()
  ```

  or
  ```python
  tp = stackprinter.TracePrinter(style='darkbg2')
  tp.enable()
  dosomething()

  tp.disable()
  ```
  <img src="https://raw.githubusercontent.com/cknd/stackprinter/master/trace.png" width="300">


pkgId: a39adac841bb250645bc424ba8a89de26e9567c506dd95e33d30d18eeaf2de2b
name: python-stanza
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: A Python NLP Library for Many Human Languages, by the Stanford NLP Group
url: https://github.com/stanfordnlp/stanza
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1b4b17be-9cb9-4290-95e2-8cab4557fc55
location_href: 00012261-python-stanza/python-stanza-1.5.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center"><img src="https://github.com/stanfordnlp/stanza/raw/dev/images/stanza-logo.png" height="100px"/></div>

  <h2 align="center">Stanza: A Python NLP Library for Many Human Languages</h2>

  <div align="center">
      <a href="https://github.com/stanfordnlp/stanza/actions">
         <img alt="Run Tests" src="https://github.com/stanfordnlp/stanza/actions/workflows/stanza-tests.yaml/badge.svg">
      </a>
      <a href="https://pypi.org/project/stanza/">
          <img alt="PyPI Version" src="https://img.shields.io/pypi/v/stanza?color=blue">
      </a>
      <a href="https://anaconda.org/stanfordnlp/stanza">
          <img alt="Conda Versions" src="https://img.shields.io/conda/vn/stanfordnlp/stanza?color=blue&label=conda">
      </a>
      <a href="https://pypi.org/project/stanza/">
          <img alt="Python Versions" src="https://img.shields.io/pypi/pyversions/stanza?colorB=blue">
      </a>
  </div>

  The Stanford NLP Group's official Python NLP library. It contains support for running various accurate natural language processing tools on 60+ languages and for accessing the Java Stanford CoreNLP software from Python. For detailed information please visit our [official website](https://stanfordnlp.github.io/stanza/).

  🔥 &nbsp;A new collection of **biomedical** and **clinical** English model packages are now available, offering seamless experience for syntactic analysis and named entity recognition (NER) from biomedical literature text and clinical notes. For more information, check out our [Biomedical models documentation page](https://stanfordnlp.github.io/stanza/biomed.html).



  If you use this library in your research, please kindly cite our [ACL2020 Stanza system demo paper](https://arxiv.org/abs/2003.07082):

  ```bibtex
  @inproceedings{qi2020stanza,
      title={Stanza: A {Python} Natural Language Processing Toolkit for Many Human Languages},
      author={Qi, Peng and Zhang, Yuhao and Zhang, Yuhui and Bolton, Jason and Manning, Christopher D.},
      booktitle = "Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics: System Demonstrations",
      year={2020}
  }
  ```

  If you use our biomedical and clinical models, please also cite our [Stanza Biomedical Models description paper](https://arxiv.org/abs/2007.14640):

  ```bibtex
  @article{zhang2021biomedical,
      author = {Zhang, Yuhao and Zhang, Yuhui and Qi, Peng and Manning, Christopher D and Langlotz, Curtis P},
      title = {Biomedical and clinical {E}nglish model packages for the {S}tanza {P}ython {NLP} library},
      journal = {Journal of the American Medical Informatics Association},
      year = {2021},
      month = {06},
      issn = {1527-974X}
  }
  ```

  The PyTorch implementation of the neural pipeline in this repository is due to [Peng Qi](http://qipeng.me) (@qipeng), [Yuhao Zhang](http://yuhao.im) (@yuhaozhang), and [Yuhui Zhang](https://cs.stanford.edu/~yuhuiz/) (@yuhui-zh15), with help from [Jason Bolton](mailto:jebolton@stanford.edu) (@j38), [Tim Dozat](https://web.stanford.edu/~tdozat/) (@tdozat) and [John Bauer](https://www.linkedin.com/in/john-bauer-b3883b60/) (@AngledLuffa). Maintenance of this repo is currently led by [John Bauer](https://www.linkedin.com/in/john-bauer-b3883b60/).

  If you use the CoreNLP software through Stanza, please cite the CoreNLP software package and the respective modules as described [here](https://stanfordnlp.github.io/CoreNLP/#citing-stanford-corenlp-in-papers) ("Citing Stanford CoreNLP in papers"). The CoreNLP client is mostly written by [Arun Chaganty](http://arun.chagantys.org/), and [Jason Bolton](mailto:jebolton@stanford.edu) spearheaded merging the two projects together.



  To ask questions, report issues or request features 🤔, please use the [GitHub Issue Tracker](https://github.com/stanfordnlp/stanza/issues). Before creating a new issue, please make sure to search for existing issues that may solve your problem, or visit the [Frequently Asked Questions (FAQ) page](https://stanfordnlp.github.io/stanza/faq.html) on our website.



  We welcome community contributions to Stanza in the form of bugfixes 🛠️ and enhancements 💡! If you want to contribute, please first read [our contribution guideline](CONTRIBUTING.md).





  Stanza supports Python 3.6 or later. We recommend that you install Stanza via [pip](https://pip.pypa.io/en/stable/installing/), the Python package manager. To install, simply run:
  ```bash
  pip install stanza
  ```
  This should also help resolve all of the dependencies of Stanza, for instance [PyTorch](https://pytorch.org/) 1.3.0 or above.

  If you currently have a previous version of `stanza` installed, use:
  ```bash
  pip install stanza -U
  ```



  To install Stanza via Anaconda, use the following conda command:

  ```bash
  conda install -c stanfordnlp stanza
  ```

  Note that for now installing Stanza via Anaconda does not work for Python 3.10. For Python 3.10 please use pip installation.



  Alternatively, you can also install from source of this git repository, which will give you more flexibility in developing on top of Stanza. For this option, run
  ```bash
  git clone https://github.com/stanfordnlp/stanza.git
  cd stanza
  pip install -e .
  ```





  To run your first Stanza pipeline, simply following these steps in your Python interactive interpreter:

  ```python
  >>> import stanza
  >>> stanza.download('en')       # This downloads the English models for the neural pipeline
  >>> nlp = stanza.Pipeline('en') # This sets up a default neural pipeline in English
  >>> doc = nlp("Barack Obama was born in Hawaii.  He was elected president in 2008.")
  >>> doc.sentences[0].print_dependencies()
  ```

  If you encounter `requests.exceptions.ConnectionError`, please try to use a proxy:

  ```python
  >>> import stanza
  >>> proxies = {'http': 'http://ip:port', 'https': 'http://ip:port'}
  >>> stanza.download('en', proxies=proxies)  # This downloads the English models for the neural pipeline
  >>> nlp = stanza.Pipeline('en')             # This sets up a default neural pipeline in English
  >>> doc = nlp("Barack Obama was born in Hawaii.  He was elected president in 2008.")
  >>> doc.sentences[0].print_dependencies()
  ```

  The last command will print out the words in the first sentence in the input string (or [`Document`](https://stanfordnlp.github.io/stanza/data_objects.html#document), as it is represented in Stanza), as well as the indices for the word that governs it in the Universal Dependencies parse of that sentence (its "head"), along with the dependency relation between the words. The output should look like:

  ```
  ('Barack', '4', 'nsubj:pass')
  ('Obama', '1', 'flat')
  ('was', '4', 'aux:pass')
  ('born', '0', 'root')
  ('in', '6', 'case')
  ('Hawaii', '4', 'obl')
  ('.', '4', 'punct')
  ```

  See [our getting started guide](https://stanfordnlp.github.io/stanza/installation_usage.html#getting-started) for more details.



  Aside from the neural pipeline, this package also includes an official wrapper for accessing the Java Stanford CoreNLP software with Python code.

  There are a few initial setup steps.

  * Download [Stanford CoreNLP](https://stanfordnlp.github.io/CoreNLP/) and models for the language you wish to use
  * Put the model jars in the distribution folder
  * Tell the Python code where Stanford CoreNLP is located by setting the `CORENLP_HOME` environment variable (e.g., in *nix): `export CORENLP_HOME=/path/to/stanford-corenlp-4.5.1`

  We provide [comprehensive examples](https://stanfordnlp.github.io/stanza/corenlp_client.html) in our documentation that show how one can use CoreNLP through Stanza and extract various annotations from it.



  To get your started, we also provide interactive Jupyter notebooks in the `demo` folder. You can also open these notebooks and run them interactively on [Google Colab](https://colab.research.google.com). To view all available notebooks, follow these steps:

  * Go to the [Google Colab website](https://colab.research.google.com)
  * Navigate to `File` -> `Open notebook`, and choose `GitHub` in the pop-up menu
  * Note that you do **not** need to give Colab access permission to your github account
  * Type `stanfordnlp/stanza` in the search bar, and click enter



  We currently provide models for all of the [Universal Dependencies](https://universaldependencies.org/) treebanks v2.8, as well as NER models for a few widely-spoken languages. You can find instructions for downloading and using these models [here](https://stanfordnlp.github.io/stanza/models.html).



  To maximize speed performance, it is essential to run the pipeline on batches of documents. Running a for loop on one sentence at a time will be very slow. The best approach at this time is to concatenate documents together, with each document separated by a blank line (i.e., two line breaks `\n\n`).  The tokenizer will recognize blank lines as sentence breaks. We are actively working on improving multi-document processing.



  All neural modules in this library can be trained with your own data. The tokenizer, the multi-word token (MWT) expander, the POS/morphological features tagger, the lemmatizer and the dependency parser require [CoNLL-U](https://universaldependencies.org/format.html) formatted data, while the NER model requires the BIOES format. Currently, we do not support model training via the `Pipeline` interface. Therefore, to train your own models, you need to clone this git repository and run training from the source.

  For detailed step-by-step guidance on how to train and evaluate your own models, please visit our [training documentation](https://stanfordnlp.github.io/stanza/training.html).



  Stanza is released under the Apache License, Version 2.0. See the [LICENSE](https://github.com/stanfordnlp/stanza/blob/master/LICENSE) file for more details.


pkgId: 08fc99ed1cb9d79488744a56ffe7624a2caffc74aaf88a19eddf9a05f58ceb2a
name: python-static3
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: A really simple WSGI way to serve static (or mixed) content.
url: https://github.com/rmohr/static3
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-93dbc132-b259-42e7-ae49-d14fc90e1df8
location_href: 00012156-python-static3/python-static3-0.7.0-1.src.rpm
checksum_type: sha256
description:
  This software is a Python3 compatible fork of Luke Arnos library static_.
  The library is now Python3 compatible and Genshi_ support (the sucessor of
  kid_) is added. On Python2 Genshi and/or kid can be used as template engine. On
  Python3 only Genshi is available.
  This library provides an easy way to include static content
  in your WSGI applications. There is a convenience method for serving
  files located via pkg_resources. There are also facilities for serving
  mixed (static and dynamic) content using "magic" file handlers.
  Python builtin string substitution, kid and Genshi template support are provided
  and it is easy to roll your own handlers. Note that this distribution
  does not require kid or Genshi unless you want to use that type of template. Also
  provides a command of the same name as a convenience when you just want
  to share a little content over HTTP, ad hoc.


pkgId: d183f67fb02b9e8a1609b5e47a1eab23233894bf92d35b0f6ca5c005339e7f85
name: python-statsmodels
arch: src
version: 0.13.5
epoch: 0
release: 1
summary: Statistical computations and models for Python
url: https://www.statsmodels.org/
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9866dbf1-24a2-493b-bc33-15cc37a275c3
location_href: 00005213-python-statsmodels/python-statsmodels-0.13.5-1.src.rpm
checksum_type: sha256
description:
  statsmodels is a Python package that provides a complement to scipy for
  statistical computations including descriptive statistics and estimation
  and inference for statistical models.


pkgId: eff70be9b5ce750df6a75b410939f928e61594fec5781cebbc15157a86a716ff
name: python-stdiomask
arch: src
version: 0.0.6
epoch: 0
release: 1
url: https://github.com/asweigart/stdiomask
rpm_license: GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b94a5f64-06fa-4285-a629-90f8534d8eee
location_href: 00005216-python-stdiomask/python-stdiomask-0.0.6-1.src.rpm
checksum_type: sha256
summary:
  A cross-platform Python module for entering passwords to a stdio terminal and displaying a **** mask, which getpass cannot do.

description:
  A cross-platform Python module for entering passwords to a stdio terminal and displaying a **** mask, which getpass cannot do.


pkgId: 0b1a56ddd9d325081e30f43b52c4140eae5cb28ea13a17187db4598882a6340e
name: python-stdlib-list
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: A list of Python Standard Libraries (2.6-7, 3.2-9).
url: https://github.com/jackmaney/python-stdlib-list
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-aeed34ce-3eca-4d18-9102-a5d0633be8d6
location_href: 00005217-python-stdlib-list/python-stdlib-list-0.8.0-1.src.rpm
checksum_type: sha256
description:
  This package includes lists of all of the standard libraries for Python 2.6, 2.7, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.8, and 3.9 along with the code for scraping the official Python docs to get said lists.


pkgId: 16f7dfad4363ed204e9f427d997e5889a32773e84e875549414a74b5a1b2cb3d
name: python-stem
arch: src
version: 1.8.1
epoch: 0
release: 1
url: https://stem.torproject.org/
rpm_license: LGPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-340fed61-bb65-4520-85b9-9ed73d509d08
location_href: 00005219-python-stem/python-stem-1.8.1-1.src.rpm
checksum_type: sha256
summary:
  Stem is a Python controller library that allows applications to interact with Tor (https://www.torproject.org/).

description:
  To install you can either use...
    pip install stem
    python3 setup.py install
  After that, give some `tutorials <https://stem.torproject.org/tutorials.html>`_ a try! For questions or to discuss project ideas we're available on `irc <https://www.torproject.org/about/contact.html.en#irc>`_ and the `tor-dev@ email list <https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-dev>`_.


pkgId: 722306628d6bd2b386afa01d12a6c52a4108ac1d85cf5426daa1972700f6a2ae
name: python-stestr
arch: src
version: 4.0.1
epoch: 0
release: 1
summary: A parallel Python test runner built around subunit
url: http://stestr.readthedocs.io/en/latest/
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-90d3dc34-e692-43aa-a7bc-ed04017a1fc7
location_href: 00005223-python-stestr/python-stestr-4.0.1-1.src.rpm
checksum_type: sha256
description:
  * Read this in other languages: `English`_, `日本語`_
  * You can see the full rendered docs at: http://stestr.readthedocs.io/en/latest/
  * The code of the project is on Github: https://github.com/mtreinish/stestr
      Python 2. Support for Python 2.7 was dropped in stestr release 3.0.0.


pkgId: eeecb6e1f5f64768c92f75158ad8888de6b8229cd6f946110a50e58581b344d5
name: python-stldecompose
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: A Python implementation of seasonal trend with Loess (STL) time series decomposition
url: https://github.com/jrmontag/STLDecompose
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7273b7de-9a25-4cda-9e41-f84a59e55f18
location_href: 00011343-python-stldecompose/python-stldecompose-0.0.5-1.src.rpm
checksum_type: sha256
description:
  This is a relatively naive Python implementation of a seasonal and trend decomposition using Loess smoothing. Commonly referred to as an "STL decomposition", Cleveland's 1990 paper is the canonical reference.
  This implementation is a variation of (and takes inspiration from) the implementation of the ``seasonal_decompose`` method `in statsmodels <http://www.statsmodels.org/stable/generated/statsmodels.tsa.seasonal.seasonal_decompose.html#statsmodels.tsa.seasonal.seasonal_decompose>`_. In this implementation, the trend component is calculated by substituting a configurable `Loess regression <https://en.wikipedia.org/wiki/Local_regression>`_ for the convolutional method used in ``seasonal_decompose``. It also extends the existing ``DecomposeResult`` from ``statsmodels`` to allow for forecasting based on the calculated decomposition.


pkgId: 083d11419d85dbcc1bf05621097004359c63ff16dc5c6936f9423d794fc40fda
name: python-stompest
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: STOMP library for Python including a synchronous client.
url: https://github.com/nikipore/stompest
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-161d3192-0579-4668-aa2a-c0b5a5b479c3
location_href: 00005226-python-stompest/python-stompest-2.3.0-1.src.rpm
checksum_type: sha256
description:
  `stompest <https://github.com/nikipore/stompest/>`_ is a full-featured `STOMP <http://stomp.github.com/>`_ `1.0 <http://stomp.github.com//stomp-specification-1.0.html>`_, `1.1 <http://stomp.github.com//stomp-specification-1.1.html>`_, and `1.2 <http://stomp.github.com//stomp-specification-1.2.html>`_ implementation for Python 2.7 and Python 3 (versions 3.3 and higher), with optional TLS/SSL support.
  The STOMP client in this package is dead simple: It does not assume anything about your concurrency model (thread vs process) or force you to use it any particular way. It gets out of your way and lets you do what you want. The package also consists of a generic set of components each of which you may use independently to roll your own STOMP client:
  * a wire-level STOMP frame parser and compiler,
  * a faithful implementation of the syntax of the STOMP protocol with a simple stateless function API,
  * a generic implementation of the STOMP session state semantics, such as protocol version negotiation at connect time, transaction and subscription handling (including a generic subscription replay scheme which may be used to reconstruct the session's subscription state after a forced disconnect),
  * and a `failover transport <http://activemq.apache.org/failover-transport-reference.html>`_ URI scheme akin to the one used in ActiveMQ.
  This package is thoroughly unit tested and production hardened for the functionality used by the current maintainer and by `Mozes <http://www.mozes.com/>`_ -- persistent queueing on `ActiveMQ <http://activemq.apache.org/>`_. Minor enhancements may be required to use this STOMP adapter with other brokers.


pkgId: 447e391f022178fa4a747fc299f493584b96862f270df1985155c594d39cb9c8
name: python-stone
arch: src
version: 3.3.1
epoch: 0
release: 1
summary: Stone is an interface description language (IDL) for APIs.
url: https://github.com/dropbox/stone
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-61e2c6a8-6bf9-429b-b75b-774acfd3f0a8
location_href: 00005229-python-stone/python-stone-3.3.1-1.src.rpm
checksum_type: sha256
description:
  Install stone using ``pip``::
      $ pip install --user stone
  This will install a script ``stone`` to your PATH that can be run from the
  command line::
      $ stone -h


pkgId: 07dcd1e25d340235bfadae9d9ba8d58abc2559f8833df2ef28d5087593876948
name: python-streamlink
arch: src
version: 5.3.1
epoch: 0
release: 1
url: https://github.com/streamlink/streamlink
rpm_license: Simplified BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6980620d-c75b-4c71-a4a9-f52c8dacc166
location_href: 00005231-python-streamlink/python-streamlink-5.3.1-1.src.rpm
checksum_type: sha256
summary:
  Streamlink is a command-line utility that extracts streams from various services and pipes them into a video player of choice.

description:
  <h1 align="center"><a href="https://streamlink.github.io/">Streamlink<br><img height="150" alt="Streamlink" src="https://raw.githubusercontent.com/streamlink/streamlink/master/icon.svg"></a></h1>

  <p align="center">
    <a href="https://streamlink.github.io/install.html"><img alt="Supported Python versions" src="https://img.shields.io/pypi/pyversions/streamlink.svg?style=flat-square&maxAge=86400"></a>
    <a href="https://streamlink.github.io/changelog.html"><img alt="Latest release" src="https://img.shields.io/github/release/streamlink/streamlink.svg?style=flat-square&maxAge=86400"></a>
    <a href="https://github.com/streamlink/streamlink"><img alt="License" src="https://img.shields.io/github/license/streamlink/streamlink.svg?style=flat-square&maxAge=86400"></a>
    <a href="https://github.com/streamlink/streamlink/issues"><img alt="Open issues" src="https://img.shields.io/github/issues/streamlink/streamlink.svg?style=flat-square&maxAge=86400"></a>
    <a href="https://github.com/streamlink/streamlink/actions?query=event%3Apush"><img alt="Build status" src="https://img.shields.io/github/actions/workflow/status/streamlink/streamlink/main.yml?branch=master&event=push&style=flat-square&maxAge=86400"></a>
    <a href="https://codecov.io/github/streamlink/streamlink?branch=master"><img alt="Overall code coverage" src="https://img.shields.io/codecov/c/github/streamlink/streamlink.svg?branch=master&style=flat-square&maxAge=86400"></a>
  </p>

  <p align="center">
    A Python library and command-line interface which pipes streams from various services into a video player.<br>
    Avoid resource-heavy and unoptimized websites, and still enjoy streamed content.
  </p>

  <p align="center">
    Streamlink was forked in 2016 from the abandoned <em>Livestreamer</em> project.
  </p>




  Please take a look at the documentation for different ways of installing Streamlink:

  - [Windows][streamlink-installation-windows]
  - [macOS][streamlink-installation-macos]
  - [Linux and BSD][streamlink-installation-linux-and-bsd]
  - [PyPI package and source code][streamlink-installation-pypi-source]




  Streamlink is built on top of a plugin system which allows support for new services to be added easily.

  Most of the popular streaming services are supported, such as:

  - [Twitch](https://www.twitch.tv)
  - [YouTube](https://www.youtube.com)
  - [Livestream](https://livestream.com)
  - [Dailymotion](https://www.dailymotion.com)

  ... and many more. A list of all plugins currently included can be found on the [plugins page][streamlink-plugins].




  After installing, simply run:

  ```sh
  streamlink "STREAMURL" best
  ```

  The default behavior of Streamlink is to play back streams in the [VLC player][player-vlc], but a lot of other options and output methods are available, such as writing the stream to the filesystem, reading stream metadata, etc.

  For more in-depth usage, please refer to the [CLI documentation][streamlink-documentation-cli].

  An [API guide][streamlink-documentation-apiguide] and [API reference][streamlink-documentation-apiref] is available for Python implementors of Streamlink.




  All contributions are welcome.
  Feel free to open a new thread on the issue tracker or submit a new pull request.
  Please read [CONTRIBUTING.md][contributing] first. Thanks!




  If you think that Streamlink is useful and if you want to keep the project alive, then please consider supporting its maintainers by sending a small and optionally recurring tip via the [available options][support].
  Your support is very much appreciated, thank you!


    [streamlink-installation-windows]: https://streamlink.github.io/install.html#windows
    [streamlink-installation-macos]: https://streamlink.github.io/install.html#macos
    [streamlink-installation-linux-and-bsd]: https://streamlink.github.io/install.html#linux-and-bsd
    [streamlink-installation-pypi-source]: https://streamlink.github.io/install.html#pypi-package-and-source-code
    [streamlink-documentation-cli]: https://streamlink.github.io/cli.html
    [streamlink-documentation-apiguide]: https://streamlink.github.io/api_guide.html
    [streamlink-documentation-apiref]: https://streamlink.github.io/api.html
    [streamlink-plugins]: https://streamlink.github.io/plugins.html
    [player-vlc]: https://www.videolan.org/vlc/
    [contributing]: https://github.com/streamlink/streamlink/blob/master/CONTRIBUTING.md
    [support]: https://streamlink.github.io/latest/donate.html


pkgId: cf4505e6ddcd7bce9d1d9015c07ec5ba2ee8c54319fb49728d0351e012765f4b
name: python-streamlit
arch: src
version: 1.21.0
epoch: 0
release: 1
summary: The fastest way to build data apps in Python
url: https://streamlit.io
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cc5238f5-05cc-4c88-bcd4-11de0cb7de81
location_href: 00009815-python-streamlit/python-streamlit-1.21.0-1.src.rpm
checksum_type: sha256
description:
  <br>

  <img src="https://user-images.githubusercontent.com/7164864/217935870-c0bc60a3-6fc0-4047-b011-7b4c59488c91.png" alt="Streamlit logo" style="margin-top:50px"></img>



  **A faster way to build and share data apps.**

  Streamlit lets you turn data scripts into shareable web apps in minutes, not weeks. It’s all Python, open-source, and free! And once you’ve created an app you can use our [Community Cloud platform](https://streamlit.io/cloud) to deploy, manage, and share your app.




  Open a terminal and run:

  ```bash
  $ pip install streamlit
  $ streamlit hello
  ```

  If this opens our sweet _Streamlit Hello_ app in your browser, you're all set! If not, head over to [our docs](https://docs.streamlit.io/library/get-started) for specific installs.

  The app features a bunch of examples of what you can do with Streamlit. Jump to the [quickstart](#quickstart) section to understand how that all works.

  <img src="https://user-images.githubusercontent.com/7164864/217936487-1017784e-68ec-4e0d-a7f6-6b97525ddf88.gif" alt="Streamlit Hello" width=500 href="none"></img>





  Create a new file `streamlit_app.py` with the following code:
  ```python
  import streamlit as st
  x = st.slider("Select a value")
  st.write(x, "squared is", x * x)
  ```

  Now run it to open the app!
  ```
  $ streamlit run streamlit_app.py
  ```

  <img src="https://user-images.githubusercontent.com/7164864/215172915-cf087c56-e7ae-449a-83a4-b5fa0328d954.gif" width=300 alt="Little example"></img>



  Streamlit comes in with [a ton of additional powerful elements](https://docs.streamlit.io/library/api-reference) to spice up your data apps and delight your viewers. Some examples:


  <table border="0">
     <tr>
       <td><img src="https://user-images.githubusercontent.com/7164864/217936099-12c16f8c-7fe4-44b1-889a-1ac9ee6a1b44.png" style="max-height:150; width:auto; display:block;"></td>
       <td><img src="https://user-images.githubusercontent.com/7164864/215110064-5eb4e294-8f30-4933-9563-0275230e52b5.gif"  style="max-height:150; width:auto; display:block;"></td>
       <td><img src="https://user-images.githubusercontent.com/7164864/215174472-bca8a0d7-cf4b-4268-9c3b-8c03dad50bcd.gif" style="max-height:150; width:auto; display:block;"></td>
       <td><img src="https://user-images.githubusercontent.com/7164864/217936149-a35c35be-0d96-4c63-8c6a-1c4b52aa8f60.png" style="max-height:150; width:auto; display:block;"></td>
       <td><img src="https://user-images.githubusercontent.com/7164864/215173883-eae0de69-7c1d-4d78-97d0-3bc1ab865e5b.gif" style="max-height:150; width:auto; display:block;"></td>
       <td><img src="https://user-images.githubusercontent.com/7164864/215109229-6ae9111f-e5c1-4f0b-b3a2-87a79268ccc9.gif" style="max-height:150; width:auto; display:block;"></td>

    </tr>
      <tr>
        <td>Input widgets</td>
        <td>Dataframes</td>
        <td>Charts</td>
        <td>Layout</td>
        <td>Multi-page apps</td>
        <td>Fun</td>
     </tr>
  <table>

  Our vibrant creators community also extends Streamlit capabilities using  🧩 [Streamlit Components](http://components.streamlit.app).



  There's so much you can build with Streamlit:
  - 🧬  [Science & technology apps](https://streamlit.io/gallery?category=science-technology)
  - 💬  [NLP & language apps](https://streamlit.io/gallery?category=nlp-language)
  - 👀  [Computer vision apps](https://streamlit.io/gallery?category=computer-vision-images)
  - 🏦  [Finance & business apps](https://streamlit.io/gallery?category=finance-business)
  - 🗺  [Geography & society apps](https://streamlit.io/gallery?category=geography-society)
  - and more!

  **Check out [our gallery!](https://streamlit.io/gallery)** 🎈



  Deploy, manage and share your apps for free using our [Community Cloud](https://streamlit.io/cloud)! Sign-up [here](https://share.streamlit.io/signup). <br><br>
  <img src="https://user-images.githubusercontent.com/7164864/214965336-64500db3-0d79-4a20-8052-2dda883902d2.gif" width="400"></img>



  - Streamlit [docs](https://docs.streamlit.io), [community forum](https://discuss.streamlit.io) and [blog](https://blog.streamlit.io).
  - Extend Streamlit's capabilities by installing or creating your own [Streamlit Components](http://components.streamlit.app/).
  - Help others find and play with your app by using the Streamlit GitHub badge in your repository:
  ```markdown
  [![Streamlit App](https://static.streamlit.io/badges/streamlit_badge_black_white.svg)](URL_TO_YOUR_APP)
  ```
  [![Streamlit App](https://static.streamlit.io/badges/streamlit_badge_black_white.svg)](https://share.streamlit.io/streamlit/roadmap)



  Streamlit is completely free and open-source and licensed under the [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0) license.


pkgId: f920e6a192c28c2f0522c306c97b9b78cb3cb9eedd7a3bdb92cf42a8b2d67ae2
name: python-strictyaml
arch: src
version: 1.6.2
epoch: 0
release: 1
summary: Strict, typed YAML parser
url: http://hitchdev.com/strictyaml
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4f37964a-fbbb-449d-91d4-90ff59a8ce30
location_href: 00005233-python-strictyaml/python-strictyaml-1.6.2-1.src.rpm
checksum_type: sha256
description:
  StrictYAML is a [type-safe](https://en.wikipedia.org/wiki/Type_safety) YAML parser
  that parses and validates a [restricted subset](https://hitchdev.com/strictyaml/features-removed) of the [YAML](https://hitchdev.com/strictyaml/what-is-yaml)
  specification.

  Priorities:

  - Beautiful API
  - Refusing to parse [the ugly, hard to read and insecure features of YAML](https://hitchdev.com/strictyaml/features-removed) like [the Norway problem](https://hitchdev.com/strictyaml/why/implicit-typing-removed).
  - Strict validation of markup and straightforward type casting.
  - Clear, readable exceptions with **code snippets** and **line numbers**.
  - Acting as a near-drop in replacement for pyyaml, ruamel.yaml or poyo.
  - Ability to read in YAML, make changes and write it out again with comments preserved.
  - [Not speed](https://hitchdev.com/strictyaml/why/speed-not-a-priority), currently.


  Simple example:

  ```yaml

  name: Ford Prefect
  age: 42
  possessions:
  - Towel

  ```


  ```python
  from strictyaml import load, Map, Str, Int, Seq, YAMLError

  ```





  Default parse result:


  ```python
  >>> load(yaml_snippet)
  YAML({'name': 'Ford Prefect', 'age': '42', 'possessions': ['Towel']})
  ```



  All data is string, list or OrderedDict:


  ```python
  >>> load(yaml_snippet).data
  {'name': 'Ford Prefect', 'age': '42', 'possessions': ['Towel']}
  ```



  Quickstart with schema:


  ```python
  from strictyaml import load, Map, Str, Int, Seq, YAMLError

  schema = Map({"name": Str(), "age": Int(), "possessions": Seq(Str())})

  ```





  42 is now parsed as an integer:


  ```python
  >>> person = load(yaml_snippet, schema)
  >>> person.data
  {'name': 'Ford Prefect', 'age': 42, 'possessions': ['Towel']}
  ```



  A YAMLError will be raised if there are syntactic problems, violations of your schema or use of disallowed YAML features:

  ```yaml

  name: Ford Prefect
  age: 42

  ```






  For example, a schema violation:


  ```python
  try:
      person = load(yaml_snippet, schema)
  except YAMLError as error:
      print(error)

  ```

  ```yaml
  while parsing a mapping
    in "<unicode string>", line 1, column 1:
      
       ^ (line: 1)
  required key(s) 'possessions' not found
    in "<unicode string>", line 3, column 1:
      age: '42'
      ^ (line: 3)
  ```





  If parsed correctly:


  ```python
  from strictyaml import load, Map, Str, Int, Seq, YAMLError, as_document

  schema = Map({"name": Str(), "age": Int(), "possessions": Seq(Str())})

  ```





  You can modify values and write out the YAML with comments preserved:


  ```python
  person = load(yaml_snippet, schema)
  person['age'] = 43
  print(person.as_yaml())

  ```

  ```yaml

  name: Ford Prefect
  age: 43
  possessions:
  - Towel
  ```





  As well as look up line numbers:


  ```python
  >>> person = load(yaml_snippet, schema)
  >>> person['possessions'][0].start_line
  5
  ```



  And construct YAML documents from dicts or lists:


  ```python
  print(as_document({"x": 1}).as_yaml())

  ```

  ```yaml
  x: 1
  ```









  ```sh
  $ pip install strictyaml
  ```




  There are a number of formats and approaches that can achieve more or
  less the same purpose as StrictYAML. I've tried to make it the best one.
  Below is a series of documented justifications:

  - [Why avoid using environment variables as configuration?](https://hitchdev.com/strictyaml/why-not/environment-variables-as-config)
  - [Why not use HJSON?](https://hitchdev.com/strictyaml/why-not/hjson)
  - [Why not HOCON?](https://hitchdev.com/strictyaml/why-not/hocon)
  - [Why not use INI files?](https://hitchdev.com/strictyaml/why-not/ini)
  - [Why not use JSON Schema for validation?](https://hitchdev.com/strictyaml/why-not/json-schema)
  - [Why not JSON for simple configuration files?](https://hitchdev.com/strictyaml/why-not/json)
  - [Why not JSON5?](https://hitchdev.com/strictyaml/why-not/json5)
  - [Why not use the YAML 1.2 standard? - we don't need a new standard!](https://hitchdev.com/strictyaml/why-not/ordinary-yaml)
  - [Why not use kwalify with standard YAML to validate my YAML?](https://hitchdev.com/strictyaml/why-not/pykwalify)
  - [Why not use Python's schema library (or similar) for validation?](https://hitchdev.com/strictyaml/why-not/python-schema)
  - [Why not use SDLang?](https://hitchdev.com/strictyaml/why-not/sdlang)
  - [What is wrong with TOML?](https://hitchdev.com/strictyaml/why-not/toml)
  - [Why shouldn't I just use Python code for configuration?](https://hitchdev.com/strictyaml/why-not/turing-complete-code)
  - [Why not use XML for configuration or DSLs?](https://hitchdev.com/strictyaml/why-not/xml)





  How to:

  - [Build a YAML document from scratch in code](https://hitchdev.com/strictyaml/using/alpha/howto/build-yaml-document)
  - [Either/or schema validation of different, equally valid different kinds of YAML](https://hitchdev.com/strictyaml/using/alpha/howto/either-or-validation)
  - [Labeling exceptions](https://hitchdev.com/strictyaml/using/alpha/howto/label-exceptions)
  - [Merge YAML documents](https://hitchdev.com/strictyaml/using/alpha/howto/merge-yaml-documents)
  - [Revalidate an already validated document](https://hitchdev.com/strictyaml/using/alpha/howto/revalidation)
  - [Reading in YAML, editing it and writing it back out](https://hitchdev.com/strictyaml/using/alpha/howto/roundtripping)
  - [Get line numbers of YAML elements](https://hitchdev.com/strictyaml/using/alpha/howto/what-line)
  - [Parsing YAML without a schema](https://hitchdev.com/strictyaml/using/alpha/howto/without-a-schema)


  Compound validators:

  - [Fixed length sequences (FixedSeq)](https://hitchdev.com/strictyaml/using/alpha/compound/fixed-length-sequences)
  - [Mappings combining defined and undefined keys (MapCombined)](https://hitchdev.com/strictyaml/using/alpha/compound/map-combined)
  - [Mappings with arbitrary key names (MapPattern)](https://hitchdev.com/strictyaml/using/alpha/compound/map-pattern)
  - [Mapping with defined keys and a custom key validator (Map)](https://hitchdev.com/strictyaml/using/alpha/compound/mapping-with-slug-keys)
  - [Using a YAML object of a parsed mapping](https://hitchdev.com/strictyaml/using/alpha/compound/mapping-yaml-object)
  - [Mappings with defined keys (Map)](https://hitchdev.com/strictyaml/using/alpha/compound/mapping)
  - [Optional keys with defaults (Map/Optional)](https://hitchdev.com/strictyaml/using/alpha/compound/optional-keys-with-defaults)
  - [Validating optional keys in mappings (Map)](https://hitchdev.com/strictyaml/using/alpha/compound/optional-keys)
  - [Sequences of unique items (UniqueSeq)](https://hitchdev.com/strictyaml/using/alpha/compound/sequences-of-unique-items)
  - [Sequence/list validator (Seq)](https://hitchdev.com/strictyaml/using/alpha/compound/sequences)
  - [Updating document with a schema](https://hitchdev.com/strictyaml/using/alpha/compound/update)


  Scalar validators:

  - [Boolean (Bool)](https://hitchdev.com/strictyaml/using/alpha/scalar/boolean)
  - [Parsing comma separated items (CommaSeparated)](https://hitchdev.com/strictyaml/using/alpha/scalar/comma-separated)
  - [Datetimes (Datetime)](https://hitchdev.com/strictyaml/using/alpha/scalar/datetime)
  - [Decimal numbers (Decimal)](https://hitchdev.com/strictyaml/using/alpha/scalar/decimal)
  - [Email and URL validators](https://hitchdev.com/strictyaml/using/alpha/scalar/email-and-url)
  - [Empty key validation](https://hitchdev.com/strictyaml/using/alpha/scalar/empty)
  - [Enumerated scalars (Enum)](https://hitchdev.com/strictyaml/using/alpha/scalar/enum)
  - [Floating point numbers (Float)](https://hitchdev.com/strictyaml/using/alpha/scalar/float)
  - [Hexadecimal Integers (HexInt)](https://hitchdev.com/strictyaml/using/alpha/scalar/hexadecimal-integer)
  - [Integers (Int)](https://hitchdev.com/strictyaml/using/alpha/scalar/integer)
  - [Validating strings with regexes (Regex)](https://hitchdev.com/strictyaml/using/alpha/scalar/regular-expressions)
  - [Parsing strings (Str)](https://hitchdev.com/strictyaml/using/alpha/scalar/string)


  Restrictions:

  - [Disallowed YAML](https://hitchdev.com/strictyaml/using/alpha/restrictions/disallowed-yaml)
  - [Duplicate keys](https://hitchdev.com/strictyaml/using/alpha/restrictions/duplicate-keys)
  - [Dirty load](https://hitchdev.com/strictyaml/using/alpha/restrictions/loading-dirty-yaml)





  There are some design decisions in StrictYAML which are controversial
  and/or not obvious. Those are documented here:

  - [What is wrong with duplicate keys?](https://hitchdev.com/strictyaml/why/duplicate-keys-disallowed)
  - [What is wrong with explicit tags?](https://hitchdev.com/strictyaml/why/explicit-tags-removed)
  - [What is wrong with flow-style YAML?](https://hitchdev.com/strictyaml/why/flow-style-removed)
  - [The Norway Problem - why StrictYAML refuses to do implicit typing and so should you](https://hitchdev.com/strictyaml/why/implicit-typing-removed)
  - [What is wrong with node anchors and references?](https://hitchdev.com/strictyaml/why/node-anchors-and-references-removed)
  - [Why does StrictYAML not parse direct representations of Python objects?](https://hitchdev.com/strictyaml/why/not-parse-direct-representations-of-python-objects)
  - [Why does StrictYAML only parse from strings and not files?](https://hitchdev.com/strictyaml/why/only-parse-strings-not-files)
  - [Why is parsing speed not a high priority for StrictYAML?](https://hitchdev.com/strictyaml/why/speed-not-a-priority)
  - [What is syntax typing?](https://hitchdev.com/strictyaml/why/syntax-typing-bad)
  - [Why does StrictYAML make you define a schema in Python - a Turing-complete language?](https://hitchdev.com/strictyaml/why/turing-complete-schema)





  - @wwoods
  - @chrisburr
  - @jnichols0



  - @eulores
  - @WaltWoods
  - @ChristopherGS
  - @gvx
  - @AlexandreDecan
  - @lots0logs
  - @tobbez
  - @jaredsampson
  - @BoboTIG

  StrictYAML also includes code from [ruamel.yaml](https://yaml.readthedocs.io/en/latest/), Copyright Anthon van der Neut.



  - Before writing any code, please read the tutorial on [contributing to hitchdev libraries](https://hitchdev.com/approach/contributing-to-hitch-libraries/).
  - Before writing any code, if you're proposing a new feature, please raise it on github. If it's an existing feature / bug, please comment and briefly describe how you're going to implement it.
  - All code needs to come accompanied with a story that exercises it or a modification to an existing story. This is used both to test the code and build the documentation.


pkgId: 217d38e55d691ae0f7b415f79211bc9125d78dbe434c642851eff709367c9aa3
name: python-stringcase
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: String case converter.
url: https://github.com/okunishinishi/python-stringcase
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-43ec21dc-c66e-4dec-b734-3af2385863de
location_href: 00009300-python-stringcase/python-stringcase-1.2.0-1.src.rpm
checksum_type: sha256
description:
  Convert string cases between camel case, pascal case, snake case etc...
  |build_status_badge| |coverage_badge| |pypi_version_badge|


pkgId: 3b5c770868ccbaefcf738f3745a5a3b269f583ed8470d655c0173a16b00668f9
name: python-strip-hints
arch: src
version: 0.1.10
epoch: 0
release: 1
summary: Function and command-line program to strip Python type hints.
url: https://github.com/abarker/strip-hints
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f2903bd5-c3f2-4911-8a2a-71589420d579
location_href: 00009723-python-strip-hints/python-strip-hints-0.1.10-1.src.rpm
checksum_type: sha256
description:
  This package provides a command-line command and a corresponding importable
  function that strips type hints from Python code files.  The stripping process
  leaves runnable code, assuming the rest of the code is runnable in the
  interpreter version.  The program tries to make as few changes as possible to
  the processed code so that line and column numbers in error messages for the
  processed code file also correspond to those for the original code file.  In
  most cases, with the default options, both the line and column numbers are
  preserved.
  This program was originally written to strip hints from Python 2 code to allow
  for developing such code on Python 3 but running it with Python 2.  Since
  Python 2 is no longer maintained the program is no longer tested when run with
  Python 2 (but it probably still works).
  This project also contains a general-purpose class named ``TokenList`` which
  allows lists of Python tokens to be operated on using an interface similar to
  that of Python strings.  In particular, a ``split`` method is used for much of
  the processing in stripping hints.  This module could be useful for doing other
  things with Python at the token level.


pkgId: 40f61433fe57941cf2d2b879d8d26b1ee3b2f42264de94b9c9db4c5e672a2827
name: python-strsim
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: A library implementing different string similarity and distance measures
url: https://github.com/luozhouyang/python-string-similarity
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-56d0063b-8baa-48e0-a8ed-d83307914c57
location_href: 00011583-python-strsim/python-strsim-0.0.3-1.src.rpm
checksum_type: sha256
description:
  **Python3.5 implementation of [tdebatty/java-string-similarity](https://github.com/tdebatty/java-string-similarity)**


  A library implementing different string similarity and distance measures. A dozen of algorithms (including Levenshtein edit distance and sibblings, Jaro-Winkler, Longest Common Subsequence, cosine similarity etc.) are currently implemented. Check the summary table below for the complete list...

  * [Download](#download)
  * [Overview](#overview)
  * [Normalized, metric, similarity and distance](#normalized-metric-similarity-and-distance)
  * [Shingles (n-gram) based similarity and distance](#shingles-n-gram-based-similarity-and-distance)
  * [Levenshtein](#levenshtein)
  * [Normalized Levenshtein](#normalized-levenshtein)
  * [Weighted Levenshtein](#weighted-levenshtein)
  * [Damerau-Levenshtein](#damerau-levenshtein)
  * [Optimal String Alignment](#optimal-string-alignment)
  * [Jaro-Winkler](#jaro-winkler)
  * [Longest Common Subsequence](#longest-common-subsequence)
  * [Metric Longest Common Subsequence](#metric-longest-common-subsequence)
  * [N-Gram](#n-gram)
  * [Shingle (n-gram) based algorithms](#shingle-n-gram-based-algorithms)
    * [Q-Gram](#shingle-n-gram-based-algorithms)
    * [Cosine similarity](#shingle-n-gram-based-algorithms)
    * [Jaccard index](#shingle-n-gram-based-algorithms)
    * [Sorensen-Dice coefficient](#shingle-n-gram-based-algorithms)
  * [Experimental](#experimental)
    * [SIFT4](#sift4)
  * [Users](#users)




  From pypi:

  ```bash
  pip install strsim
  ```

  or clone this repository:

  ```bash
  git clone https://github.com/luozhouyang/python-string-similarity
  cd python-string-similarity
  pip install -r requirements.txt
  ```



  The main characteristics of each implemented algorithm are presented below. The "cost" column gives an estimation of the computational cost to compute the similarity between two strings of length m and n respectively.

  |  									|  						| Normalized? 	| Metric?	| Type    | Cost | Typical usage |
  | --------					|-------			|-------------	|-------- | ------  | ---- | ---   |
  | [Levenshtein](#levenshtein)		|distance 				| No 			| Yes 		|         | O(m*n) <sup>1</sup> |  |
  | [Normalized Levenshtein](#normalized-levenshtein)	|distance<br>similarity	| Yes 			| No 		| 	      | O(m*n) <sup>1</sup> |  |
  | [Weighted Levenshtein](#weighted-levenshtein)		|distance 				| No 			| No 		| 	      | O(m*n) <sup>1</sup> | OCR |
  | [Damerau-Levenshtein](#damerau-levenshtein) <sup>3</sup> 	|distance 				| No 			| Yes 		| 	      | O(m*n) <sup>1</sup> |  |
  | [Optimal String Alignment](#optimal-string-alignment) <sup>3</sup> |distance | No 			| No 		| 	      | O(m*n) <sup>1</sup> |  |
  | [Jaro-Winkler](#jaro-winkler) 		|similarity<br>distance	| Yes  			| No 		| 	      | O(m*n) | typo correction |
  | [Longest Common Subsequence](#longest-common-subsequence) 		|distance 				| No 			| No 		| 	      | O(m*n) <sup>1,2</sup> | diff utility, GIT reconciliation |
  | [Metric Longest Common Subsequence](#metric-longest-common-subsequence) |distance   			| Yes 			| Yes  		| 	      | O(m*n) <sup>1,2</sup> |  |
  | [N-Gram](#n-gram)	 				|distance				| Yes  			| No 		| 	      | O(m*n) |  |
  | [Q-Gram](#q-gram) 				|distance  			 	| No  			| No 		| Profile | O(m+n) |  |
  | [Cosine similarity](#cosine-similarity) 				|similarity<br>distance | Yes  			| No  		| Profile | O(m+n) |  |
  | [Jaccard index](#jaccard-index)				|similarity<br>distance | Yes  			| Yes  		| Set	  | O(m+n) |  |
  | [Sorensen-Dice coefficient](#sorensen-dice-coefficient) 	|similarity<br>distance | Yes 			| No 		| Set	  | O(m+n) |  |

  [1] In this library, Levenshtein edit distance, LCS distance and their sibblings are computed using the **dynamic programming** method, which has a cost O(m.n). For Levenshtein distance, the algorithm is sometimes called **Wagner-Fischer algorithm** ("The string-to-string correction problem", 1974). The original algorithm uses a matrix of size m x n to store the Levenshtein distance between string prefixes.

  If the alphabet is finite, it is possible to use the **method of four russians** (Arlazarov et al. "On economic construction of the transitive closure of a directed graph", 1970) to speedup computation. This was published by Masek in 1980 ("A Faster Algorithm Computing String Edit Distances"). This method splits the matrix in blocks of size t x t. Each possible block is precomputed to produce a lookup table. This lookup table can then be used to compute the string similarity (or distance) in O(nm/t). Usually, t is choosen as log(m) if m > n. The resulting computation cost is thus O(mn/log(m)). This method has not been implemented (yet).

  [2] In "Length of Maximal Common Subsequences", K.S. Larsen proposed an algorithm that computes the length of LCS in time O(log(m).log(n)). But the algorithm has a memory requirement O(m.n²) and was thus not implemented here.

  [3] There are two variants of Damerau-Levenshtein string distance: Damerau-Levenshtein with adjacent transpositions (also sometimes called unrestricted Damerau–Levenshtein distance) and Optimal String Alignment (also sometimes called restricted edit distance). For Optimal String Alignment, no substring can be edited more than once.


  Although the topic might seem simple, a lot of different algorithms exist to measure text similarity or distance. Therefore the library defines some interfaces to categorize them.



  - StringSimilarity : Implementing algorithms define a similarity between strings (0 means strings are completely different).
  - NormalizedStringSimilarity : Implementing algorithms define a similarity between 0.0 and 1.0, like Jaro-Winkler for example.
  - StringDistance : Implementing algorithms define a distance between strings (0 means strings are identical), like Levenshtein for example. The maximum distance value depends on the algorithm.
  - NormalizedStringDistance : This interface extends StringDistance. For implementing classes, the computed distance value is between 0.0 and 1.0. NormalizedLevenshtein is an example of NormalizedStringDistance.

  Generally, algorithms that implement NormalizedStringSimilarity also implement NormalizedStringDistance, and similarity = 1 - distance. But there are a few exceptions, like N-Gram similarity and distance (Kondrak)...


  The MetricStringDistance interface : A few of the distances are actually metric distances, which means that verify the triangle inequality d(x, y) <= d(x,z) + d(z,y). For example, Levenshtein is a metric distance, but NormalizedLevenshtein is not.

  A lot of nearest-neighbor search algorithms and indexing structures rely on the triangle inequality.


  A few algorithms work by converting strings into sets of n-grams (sequences of n characters, also sometimes called k-shingles). The similarity or distance between the strings is then the similarity or distance between the sets.

  Some of them, like jaccard, consider strings as sets of shingles, and don't consider the number of occurences of each shingle. Others, like cosine similarity, work using what is sometimes called the profile of the strings, which takes into account the number of occurences of each shingle.

  For these algorithms, another use case is possible when dealing with large datasets:
  1. compute the set or profile representation of all the strings
  2. compute the similarity between sets or profiles


  The Levenshtein distance between two words is the minimum number of single-character edits (insertions, deletions or substitutions) required to change one word into the other.

  It is a metric string distance. This implementation uses dynamic programming (Wagner–Fischer algorithm), with only 2 rows of data. The space requirement is thus O(m) and the algorithm runs in O(m.n).

  ```python
  from similarity.levenshtein import Levenshtein

  levenshtein = Levenshtein()
  print(levenshtein.distance('My string', 'My $string'))
  print(levenshtein.distance('My string', 'My $string'))
  print(levenshtein.distance('My string', 'My $string'))

  ```



  This distance is computed as levenshtein distance divided by the length of the longest string. The resulting value is always in the interval [0.0 1.0] but it is not a metric anymore!

  The similarity is computed as 1 - normalized distance.

  ```python
  from similarity.normalized_levenshtein import NormalizedLevenshtein

  normalized_levenshtein = NormalizedLevenshtein()
  print(normalized_levenshtein.distance('My string', 'My $string'))
  print(normalized_levenshtein.distance('My string', 'My $string'))
  print(normalized_levenshtein.distance('My string', 'My $string'))

  print(normalized_levenshtein.similarity('My string', 'My $string'))
  print(normalized_levenshtein.similarity('My string', 'My $string'))
  print(normalized_levenshtein.similarity('My string', 'My $string'))

  ```


  An implementation of Levenshtein that allows to define different weights for different character substitutions.

  This algorithm is usually used for optical character recognition (OCR) applications. For OCR, the cost of substituting P and R is lower then the cost of substituting P and M for example because because from and OCR point of view P is similar to R.

  It can also be used for keyboard typing auto-correction. Here the cost of substituting E and R is lower for example because these are located next to each other on an AZERTY or QWERTY keyboard. Hence the probability that the user mistyped the characters is higher.

  ```python
  from similarity.weighted_levenshtein import WeightedLevenshtein
  from similarity.weighted_levenshtein import CharacterSubstitutionInterface

  class CharacterSubstitution(CharacterSubstitutionInterface):
      def cost(self, c0, c1):
          if c0=='t' and c1=='r':
              return 0.5
          return 1.0

  weighted_levenshtein = WeightedLevenshtein(CharacterSubstitution())
  print(weighted_levenshtein.distance('String1', 'String2'))

  ```


  Similar to Levenshtein, Damerau-Levenshtein distance with transposition (also sometimes calls unrestricted Damerau-Levenshtein distance) is the minimum number of operations needed to transform one string into the other, where an operation is defined as an insertion, deletion, or substitution of a single character, or a **transposition of two adjacent characters**.

  It does respect triangle inequality, and is thus a metric distance.

  This is not to be confused with the optimal string alignment distance, which is an extension where no substring can be edited more than once.

  ```python
  from similarity.damerau import Damerau

  damerau = Damerau()
  print(damerau.distance('ABCDEF', 'ABDCEF'))
  print(damerau.distance('ABCDEF', 'BACDFE'))
  print(damerau.distance('ABCDEF', 'ABCDE'))
  print(damerau.distance('ABCDEF', 'BCDEF'))
  print(damerau.distance('ABCDEF', 'ABCGDEF'))
  print(damerau.distance('ABCDEF', 'POIU'))

  ```

  Will produce:

  ```
  1.0
  2.0
  1.0
  1.0
  1.0
  6.0
  ```


  The Optimal String Alignment variant of Damerau–Levenshtein (sometimes called the restricted edit distance) computes the number of edit operations needed to make the strings equal under the condition that **no substring is edited more than once**, whereas the true Damerau–Levenshtein presents no such restriction.
  The difference from the algorithm for Levenshtein distance is the addition of one recurrence for the transposition operations.

  Note that for the optimal string alignment distance, the triangle inequality does not hold and so it is not a true metric.

  ```python
  from similarity.optimal_string_alignment import OptimalStringAlignment

  optimal_string_alignment = OptimalStringAlignment()
  print(optimal_string_alignment.distance('CA', 'ABC'))

  ```

  Will produce:

  ```
  3.0
  ```


  Jaro-Winkler is a string edit distance that was developed in the area of record linkage (duplicate detection) (Winkler, 1990). The Jaro–Winkler distance metric is designed and best suited for short strings such as person names, and to detect typos.

  Jaro-Winkler computes the similarity between 2 strings, and the returned value lies in the interval [0.0, 1.0].
  It is (roughly) a variation of Damerau-Levenshtein, where the substitution of 2 close characters is considered less important then the substitution of 2 characters that a far from each other.

  The distance is computed as 1 - Jaro-Winkler similarity.

  ```python
  from similarity.jarowinkler import JaroWinkler

  jarowinkler = JaroWinkler()
  print(jarowinkler.similarity('My string', 'My tsring'))
  print(jarowinkler.similarity('My string', 'My ntrisg'))

  ```

  will produce:

  ```
  0.9740740740740741
  0.8962962962962963
  ```



  The longest common subsequence (LCS) problem consists in finding the longest subsequence common to two (or more) sequences. It differs from problems of finding common substrings: unlike substrings, subsequences are not required to occupy consecutive positions within the original sequences.

  It is used by the diff utility, by Git for reconciling multiple changes, etc.

  The LCS distance between strings X (of length n) and Y (of length m) is n + m - 2 |LCS(X, Y)|
  min = 0
  max = n + m

  LCS distance is equivalent to Levenshtein distance when only insertion and deletion is allowed (no substitution), or when the cost of the substitution is the double of the cost of an insertion or deletion.

  This class implements the dynamic programming approach, which has a space requirement O(m.n), and computation cost O(m.n).

  In "Length of Maximal Common Subsequences", K.S. Larsen proposed an algorithm that computes the length of LCS in time O(log(m).log(n)). But the algorithm has a memory requirement O(m.n²) and was thus not implemented here.

  ```python
  from similarity.longest_common_subsequence import LongestCommonSubsequence

  lcs = LongestCommonSubsequence()

  print(lcs.distance('AGCAT', 'GAC'))

  print(lcs.distance('AGCAT', 'AGCT'))

  ```


  Distance metric based on Longest Common Subsequence, from the notes "An LCS-based string metric" by Daniel Bakkelund.
  http://heim.ifi.uio.no/~danielry/StringMetric.pdf

  The distance is computed as 1 - |LCS(s1, s2)| / max(|s1|, |s2|)

  ```python
  from similarity.metric_lcs import MetricLCS

  metric_lcs = MetricLCS()
  s1 = 'ABCDEFG'
  s2 = 'ABCDEFHJKL'




  print(metric_lcs.distance(s1, s2))




  print(metric_lcs.distance('ABDEF', 'ABDIF'))

  ```

  will produce:

  ```
  0.4
  0.19999999999999996
  ```




  Normalized N-Gram distance as defined by Kondrak, "N-Gram Similarity and Distance", String Processing and Information Retrieval, Lecture Notes in Computer Science Volume 3772, 2005, pp 115-126.

  http://webdocs.cs.ualberta.ca/~kondrak/papers/spire05.pdf

  The algorithm uses affixing with special character '\n' to increase the weight of first characters. The normalization is achieved by dividing the total similarity score the original length of the longest word.

  In the paper, Kondrak also defines a similarity measure, which is not implemented (yet).

  ```python
  from similarity.ngram import NGram

  twogram = NGram(2)
  print(twogram.distance('ABCD', 'ABTUIO'))

  s1 = 'Adobe CreativeSuite 5 Master Collection from cheap 4zp'
  s2 = 'Adobe CreativeSuite 5 Master Collection from cheap d1x'
  fourgram = NGram(4)
  print(fourgram.distance(s1, s2))

  ```


  A few algorithms work by converting strings into sets of n-grams (sequences of n characters, also sometimes called k-shingles). The similarity or distance between the strings is then the similarity or distance between the sets.

  The cost for computing these similarities and distances is mainly domnitated by k-shingling (converting the strings into sequences of k characters). Therefore there are typically two use cases for these algorithms:

  Directly compute the distance between strings:

  ```python
  from similarity.qgram import QGram

  qgram = QGram(2)
  print(qgram.distance('ABCD', 'ABCE'))

  ```

  Or, for large datasets, pre-compute the profile of all strings. The similarity can then be computed between profiles:

  ```python
  from similarity.cosine import Cosine

  cosine = Cosine(2)
  s0 = 'My first string'
  s1 = 'My other string...'
  p0 = cosine.get_profile(s0)
  p1 = cosine.get_profile(s1)
  print(cosine.similarity_profiles(p0, p1))

  ```

  Pay attention, this only works if the same KShingling object is used to parse all input strings !



  Q-gram distance, as defined by Ukkonen in "Approximate string-matching with q-grams and maximal matches"
  http://www.sciencedirect.com/science/article/pii/0304397592901434

  The distance between two strings is defined as the L1 norm of the difference of their profiles (the number of occurences of each n-gram): SUM( |V1_i - V2_i| ). Q-gram distance is a lower bound on Levenshtein distance, but can be computed in O(m + n), where Levenshtein requires O(m.n)



  The similarity between the two strings is the cosine of the angle between these two vectors representation, and is computed as V1 . V2 / (|V1| * |V2|)

  Distance is computed as 1 - cosine similarity.


  Like Q-Gram distance, the input strings are first converted into sets of n-grams (sequences of n characters, also called k-shingles), but this time the cardinality of each n-gram is not taken into account. Each input string is simply a set of n-grams. The Jaccard index is then computed as |V1 inter V2| / |V1 union V2|.

  Distance is computed as 1 - similarity.
  Jaccard index is a metric distance.


  Similar to Jaccard index, but this time the similarity is computed as 2 * |V1 inter V2| / (|V1| + |V2|).

  Distance is computed as 1 - similarity.




  SIFT4 is a general purpose string distance algorithm inspired by JaroWinkler and Longest Common Subsequence. It was developed to produce a distance measure that matches as close as possible to the human perception of string distance. Hence it takes into account elements like character substitution, character distance, longest common subsequence etc. It was developed using experimental testing, and without theoretical background.

  **Not implemented yet**




  * [StringSimilarity.NET](https://github.com/feature23/StringSimilarity.NET) a .NET port of java-string-similarity

  Use java-string-similarity in your project and want it to be mentioned here? Don't hesitate to drop me a line!


