# packages

pkgId: b7f0953ad039f8fb578d83003ea44899d762c2d3b7ab162773680786e35f929a
name: python-pydata-google-auth
arch: src
version: 1.7.0
epoch: 0
release: 1
summary: PyData helpers for authenticating to Google APIs
url: https://github.com/pydata/pydata-google-auth
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1d9e6ca2-6967-4bfc-98b2-2c7c30e04edc
location_href: 00009095-python-pydata-google-auth/python-pydata-google-auth-1.7.0-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Version Status| |Coverage Status|
  **pydata-google-auth** is a package providing helpers for authenticating to Google APIs.


pkgId: 6692fca295c2c9e3a0cedccea5f1abdde8ed627c44aca27e0c08aa16481ce2a4
name: python-pydeequ
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: PyDeequ - Unit Tests for Data
url: https://pydeequ.readthedocs.io
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ae061658-f8fa-46c0-b682-216a74bcc790
location_href: 00009711-python-pydeequ/python-pydeequ-1.0.1-1.src.rpm
checksum_type: sha256
description:
  PyDeequ is a Python API for [Deequ](https://github.com/awslabs/deequ), a library built on top of Apache Spark for defining "unit tests for data", which measure data quality in large datasets. PyDeequ is written to support usage of Deequ in Python.

  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0) ![Coverage](https://img.shields.io/badge/coverage-90%25-green)

  There are 4 main components of Deequ, and they are:
  - Metrics Computation:
      - `Profiles` leverages Analyzers to analyze each column of a dataset.
      - `Analyzers` serve here as a foundational module that computes metrics for data profiling and validation at scale.
  - Constraint Suggestion:
      - Specify rules for various groups of Analyzers to be run over a dataset to return back a collection of constraints suggested to run in a Verification Suite.
  - Constraint Verification:
      - Perform data validation on a dataset with respect to various constraints set by you.
  - Metrics Repository
      - Allows for persistence and tracking of Deequ runs over time.

  ![](imgs/pydeequ_architecture.jpg)


  - With PyDeequ v0.1.8+, we now officially support Spark3 ! Just make sure you have an environment variable `SPARK_VERSION` to specify your Spark version!
  - We've release a blogpost on integrating PyDeequ onto AWS leveraging services such as AWS Glue, Athena, and SageMaker! Check it out: [Monitor data quality in your data lake using PyDeequ and AWS Glue](https://aws.amazon.com/blogs/big-data/monitor-data-quality-in-your-data-lake-using-pydeequ-and-aws-glue/).
  - Check out the [PyDeequ Release Announcement Blogpost](https://aws.amazon.com/blogs/big-data/testing-data-quality-at-scale-with-pydeequ/) with a tutorial walkthrough the Amazon Reviews dataset!
  - Join the PyDeequ community on [PyDeequ Slack](https://join.slack.com/t/pydeequ/shared_invite/zt-te6bntpu-yaqPy7bhiN8Lu0NxpZs47Q) to chat with the devs!



  The following will quickstart you with some basic usage. For more in-depth examples, take a look in the [`tutorials/`](tutorials/) directory for executable Jupyter notebooks of each module. For documentation on supported interfaces, view the [`documentation`](https://pydeequ.readthedocs.io/).



  You can install [PyDeequ via pip](https://pypi.org/project/pydeequ/).

  ```
  pip install pydeequ
  ```


  ```python
  from pyspark.sql import SparkSession, Row
  import pydeequ

  spark = (SparkSession
      .builder
      .config("spark.jars.packages", pydeequ.deequ_maven_coord)
      .config("spark.jars.excludes", pydeequ.f2j_maven_coord)
      .getOrCreate())

  df = spark.sparkContext.parallelize([
              Row(a="foo", b=1, c=5),
              Row(a="bar", b=2, c=6),
              Row(a="baz", b=3, c=None)]).toDF()
  ```



  ```python
  from pydeequ.analyzers import *

  analysisResult = AnalysisRunner(spark) \
                      .onData(df) \
                      .addAnalyzer(Size()) \
                      .addAnalyzer(Completeness("b")) \
                      .run()

  analysisResult_df = AnalyzerContext.successMetricsAsDataFrame(spark, analysisResult)
  analysisResult_df.show()
  ```



  ```python
  from pydeequ.profiles import *

  result = ColumnProfilerRunner(spark) \
      .onData(df) \
      .run()

  for col, profile in result.profiles.items():
      print(profile)
  ```



  ```python
  from pydeequ.suggestions import *

  suggestionResult = ConstraintSuggestionRunner(spark) \
               .onData(df) \
               .addConstraintRule(DEFAULT()) \
               .run()


  print(suggestionResult)
  ```



  ```python
  from pydeequ.checks import *
  from pydeequ.verification import *

  check = Check(spark, CheckLevel.Warning, "Review Check")

  checkResult = VerificationSuite(spark) \
      .onData(df) \
      .addCheck(
          check.hasSize(lambda x: x >= 3) \
          .hasMin("b", lambda x: x == 0) \
          .isComplete("c")  \
          .isUnique("a")  \
          .isContainedIn("a", ["foo", "bar", "baz"]) \
          .isNonNegative("b")) \
      .run()

  checkResult_df = VerificationResult.checkResultsAsDataFrame(spark, checkResult)
  checkResult_df.show()
  ```



  Save to a Metrics Repository by adding the `useRepository()` and `saveOrAppendResult()` calls to your Analysis Runner.
  ```python
  from pydeequ.repository import *
  from pydeequ.analyzers import *

  metrics_file = FileSystemMetricsRepository.helper_metrics_file(spark, 'metrics.json')
  repository = FileSystemMetricsRepository(spark, metrics_file)
  key_tags = {'tag': 'pydeequ hello world'}
  resultKey = ResultKey(spark, ResultKey.current_milli_time(), key_tags)

  analysisResult = AnalysisRunner(spark) \
      .onData(df) \
      .addAnalyzer(ApproxCountDistinct('b')) \
      .useRepository(repository) \
      .saveOrAppendResult(resultKey) \
      .run()
  ```

  To load previous runs, use the `repository` object to load previous results back in.

  ```python
  result_metrep_df = repository.load() \
      .before(ResultKey.current_milli_time()) \
      .forAnalyzers([ApproxCountDistinct('b')]) \
      .getSuccessMetricsAsDataFrame()
  ```


  Please refer to the [contributing doc](https://github.com/awslabs/python-deequ/blob/master/CONTRIBUTING.md) for how to contribute to PyDeequ.



  This library is licensed under the Apache 2.0 License.

  ******



  1. Setup [SDKMAN](#setup-sdkman)
  1. Setup [Java](#setup-java)
  1. Setup [Apache Spark](#setup-apache-spark)
  1. Install [Poetry](#poetry)
  1. Run [tests locally](#running-tests-locally)



  SDKMAN is a tool for managing parallel Versions of multiple Software Development Kits on any Unix based
  system. It provides a convenient command line interface for installing, switching, removing and listing
  Candidates. SDKMAN! installs smoothly on Mac OSX, Linux, WSL, Cygwin, etc... Support Bash and ZSH shells. See
  documentation on the [SDKMAN! website](https://sdkman.io).

  Open your favourite terminal and enter the following:

  ```bash
  $ curl -s https://get.sdkman.io | bash
  If the environment needs tweaking for SDKMAN to be installed,
  the installer will prompt you accordingly and ask you to restart.

  Next, open a new terminal or enter:

  $ source "$HOME/.sdkman/bin/sdkman-init.sh"

  Lastly, run the following code snippet to ensure that installation succeeded:

  $ sdk version
  ```



  Install Java Now open favourite terminal and enter the following:

  ```bash
  List the AdoptOpenJDK OpenJDK versions
  $ sdk list java

  To install For Java 11
  $ sdk install java 11.0.10.hs-adpt

  To install For Java 11
  $ sdk install java 8.0.292.hs-adpt
  ```



  Install Java Now open favourite terminal and enter the following:

  ```bash
  List the Apache Spark versions:
  $ sdk list spark

  To install For Spark 3
  $ sdk install spark 3.0.2
  ```



  Poetry [Commands](https://python-poetry.org/docs/cli/#search)

  ```bash
  poetry install

  poetry update




  poetry show -o
  ```



  Take a look at tests in `tests/dataquality` and `tests/jobs`

  ```bash
  $ poetry run pytest
  ```


pkgId: cc404486d37b92451efd32a9a74b4e29aa54bcc3c959b0d4ab1c5573d6d10dab
name: python-pydenticon
arch: src
version: 0.3.1
epoch: 0
release: 1
url: https://github.com/azaghal/pydenticon
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bec284f3-9e7d-47cf-abec-d9e0af42fc00
location_href: 00004659-python-pydenticon/python-pydenticon-0.3.1-1.src.rpm
checksum_type: sha256
summary:
  Library for generating identicons. Port of Sigil (https://github.com/cupcake/sigil) with enhancements.

description:
  Pydenticon is a small utility library that can be used for deterministically
  generating identicons based on the hash of provided data.
  The implementation is a port of the Sigil identicon implementation from:
  * https://github.com/cupcake/sigil/
  Pydenticon provides a couple of extensions of its own when compared to the
  original Sigil implementation, like:
  * Ability to supply custom digest algorithms (allowing for larger identicons if
    digest provides enough entropy).
  * Ability to specify a rectangle for identicon size..


pkgId: f69e27ed657ff2d78d37d01b6712f9513b890b82c1a9289df4f7d2576e40c066
name: python-pydevicetree
arch: src
version: 0.0.12
epoch: 0
release: 1
summary: A library for parsing Devicetree Source v1
url: https://github.com/sifive/pydevicetree
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-48d2f4f7-9573-44e4-97c2-9b18e021037e
location_href: 00011573-python-pydevicetree/python-pydevicetree-0.0.12-1.src.rpm
checksum_type: sha256
description:
  This is a Python 3 library for parsing, querying, and modifying Devicetree Source v1 files as
  described in the [Devicetree Specification v0.2](https://github.com/devicetree-org/devicetree-specification/releases/tag/v0.2).



  pydevicetree supports Python >= 3.5 and can be installed with pip from the [Python Package Index](https://pypi.org/project/pydevicetree/).

  `pip install pydevicetree`





  Let's say you have a file design.dts with the contents
  ```
  /dts-v1/;

  / {
  	
  	
  	compatible = "my,design";
  	aliases {
  		serial0 = "/soc/uart@10000000";
  	};
  	chosen {
  		stdout-path = "/soc/uart@10000000:115200";
  	};
  	cpus {
  		
  		
  		cpu@0 {
  			compatible = "sifive,rocket0", "riscv";
  			device_type = "cpu";
  			reg = <0>;
  			riscv,isa = "rv32imac";
  			status = "okay";
  			timebase-frequency = <1000000>;
  			sifive,dtim = <&dtim>;
  			interrupt-controller {
  				
  				compatible = "riscv,cpu-intc";
  				interrupt-controller;
  			};
  		};
  	};
  	soc {
  		
  		
  		compatible = "my,design-soc";
  		ranges;
  		dtim: dtim@20000000 {
  			compatible = "sifive,dtim0";
  			reg = <0x20000000 0x10000000>;
  			reg-names = "mem";
  		};
  		uart: uart@10000000 {
  			compatible = "sifive,uart0";
  			reg = <0x10000000 0x1000>;
  			reg-names = "control";
  		};
  	};
  };
  ```



  Parsing the tree is as easy as 1, 2...

  ```
  >>> from pydevicetree import Devicetree
  >>> tree = Devicetree.parseFile("design.dts")
  >>> tree
  <Devicetree my,design>
  ```





  ```
  >>> tree.match("sifive,rocket0")
  [<Node cpu>]
  ```



  ```
  >>> tree.get_by_path("/soc/dtim")
  <Node dtim@20000000>
  ```

  Devicetree aliases are allowed in paths

  ```
  >>> tree.get_by_path("serial0")
  <Node uart@10000000>
  ```



  The value (or first value of a list/array) of a property can be retrieved with `Node.get_field()`

  ```
  >>> tree.match("sifive,rocket0")[0].get_field("timebase-frequency")
  1000000
  ```

  The list or array of values assigned to a property can be retrieved with `Node.get_fields()`

  ```
  >>> tree.match("sifive,rocket0")[0].get_fields("compatible")
  <StringList ['sifive,rocket0', 'riscv']>
  ```

  There are helper methods `Node.get_reg()` and `Node.get_ranges()` for the `reg` and `ranges`
  Devicetree properties.

  ```
  >>> tree.get_by_path("/soc/dtim").get_reg()
  <RegArray [536870912, 268435456]>
  >>> tree.get_by_path("/soc/dtim").get_reg().get_by_name("mem")
  (536870912, 268435456)
  >>> "0x%x" % tree.get_by_path("/soc/dtim").get_reg().get_by_name("mem")[0]
  '0x20000000'
  ```



  `Devicetree.chosen()` provides quick access to the properties of the `chosen` node

  ```
  >>> tree.chosen("stdout-path")
  <StringList ['/soc/uart@10000000:115200']>
  ```



  Any tree or subtree can be converted back to Devicetree by calling `Node.to_dts()` or simply
  by `print`ing it:

  ```
  >>> print(tree.match("sifive,rocket0")[0])
  cpu@0 {
          
          compatible = "sifive,rocket0", "riscv";
          device_type = "cpu";
          reg = <0x0>;
          riscv,isa = "rv32imac";
          status = "okay";
          timebase-frequency = <1000000>;
          sifive,dtim = <&dtim>;
          interrupt-controller {
                  
                  compatible = "riscv,cpu-intc";
                  interrupt-controller;
          };
  };
  ```


pkgId: 36737a065a182402b1f3e942fee6bdc2bb2a29116ddb55b1cfd069ae2f8d8074
name: python-pydicom
arch: src
version: 2.3.1
epoch: 0
release: 1
summary: A pure Python package for reading and writing DICOM data
url: https://github.com/pydicom/pydicom
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7a62bea9-fa2a-4030-b837-ca07349c2c83
location_href: 00004660-python-pydicom/python-pydicom-2.3.1-1.src.rpm
checksum_type: sha256
description:
  [![unit-tests](https://github.com/pydicom/pydicom/workflows/unit-tests/badge.svg)](https://github.com/pydicom/pydicom/actions?query=workflow%3Aunit-tests)
  [![type-hints](https://github.com/pydicom/pydicom/workflows/type-hints/badge.svg)](https://github.com/pydicom/pydicom/actions?query=workflow%3Atype-hints)
  [![doc-build](https://circleci.com/gh/pydicom/pydicom/tree/master.svg?style=shield)](https://circleci.com/gh/pydicom/pydicom/tree/master)
  [![test-coverage](https://codecov.io/gh/pydicom/pydicom/branch/master/graph/badge.svg)](https://codecov.io/gh/pydicom/pydicom)
  [![Python version](https://img.shields.io/pypi/pyversions/pydicom.svg)](https://img.shields.io/pypi/pyversions/pydicom.svg)
  [![PyPI version](https://badge.fury.io/py/pydicom.svg)](https://badge.fury.io/py/pydicom)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.6394735.svg)](https://doi.org/10.5281/zenodo.6394735)
  [![Gitter](https://badges.gitter.im/pydicom/Lobby.svg)](https://gitter.im/pydicom/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)



  *pydicom* is a pure Python package for working with [DICOM](https://www.dicomstandard.org/) files. It lets you read, modify and write DICOM data in an easy "pythonic" way.

  As a pure Python package, *pydicom* can run anywhere Python runs without any other requirements, although if you're working with *Pixel Data* then we recommend you also install [NumPy](http://www.numpy.org).

  If you're looking for a Python library for DICOM networking then you might be interested in another of our projects: [pynetdicom](https://github.com/pydicom/pynetdicom).



  Using [pip](https://pip.pypa.io/en/stable/):
  ```
  pip install pydicom
  ```
  Using [conda](https://docs.conda.io/en/latest/):
  ```
  conda install -c conda-forge pydicom
  ```

  For more information, including installation instructions for the development version, see the [installation guide](https://pydicom.github.io/pydicom/stable/tutorials/installation.html).




  The *pydicom* [user guide](https://pydicom.github.io/pydicom/stable/old/pydicom_user_guide.html), [tutorials](https://pydicom.github.io/pydicom/stable/tutorials/index.html), [examples](https://pydicom.github.io/pydicom/stable/auto_examples/index.html) and [API reference](https://pydicom.github.io/pydicom/stable/reference/index.html) documentation is available for both the [current release](https://pydicom.github.io/pydicom/stable) and the [development version](https://pydicom.github.io/pydicom/dev) on GitHub Pages.



  Compressed and uncompressed *Pixel Data* is always available to
  be read, changed and written as [bytes](https://docs.python.org/3/library/stdtypes.html#bytes-objects):
  ```python
  >>> from pydicom import dcmread
  >>> from pydicom.data import get_testdata_file
  >>> path = get_testdata_file("CT_small.dcm")
  >>> ds = dcmread(path)
  >>> type(ds.PixelData)
  <class 'bytes'>
  >>> len(ds.PixelData)
  32768
  >>> ds.PixelData[:2]
  b'\xaf\x00'

  ```

  If [NumPy](http://www.numpy.org) is installed, *Pixel Data* can be converted to an [ndarray](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html) using the [Dataset.pixel_array](https://pydicom.github.io/pydicom/stable/reference/generated/pydicom.dataset.Dataset.html#pydicom.dataset.Dataset.pixel_array) property:

  ```python
  >>> arr = ds.pixel_array
  >>> arr.shape
  (128, 128)
  >>> arr
  array([[175, 180, 166, ..., 203, 207, 216],
         [186, 183, 157, ..., 181, 190, 239],
         [184, 180, 171, ..., 152, 164, 235],
         ...,
         [906, 910, 923, ..., 922, 929, 927],
         [914, 954, 938, ..., 942, 925, 905],
         [959, 955, 916, ..., 911, 904, 909]], dtype=int16)
  ```


  Converting JPEG compressed *Pixel Data* to an ``ndarray`` requires installing one or more additional Python libraries. For information on which libraries are required, see the [pixel data handler documentation](https://pydicom.github.io/pydicom/stable/old/image_data_handlers.html#guide-compressed).

  Compressing data into one of the JPEG formats is not currently supported.


  Encoding and decoding RLE *Pixel Data* only requires NumPy, however it can
  be quite slow. You may want to consider [installing one or more additional
  Python libraries](https://pydicom.github.io/pydicom/stable/old/image_data_compression.html) to speed up the process.


  More [examples](https://pydicom.github.io/pydicom/stable/auto_examples/index.html) are available in the documentation.

  **Change a patient's ID**
  ```python
  from pydicom import dcmread

  ds = dcmread("/path/to/file.dcm")

  ds.PatientID = "12345678"
  ds.save_as("/path/to/file_updated.dcm")
  ```

  **Display the Pixel Data**

  With [NumPy](http://www.numpy.org) and [matplotlib](https://matplotlib.org/)
  ```python
  import matplotlib.pyplot as plt
  from pydicom import dcmread
  from pydicom.data import get_testdata_file


  path = get_testdata_file("CT_small.dcm")
  ds = dcmread(path)

  arr = ds.pixel_array

  plt.imshow(arr, cmap="gray")
  plt.show()
  ```



  To contribute to *pydicom*, read our [contribution guide](https://github.com/pydicom/pydicom/blob/master/CONTRIBUTING.md).

  To contribute an example or extension of *pydicom* that doesn't belong with the core software, see our contribution repository:
  [contrib-pydicom](https://www.github.com/pydicom/contrib-pydicom).


pkgId: c98794d0391c39689e602bdf2004e0b14fd0b00494f8ac263dbb553da59abbfa
name: python-pydocstyle
arch: src
version: 6.3.0
epoch: 0
release: 1
summary: Python docstring style checker
url: https://www.pydocstyle.org/en/stable/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ad22a138-8d29-43df-b1c5-3942f24a01e2
location_href: 00009412-python-pydocstyle/python-pydocstyle-6.3.0-1.src.rpm
checksum_type: sha256
description:
  **pydocstyle** is a static analysis tool for checking compliance with Python
  docstring conventions.
  **pydocstyle** supports most of
  `PEP 257 <http://www.python.org/dev/peps/pep-0257/>`_ out of the box, but it
  should not be considered a reference implementation.
  **pydocstyle** supports Python 3.6+.


pkgId: 27892bcc58c14e159d8fc5c11d158c36f03b785983dbcc84391ae78917508f70
name: python-pydot
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: Python interface to Graphviz's Dot
url: https://github.com/pydot/pydot
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-96805b31-7fed-4ba9-9b6c-08f7025384e0
location_href: 00004662-python-pydot/python-pydot-1.4.2-1.src.rpm
checksum_type: sha256
description:
  `pydot`:
    - is an interface to [Graphviz][1]
    - can parse and dump into the [DOT language][2] used by GraphViz,
    - is written in pure Python,
  and [`networkx`][3] can convert its graphs to `pydot`.
  Development occurs at [GitHub][11], where you can report issues and
  contribute code.


pkgId: 6cdfc56ba0f352c907ec6d83aeee4bf937b315859984561ee760c4004f4d94be
name: python-pydub
arch: src
version: 0.25.1
epoch: 0
release: 1
summary: Manipulate audio with an simple and easy high level interface
url: http://pydub.com
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-044ad970-7115-41b9-8fb2-700fdd6dda13
location_href: 00009634-python-pydub/python-pydub-0.25.1-1.src.rpm
checksum_type: sha256
description:
  Manipulate audio with an simple and easy high level interface.

  See the README file for details, usage info, and a list of gotchas.


pkgId: c8d5b44fc328248fb198af8881bf943dac81422167ff1ed5843e47c5874a1725
name: python-pyduofern
arch: src
version: 0.35.1
epoch: 0
release: 1
url: https://github.com/gluap/pyduofern
rpm_license: GPL-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-25ef5d27-5bdf-45f4-a530-a6deda002ff3
location_href: 00004664-python-pyduofern/python-pyduofern-0.35.1-1.src.rpm
checksum_type: sha256
summary:
  Library for controlling Rademacher DuoFern actors using python. Requires the RademacherDuofern USB Stick Art.-Nr.: 70000093

description:
  **Disclaimer:** this library is **not** endorsed by the company Rademacher, the manufacturer of home automation products
  under the label duofern. The name pyduofern was chosen to indicate the function of the library: communicating with
  duofern devices via python.
  These are my efforts in porting the `FHEM <http://fhem.de/fhem.html>`_
  `Duofern USB-Stick <https://wiki.fhem.de/wiki/DUOFERN>`_ based module to
  `Homeassistant <https://home-assistant.io/>`_. As of now the port is rather ugly, but it is usable enough to control
  my Duofern blinds. I did not port the Weather-Station related features of the original module -- Mainly because I
  do not own the corresponding hardware and have no means to test if it works. I only tested it with the model
  *RolloTron Standard DuoFern 14233011 Funk-Gurtwickler Aufputz*.
  As reported in `#31 <https://github.com/gluap/pyduofern/issues/31>`_ 10-Digit codes recently announced by Rademacher are not supported as of now as the handshake/
  protocol for these devices was not reverse engineered by anyone as far as I know.
  This requires the Duofern USB Stick Art.-Nr.: 70000093 by Rademacher.
  I do not provide any guarantees for the usability of this software. Use at your own risk.
  License::
     python interface for dufoern usb stick
     Copyright (C) 2017 Paul Görgen
     Rough python python translation of the FHEM duofern modules by telekatz
                (also licensed under GPLv2)
     This re-write does not literally contain contain any verbatim lines
     of the original code (given it was translated to another language)
     apart from some comments to facilitate translation of the not-yet
     translated parts of the original software. Modification dates are
     documented as submits to the git repository of this code, currently
     maintained at `https://github.com/gluap/pyduofern.git <https://github.com/gluap/pyduofern.git>`_
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software Foundation,
     Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA


pkgId: 32a1bafb52f362f073945d3cda52ab0dedb6c6c5002b4a1287dc4e5842503741
name: python-pyeclib
arch: src
version: 1.6.1
epoch: 0
release: 1
url: https://opendev.org/openstack/pyeclib
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0fb7bdde-b6ca-4156-aa54-d930d464acd8
location_href: 00004665-python-pyeclib/python-pyeclib-1.6.1-1.src.rpm
checksum_type: sha256
summary:
  This library provides a simple Python interface for implementing erasure codes.  To obtain the best possible performance, the underlying erasure code algorithms are written in C.

description:
  This library provides a simple Python interface for implementing erasure codes
  and is known to work with Python v2.6, 2.7 and 3.x. To obtain the best possible
  performance, the library utilizes liberasurecode, which is a C based erasure
  code library.
  PyECLib supports a variety of Erasure Coding backends including the standard
  Reed-Solomon implementations provided by Jerasure [1], liberasurecode [3],
  Intel's ISA-L [4] and Phazr.IO's libphazr.  It also provides support for a flat
  XOR-based encoder and decoder (part of liberasurecode) - a class of HD
  Combination Codes based on "Flat XOR-based erasure codes in storage systems:
  Constructions, efficient recovery, and tradeoffs" in IEEE MSST 2010[2]).
  These codes are well-suited to archival use-cases, have a simple construction
  and require a minimum number of participating disks during single-disk


pkgId: 3a6ef1c45d8de12fb1a9ac1c9ea5371c09c1b62165488e2a390bf6d1f049e2d7
name: python-pyee
arch: src
version: 9.0.4
epoch: 0
release: 1
summary: A port of node.js's EventEmitter to python.
url: https://github.com/jfhbrook/pyee
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c0bf21be-6b24-4127-a767-8a64d9bbc1f7
location_href: 00009556-python-pyee/python-pyee-9.0.4-1.src.rpm
checksum_type: sha256
description:
  pyee supplies a ``EventEmitter`` object that is similar to the
  ``EventEmitter`` class from Node.js. It also supplies a number of subclasses
  with added support for async and threaded programming in python, such as
  async/await as seen in python 3.5+.


pkgId: 522f3121b660cd6f987197315db20655adba2a40126f49bd66ac90a9f244f9f4
name: python-pyemd
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: A Python wrapper for Ofir Pele and Michael Werman's implementation of the Earth Mover's Distance.
url: https://github.com/wmayner/pyemd
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-49c91428-657c-4bab-89ef-ff8ba97ec0f5
location_href: 00004668-python-pyemd/python-pyemd-1.0.0-1.src.rpm
checksum_type: sha256
description:
  PyEMD is a Python wrapper for `Ofir Pele and Michael Werman's implementation
  <https://ofirpele.droppages.com/>`_ of the `Earth Mover's
  Distance <https://en.wikipedia.org/wiki/Earth_mover%27s_distance>`_ that allows
  it to be used with NumPy. **If you use this code, please cite the papers listed
  at the end of this document.**

rpm_license:
  Copyright (c) 2014-2023 Will Mayner  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: 2a90f1788e39d71a2393d35b06a90602d8fe31ffc04b0e614e5ca0b1786a1e58
name: python-pyepsg
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Easy access to the EPSG database via http://epsg.io/
url: https://github.com/rhattersley/pyepsg
rpm_license: GNU Lesser General Public License v3 (LGPLv3)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7cc4d555-b0be-4926-88b4-8e4ffdcdfa43
location_href: 00011516-python-pyepsg/python-pyepsg-0.4.0-1.src.rpm
checksum_type: sha256
description:
  |build_status|
  A simple interface to http://epsg.io/
  For example, we can request the details for the projected coordinate system
  identified by EPSG code 21781, aka. "Swiss CH1903 / LV03"::
      >>> projection = pyepsg.get(21781)
      >>> projection
      <ProjectedCRS: 21781, CH1903 / LV03>
      >>> projection.domain_of_validity()
      [5.97, 10.49, 45.83, 47.81]
      >>> projection.cartesian_cs.axes
      [<Axis: east / metre>, <Axis: north / metre>]
  Projected and geodetic coordinate systems can also be converted to various
  other forms::
      >>> print(projection.as_proj4()[:70] + '...')
      +proj=somerc +lat_0=46.95240555555556 +lon_0=7.439583333333333 +k_0=1 ...
      >>> print(projection.as_wkt()[:70] + '...')
      PROJCS["CH1903 / LV03",GEOGCS["CH1903",DATUM["CH1903",SPHEROID["Bessel...


pkgId: a01bcc723e18e8f39eb6f956b1e122cb6535302cde2862ce46cb8f83c34a0ca2
name: python-pyexasol
arch: src
version: 0.25.2
epoch: 0
release: 1
summary: Exasol python driver with extra features
url: https://github.com/exasol/pyexasol
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-33eee86f-e3cb-4eea-83ce-e0dfdc5c9660
location_href: 00011313-python-pyexasol/python-pyexasol-0.25.2-1.src.rpm
checksum_type: sha256
description:
  Exasol driver with low overhead, fast HTTP transport and compression. It is implemented in Python 3.6+.

  Main features:

  -  Based on WebSocket protocol;
  -  Optimized for minimum overhead;
  -  Easy integration with pandas via HTTP transport;
  -  Compression to reduce network bottleneck;

  PyEXASOL does not follow DB-API 2.0 in favor of Exasol-specific features.

  Please read "Best practices" manual page to learn how to use PyEXASOL with maximum efficiency.


pkgId: 33ca58840664affc835bda72ba0197c56534103f9a0e21fc9cce2ac2d472aa35
name: python-pyexcel
arch: src
version: 0.7.0
epoch: 0
release: 1
url: https://github.com/pyexcel/pyexcel
rpm_license: New BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-12b69fae-adc7-4063-9099-1d88312060d9
location_href: 00011265-python-pyexcel/python-pyexcel-0.7.0-1.src.rpm
checksum_type: sha256
summary:
  A wrapper library that provides one API to read, manipulate and writedata in different excel formats


pkgId: 52bfb3313ae77b9496f91957b879d472ed80596075be98c5ed43fa5c6648ada1
name: python-pyfakefs
arch: src
version: 5.1.0
epoch: 0
release: 1
summary: pyfakefs implements a fake file system that mocks the Python file system modules.
url: https://github.com/pytest-dev/pyfakefs
rpm_license: http://www.apache.org/licenses/LICENSE-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7f93517a-1ff6-4ba7-b729-b9811708af52
location_href: 00004674-python-pyfakefs/python-pyfakefs-5.1.0-1.src.rpm
checksum_type: sha256
description:
  pyfakefs implements a fake file system that mocks the Python file system modules.
  Using pyfakefs, your tests operate on a fake file system in memory without
  touching the real disk. The software under test requires no modification to
  work with pyfakefs.

  pyfakefs acts as a `pytest` plugin by providing the `fs` fixture, which will
  automatically invoke the fake filesystem. It also provides
  the `fake_filesystem_unittest.TestCase` class for use with `unittest` and
  the means to use the fake filesystem with other test frameworks.

  pyfakefs works with current versions of Linux, Windows and macOS.



  This document provides a general overview for pyfakefs.  There is more:

  * The documentation at **Read the Docs**:
    * The [Release documentation](https://pytest-pyfakefs.readthedocs.io/en/stable)
      contains usage documentation for pyfakefs and a description of the
      most relevant classes, methods and functions for the last version
      released on PyPI
    * The [Development documentation](https://pytest-pyfakefs.readthedocs.io/en/latest)
      contains the same documentation for the current main branch
    * The [Release 3.7 documentation](https://pytest-pyfakefs.readthedocs.io/en/v3.7.2/)
      contains usage documentation for the last version of pyfakefs
      supporting Python 2.7
  * The [Release Notes](https://github.com/pytest-dev/pyfakefs/blob/main/CHANGES.md)
    show a list of changes in the latest versions


  The simplest method to use pyfakefs is using the `fs` fixture with `pytest`.
  Refer to the
  [usage documentation](https://pytest-pyfakefs.readthedocs.io/en/latest/usage.html)
  for information on other test scenarios, test customization and
  using convenience functions.


  Apart from automatically mocking most file-system functions, pyfakefs
  provides some additional features:
  - mapping files and directories from the real file system into the fake filesystem
  - configuration and tracking of the file system size
  - pause and resume of patching to be able to use the real file system inside a
    test step
  - (limited) emulation of other OSes (Linux, macOS or Windows)
  - configuration to behave as if running as a non-root user while running
    under root


  pyfakefs works with CPython 3.7 and above, on Linux, Windows and macOS, and
  with PyPy3.

  pyfakefs works with [pytest](http://doc.pytest.org) version 3.0.0 or above,
  though a current version is recommended.

  pyfakefs will not work with Python libraries that use C libraries to access the
  file system. This is because pyfakefs cannot patch the underlying C libraries'
  file access functions--the C libraries will always access the real file
  system. Refer to the
  [documentation](https://pytest-pyfakefs.readthedocs.io/en/latest/intro.html#limitations)
  for more information about the limitations of pyfakefs.





  pyfakefs is currently automatically tested on Linux, macOS and Windows, with
  Python 3.7 to 3.11, and with PyPy3 on Linux, using
  [GitHub Actions](https://github.com/pytest-dev/pyfakefs/actions).




  pyfakefs unit tests can be run using `pytest` (all tests) or `unittest`
  (all tests except `pytest`-specific ones):

  ```bash
  $ cd pyfakefs/
  $ export PYTHONPATH=$PWD

  $ python -m pytest pyfakefs
  $ python -m pyfakefs.tests.all_tests
  ```

  Similar scripts are called by `tox` and Github Actions. `tox` can be used to
  run tests locally against supported python versions:

  ```bash
  $ tox
  ```



  The `Dockerfile` at the repository root will run the tests on the latest
  Ubuntu version.  Build the container:
  ```bash
  cd pyfakefs/
  docker build -t pyfakefs .
  ```
  Run the unit tests in the container:
  ```bash
  docker run -t pyfakefs
  ```



  We always welcome contributions to the library. Check out the
  [Contributing Guide](https://github.com/pytest-dev/pyfakefs/blob/main/CONTRIBUTING.md)
  for more information.


  pyfakefs.py was initially developed at Google by Mike Bland as a modest fake
  implementation of core Python modules.  It was introduced to all of Google
  in September 2006. Since then, it has been enhanced to extend its
  functionality and usefulness.  At last count, pyfakefs was used in over 2,000
  Python tests at Google.

  Google released pyfakefs to the public in 2011 as Google Code project
  [pyfakefs](http://code.google.com/p/pyfakefs/):
  * Fork
    [jmcgeheeiv-pyfakefs](http://code.google.com/p/jmcgeheeiv-pyfakefs/) added
    [direct support for unittest and doctest](../../wiki/Automatically-find-and-patch-file-functions-and-modules)
  * Fork
    [shiffdane-jmcgeheeiv-pyfakefs](http://code.google.com/p/shiffdane-jmcgeheeiv-pyfakefs/)
    added further corrections

  After the [shutdown of Google Code](http://google-opensource.blogspot.com/2015/03/farewell-to-google-code.html)
  was announced, [John McGehee](https://github.com/jmcgeheeiv) merged all three Google Code projects together
  [here on GitHub](https://github.com/pytest-dev/pyfakefs) where an enthusiastic community actively supports, maintains
  and extends pyfakefs. In 2022, the repository has been transferred to
  [pytest-dev](https://github.com/pytest-dev) to ensure continuous maintenance.


pkgId: 5bb075124742f9aa38cc409d8e3d52138c9a9e93a3f7c96f337075292bd1e3ec
name: python-pyfarmhash
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Google FarmHash Bindings for Python
url: https://github.com/veelion/python-farmhash
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bde40491-ab35-4e82-bae3-f8aa7dbfbdc8
location_href: 00009125-python-pyfarmhash/python-pyfarmhash-0.3.2-1.src.rpm
checksum_type: sha256
description:
  Google's FarmHash binding for Python




  This package provides bindings for the [Google's FarmHash](http://code.google.com/p/farmhash/).
  Code specific to this project is covered by [The MIT License](http://opensource.org/licenses/MIT)



  *Update:* Windows binary wheel uploaded to pypi

  Currently, clone the repo and:

  pip(Linux & Windows):
  ```bash
  $ sudo pip install pyfarmhash
  ```

  From Source:
  ```bash
  $ cd python-farmhash
  $ sudo python setup.py Install
  ```



  1. Install Microsoft Visual C++ Compiler
  2. Install miniconda for Python

  ```bash
  $ cd python-farmhash
  $ sudo python setup.py install
  ```




  ```
  import farmhash
  print farmhash.hash64('abc')
  2640714258260161385

  For more details, use ipython:
  In [1]: import farmhash

  In [2]: farmhash.hash64withseed?
  Type:       builtin_function_or_method
  String Form:<built-in function hash64withseed>
  Docstring:
  Hash function for a string.  For convenience, a 64-bit seed is also hashed into the result.
  example: print farmhash.hash64withseed('abc', 12345)
  13914286602242141520L
  ```


pkgId: d1cadc95fe1481ae4117144aa4205cf0e9c504a1fba876a2b00b4cbd5a054349
name: python-pyfarmhash-debuginfo
arch: x86_64
version: 0.3.2
epoch: 0
release: 1
summary: Debug information for package python-pyfarmhash
url: https://github.com/veelion/python-farmhash
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-bde40491-ab35-4e82-bae3-f8aa7dbfbdc8
rpm_sourcerpm: python-pyfarmhash-0.3.2-1.src.rpm
location_href: 00009125-python-pyfarmhash/python-pyfarmhash-debuginfo-0.3.2-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pyfarmhash.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 1944f698cb38b55ca461ef24ac69562244ec1da1e1d69cca05bf390b8b419d50
name: python-pyfarmhash-debugsource
arch: x86_64
version: 0.3.2
epoch: 0
release: 1
summary: Debug sources for package python-pyfarmhash
url: https://github.com/veelion/python-farmhash
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-bde40491-ab35-4e82-bae3-f8aa7dbfbdc8
rpm_sourcerpm: python-pyfarmhash-0.3.2-1.src.rpm
location_href: 00009125-python-pyfarmhash/python-pyfarmhash-debugsource-0.3.2-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pyfarmhash.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 0fa05dec9891f3a277cdce000cc12d96c8861f8a9df52f086e1bce164a4e20e3
name: python-pyfastnoisesimd
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: Python Fast Noise with SIMD
url: http://github.com/robbmcleod/pyfastnoisesimd
rpm_license: https://opensource.org/licenses/BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-39dbeda2-301e-41ab-b815-cd0171420f1b
location_href: 00004675-python-pyfastnoisesimd/python-pyfastnoisesimd-0.4.2-1.src.rpm
checksum_type: sha256
description:
  PyFastNoiseSIMD is a wrapper around Jordan Peck's synthetic noise library
  https://github.com/Auburns/FastNoise-SIMD which has been
  accelerated with SIMD instruction sets. It may be installed via pip:
      pip install pyfastnoisesimd
  Parallelism is further enhanced by the use of ``concurrent.futures`` to multi-thread
  the generation of noise for large arrays. Thread scaling is generally in the
  range of 50-90 %, depending largely on the vectorized instruction set used.
  The number of threads, defaults to the number of virtual cores on the system. The
  ideal number of threads is typically the number of physical cores, irrespective
  of Intel Hyperthreading®.
  Here is a simple example to generate Perlin-style noise on a 3D rectilinear
  grid::
      import pyfastnoisesimd as fns
      import numpy as np
      shape = [512, 512, 512]
      seed = np.random.randint(2**31)
      N_threads = 4
      perlin = fns.Noise(seed=seed, numWorkers=N_threads)
      perlin.frequency = 0.02
      perlin.noiseType = fns.NoiseType.Perlin
      perlin.fractal.octaves = 4
      perlin.fractal.lacunarity = 2.1
      perlin.fractal.gain = 0.45
      perlin.perturb.perturbType = fns.PerturbType.NoPerturb
      result = perlin.genAsGrid(shape)
  where ``result`` is a 3D ``numpy.ndarray`` of dtype ``'float32'``. Alternatively,
  the user can provide coordinates, which is helpful for tasks such as
  custom bump-mapping a tessellated surface, via ``Noise.getFromCoords(coords)``.
  More extensive examples are found in the ``examples`` folder on the Github repository.
  Parallelism is further enhanced by the use of ``concurrent.futures`` to multi-thread
  the generation of noise for large arrays. Thread scaling is generally in the
  range of 50-90 %, depending largely on the vectorized instruction set used.
  The number of threads, defaults to the number of virtual cores on the system. The
  ideal number of threads is typically the number of physical cores, irrespective
  of Intel Hyperthreading®.


pkgId: 4e8113cfea18fc8f435bf9148853261b15202f8ba6c03a3b99d268ddf6be1058
name: python-pyforce
arch: src
version: 1.9.1
epoch: 0
release: 1
summary: A Python client wrapping the Salesforce.com SOAP API
url: https://github.com/alanjcastonguay/pyforce
rpm_license: GNU GENERAL PUBLIC LICENSE Version 2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c2e590f8-07db-4d79-bd8e-082dd38d0d88
location_href: 00014124-python-pyforce/python-pyforce-1.9.1-1.src.rpm
checksum_type: sha256
description:
  This is a reluctant fork of the beatbox project originally authored by Simon
  Fell, (their version locked at 0.92) later drastically changed by these folks
  https://code.google.com/p/salesforce-beatbox/ (versioned at 20.0).
  Renamed to `pyforce` to avoid confusion related to the fractured community
  version. (https://github.com/superfell/Beatbox/issues/6) Long story short,
  the python client in the fork at version 20.0 is exceptionally useful, so
  going back to 0.92 would be a mistake, however the beatbox version at 20.0 is
  also no longer maintained (judging by the issues). `pyforce` builds off
  the version available there, integrating bug fixes, and new features.
  This module contains 2 versions of the Salesforce.com client:
   XMLClient
      An xmltramp wrapper that handles the xml fun.
   PythonClient
     Marshalls the returned objects into proper Python data types. e.g. integer
     fields return integers.


pkgId: 042b7f2d526a5101e72a86cbb342af471c127231330e7b59af74e08b30962fe3
name: python-pyftpdlib
arch: src
version: 1.5.7
epoch: 0
release: 1
summary: Very fast asynchronous FTP server library
url: https://github.com/giampaolo/pyftpdlib/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e1530cbf-f81e-401a-8148-0df5c9fb087c
location_href: 00011971-python-pyftpdlib/python-pyftpdlib-1.5.7-1.src.rpm
checksum_type: sha256
description:
  - `Home <https://github.com/giampaolo/pyftpdlib>`__
  - `Documentation <http://pyftpdlib.readthedocs.io>`__
  - `Download <https://pypi.python.org/pypi/pyftpdlib/>`__
  - `Blog <http://grodola.blogspot.com/search/label/pyftpdlib>`__
  - `Mailing list <http://groups.google.com/group/pyftpdlib/topics>`__
  - `What's new <https://github.com/giampaolo/pyftpdlib/blob/master/HISTORY.rst>`__


pkgId: 836dcc3e020c183b79312a5836b0be86baec66730151a3503e51250cabc31025
name: python-pygatt
arch: src
version: 4.0.5
epoch: 0
release: 1
summary: Python Bluetooth LE (Low Energy) and GATT Library
url: https://github.com/peplin/pygatt
rpm_license: Apache 2.0 and MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-23b11e87-2bcb-4972-a9d0-623a05fac302
location_href: 00004680-python-pygatt/python-pygatt-4.0.5-1.src.rpm
checksum_type: sha256
description:
  This Module allows reading and writing to GATT descriptors on devices
  such as fitness trackers, sensors, and anything implementing standard
  GATT Descriptor behavior.
  pygatt provides a Pythonic API by wrapping two different backends:
  -  BlueZ (requires Linux), using the ``gatttool`` command-line utility.
  -  Bluegiga's BGAPI, compatible with USB adapters like the BLED112.


pkgId: 9beb8765e311e7640c9004afbd5e05c38d9491a3d4115d1c9f31e3ab10c074c6
name: python-pygdbmi
arch: src
version: 0.11.0.0
epoch: 0
release: 1
summary: Parse gdb machine interface output with Python
url: https://github.com/cs01/pygdbmi
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7af81b90-5b23-4ff0-a385-5c2740b29fc1
location_href: 00010893-python-pygdbmi/python-pygdbmi-0.11.0.0-1.src.rpm
checksum_type: sha256
description:
  Python (**py**) [**gdb**](https://www.gnu.org/software/gdb/) machine interface [(**mi**)](https://sourceware.org/gdb/onlinedocs/gdb/GDB_002fMI.html)
  > GDB/MI is a line based machine oriented text interface to GDB and is activated by specifying using the --interpreter command line option (see Mode Options). It is specifically intended to support the development of systems which use the debugger as just one small component of a larger system.

  1.  A function to parse gdb machine interface string output and return structured data types (Python dicts) that are JSON serializable. Useful for writing the backend to a gdb frontend. For example, [gdbgui](https://github.com/cs01/gdbgui) uses pygdbmi on the backend.
  2.  A Python class to control and interact with gdb as a subprocess
  To get [machine interface](https://sourceware.org/gdb/onlinedocs/gdb/GDB_002fMI.html) output from gdb, run gdb with the `--interpreter=mi2` flag like so:
  ```
  gdb --interpreter=mi2
  ```

      pip install pygdbmi


  Cross platform support for Linux, macOS and Windows
  - Linux/Unix
    Ubuntu 14.04 and 16.04 have been tested to work. Other versions likely work as well.
  - macOS
    Note: the error `please check gdb is codesigned - see taskgated(8)` can be fixed by codesigning gdb with [these instructions](http://andresabino.com/2015/04/14/codesign-gdb-on-mac-os-x-yosemite-10-10-2/). If the error is not fixed, please [create an issue in github](https://github.com/cs01/pygdbmi/issues).
  - Windows
    Windows 10 has been tested to work with MinGW and cygwin.

  - gdb 7.6+ has been tested. Older versions may work as well.

  gdb mi defines a syntax for its output that is suitable for machine readability and scripting: [example output](https://sourceware.org/gdb/onlinedocs/gdb/GDB_002fMI-Simple-Examples.html#GDB_002fMI-Simple-Examples):
  ```
  -> -break-insert main
  <- ^done,bkpt={number="1",type="breakpoint",disp="keep",
  enabled="y",addr="0x08048564",func="main",file="myprog.c",
  fullname="/home/myprog.c",line="68",thread-groups=["i1"],
  times="0"}
  <- (gdb)
  ```
  Use `pygdbmi.gdbmiparser.parse_response` to turn that string output into a JSON serializable dictionary
  ```python
  from pygdbmi import gdbmiparser
  from pprint import pprint
  response = gdbmiparser.parse_response('^done,bkpt={number="1",type="breakpoint",disp="keep", enabled="y",addr="0x08048564",func="main",file="myprog.c",fullname="/home/myprog.c",line="68",thread-groups=["i1"],times="0"')
  pprint(response)
  pprint(response)















  ```

  But how do you get the gdb output into Python in the first place? If you want, `pygdbmi` also has a class to control gdb as subprocess. You can write commands, and get structured output back:
  ```python
  from pygdbmi.gdbcontroller import GdbController
  from pprint import pprint

  gdbmi = GdbController()
  print(gdbmi.command)  # print actual command run as subprocess

  response = gdbmi.write('-file-exec-file a.out')
  pprint(response)











  ```
  Now do whatever you want with gdb. All gdb commands, as well as gdb [machine interface commands](<(https://sourceware.org/gdb/onlinedocs/gdb/GDB_002fMI-Input-Syntax.html#GDB_002fMI-Input-Syntax)>) are acceptable. gdb mi commands give better structured output that is machine readable, rather than gdb console output. mi commands begin with a `-`.
  ```python
  response = gdbmi.write('-break-insert main')  # machine interface (MI) commands start with a '-'
  response = gdbmi.write('break main')  # normal gdb commands work too, but the return value is slightly different
  response = gdbmi.write('-exec-run')
  response = gdbmi.write('run')
  response = gdbmi.write('-exec-next', timeout_sec=0.1)  # the wait time can be modified from the default of 1 second
  response = gdbmi.write('next')
  response = gdbmi.write('next', raise_error_on_timeout=False)
  response = gdbmi.write('next', raise_error_on_timeout=True, timeout_sec=0.01)
  response = gdbmi.write('-exec-continue')
  response = gdbmi.send_signal_to_gdb('SIGKILL')  # name of signal is okay
  response = gdbmi.send_signal_to_gdb(2)  # value of signal is okay too
  response = gdbmi.interrupt_gdb()  # sends SIGINT to gdb
  response = gdbmi.write('continue')
  response = gdbmi.exit()
  ```

  Each parsed gdb response consists of a list of dictionaries. Each dictionary has keys `message`, `payload`, `token`, and `type`.
  - `message` contains a textual message from gdb, which is not always present. When missing, this is `None`.
  - `payload` contains the content of gdb's output, which can contain any of the following: `dictionary`, `list`, `string`. This too is not always present, and can be `None` depending on the response.
  - `token` If an input command was prefixed with a (optional) token then the corresponding output for that command will also be prefixed by that same token. This field is only present for pygdbmi output types `nofity` and `result`. When missing, this is `None`.
  The `type` is defined based on gdb's various [mi output record types](<(https://sourceware.org/gdb/onlinedocs/gdb/GDB_002fMI-Output-Records.html#GDB_002fMI-Output-Records)>), and can be
  - `result` - the result of a gdb command, such as `done`, `running`, `error`, etc.
  - `notify` - additional async changes that have occurred, such as breakpoint modified
  - `console` - textual responses to cli commands
  - `log` - debugging messages from gdb's internals
  - `output` - output from target
  - `target` - output from remote target
  - `done` - when gdb has finished its output

  Documentation fixes, bug fixes, performance improvements, and functional improvements are welcome. You may want to create an issue before beginning work to make sure I am interested in merging it to the master branch.
  pygdbmi uses [nox](https://github.com/theacodes/nox) for automation.
  See available tasks with
  ```
  nox -l
  ```
  Run tests and lint with
  ```
  nox -s tests
  nox -s lint
  ```
  Positional arguments passed to `nox -s tests` are passed directly to `pytest`. For instance, to run only the parse tests use
  ```
  nox -s tests -- tests/test_gdbmiparser.py
  ```
  See [`pytest`'s documentation](https://docs.pytest.org/) for more details on how to run tests.
  To format code using the correct settings use
  ```
  nox -s format
  ```
  Or, to format only specified files, use
  ```
  nox -s format -- example.py pygdbmi/IoManager.py
  ```

  Only maintainers of the [pygdbmi package on PyPi](https://pypi.org/project/pygdbmi/) can make a release.
  In the following steps, replace these strings with the correct values:
  - `<REMOTE>` is the name of the remote for the main pygdbmi repository (for instance, `origin`)
  - `<VERSION>` is the version number chosen in step 2.
  To make a release:
  1. Checkout the `master` branch and pull from the main repository with `git pull <REMOTE> master`
  2. Decide the version number for the new release; we follow
     [Semantic Versioning](https://semver.org/) but prefixing the version with `0.`: given a version
     number _0.SECOND.THIRD.FOURTH_, increment the:
     - _SECOND_ component when you make incompatible API changes
     - _THIRD_ component when you add functionality in a backwards compatible manner
     - _FOURTH_ component when you make backwards compatible bug fixes
  3. Update `CHANGELOG.md` to list the chosen version number instead of `## dev`
  4. Update `__version__` in `pygdbmi/__init__.py` to the chosen version number
  5. Create a branch, for instance using `git checkout -b before-release-<VERSION>`
  6. Commit your changes, for instance using `git commit -a -m 'Bump version to <VERSION> for release'`
  7. Check that the docs look fine by serving them locally with `nox -s serve_docs`
  8. Push the branch, for instance with `git push --set-upstream <REMOTE> before-release-<VERSION>`
  9. If tests pass on the PR you created, you can merge into `master`
  10. Go to the [new release page](https://github.com/cs01/pygdbmi/releases/new) and prepare the
      release:
      - Add a tag in the form `v<VERSION>` (for example `v0.1.2.3`)
      - Set the title to `pygdbmi v<VERSION>` (for example `pygdbmi v0.1.2.3`)
      - Copy and paste the section for the new release only from `CHANGELOG.md` excluding the line
        with the version number
      - Press “Publish release”
  10. Publish the release to PyPI with `nox -s publish`
  11. Publish the docs with `nox -s publish_docs`
  11. Verify that the [PyPi page for pygdbmi](https://pypi.org/project/pygdbmi/) looks correct
  12. Verify that the [published docs](https://cs01.github.io/pygdbmi/) look correct
  13. Prepare for changes for the next release by adding something like this above the previous
      entries in `CHANGELOG.md` (where `<VERSION+1>` is `<VERSION>` with the last digit increaded
      by 1):
      ```
      
      - *Replace this line with new entries*
      ```
  14. Create a branch for the changes with `git checkout -b after-release-<VERSION>`
  15. Commit the change with `git commit -m 'Prepare for work on the next release' CHANGELOG.md`
  16. Push the branch with `git push --set-upstream <REMOTE> after-release-<VERSION>`
  17. If tests pass, merge into `master`

  - [tsgdbmi](https://github.com/Guyutongxue/tsgdbmi) A port of pygdbmi to TypeScript
  - [danielzfranklin/gdbmi](https://github.com/danielzfranklin/gdbmi) A port of pygdbmi to Rust

  - [gdbgui](https://github.com/cs01/gdbgui) implements a browser-based frontend to gdb, using pygdbmi on the backend
  - [PINCE](https://github.com/korcankaraokcu/PINCE) is a gdb frontend that aims to provide a reverse engineering tool and a reusable library focused on games. It uses pygdbmi to parse gdb/mi based output for some functions
  - [avatar²](https://github.com/avatartwo/avatar2) is an orchestration framework for reversing and analysing firmware of embedded devices. It utilizes pygdbmi for internal communication to different analysis targets.
  - [UDB](https://undo.io/udb) is a proprietary time-travel debugger for C and C++ based on GDB. It uses pygdbmi in its extensive test suite to parse the debugger's output.
  - Know of another project? Create a PR and add it here.

  - [Chad Smith](https://github.com/cs01) (main author and creator).
  - [Marco Barisione](http://www.barisione.org/) (co-maintainer).
  - [The community](https://github.com/cs01/pygdbmi/graphs/contributors). Thanks especially to @mariusmue, @bobthekingofegypt, @mouuff, and @felipesere.


pkgId: f547feda502f4fdb1ee8eb51648113cb3c7462580b43220256b9b9106fedad02
name: python-pygelf
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: Logging handlers with GELF support
url: https://github.com/keeprocking/pygelf
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a6891ff0-2a1d-46da-947b-54fa19c5a37f
location_href: 00011751-python-pygelf/python-pygelf-0.4.2-1.src.rpm
checksum_type: sha256
description:
  |travis| |coveralls| |pypi| |downloads|
  Python logging handlers with GELF (Graylog Extended Log Format) support.
  Currently TCP, UDP, TLS (encrypted TCP) and HTTP logging handlers are supported.


pkgId: d6060a03d2033d9a2a47f891812c87b366b033875a2845185b521e170d33b122
name: python-pygeoip
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Pure Python GeoIP API
url: https://github.com/appliedsec/pygeoip
rpm_license: LGPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-165af908-3977-4f7c-abd6-42d5a7b31d35
location_href: 00004681-python-pygeoip/python-pygeoip-0.3.2-1.src.rpm
checksum_type: sha256
description:
  This library is based on `Maxmind's GeoIP C API <https://github.com/maxmind/geoip-api-c>`__.
  Tested with Python version 2.6, 2.7, 3.2, 3.3 and 3.4.


pkgId: 45bd04981c8a94342ac329ddaf19f1e3d949568009c0ac67203c4821442c6842
name: python-pyghmi
arch: src
version: 1.5.59
epoch: 0
release: 1
summary: Python General Hardware Management Initiative (IPMI and others)
url: http://github.com/openstack/pyghmi/
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e5dd2c21-9936-49c4-9284-f35d838e9f55
location_href: 00004682-python-pyghmi/python-pyghmi-1.5.59-1.src.rpm
checksum_type: sha256
description:
  This is a pure python implementation of IPMI protocol.

  pyghmicons and pyghmiutil are example scripts to show how one may incorporate
  this library into python code


pkgId: abd175bc8982b71696055bec244493a0ca16b3b8050711a6752dc0284d17d677
name: python-pygit2
arch: src
version: 1.11.1
epoch: 0
release: 1
summary: Python bindings for libgit2.
url: https://github.com/libgit2/pygit2
rpm_license: GPLv2 with linking exception
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f6ae1c27-5c46-457a-827b-7983de70e6c0
location_href: 00004685-python-pygit2/python-pygit2-1.11.1-1.src.rpm
checksum_type: sha256
description:
  - Documentation - http://www.pygit2.org/
  - Install - http://www.pygit2.org/install.html
  - Download - https://pypi.python.org/pypi/pygit2
  - Source code and issue tracker - https://github.com/libgit2/pygit2
  - Changelog - https://github.com/libgit2/pygit2/blob/master/CHANGELOG.rst
  - Authors - https://github.com/libgit2/pygit2/blob/master/AUTHORS.rst


pkgId: c6d51d1f7d858aa368f88f4763682e09b48300aaf87e3d3965757a21954280ff
name: python-pyglet
arch: src
version: 2.0.5
epoch: 0
release: 1
summary: Cross-platform windowing and multimedia library
url: http://pyglet.readthedocs.org/en/latest/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ed2e374d-4ea5-4a92-8d82-3f2e23945ee2
location_href: 00004687-python-pyglet/python-pyglet-2.0.5-1.src.rpm
checksum_type: sha256
description:
  [![pypi](https://badge.fury.io/py/pyglet.svg)](https://pypi.python.org/pypi/pyglet) [![rtd](https://readthedocs.org/projects/pyglet/badge/?version=latest)](https://pyglet.readthedocs.io) [![PyTest](https://github.com/pyglet/pyglet/actions/workflows/unittests.yml/badge.svg)](https://github.com/pyglet/pyglet/actions/workflows/unittests.yml)

  ![logo_large.png](https://bitbucket.org/repo/aejyXX/images/3385888514-logo_large.png)



  *pyglet* is a cross-platform windowing and multimedia library for Python, intended for developing games
  and other visually rich applications. It supports windowing, user interface event handling, Joysticks,
  OpenGL graphics, loading images and videos, and playing sounds and music. *pyglet* works on Windows, OS X and Linux.

  > :exclamation: :exclamation: A major pyglet update has just been released (v2.0). This brings many
  > new exciting features, but also some necessary breaking changes. If your game/application has suddenly
  > stopped working, please read the [migration section in the documentation](https://pyglet.readthedocs.io/en/latest/programming_guide/migration.html)
  > The previous version of pyglet is tracked in the `pyglet-1.5-maintenance` branch.
  > **If you want to do a pull request for the previous release, please target the appropriate branch**.

  > :exclamation: `pyglet.graphics.draw` and `pyglet.graphics.draw_indexed` will be removed
  > in pyglet v2.1. The `shapes` module is an alternative for drawing simple shapes.

  * pyglet [documentation]
  * pyglet on [PyPI]
  * pyglet [discord] server
  * pyglet [mailing list]
  * pyglet [issue tracker]
  * pyglet [website]

  pyglet has an active developer and user community.  If you find a bug or a problem with the documentation,
  please [open an issue](https://github.com/pyglet/pyglet/issues).
  Anyone is welcome to join our [discord] server where a lot of the development discussion is going on.
  It's also a great place to ask for help.

  Some features of pyglet are:

  * **No external dependencies or installation requirements.** For most application and game requirements, *pyglet*
    needs nothing else besides Python, simplifying distribution and installation. It's easy to package your project
    with freezers such as PyInstaller.
  * **Take advantage of multiple windows and multi-monitor desktops.** *pyglet* allows you to use multiple
    platform-native windows, and is fully aware of multi-monitor setups for use with fullscreen games.
  * **Load images, sound, music and video in almost any format.** *pyglet* can optionally use FFmpeg to play back
    audio formats such as MP3, OGG/Vorbis and WMA, and video formats such as MPEG2, H.264, H.265, WMV and Xvid.
    Without FFmpeg, *pyglet* contains built-in support for standard formats such as wav, png, bmp, and others.
  * **pyglet is written entirely in pure Python**, and makes use of the *ctypes* module to interface with system
    libraries. You can modify the codebase or make a contribution without any second language compilation steps or
    compiler setup. Despite being pure Python, *pyglet* has excellent performance thanks to advanced batching for
    drawing thousands of objects.
  * **pyglet is provided under the BSD open-source license**, allowing you to use it for both commercial and other
    open-source projects with very little restriction.



  pyglet runs under Python 3.8+. Being written in pure Python, it also works on other Python interpreters such as PyPy. Supported platforms are:

  * Windows 7 or later
  * Mac OS X 10.3 or later
  * Linux, with the following libraries (most recent distributions will have
    these in a default installation):
    * OpenGL and GLX
    * GDK 2.0+ or Pillow (required for loading images other than PNG and BMP)
    * OpenAL or Pulseaudio (required for playing audio)

  **As of pyglet 2.0, OpenGL 3.3+ is required**.

  To play a large variety of compressed audio and video files,
  pyglet can optionally take advantage of [FFmpeg](https://ffmpeg.org/).



  pyglet is installable from PyPI:

      pip install --upgrade --user pyglet



  If you're reading this `README` from a source distribution, you can install pyglet with:

      python setup.py install --user

  You can also install the latest development version direct from Github using:

      pip install --upgrade --user https://github.com/pyglet/pyglet/archive/master.zip

  For local development install pyglet in editable mode:

  ```bash

  pip install -e .

  python setup.py develop
  ```

  There are no compilation steps during the installation; if you prefer,
  you can simply add this directory to your `PYTHONPATH` and use pyglet without
  installing it. You can also copy pyglet directly into your project folder.



  **A good way to start contributing to a component of pyglet is by its documentation**. When studying the code you
  are going to work with, also read the associated docs. If you don't understand the code with the help of the docs,
  it is a sign that the docs should be improved.

  If you want to contribute to pyglet, we suggest the following:

  * Fork the [official repository](https://github.com/pyglet/pyglet/fork).
  * Checkout the branch you wish to contribute to (such as *pyglet-1.4-maintenance*).
  * Apply your changes to your fork.
  * Submit a [pull request](https://github.com/pyglet/pyglet/pulls) describing the changes you have made.
  * Alternatively you can create a patch and submit it to the issue tracker.

  When making a pull request, check that you have addressed its respective documentation, both within the code docstrings
  and the programming guide (if applicable). It is very important to all of us that the documentation matches the latest
  code and vice-versa.

  Consequently, an error in the documentation, either because it is hard to understand or because it doesn't match the
  code, is a bug that deserves to be reported on a ticket.



      pip install -r doc/requirements.txt
      python setup.py build_sphinx

  Please check [the README.md file in the doc directory](doc/README.md) for more details.



  pyglet makes use of pytest for its test suite.

  ```bash
  pip install -r tests/requirements.txt --user

  pytest tests/unit
  ```

  Please check the [testing section in the development guide](https://pyglet.readthedocs.io/en/latest/internal/testing.html)
  for more information about running and writing tests.



  pyglet is developed by many individual volunteers, and there is no central point of contact. If you have a question
  about developing with pyglet, or you wish to contribute, please join the [mailing list] or the [discord] server.

  For legal issues, please contact [Alex Holkner](mailto:Alex.Holkner@gmail.com).

  [discord]: https://discord.gg/QXyegWe
  [mailing list]: http://groups.google.com/group/pyglet-users
  [documentation]: https://pyglet.readthedocs.io
  [wiki]:  https://github.com/pyglet/pyglet/wiki
  [pypi]:  https://pypi.org/project/pyglet/
  [website]: http://pyglet.org/
  [issue tracker]: https://github.com/pyglet/pyglet/issues


pkgId: 27fb228d2b0cd409ad88e2e34de799a4eb649f5eb676091534e41815ecf36578
name: python-pygments-markdown-lexer
arch: src
version: 0.1.0.dev39
epoch: 0
release: 1
summary: Pygments Markdown Lexer – A Markdown lexer for Pygments to highlight Markdown code snippets.
url: https://github.com/jhermann/pygments-markdown-lexer
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9a8a6871-32cb-4e1b-8ec3-bf53f9ec7f8b
location_href: 00004688-python-pygments-markdown-lexer/python-pygments-markdown-lexer-0.1.0.dev39-1.src.rpm
checksum_type: sha256
description:
  Copyright ©  2015 Jürgen Hermann <jh@web.de>

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.


pkgId: d0670cdb67796692994e8c53fe6d6eb6cd7fc9af73cc394e314e5c4ce4c4ffae
name: python-pygments-pytest
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: A pygments lexer for pytest output.
url: https://github.com/asottile/pygments-pytest
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-beaf7613-2da0-4136-90e9-34232d8612d6
location_href: 00004689-python-pygments-pytest/python-pygments-pytest-2.3.0-1.src.rpm
checksum_type: sha256
description:
  A pygments lexer for pytest output
  See [some demos](https://asottile.github.io/pygments-pytest)!  Or
  [see it in action on pytest.org](https://pytest.org).

  `pip install pygments-pytest`

  This library provides a pygments lexer called `pytest`.
  ```rst


pkgId: f9f9f16bc8f83010b79427b2102047db570750cd6b69bb55775af47629bc30bd
name: python-pygraphviz
arch: src
version: 1.10
epoch: 0
release: 1
summary: Python interface to Graphviz
url: http://pygraphviz.github.io
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f20c2aad-28ce-43af-b158-573609c91251
location_href: 00004695-python-pygraphviz/python-pygraphviz-1.10-1.src.rpm
checksum_type: sha256
description:
  PyGraphviz is a Python interface to the Graphviz graph layout and
  visualization package.
  With PyGraphviz you can create, edit, read, write, and draw graphs using
  Python to access the Graphviz graph data structure and layout algorithms.
  PyGraphviz provides a similar programming interface to NetworkX
  (https://networkx.org).
  - **Website (including documentation):** https://pygraphviz.github.io
  - **Mailing list:** https://groups.google.com/forum/#!forum/pygraphviz-discuss
  - **Source:** https://github.com/pygraphviz/pygraphviz
  - **Bug reports:** https://github.com/pygraphviz/pygraphviz/issues


pkgId: 825bc418eae75138c89be44d0c7e7de4dcf59059f4fc7612b662464f6cf550d0
name: python-pygrib
arch: src
version: 2.1.4
epoch: 0
release: 1
summary: Python module for reading/writing GRIB files
url: https://github.com/jswhit/pygrib
rpm_license: License :: OSI Approved :: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3b07194e-0b44-4b7f-b8bb-c0eca30a6d79
location_href: 00004697-python-pygrib/python-pygrib-2.1.4-1.src.rpm
checksum_type: sha256
description:
  The easiest way to get everything installed is to use [pip](https://py.pypa.io):
  ```
  pip install pygrib
  ```
  You can also use [conda](https://docs.conda.io/en/latest/):
  ```
  conda install -c conda-forge pygrib
  ```
  Alternately, clone the github repo and run `python setup.py install` (after setting `$ECCCODES_DIR`)
  where `$ECCODES_DIR` is the path to the directory containing `include/grib_api.h`
  and `lib/libeccodes.so`. If `ECCODES_DIR` is not specified, a few common locations
  such as `$CONDA_PREFIX,/usr,/usr/local,/opt/local` will be searched.
  For full installation instructions and API documentation, see https://jswhit.github.io/pygrib.
  Sample [IPython](http://ipython.org/) notebooks illustrating pygrib usage:
  * http://nbviewer.jupyter.org/gist/jswhit/8635665
  * https://github.com/scollis/HRRR/blob/master/notebooks/HRRR%20Grib.ipynb
  Questions or comments - contact Jeff Whitaker <jeffrey.s.whitaker@noaa.gov>
  or use https://github.com/jswhit/pygrib/issues.


pkgId: 6eef9fd8e9bc37a45cae5573362545dfb64497745386a5e39ec72fe7005acd04
name: python-pygrocy
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/sebrut/pygrocy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-45850fe1-f894-426c-93e8-606ee96f403b
location_href: 00004698-python-pygrocy/python-pygrocy-1.5.0-1.src.rpm
checksum_type: sha256
description:
  [![Development Build Status](https://api.travis-ci.com/SebRut/pygrocy.svg?branch=develop)](https://travis-ci.com/SebRut/pygrocy)
  [![PyPI](https://img.shields.io/pypi/v/pygrocy.svg)](https://pypi.org/project/pygrocy/)
  ![Python Version](https://img.shields.io/badge/python-3.8%20%7C%203.9%20%7C%203.10-blue)
  ![Grocy Version](https://img.shields.io/badge/grocy-3.1.0-yellow)
  [![Coverage Status](https://coveralls.io/repos/github/SebRut/pygrocy/badge.svg?branch=master)](https://coveralls.io/github/SebRut/pygrocy?branch=master)
  [![CodeFactor](https://www.codefactor.io/repository/github/sebrut/pygrocy/badge)](https://www.codefactor.io/repository/github/sebrut/pygrocy)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
  [Documentation](https://sebrut.github.io/pygrocy/)



  `pip install pygrocy`


  Import the package:
  ```python
  from pygrocy import Grocy
  ```

  Obtain a grocy instance:
  ```python
  grocy = Grocy("https://example.com", "GROCY_API_KEY")
  ```
  or
  ```python
  grocy = Grocy("https://example.com", "GROCY_API_KEY", port = 9192, verify_ssl = True)
  ```

  Get current stock:
  ```python
  for entry in grocy.stock():
      print("{} in stock for product id {}".format(entry.available_amount, entry.id))
  ```



  If you need help using pygrocy check the [discussions](https://github.com/SebRut/pygrocy/issues) section. Feel free to create an issue for feature requests, bugs and errors in the library.


  You need tox and Python 3.8/9/10 to run the tests. Navigate to the root dir of `pygrocy` and execute `tox` to run the tests.


pkgId: 558e4c0162a21fb09d8a8530f23cc5ef6860d3951337fbaaf5d5e00d24a9830b
name: python-pygsheets
arch: src
version: 2.0.6
epoch: 0
release: 1
summary: Google Spreadsheets Python API v4
url: https://github.com/nithinmurali/pygsheets
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5a110296-58ed-4cf6-a199-8e09ad79a7df
location_href: 00009339-python-pygsheets/python-pygsheets-2.0.6-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/nithinmurali/pygsheets.svg?branch=staging)](https://travis-ci.org/nithinmurali/pygsheets)  [![PyPI version](https://badge.fury.io/py/pygsheets.svg)](https://badge.fury.io/py/pygsheets)    [![Documentation Status](https://readthedocs.org/projects/pygsheets/badge/?version=latest)](http://pygsheets.readthedocs.io/en/latest/?badge=latest) [![Gitpod ready-to-code](https://img.shields.io/badge/Gitpod-ready--to--code-blue?logo=gitpod)](https://gitpod.io/#https://github.com/nithinmurali/pygsheets)

  A simple, intuitive library for google sheets which gets your work done.

  Features:

  * Open, create, delete and share spreadsheets using _title_ or _key_
  * Intuitive models - spreadsheet, worksheet, cell, datarange
  * Control permissions of spreadsheets.
  * Set cell format, text format, color, write notes
  * Named and Protected Ranges Support
  * Work with range of cells easily with DataRange and Gridrange
  * Data validation support. checkboxes, drop-downs etc.
  * Conditional formatting support
  * get multiple ranges with get_values_batch and update wit update_values_batch


  * version [2.0.6](https://github.com/nithinmurali/pygsheets/releases/tag/2.0.6) released





  ```sh
  pip install pygsheets

  ```

  If you are installing from pypi please see the docs [here](https://pygsheets.readthedocs.io/en/stable/).




  ```sh
  pip install https://github.com/nithinmurali/pygsheets/archive/staging.zip

  ```

  If you are installing from github please see the docs [here](https://pygsheets.readthedocs.io/en/staging/).



  Basic features are shown here, for complete set of features see the full documentation [here](http://pygsheets.readthedocs.io/en/staging/).

  1. Obtain OAuth2 credentials from Google Developers Console for __google spreadsheet api__ and __drive api__ and save the file as `client_secret.json` in same directory as project. [read more here.](https://pygsheets.readthedocs.io/en/latest/authorization.html)

  2. Start using pygsheets:

  Sample scenario : you want to share a numpy array with your remote friend

  ```python
  import pygsheets
  import numpy as np

  gc = pygsheets.authorize()


  sh = gc.open('my new sheet')
  wks = sh.sheet1


  wks.update_value('A1', "Hey yank this numpy array")
  my_nparray = np.random.randint(10, size=(3, 4))


  wks.update_values('A2', my_nparray.tolist())


  sh.share("myFriend@gmail.com")

  ```

  Sample Scenario: you want to fill height values of students
  ```python



  header = wks.cell('A1')
  header.value = 'Names'
  header.text_format['bold'] = True # make the header bold
  header.update()


  wks.cell('B1').set_text_format('bold', True).value = 'heights'


  wks.update_values('A2:A5',[['name1'],['name2'],['name3'],['name4']])


  heights = wks.range('B2:B5', returnas='range')  # get the range as DataRange object
  heights.name = "heights"  # name the range
  heights.update_values([[50],[60],[67],[66]]) # update the values
  wks.update_value('B6','=average(heights)') # set the avg value of heights using named range

  ```





  ```python

  sh = gc.open("pygsheetTest")


  sht1 = gc.open_by_key('1mwA-NmvjDqd3A65c8hsxOpqdfdggPR0fgfg5nXRKScZAuM')


  sht2 = gc.create("new sheet", folder_name="my worksheets")


  gc.drive.enable_team_drive("Dqd3A65c8hsxOpqdfdggPR0fgfg")

  ```



  <details> <summary>show code</summary>

  ```python

  import pygsheets
  c = pygsheets.authorize()
  sh = c.open('spreadsheet')


  wks = sh.add_worksheet("new sheet",rows=50,cols=60)


  wks = sh.add_worksheet("new sheet",rows=50,cols=60,index=0)


  wks = sh.add_worksheet("new sheet", src_worksheet='<other worksheet instance>')


  sh.del_worksheet(wks)


  sh.remove_permissions("myNotSoFriend@gmail.com")

  ```

  </details>



  <details> <summary>show code</summary>

  ```python
  import pygsheets
  c = pygsheets.authorize()
  sh = c.open('spreadsheet')


  wks = sh.worksheet_by_title("my test sheet")


  wks = sh.worksheet('index', 0)


  wks_list = sh.worksheets()


  wks = sh[0]
  ```

  </details>



  <details> <summary>show code</summary>

  ```python

  values_mat = wks.get_values(start=(1,1), end=(20,20), returnas='matrix')


  wks.get_values_batch(['A1:B10', 'C', '1', (10, None)])


  cell_matrix = wks.get_all_values(returnas='matrix')


  wks.update_values(crange='A1:E10', values=values_mat)


  wks.update_values_batch(['A1:A2', 'B1:B2'], [[[1],[2]], [[3],[4]]])


  wks.insert_rows(row=20, number=2, values=values_list)


  wks.rows=30


  for row in wks:
      print(row)


   A1_value = wks[0][0]


  wks.clear()


  wks.append_table(values=[1,2,3,4])


  wks.export(pygsheets.ExportType.CSV)


  cell_list = worksheet.find("query string")


  filter_re = re.compile(r'(small|big) house')
  cell_list = worksheet.find(filter_re, searchByRegex=True)
  cell_list = worksheet.replace(filter_re, 'some house', searchByRegex=True)


  wks.index = 2 # index start at 1 , not 0


  wks.title = "NewTitle"


  wks.hidden = False


  wks.create_named_range('A1', 'A10', 'prices')
  wks.get_named_range('prices')
  wks.get_named_ranges()  # will return a list of DataRange objects
  wks.delete_named_range('prices')


  wks.apply_format(['A1:B1', 'D:E'], ["NUMBER", "TEXT"])


  wks.add_chart(('A1', 'A6'), [('B1', 'B6')], 'Health Trend')


  wks.set_data_validation(start='C4', end='E7', condition_type='NUMBER_BETWEEN', condition_values=[2,10], strict=True, inputMessage="inut between 2 and 10")


  cell = wks.cell('C1')
  cell.value = '=A1+B1'
  wks.apply_format('C1:C10', cell, 'userEnteredValue.formulaValue')

  ```

  </details>


  If you work with pandas, you can directly use the dataframes
  ```python

  wks.set_dataframe(df,(1,1))


  df = wks.get_as_df()

  ```




  Each cell has a __value__ and cordinates (__row__, __col__, __label__) properties.

  Getting cell objects

  <details open> <summary>show code</summary>

  ```python
  c1 = Cell('A1',"hello")  # create a unlinked cell
  c1 = worksheet.cell('A1')  # creates a linked cell whose changes syncs instantanously
  cl.value  # Getting cell value
  c1.value_unformatted #Getting cell unformatted value
  c1.formula # Getting cell formula if any
  c1.note # any notes on the cell
  c1.address # address object with cell position

  cell_list = worksheet.range('A1:C7')  # get a range of cells
  cell_list = worksheet.col(5, returnas='cell')  # return all cells in 5th column(E)

  ```

  </details>

  Most of the functions has `returnas` param, if whose value is `cell` it will return a list of cell objects. Also you can use *label* or *(row,col)* tuple interchangbly as a cell adress



  Each cell is directly linked with its cell in spreadsheet, hence changing the value of cell object will update the corresponding cell in spreadsheet unless you explictly unlink it
  Also not that bu default only the value of cell is fetched, so if you are directly accessing any cell properties call `cell.fetch()` beforehand.

  Different ways of updating Cells

  <details> <summary>show code</summary>

  ```python

  c1 = worksheet.cell('B1') # created from worksheet, so linked cell
  c1.col = 5  # Now c1 correponds to E1
  c1.value = "hoho"  # will change the value of E1


  worksheet.update_value('B1', 'hehe')


  cell_list = worksheet.range('A1:C7')
  cell_list = worksheet.get_values(start='A1', end='C7', returnas='cells')
  cell_list = worksheet.get_row(2, returnas='cells')



  c1.formula = 'A1+C2'
  c1.formula # '=A1+C2'


  c2 = c1.neighbour('topright') # you can also specify relative position as tuple eg (1,1)


  c1.set_number_format(pygsheets.FormatType.NUMBER, '00.0000')


  c1.note = "yo mom"


  c1.color = (1.0, 1.0, 1.0, 1.0) # Red, Green, Blue, Alpha


  c1.text_format['fontSize'] = 14
  c1.set_text_format('bold', True)


   c1.update()



  c.unlink()
  c.note = "offine note"
  c.link(wks1, True)
  c.link(wks2, True)

  ```

  </details>



  The DataRange is used to represent a range of cells in a worksheet. They can be named or protected.
  Almost all `get_` functions has a `returnas` param, set it to `range` to get a range object.

  <details open> <summary>show code</summary>

  ```python

  rng = wks.get_values('A1', 'C5', returnas='range')
  rng.start_addr = 'A' # make the range unbounded on rows <Datarange Sheet1!A:B>
  drange.end_addr = None # make the range unbounded on both axes <Datarange Sheet1>


  rng.name = 'pricesRange'  # will make this range a named range
  rng = wks.get_named_ranges('commodityCount') # directly get a named range
  rng.name = ''  # will delete this named range


  rng.protected = True
  rng.editors = ('users', 'someemail@gmail.com')


   
  model_cell = Cell('A1')
  model_cell.color = (1.0,0,1.0,1.0) # rose color cell
  model_cell.format = (pygsheets.FormatType.PERCENT, '')

   
  rng.apply_format(model_cell)  # will make all cell in this range rose color and percent format

  Datarange('A1','A10', worksheet=wks).apply_format(model_cell)


  cell = rng[0][1]

  ```
  </details>



  If you are calling a lot of spreadsheet modification functions (non value update). you can merge them into a single call.
  By doing so all the requests will be merged into a single call.

  ```python
  gc.set_batch_mode(True)
  wks.merge_cells("A1", "A2")
  wks.merge_cells("B1", "B2")
  Datarange("D1", "D5", wks).apply_format(cell)
  gc.run_batch() # All the above requests are executed here
  gc.set_batch_mode(False)

  ```
  Batching also happens when you unlink worksheet. But in that case the requests are not merged.




  This library is still in development phase.

  * Follow the [Contributing to Open Source](https://guides.github.com/activities/contributing-to-open-source/) Guide.
  * Branch off of the `staging` branch, and submit Pull Requests back to
    that branch.  Note that the `master` branch is used for version
    bumps and hotfixes only.
  * For quick testing the changes you have made to source, run the file `tests/manual_testing.py`. It will give you an IPython shell with lastest code loaded.



  * Please report bugs and suggest features via the [GitHub Issues](https://github.com/nithinmurali/pygsheets/issues).
  * Before opening an issue, search the tracker for possible duplicates.
  * If you have any usage questions, ask a question on stackoverflow with `pygsheets` Tag


  * install `pip install -r requirements-dev.txt`
  * run `make test`

  Now that you have scrolled all the way down, **finding this library useful?**  <a href="https://www.buymeacoffee.com/pygsheets" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy Me A Coffee" style="height: auto !important;width: auto !important;" ></a>


pkgId: 8bc4a3ad4af2abe0665a3f2471ee07a016b909cd9ecd63ca2cf86b4494645109
name: python-pygtrie
arch: src
version: 2.5.0
epoch: 0
release: 1
summary: A pure Python trie data structure implementation.
url: https://github.com/mina86/pygtrie
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c22c7a8e-adae-4bc3-aad6-71a5782d9cda
location_href: 00010573-python-pygtrie/python-pygtrie-2.5.0-1.src.rpm
checksum_type: sha256
description:
  pygtrie is a pure Python implementation of a trie data structure
  compatible with Python 2.x and Python 3.x.
  `Trie data structure <http://en.wikipedia.org/wiki/Trie>`_, also known
  as radix or prefix tree, is a tree associating keys to values where
  all the descendants of a node have a common prefix (associated with
  that node).
  The trie module contains ``Trie``, ``CharTrie`` and ``StringTrie``
  classes each implementing a mutable mapping interface, i.e. ``dict``
  interface.  As such, in most circumstances, ``Trie`` could be used as
  a drop-in replacement for a ``dict``, but the prefix nature of the
  data structure is trie’s real strength.
  The module also contains ``PrefixSet`` class which uses a trie to
  store a set of prefixes such that a key is contained in the set if it
  or its prefix is stored in the set.


pkgId: 7733298ef445207ac0a3edf20beb5474bfdb33a36603a7d3cc4fd4b5c7b6971e
name: python-pyhcl
arch: src
version: 0.4.4
epoch: 0
release: 1
summary: HCL configuration parser for python
url: https://github.com/virtuald/pyhcl
rpm_license: Mozilla Public License 2.0 (MPL 2.0)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b31aed6e-411d-489a-a713-3a6b27afe95a
location_href: 00004702-python-pyhcl/python-pyhcl-0.4.4-1.src.rpm
checksum_type: sha256
description:
  |Build Status|
  Implements a parser for `HCL (HashiCorp Configuration
  Language) <https://github.com/hashicorp/hcl>`__ in Python. This
  implementation aims to be compatible with the original golang version of
  the parser.
  The grammar and many of the tests/fixtures were copied/ported from the
  golang parser into pyhcl. All releases are tested with a variety of
  python versions from Python 2.7 onward.
  This version has been modified to work with terraform 0.12 syntax.
  It should be backward compatible with earlier versions.
  It doesn't cover every situation.  See discussion in pull request:
  https://github.com/virtuald/pyhcl/pull/57


pkgId: 45dafedb7e34a8f75891fc4f0569d791a708600f76c994756820c3773cb5f88a
name: python-pyhdb
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: SAP HANA Database Client for Python
url: https://github.com/SAP/pyhdb
rpm_license: Apache License Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e64a8b13-47a1-4dd4-88ad-cc1bcf904c9a
location_href: 00010165-python-pyhdb/python-pyhdb-0.3.4-1.src.rpm
checksum_type: sha256
description:
  A pure Python client for the SAP HANA Database based on the `SAP HANA Database SQL Command Network Protocol <http://help.sap.com/hana/SAP_HANA_SQL_Command_Network_Protocol_Reference_en.pdf>`_.
  pyhdb supports Python 2.7, 3.3, 3.4, 3.5 and also PyPy on Linux, OSX and Windows. It implements a large part of the `DBAPI Specification v2.0 (PEP 249) <http://legacy.python.org/dev/peps/pep-0249/>`_. We plan to support Python 2.6 again in the future.


pkgId: 356fef5d0f8eae68b5d5cadffc99dfa6117086e44a1d05d5a650ef059038d418
name: python-pyhdfe
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: High dimensional fixed effect absorption with Python 3
url: https://github.com/jeffgortmaker/pyhdfe
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b3eeb795-02aa-4b41-ab93-4d5748b3540b
location_href: 00011609-python-pyhdfe/python-pyhdfe-0.1.2-1.src.rpm
checksum_type: sha256
description:
  The PyHDFE package has been tested on `Python <https://www.python.org/downloads/>`_ versions 3.6 through 3.9. The `SciPy instructions <https://scipy.org/install/>`_ for installing related packages is a good guide for how to install a scientific Python environment. A good choice is the `Anaconda Distribution <https://www.anaconda.com/products/distribution>`_, since, along with many other packages that are useful for scientific computing, it comes packaged with PyHDFE's only required dependencies: `NumPy <https://numpy.org/>`_ and `SciPy <https://scipy.org/>`_.
  You can install the current release of PyHDFE with `pip <https://pip.pypa.io/en/latest/>`_::
      pip install pyhdfe
  You can upgrade to a newer release with the ``--upgrade`` flag::
      pip install --upgrade pyhdfe
  If you lack permissions, you can install PyHDFE in your user directory with the ``--user`` flag::
      pip install --user pyhdfe
  Alternatively, you can download a wheel or source archive from `PyPI <https://pypi.org/project/pyhdfe/>`_. You can find the latest development code on `GitHub <https://github.com/jeffgortmaker/pyhdfe/>`_ and the latest development documentation `here <https://pyhdfe.readthedocs.io/en/latest/>`_.


pkgId: 6a5c8e8983517b22fdf9ab64dc1bae215eec52fa380101b612e99e2b27135ad3
name: python-pyhocon
arch: src
version: 0.3.60
epoch: 0
release: 1
summary: HOCON parser for Python
url: http://github.com/chimpler/pyhocon/
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d38fbf86-9ed0-4ceb-aa8b-141749ce6907
location_href: 00009774-python-pyhocon/python-pyhocon-0.3.60-1.src.rpm
checksum_type: sha256
description:
  pyhocon is a HOCON parser for Python. Additionally we provide a tool (pyhocon) to convert any HOCON content into json, yaml and properties format.


pkgId: 3273bbd5b56dc260a769520a5a67d0e3b1c3b81baa3a4180ca25cc9b171742cd
name: python-pyhumps
arch: src
version: 3.8.0
epoch: 0
release: 1
url: https://github.com/nficano/humps
rpm_license: The Unlicense (Unlicense)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ca72a267-0aa1-4b81-81ad-d3f25e81ca13
location_href: 00010203-python-pyhumps/python-pyhumps-3.8.0-1.src.rpm
checksum_type: sha256
summary:
  🐫  Convert strings (and dictionary keys) between snake case, camel case and pascal case in Python. Inspired by Humps for Node

description:
  <p align="center">
    <img src="https://raw.githubusercontent.com/nficano/humps/master/artwork/humps.png" alt="Humps logo" width="245" height="118">
  </p>

  <div align="center">
    <a href="http://humps.readthedocs.io/en/latest/?badge=latest">
      <img src="https://readthedocs.org/projects/humps/badge/?version=latest" />
    </a>
    <a href="https://coveralls.io/github/nficano/humps?branch=master">
      <img src="https://coveralls.io/repos/github/nficano/humps/badge.svg?branch=master#cachebus" />
    </a>
    <a href="https://pypi.org/project/pyhumps/">
      <img src="https://img.shields.io/pypi/v/pyhumps.svg#cachebust" />
    </a>
    <a href="https://pypi.org/project/pyhumps/">
      <img src="https://img.shields.io/pypi/dm/pyhumps.svg" />
    </a>
    <a href="https://pypi.python.org/pypi/pyhumps/">
      <img src="https://img.shields.io/pypi/pyversions/pyhumps.svg" />
    </a>
  </div>
  </p>

  Convert strings (and dictionary keys) between snake case, camel case and pascal case in Python. Inspired by [Humps](https://github.com/domchristie/humps) for Node.



  Please email me at nficano@gmail.com.



  To install humps, simply use pipenv (or pip, of course):

  ```bash
  $ pipenv install pyhumps
  ```





  ```python
  import humps

  humps.camelize("jack_in_the_box")  # jackInTheBox
  humps.decamelize("rubyTuesdays")  # ruby_tuesdays
  humps.pascalize("red_robin")  # RedRobin
  humps.kebabize("white_castle")  # white-castle
  ```



  ```python
  import humps

  array = [{"attrOne": "foo"}, {"attrOne": "bar"}]
  humps.decamelize(array) # [{"attr_one": "foo"}, {"attr_one": "bar"}]

  array = [{"attr_one": "foo"}, {"attr_one": "bar"}]
  humps.camelize(array)  # [{"attrOne": "foo"}, {"attrOne": "bar"}]

  array = [{'attr_one': 'foo'}, {'attr_one': 'bar'}]
  humps.kebabize(array)  # [{'attr-one': 'foo'}, {'attr-one': 'bar'}]

  array = [{"attr_one": "foo"}, {"attr_one": "bar"}]
  humps.pascalize(array)  # [{"AttrOne": "foo"}, {"AttrOne": "bar"}]
  ```



  ```python
  import humps

  humps.is_camelcase("illWearYourGranddadsClothes")  # True
  humps.is_pascalcase("ILookIncredible")  # True
  humps.is_snakecase("im_in_this_big_ass_coat")  # True
  humps.is_kebabcase('from-that-thrift-shop')  # True
  humps.is_camelcase("down_the_road")  # False

  humps.is_snakecase("imGonnaPopSomeTags")  # False
  humps.is_kebabcase('only_got_twenty_dollars_in_my_pocket')  # False



  humps.decamelize("APIResponse")  # api_response
  ```

  <hr>





  ```python

  import humps
  import boto3

  def api(service, decamelize=True, *args, **kwargs):
      service, func = service.split(":")
      client = boto3.client(service)
      kwargs = humps.pascalize(kwargs)
      response = getattr(client, func)(*args, **kwargs)
      return (depascalize(response) if decamelize else response)


  api("s3:download_file", bucket="bucket", key="hello.png", filename="hello.png")
  ```


pkgId: 1884f9e681cad7e343a0864d5bfae3fdf92638b482db6237f0356760cc8005df
name: python-pyi2cflash
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: I2C eeprom device drivers (pure Python)
url: http://github.com/eblot/pyi2cflash
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c99404f7-99de-4050-8613-bfe9dba559ab
location_href: 00004705-python-pyi2cflash/python-pyi2cflash-0.2.2-1.src.rpm
checksum_type: sha256
description:
  I2C eeprom device drivers (pure Python)
  I2C flash devices, also known as *DataFlash* are commonly found in embedded
  products, to store firmware, microcode or configuration parameters.
  PyI2CFlash_ comes with several pure Python drivers for those flash devices, that
  demonstrate use of I2C devices with PyFtdi_. It could also be useful to dump
  flash contents or recover from a bricked devices.


pkgId: 0e06f4f5f12af47c220446730314f5ed327cf0f40ec375340c6d53d4361892fc
name: python-pyinels
arch: src
version: 0.6.11
epoch: 0
release: 1
summary: Python library for iNels BUS
url: https://github.com/JH-Soft-Technology/pyinels
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0aa05f68-d3f7-477c-9fd5-b5d903885cb8
location_href: 00004707-python-pyinels/python-pyinels-0.6.11-1.src.rpm
checksum_type: sha256
description:
  A Python library that handles communication with proprietary home intelligent system
  named [iNels](https://www.inels.com/) by ElkoEP company.
  This package is developed against iNels BUS version. It is not tested on older
  version CU2 and does not support RF components.


pkgId: e8fc7c2c8a5373c819eb45b1e4a535044d9fecda012c0c5e748c47d1e3ae6c96
name: python-pyinotify
arch: src
version: 0.9.6
epoch: 0
release: 1
summary: Linux filesystem events monitoring
url: http://github.com/seb-m/pyinotify
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9e482d88-13dc-49a5-a182-0e90eb364296
location_href: 00009884-python-pyinotify/python-pyinotify-0.9.6-1.src.rpm
checksum_type: sha256
description:
  * License          : MIT
  * Project URL      : [http://github.com/seb-m/pyinotify](http://github.com/seb-m/pyinotify)
  * Project Wiki     : [http://github.com/seb-m/pyinotify/wiki](http://github.com/seb-m/pyinotify/wiki)
  * API Documentation: [http://seb-m.github.com/pyinotify](http://seb-m.github.com/pyinotify)




  * Linux ≥ 2.6.13
  * Python ≥ 2.4 (including Python 3.x)






      
      $ sudo pip install pyinotify



      
      
      $ sudo pythonXXX setup.py install




  Install pyinotify and run this command from a shell:

      $ python -m pyinotify -v /my-dir-to-watch


pkgId: d9c2b9684239e83e195f39dc6e8fb1d903ea304569bc383b2b28b8d884ddee32
name: python-pyinsane2
arch: src
version: 2.0.13
epoch: 0
release: 1
summary: Python library to access and use image scanners (Linux/Windows/etc)
url: https://github.com/openpaperwork/pyinsane
rpm_license: GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-28051670-e655-45fd-aa95-76e038a9f81d
location_href: 00004708-python-pyinsane2/python-pyinsane2-2.0.13-1.src.rpm
checksum_type: sha256
description:
  Python library to access and use image scanners (devices). Works on GNU/Linux (Sane), *BSD (Sane), Windows >= Vista (WIA 2), MacOSX (Sane), etc.


pkgId: 03bd3fb68d20ded05efd6cf2eb354459ec127bd2564b43a4f93d2bf40fc980dd
name: python-pyinstrument
arch: src
version: 4.4.0
epoch: 0
release: 1
summary: Call stack profiler for Python. Shows you why your code is slow!
url: https://github.com/joerick/pyinstrument
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1910916b-27d6-45ee-8e0a-ccc3c9083893
location_href: 00010436-python-pyinstrument/python-pyinstrument-4.4.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/pyinstrument.svg)](https://badge.fury.io/py/pyinstrument)
  [![.github/workflows/test.yml](https://github.com/joerick/pyinstrument/actions/workflows/test.yml/badge.svg)](https://github.com/joerick/pyinstrument/actions/workflows/test.yml)
  [![Build wheels](https://github.com/joerick/pyinstrument/actions/workflows/wheels.yml/badge.svg)](https://github.com/joerick/pyinstrument/actions/workflows/wheels.yml)
  [Documentation](https://pyinstrument.readthedocs.io/)
  <!-- MARK intro start -->
  [![Screenshot](docs/img/screenshot.jpg)](https://raw.githubusercontent.com/joerick/pyinstrument/main/docs/img/screenshot.jpg)
  Pyinstrument is a Python profiler. A profiler is a tool to help you optimize
  your code - make it faster. To get the biggest speed increase you should
  [focus on the slowest part of your program](https://en.wikipedia.org/wiki/Amdahl%27s_law).
  Pyinstrument helps you find it!
  > ☕️ Not sure where to start? Check out this [video tutorial from calmcode.io](https://calmcode.io/pyinstrument/introduction.html)!
  <!-- MARK intro end -->


pkgId: 878ff14c4c2c49bbc698fc8964fc5841d4c8a9331ee6a0b32bce34faf6fdc82c
name: python-pyinstrument-debuginfo
arch: x86_64
version: 4.4.0
epoch: 0
release: 1
summary: Debug information for package python-pyinstrument
url: https://github.com/joerick/pyinstrument
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-1910916b-27d6-45ee-8e0a-ccc3c9083893
rpm_sourcerpm: python-pyinstrument-4.4.0-1.src.rpm
location_href: 00010436-python-pyinstrument/python-pyinstrument-debuginfo-4.4.0-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pyinstrument.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: a339473acccc8871dc00d459ba1bfa4895ed749c894e0778226be01f768442f4
name: python-pyinstrument-debugsource
arch: x86_64
version: 4.4.0
epoch: 0
release: 1
summary: Debug sources for package python-pyinstrument
url: https://github.com/joerick/pyinstrument
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-1910916b-27d6-45ee-8e0a-ccc3c9083893
rpm_sourcerpm: python-pyinstrument-4.4.0-1.src.rpm
location_href: 00010436-python-pyinstrument/python-pyinstrument-debugsource-4.4.0-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pyinstrument.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 4f9867d2dd792d36c3d13509b6fc199c5ac444df1712cee43707cbf391753d4d
name: python-pyiqvia
arch: src
version: 2022.10.0
epoch: 0
release: 1
summary: A clean, async-focused Python3 API for IQVIA data
url: https://github.com/bachya/pyiqvia
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-611cb3aa-7b29-4f81-801f-b0dfc13a16a6
location_href: 00004709-python-pyiqvia/python-pyiqvia-2022.10.0-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/bachya/pyiqvia/workflows/CI/badge.svg)](https://github.com/bachya/pyiqvia/actions)
  [![PyPi](https://img.shields.io/pypi/v/pyiqvia.svg)](https://pypi.python.org/pypi/pyiqvia)
  [![Version](https://img.shields.io/pypi/pyversions/pyiqvia.svg)](https://pypi.python.org/pypi/pyiqvia)
  [![License](https://img.shields.io/pypi/l/pyiqvia.svg)](https://github.com/bachya/pyiqvia/blob/master/LICENSE)
  [![Code Coverage](https://codecov.io/gh/bachya/pyiqvia/branch/dev/graph/badge.svg)](https://codecov.io/gh/bachya/pyiqvia)
  [![Maintainability](https://api.codeclimate.com/v1/badges/3bf37f9cabf73b5d991e/maintainability)](https://codeclimate.com/github/bachya/pyiqvia/maintainability)
  [![Say Thanks](https://img.shields.io/badge/SayThanks-!-1EAEDB.svg)](https://saythanks.io/to/bachya)

  <a href="https://www.buymeacoffee.com/bachya1208P" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/default-orange.png" alt="Buy Me A Coffee" height="41" width="174"></a>

  `pyiqvia` is an async-focused Python3 library for allergen, asthma, and disease
  data from the [IQVIA™](https://www.iqvia.com) family of websites (such as
  https://pollen.com, https://flustar.com, and more).

  - [Python Versions](#python-versions)
  - [Installation](#installation)
  - [Usage](#usage)
  - [Contributing](#contributing)



  `pyiqvia` is currently supported on:

  - Python 3.9
  - Python 3.10
  - Python 3.11



  ```bash
  pip install pyiqvia
  ```



  ```python
  import asyncio

  from aiohttp import ClientSession

  from pyiqvia import Client


  async def main() -> None:
      """Run!"""
      
      client = Client("80012")

      
      await client.allergens.current()

      
      await client.allergens.outlook()

      
      await client.allergens.extended()

      
      await client.allergens.historic()

      
      await client.asthma.current()

      
      await client.asthma.extended()

      
      await client.asthma.historic()

      
      await client.disease.current()

      
      await client.disease.extended()

      
      await client.disease.historic()


  asyncio.run(main())
  ```



  By default, `pyiqvia` will retry appropriate errors 4 times (with an exponentially
  increasing delay in-between). This logic can be changed by passing a different value for
  `request_retries` to the `Client` constructor:

  ```python
  import asyncio

  from pyiqvia import Client


  async def main():
      client = Client("80012", request_retries=5)

      


  asyncio.run(main())
  ```



  By default, the library creates a new connection to IQVIA with each coroutine. If you
  are calling a large number of coroutines (or merely want to squeeze out every second of
  runtime savings possible), an
  [`aiohttp`](https://github.com/aio-libs/aiohttp) `ClientSession` can be used for connection
  pooling:

  ```python
  import asyncio

  from aiohttp import ClientSession

  from pyiqvia import Client


  async def main() -> None:
      """Run!"""
      async with ClientSession() as session:
          client = Client("80012", session=session)

          


  asyncio.run(main())
  ```



  1. [Check for open features/bugs](https://github.com/bachya/pyiqvia/issues)
     or [initiate a discussion on one](https://github.com/bachya/pyiqvia/issues/new).
  2. [Fork the repository](https://github.com/bachya/pyiqvia/fork).
  3. (_optional, but highly recommended_) Create a virtual environment: `python3 -m venv .venv`
  4. (_optional, but highly recommended_) Enter the virtual environment: `source ./.venv/bin/activate`
  5. Install the dev environment: `script/setup`
  6. Code your new feature or bug fix.
  7. Write tests that cover your new functionality.
  8. Run tests and ensure 100% code coverage: `nox -rs coverage`
  9. Update `README.md` with any new documentation.
  10. Add yourself to `AUTHORS.md`.
  11. Submit a pull request!


pkgId: 58da24b9d9ea15fa1cc9b6355a4745c7c9055bffef6053a272644018e22cccc6
name: python-pyiso8583
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: A serializer and deserializer of ISO8583 data.
url: https://github.com/knovichikhin/pyiso8583
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6463cb74-d07f-43ff-9bc9-836e665dcedd
location_href: 00011698-python-pyiso8583/python-pyiso8583-2.2.0-1.src.rpm
checksum_type: sha256
description:
  |pypi| |docs| |coverage|
  ``iso8583`` package serializes and deserializes ISO8583 data between
  raw ``bytes`` ISO8583 data and a regular Python ``dict``.
  ``iso8583`` package supports custom `specifications <https://pyiso8583.readthedocs.io/en/latest/specifications.html>`_
  that can define:
  - Field length and data encoding, such as BCD, ASCII, EBCDIC, etc.
  - Field length count measured in bytes or nibbles.
  - Field type, such as fixed, LLVAR, LLLVAR, etc.
  - Maximum length
  - Optional field description
  Multiple specifications can co-exist to support ISO8583 messages for POS, ATM,
  file actions, and so on. Simply define a new specification dictionary. ``iso8583``
  package includes a starter specification in ``iso8583.specs`` module that can be
  used as a base to create own custom/proprietary specifications.
  Additional information is available on `Read The Docs <http://pyiso8583.readthedocs.org>`_.


pkgId: 7b92c246c2f449fefaca9dc452888ae5fb7a309150c1d3d608137699ca3aba9d
name: python-pyjarowinkler
arch: src
version: 1.8
epoch: 0
release: 1
summary: Find the Jaro Winkler Distance which indicates the similarity score between two Strings
url: https://github.com/nap/jaro-winkler-distance
rpm_license: http://www.apache.org/licenses/
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b46e4be6-4b3b-4042-804c-59bcefe149dc
location_href: 00010983-python-pyjarowinkler/python-pyjarowinkler-1.8-1.src.rpm
checksum_type: sha256
description:
  Find the Jaro Winkler Distance which indicates the similarity score between two Strings.
  The Jaro measure is the weighted sum of percentage of matched characters from each file
  and transposed characters. Winkler increased this measure for matching initial characters.


pkgId: c17d4d184bef4cbd6743c16ebdddb9ef7e864ee7bfc1f691cebbbf975b60343d
name: python-pyjks
arch: src
version: 20.0.0
epoch: 0
release: 1
summary: Pure-Python Java Keystore (JKS) library
url: http://github.com/kurtbrose/pyjks
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-baa9dae6-531f-4651-8e94-4e12c9127b98
location_href: 00010949-python-pyjks/python-pyjks-20.0.0-1.src.rpm
checksum_type: sha256
description:
  PyJKS enables Python projects to load and manipulate Java KeyStore
  (JKS) data without a JVM dependency. PyJKS supports JKS, JCEKS, BKS
  and UBER (BouncyCastle) keystores. Simply::

    pip install pyjks

  Or::

    easy_install pyjks

  Then::

    import jks

    keystore = jks.KeyStore.load('keystore.jks', 'passphrase')

    print(keystore.private_keys)
    print(keystore.certs)
    print(keystore.secret_keys)

  And that's barely scratching the surface. Check out `the usage examples on
  GitHub <https://github.com/kurtbrose/pyjks#usage-examples>`_ for
  more!


pkgId: 5768509066538d0f7c1559419c7c6e50f932805d7b9ad92b51b4d1589b4d702a
name: python-pyjnius
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: A Python module to access Java classes as Python classes using JNI.
url: https://github.com/kivy/pyjnius
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-279e9e1d-b585-446e-a31c-2c9f99cd3c5f
location_href: 00004710-python-pyjnius/python-pyjnius-1.4.2-1.src.rpm
checksum_type: sha256
description:
  A Python module to access Java classes as Python classes using the Java Native
  Interface (JNI).
  Warning: the pypi name is now `pyjnius` instead of `jnius`.
  [![Tests](https://github.com/kivy/pyjnius/workflows/Continuous%20Integration/badge.svg)](https://github.com/kivy/pyjnius/actions)
  [![Tests (x86)](https://github.com/kivy/pyjnius/workflows/Continuous%20Integration%20(x86)/badge.svg)](https://github.com/kivy/pyjnius/actions)
  [![Builds](https://github.com/kivy/pyjnius/workflows/Continuous%20Delivery/badge.svg)](https://github.com/kivy/pyjnius/actions)
  [![PyPI](https://img.shields.io/pypi/v/pyjnius.svg)]()
  [![Backers on Open Collective](https://opencollective.com/kivy/backers/badge.svg)](#backers)
  [![Sponsors on Open Collective](https://opencollective.com/kivy/sponsors/badge.svg)](#sponsors)


pkgId: 12b47178b570e8f7dda17ca12f146c889ea10d1e736edf45af2f3d9cd88abcd8
name: python-pyjson5-debuginfo
arch: x86_64
version: 1.6.2
epoch: 0
release: 1
summary: Debug information for package python-pyjson5
url: https://github.com/Kijewski/pyjson5
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-d628bf21-1757-412a-9407-565ac9c034f7
rpm_sourcerpm: python-pyjson5-1.6.2-1.src.rpm
location_href: 00013113-python-pyjson5/python-pyjson5-debuginfo-1.6.2-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pyjson5.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 49a3ba3c7b237acde2c64f14c52e890e87c28407af6945f60c842531ecd43074
name: python-pyjson5-debugsource
arch: x86_64
version: 1.6.2
epoch: 0
release: 1
summary: Debug sources for package python-pyjson5
url: https://github.com/Kijewski/pyjson5
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-d628bf21-1757-412a-9407-565ac9c034f7
rpm_sourcerpm: python-pyjson5-1.6.2-1.src.rpm
location_href: 00013113-python-pyjson5/python-pyjson5-debugsource-1.6.2-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pyjson5.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 33fb330f7fcbce893683cd088bb99db12d19c5bfd505ec194e751937795e7cfd
name: python-pykafka
arch: src
version: 2.8.0
epoch: 0
release: 1
summary: Full-Featured Pure-Python Kafka Client
url: https://github.com/Parsely/pykafka
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-67f81bc3-2bd0-4c45-a239-982911a61266
location_href: 00004712-python-pykafka/python-pykafka-2.8.0-1.src.rpm
checksum_type: sha256
description:
  PyKafka is a programmer-friendly Kafka client for Python. It includes Python
  implementations of Kafka producers and consumers, which are optionally backed
  by a C extension built on `librdkafka`_. It runs under Python 2.7+, Python 3.4+,
  and PyPy, and supports versions of Kafka 0.8.2 and newer.
  PyKafka's primary goal is to provide a similar level of abstraction to the
  `JVM Kafka client`_ using idioms familiar to Python programmers and exposing
  the most Pythonic API possible.
  You can install PyKafka from PyPI with
      $ pip install pykafka
  or from conda-forge with
      $ conda install -c conda-forge pykafka
  Full documentation and usage examples for PyKafka can be found on `readthedocs`_.
  You can install PyKafka for local development and testing by cloning this repository and
  running
      $ python setup.py develop


pkgId: ec29a24d3db9af8aac8d149c3d2291b930d6df639ed106e6948eb8ee5f96d500
name: python-pykeepass
arch: src
version: 4.0.3
epoch: 0
release: 1
summary: Python library to interact with keepass databases (supports KDBX3 and KDBX4)
url: https://github.com/libkeepass/pykeepass
rpm_license: GPL3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-298f9c06-6c89-46d5-8c3a-be8e1630db8c
location_href: 00004717-python-pykeepass/python-pykeepass-4.0.3-1.src.rpm
checksum_type: sha256
description:
  This library allows you to write entries to a KeePass database.
  Come chat at `#pykeepass`_ on Freenode or `#pykeepass:matrix.org`_ on Matrix.


pkgId: 7e15db4ff299066d1476ec0c91d1f7770574872b356a90705e9d4bdddf2c6fa9
name: python-pykka
arch: src
version: 3.1.1
epoch: 0
release: 1
summary: Pykka is a Python implementation of the actor model
url: https://github.com/jodal/pykka
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-65f1bdfb-b7a4-4284-b78d-bd8d977f60eb
location_href: 00002877-python-Pykka/python-pykka-3.1.1-1.src.rpm
checksum_type: sha256
description:
  Pykka is a Python implementation of the
  [actor model](https://en.wikipedia.org/wiki/Actor_model).
  The actor model introduces some simple rules to control
  the sharing of state and cooperation between execution units,
  which makes it easier to build concurrent applications.
  For a quickstart guide and a complete API reference,
  see the [documentation](https://pykka.readthedocs.io/).

  Pykka requires Python 3.7 or newer.
  Pykka is available from [PyPI](https://pypi.org/project/pykka/):
  ```
  python3 -m pip install pykka
  ```

  - [Documentation](https://pykka.readthedocs.io/)
  - [Source code](https://github.com/jodal/pykka)
  - [Releases](https://github.com/jodal/pykka/releases)
  - [Issue tracker](https://github.com/jodal/pykka/issues)
  - [Contributors](https://github.com/jodal/pykka/graphs/contributors)
  - [Users](https://github.com/jodal/pykka/wiki/Users)

  Pykka is copyright 2010-2022 Stein Magnus Jodal and contributors.
  Pykka is licensed under the
  [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0).


pkgId: 98413c207731bc57de4e66e06edeb0da6080401f3bf9d3d3410400419fb7e78f
name: python-pyknp
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Python module for JUMAN/KNP
url: https://github.com/ku-nlp/pyknp
rpm_license: See COPYING
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0720ce37-2087-4965-81ee-a68453208210
location_href: 00012380-python-pyknp/python-pyknp-0.6.1-1.src.rpm
checksum_type: sha256
description:
  形態素解析器JUMAN++(JUMAN)と構文解析器KNPのPythonバインディング (Python2系と3系の両方に対応)。


  - Python
      - Verified Versions: 2.7.15,  3.7.11
  - 形態素解析器 [JUMAN++](http://nlp.ist.i.kyoto-u.ac.jp/index.php?JUMAN++) [[EN](http://nlp.ist.i.kyoto-u.ac.jp/EN/index.php?JUMAN++)]
  (or [JUMAN](http://nlp.ist.i.kyoto-u.ac.jp/index.php?JUMAN)[[EN](http://nlp.ist.i.kyoto-u.ac.jp/EN/index.php?JUMAN)])
      - JUMAN++ はJUMANの後継にあたる形態素解析器
  - 構文解析器 [KNP](http://nlp.ist.i.kyoto-u.ac.jp/index.php?KNP) [[EN](http://nlp.ist.i.kyoto-u.ac.jp/EN/index.php?KNP)]


  ```
  $ pip install pyknp
  ```


  https://pyknp.readthedocs.io/en/latest/



  京都大学 黒橋・河原研究室 (contact@nlp.ist.i.kyoto-u.ac.jp)
  - John Richardson, Tomohide Shibata, Yuta Hayashibe, Tomohiro Sakaguchi


pkgId: e087c05a17804d95bdb63573e2efebb9a39c0501fc98b5c3ba0ed2c479c6bb17
name: python-pykube-ng
arch: src
version: 22.9.0
epoch: 0
release: 1
summary: Python client library for Kubernetes
url: https://codeberg.org/hjacobs/pykube-ng
rpm_license: Apache
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8623c7f8-0711-4b72-baa9-1b8c0646f16e
location_href: 00012292-python-pykube-ng/python-pykube-ng-22.9.0-1.src.rpm
checksum_type: sha256
description:
  Pykube (pykube-ng) is a lightweight Python 3.6+ client library for Kubernetes.
  This is a fork of `kelproject/pykube <https://github.com/kelproject/pykube>`_ which is no longer maintained (archived). Here the original text of the pykube README:
      Kel is an open source Platform as a Service (PaaS) from Eldarion, Inc. that
      makes it easy to manage web application deployment and hosting through the
      entire lifecycle from development through testing to production. It adds
      components and tools on top of Kubernetes that help developers manage their
      application infrastructure. Kel builds on Eldarion's 7+ years experience running
      one of the leading Python and Django PaaSes.
      For more information about Kel, see `kelproject.com`_ or follow us on Twitter
      `@projectkel`_.


pkgId: 3f0ca823d39eb5f7f1587050003834e97d30b61b6a647c2ec2281c72ea9fe532
name: python-pylast
arch: src
version: 5.1.0
epoch: 0
release: 1
summary: A Python interface to Last.fm and Libre.fm
url: https://github.com/pylast/pylast
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0c97f69c-d108-4d3b-a98b-fc66d9360b7b
location_href: 00004719-python-pylast/python-pylast-5.1.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/pylast.svg)](https://pypi.org/project/pylast/)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/pylast.svg)](https://pypi.org/project/pylast/)
  [![PyPI downloads](https://img.shields.io/pypi/dm/pylast.svg)](https://pypistats.org/packages/pylast)
  [![Test](https://github.com/pylast/pylast/workflows/Test/badge.svg)](https://github.com/pylast/pylast/actions)
  [![Coverage (Codecov)](https://codecov.io/gh/pylast/pylast/branch/main/graph/badge.svg)](https://codecov.io/gh/pylast/pylast)
  [![Code style: Black](https://img.shields.io/badge/code%20style-Black-000000.svg)](https://github.com/psf/black)
  [![DOI](https://zenodo.org/badge/7803088.svg)](https://zenodo.org/badge/latestdoi/7803088)

  A Python interface to [Last.fm](https://www.last.fm/) and other API-compatible websites
  such as [Libre.fm](https://libre.fm/).

  Use the pydoc utility for help on usage or see [tests/](tests/) for examples.



  Install via pip:

  ```sh
  python3 -m pip install pylast
  ```

  Install latest development version:

  ```sh
  python3 -m pip install -U git+https://github.com/pylast/pylast
  ```

  Or from requirements.txt:

  ```txt
  -e https://github.com/pylast/pylast.git#egg=pylast
  ```

  Note:

  * pyLast 5.1+ supports Python 3.7-3.11.
  * pyLast 5.0+ supports Python 3.7-3.10.
  * pyLast 4.3+ supports Python 3.6-3.10.
  * pyLast 4.0 - 4.2 supports Python 3.6-3.9.
  * pyLast 3.2 - 3.3 supports Python 3.5-3.8.
  * pyLast 3.0 - 3.1 supports Python 3.5-3.7.
  * pyLast 2.2 - 2.4 supports Python 2.7.10+, 3.4-3.7.
  * pyLast 2.0 - 2.1 supports Python 2.7.10+, 3.4-3.6.
  * pyLast 1.7 - 1.9 supports Python 2.7, 3.3-3.6.
  * pyLast 1.0 - 1.6 supports Python 2.7, 3.3-3.4.
  * pyLast 0.5 supports Python 2, 3.
  * pyLast < 0.5 supports Python 2.



   * Simple public interface.
   * Access to all the data exposed by the Last.fm web services.
   * Scrobbling support.
   * Full object-oriented design.
   * Proxy support.
   * Internal caching support for some web services calls (disabled by default).
   * Support for other API-compatible networks like Libre.fm.




  Here's some simple code example to get you started. In order to create any object from
  pyLast, you need a `Network` object which represents a social music network that is
  Last.fm or any other API-compatible one. You can obtain a pre-configured one for Last.fm
  and use it as follows:

  ```python
  import pylast



  API_KEY = "b25b959554ed76058ac220b7b2e0a026"  # this is a sample key
  API_SECRET = "425b55975eed76058ac220b7b4e8a054"


  username = "your_user_name"
  password_hash = pylast.md5("your_password")

  network = pylast.LastFMNetwork(
      api_key=API_KEY,
      api_secret=API_SECRET,
      username=username,
      password_hash=password_hash,
  )


  track = network.get_track("Iron Maiden", "The Nomad")
  track.love()
  track.add_tags(("awesome", "favorite"))



  ```

  More examples in
  <a href="https://github.com/hugovk/lastfm-tools">hugovk/lastfm-tools</a> and
  [tests/](https://github.com/pylast/pylast/tree/main/tests).



  The [tests/](https://github.com/pylast/pylast/tree/main/tests) directory contains
  integration and unit tests with Last.fm, and plenty of code examples.

  For integration tests you need a test account at Last.fm that will become cluttered with
  test data, and an API key and secret. Either copy
  [example_test_pylast.yaml](example_test_pylast.yaml) to test_pylast.yaml and fill out
  the credentials, or set them as environment variables like:

  ```sh
  export PYLAST_USERNAME=TODO_ENTER_YOURS_HERE
  export PYLAST_PASSWORD_HASH=TODO_ENTER_YOURS_HERE
  export PYLAST_API_KEY=TODO_ENTER_YOURS_HERE
  export PYLAST_API_SECRET=TODO_ENTER_YOURS_HERE
  ```

  To run all unit and integration tests:

  ```sh
  python3 -m pip install -e ".[tests]"
  pytest
  ```

  Or run just one test case:

  ```sh
  pytest -k test_scrobble
  ```

  To run with coverage:

  ```sh
  pytest -v --cov pylast --cov-report term-missing
  coverage report # for command-line report
  coverage html   # for HTML report
  open htmlcov/index.html
  ```



  To enable from your own code:

  ```python
  import logging
  import pylast

  logging.basicConfig(level=logging.INFO)


  network = pylast.LastFMNetwork(...)
  ```

  To enable from pytest:

  ```sh
  pytest --log-cli-level info -k test_album_search_images
  ```

  To also see data returned from the API, use `level=logging.DEBUG` or
  `--log-cli-level debug` instead.


pkgId: cf2745d3d28f032d2959eaecd4351589e2f09b61f54150ace7ffc9c6b0d89d4a
name: python-pylev
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: A pure Python Levenshtein implementation that's not freaking GPL'd.
url: http://github.com/toastdriven/pylev
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4f72991e-1c81-476d-838f-388cafa5748b
location_href: 00004721-python-pylev/python-pylev-1.4.0-1.src.rpm
checksum_type: sha256
description:
  A pure Python Levenshtein implementation that's not freaking GPL'd.
  Based off the Wikipedia code samples at
  http://en.wikipedia.org/wiki/Levenshtein_distance.


pkgId: 4dad4729f55c290e46b08c2006c02400105bbfef7f163af4213d99136ef6d5a2
name: python-pylibacl
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: POSIX.1e ACLs for python
url: https://pylibacl.k1024.org/
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3bef96ff-4669-4bff-8be5-e6a2ce135554
location_href: 00004722-python-pylibacl/python-pylibacl-0.6.0-1.src.rpm
checksum_type: sha256
description:
  This is a C extension module for Python which
  implements POSIX ACLs manipulation. It is a wrapper on top
  of the systems's acl C library - see acl(5).


pkgId: 925de3b05df61cac69091a9425f595845d9bbc0edacb087ea09060a8912a15ae
name: python-pylibftdi
arch: src
version: 0.20.0
epoch: 0
release: 1
summary: Pythonic interface to FTDI devices using libftdi
url: https://github.com/codedstructure/pylibftdi
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-24723c63-a99c-47e4-a6c7-8e5d2d0a3233
location_href: 00010719-python-pylibftdi/python-pylibftdi-0.20.0-1.src.rpm
checksum_type: sha256
description:
  pylibftdi is a minimal Pythonic interface to FTDI devices using libftdi_.
   - No dependencies beyond standard library and a `libftdi` install.
   - Supports parallel and serial devices
   - Support for multiple devices
   - File-like interface wherever appropriate
   - Cross-platform
   - The API might change prior to reaching a 1.0 release.


pkgId: f07c771bdfe874e7f6f60b31e9f5cce3bcea6e8ff7d15136dc581bcd7c517857
name: python-pyliblo
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: Python bindings for the liblo OSC library
url: http://das.nasophon.de/pyliblo/
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-569dc054-ed52-4900-8099-8804d6a5f0d5
location_href: 00004723-python-pyliblo/python-pyliblo-0.10.0-1.src.rpm
checksum_type: sha256
description:
  * Python >= 2.6 (also works with 3.x) [http://www.python.org/]
  * Cython [http://www.cython.org/]
  * liblo >= 0.27 [http://liblo.sourceforge.net/]


pkgId: e4d7eb98c15fa7d32541ca2f172f47b9ebdf86f40530f206da64bde205406ca8
name: python-pylibmc
arch: src
version: 1.6.3
epoch: 0
release: 1
summary: Quick and small memcached client for Python
url: https://sendapatch.se/projects/pylibmc/
rpm_license: 3-clause BSD <https://opensource.org/licenses/bsd-license.php>
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e39e83ff-7096-4a62-961c-3612f92cd57f
location_href: 00004724-python-pylibmc/python-pylibmc-1.6.3-1.src.rpm
checksum_type: sha256
description:
  Though no major feature overhauls have taken place, this release is partially
  incompatible with 1.5.0. This stems from the fact that python-memcached is now
  using a flag that pylibmc has been using for some years. python-memcached uses
  it for a different purpose, and an incompatible one. We deemed that it would be
  better to support this interoperability. The change also means that Unicode
  strings are now stored as UTF-8 rather than pickled, which may or may not
  result in a slight performance improvement for this type of data.
  We have also introduced a `pickle_protocol` behavior to enable seamless
  interoperability between Python 2.x and 3.x. Also, this release introduces a
  ManyLinux wheel, making installation a breeze on ManyLinux systems (which I
  suppose is many linuxes.)


pkgId: 353c96664d599466132b944f360052211b4cef268adc1be3230430a1df1e1fb3
name: python-pylint-celery
arch: src
version: 0.3
epoch: 0
release: 1
description: UNKNOWN
url: https://github.com/landscapeio/pylint-celery
rpm_license: GPLv2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cf5b7b60-553c-4f19-8a45-e1722159c1e1
location_href: 00010616-python-pylint-celery/python-pylint-celery-0.3-1.src.rpm
checksum_type: sha256
summary:
  pylint-celery is a Pylint plugin to aid Pylint in recognising and understandingerrors caused when using the Celery library


pkgId: 6358edaabebee1343b9d49cf646c493a764dc8dec1092149b794df16b4a70f6a
name: python-pylint-fail-under
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Pylint wrapper that verifies code reaches a minimum quality score.
url: https://github.com/TNThieding/pylint-fail-under
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cba65723-b23c-43a3-8f83-3b4e929659d3
location_href: 00013738-python-pylint-fail-under/python-pylint-fail-under-0.3.0-1.src.rpm
checksum_type: sha256
description:
      Your code has been rated at 9.49/10 (previous run: 9.49/10, +0.00)
  Otherwise, if the Pylint score is under the minimum, the script exits with a non-zero exit code. For
  example::
      $ pylint-fail-under --fail_under 9.75 my_package
      ************* Module my_package
      my_package\__init__.py:1:0: C0111: Missing module docstring (missing-docstring)


pkgId: 7fa7e7a3bdc62956c996c8127a1846a4fef1601ad1fc233a1561f2375c23d1cb
name: python-pylint-flask
arch: src
version: 0.6
epoch: 0
release: 1
url: https://github.com/jschaf/pylint-flask
rpm_license: GPLv2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4463af3b-d292-4c31-a313-ae9f48ee9f71
location_href: 00010794-python-pylint-flask/python-pylint-flask-0.6-1.src.rpm
checksum_type: sha256
summary:
  pylint-flask is a Pylint plugin to aid Pylint in recognizing and understanding errors caused when using Flask


pkgId: fea54b4b1c3655b6d6cd75f95e5cb04334e8ebf66404c7e64ddbd2f4a0c6da7a
name: python-pylogbeat
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Simple, incomplete implementation of the Beats protocol used by Elastic Beats and Logstash.
url: https://github.com/eht16/pylogbeat/
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d8b37d83-153f-4f87-aa72-7f41a4de89b9
location_href: 00012637-python-pylogbeat/python-pylogbeat-2.0.0-1.src.rpm
checksum_type: sha256
description:
  [![Travis CI](https://travis-ci.org/eht16/pylogbeat.svg?branch=master)](https://travis-ci.org/eht16/pylogbeat)
  [![PyPI](https://img.shields.io/pypi/v/pylogbeat.svg)](https://pypi.org/project/pylogbeat/)
  [![Python Versions](https://img.shields.io/pypi/pyversions/pylogbeat.svg)](https://pypi.org/project/pylogbeat/)
  [![License](https://img.shields.io/pypi/l/pylogbeat.svg)](https://pypi.org/project/pylogbeat/)
  PyLogBeat is a simple, incomplete implementation of the Beats protocol
  used by Elastic Beats and Logstash. For more information about Beats see
  https://www.elastic.co/products/beats and
  https://www.elastic.co/guide/en/logstash/current/plugins-inputs-beats.html.
  With this library it is possible to send log messages or any data to
  Logstash' beats input plugin or any other service which implements
  the Beats protocol.
  The main difference to other transport mechanisms like direct TCP
  or UDP transfer is that with the Beats protocol there is a higher
  reliability of the data transfer, especially since the server
  acknowledges the data it received so the client knows whether and
  what to resend.


pkgId: 5baf88e86f72587393c2b7865e8e67d23d797ee8af558bd6ed9169ec05cbdc29
name: python-pylotoncycle
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Module to access your Peloton workout data
url: https://github.com/justmedude/pylotoncycle
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dfd6e75c-fa79-4491-b4c7-de11a8d12211
location_href: 00004726-python-pylotoncycle/python-pylotoncycle-0.6.0-1.src.rpm
checksum_type: sha256
description:
  Python Library for getting your Peloton workout data.


  * [General info](#general-info)
  * [Example Usage](#example-usage)


  As someone who wants to see my progress over time, I've been wanting a way
  to pull and play with my ride data. However, I'm also cautious about linking
  myself to too many external parties. As I've been playing with other libraries
  out there, I wanted something that was a bit more intuitive and would play
  nicer with the rest of my python code. So, PylotonCycle is born.


  ```
  import pylotoncycle

  username = 'your username or email address'
  password = 'your password'
  conn = pylotoncycle.PylotonCycle(username, password)
  workouts = conn.GetRecentWorkouts(5)
  ```
  `workouts` is a list of workouts.

  An example of a list element

  ```
  {'achievement_templates': [{'description': 'Awarded for working out with a '
                                             'friend.',
                              'id': '<some id hash>',
                              'image_url': 'https://s3.amazonaws.com/peloton-achievement-images-prod/702495cd985d4791bfd3d25f36e0df72',
                              'name': 'Dynamic Duo',
                              'slug': 'two_to_tango'},
                             {'description': 'Awarded for achieving Silver in '
                                             'the May Cycling Challenge.',
                              'id': '<some id hash>',
                              'image_url': 'https://s3.amazonaws.com/challenges-and-tiers-image-prod/6b772477ccd04f189fba16f2f877faad',
                              'name': 'May Cycling Challenge',
                              'slug': 'may_cycling_challenge_silver'}],
   'created': 1589642476,
   'created_at': 1589642476,
   'device_time_created_at': 1589617276,
   'device_type': 'home_bike_v1',
   'device_type_display_name': 'Bike',
   'end_time': 1589644336,
   'fitbit_id': None,
   'fitness_discipline': 'cycling',
   'ftp_info': {'ftp': 111,
                'ftp_source': 'ftp_workout_source',
                'ftp_workout_id': '<some id hash>'},
   'has_leaderboard_metrics': True,
   'has_pedaling_metrics': True,
   'id': '<some id hash>',
   'instructor_name': 'Matt Wilpers',
   'is_total_work_personal_record': False,
   'leaderboard_rank': 5015,
   'metrics_type': 'cycling',
   'name': 'Cycling Workout',
   'overall_summary': {'avg_cadence': 85.48,
                       'avg_heart_rate': 0.0,
                       'avg_power': 179.24,
                       'avg_resistance': 47.61,
                       'avg_speed': 20.39,
                       'cadence': 0.0,
                       'calories': 496.71,
                       'distance': 10.19,
                       'heart_rate': 0.0,
                       'id': '<some id hash>',
                       'instant': 1589644336,
                       'max_cadence': 122.0,
                       'max_heart_rate': 0.0,
                       'max_power': 255.8,
                       'max_resistance': 60.95,
                       'max_speed': 23.48,
                       'power': 0.0,
                       'resistance': 0.0,
                       'seconds_since_pedaling_start': 0,
                       'speed': 0.0,
                       'total_work': 322417.21,
                       'workout_id': '<some id hash>'},
   'peloton_id': '<some id hash>',
   'platform': 'home_bike',
   'ride': {'captions': ['en-US'],
            'class_type_ids': ['<some id hash>'],
            'content_format': 'video',
            'content_provider': 'peloton',
            'description': 'Max out the effectiveness of your training with this '
                           'ride. Instructors will expertly guide you through '
                           'specific output ranges 1 through 7 to help you build '
                           'endurance, strength and speed.',
            'difficulty_estimate': 6.3779,
            'difficulty_level': None,
            'difficulty_rating_avg': 6.3779,
            'difficulty_rating_count': 17157,
            'duration': 1800,
            'equipment_ids': [],
            'equipment_tags': [],
            'excluded_platforms': [],
            'extra_images': [],
            'fitness_discipline': 'cycling',
            'fitness_discipline_display_name': 'Cycling',
            'has_closed_captions': True,
            'has_free_mode': False,
            'has_pedaling_metrics': True,
            'home_peloton_id': '<some id hash>',
            'id': '<some id hash>',
            'image_url': 'https://s3.amazonaws.com/peloton-ride-images/58aa8ebc7d51d09d6513e1a2fab53c4c62c076c6/img_1580922399_a5f1fd0e3a2e48d38ecdd6a3d874820f.png',
            'instructor_id': '<some id hash>',
            'is_archived': True,
            'is_closed_caption_shown': True,
            'is_explicit': False,
            'is_live_in_studio_only': False,
            'language': 'english',
            'length': 1940,
            'live_stream_id': '<some id hash>-live',
            'live_stream_url': None,
            'location': 'nyc',
            'metrics': ['heart_rate', 'cadence', 'calories'],
            'origin_locale': 'en-US',
            'original_air_time': 1580919480,
            'overall_estimate': 0.9956,
            'overall_rating_avg': 0.9956,
            'overall_rating_count': 20737,
            'pedaling_duration': 1800,
            'pedaling_end_offset': 1860,
            'pedaling_start_offset': 60,
            'rating': 0,
            'ride_type_id': '<some id hash>',
            'ride_type_ids': ['<some id hash>'],
            'sample_vod_stream_url': None,
            'scheduled_start_time': 1580920200,
            'series_id': '<some id hash>',
            'sold_out': False,
            'studio_peloton_id': '<some id hash>',
            'title': '30 min Power Zone Endurance Ride',
            'total_in_progress_workouts': 0,
            'total_ratings': 0,
            'total_workouts': 32489,
            'vod_stream_id': '<some id hash>-vod',
            'vod_stream_url': None},
   'start_time': 1589642537,
   'status': 'COMPLETE',
   'strava_id': None,
   'timezone': 'America/Los_Angeles',
   'title': None,
   'total_leaderboard_users': 31240,
   'total_work': 322417.21,
   'user_id': '<some id hash>',
   'workout_type': 'class'}
  ```

  An example of how you may fetch performance data for a ride
  ```
  import pprint

  conn = pylotoncycle.PylotonCycle(username, password)
  workouts = conn.GetRecentWorkouts(5)
  for w in workouts:
      workout_id = w['id']
      resp = conn.GetWorkoutMetricsById(workout_id)
      pprint.pprint(resp)

  ```


  This package is available via pip install.
  ```
  pip install pylotoncycle
  ```


  * Lots more to cover. I want to find the right format for pulling in the
  ride performance data.
  * Pull in GPS data for outdoor runs


  I'm very happy to take pull requests and fix bugs that come up. But, this is definitely a side project for me.


pkgId: cb5b13dd79ec5b904c82c98be5adb3141499816067317194df62f62db964b62f
name: python-pyloudnorm
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Implementation of ITU-R BS.1770-4 loudness algorithm in Python.
url: https://github.com/csteinmetz1/pyloudnorm
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-836be7b9-2584-4545-842a-e6aae8e285fe
location_href: 00011761-python-pyloudnorm/python-pyloudnorm-0.1.1-1.src.rpm
checksum_type: sha256
description:
  Flexible audio loudness meter in Python.

  Implementation of [ITU-R BS.1770-4](https://www.itu.int/dms_pubrec/itu-r/rec/bs/R-REC-BS.1770-4-201510-I!!PDF-E.pdf). <br/>
  Allows control over gating block size and frequency weighting filters for additional control.

  For full details on the implementation see our [paper](https://csteinmetz1.github.io/pyloudnorm-eval/paper/pyloudnorm_preprint.pdf) with a summary in our [AES presentation video](https://www.youtube.com/watch?v=krSJpQ3d4gE).


  You can install with pip as follows
  ```
  pip install pyloudnorm
  ```

  For the latest releases always install from the GitHub repo
  ```
  pip install git+https://github.com/csteinmetz1/pyloudnorm
  ```



  It's easy to measure the loudness of a wav file.
  Here we use PySoundFile to read a .wav file as an ndarray.
  ```python
  import soundfile as sf
  import pyloudnorm as pyln

  data, rate = sf.read("test.wav") # load audio (with shape (samples, channels))
  meter = pyln.Meter(rate) # create BS.1770 meter
  loudness = meter.integrated_loudness(data) # measure loudness
  ```


  Methods are included to normalize audio files to desired peak values or desired loudness.
  ```python
  import soundfile as sf
  import pyloudnorm as pyln

  data, rate = sf.read("test.wav") # load audio


  peak_normalized_audio = pyln.normalize.peak(data, -1.0)


  meter = pyln.Meter(rate) # create BS.1770 meter
  loudness = meter.integrated_loudness(data)


  loudness_normalized_audio = pyln.normalize.loudness(data, loudness, -12.0)
  ```


  A number of alternate weighting filters are available, as well as the ability to adjust the analysis block size.
  Examples are shown below.
  ```python
  import soundfile as sf
  import pyloudnorm as pyln
  from pyloudnorm import IIRfilter

  data, rate = sf.read("test.wav") # load audio


  meter1 = pyln.Meter(rate)                               # 400ms block size
  meter2 = pyln.Meter(rate, block_size=0.200)             # 200ms block size


  meter3 = pyln.Meter(rate)                               # BS.1770 meter
  meter4 = pyln.Meter(rate, filter_class="DeMan")         # fully compliant filters
  meter5 = pyln.Meter(rate, filter_class="Fenton/Lee 1")  # low complexity improvement by Fenton and Lee
  meter6 = pyln.Meter(rate, filter_class="Fenton/Lee 2")  # higher complexity improvement by Fenton and Lee
  meter7 = pyln.Meter(rate, filter_class="Dash et al.")   # early modification option


  my_high_pass  = IIRfilter(0.0, 0.5, 20.0, rate, 'high_pass')
  my_high_shelf = IIRfilter(2.0, 0.7, 1525.0, rate, 'high_shelf')


  meter8 = pyln.Meter(rate, filter_class="custom")


  meter8._filters = {'my_high_pass' : my_high_pass, 'my_high_shelf' : my_high_shelf}

  ```


  - **SciPy** ([https://www.scipy.org/](https://www.scipy.org/))
  - **NumPy** ([http://www.numpy.org/](http://www.numpy.org/))



  If you use pyloudnorm in your work please consider citing us.
  ```
  @inproceedings{steinmetz2021pyloudnorm,
          title={pyloudnorm: {A} simple yet flexible loudness meter in Python},
          author={Steinmetz, Christian J. and Reiss, Joshua D.},
          booktitle={150th AES Convention},
          year={2021}}
  ```



  > Ian Dash, Luis Miranda, and Densil Cabrera, "[Multichannel Loudness Listening Test](http://www.aes.org/e-lib/browse.cfm?elib=14581),"
  > 124th International Convention of the Audio Engineering Society, May 2008

  > Pedro D. Pestana and Álvaro Barbosa, "[Accuracy of ITU-R BS.1770 Algorithm in Evaluating Multitrack Material](http://www.aes.org/e-lib/online/browse.cfm?elib=16608),"
  > 133rd International Convention of the Audio Engineering Society, October 2012

  > Pedro D. Pestana, Josh D. Reiss, and Álvaro Barbosa, "[Loudness Measurement of Multitrack Audio Content Using Modifications of ITU-R BS.1770](http://www.aes.org/e-lib/browse.cfm?elib=16714),"
  > 134th International Convention of the Audio Engineering Society, May 2013

  > Steven Fenton and Hyunkook Lee, "[Alternative Weighting Filters for Multi-Track Program Loudness Measurement](http://www.aes.org/e-lib/browse.cfm?elib=19215),"
  > 143rd International Convention of the Audio Engineering Society, October 2017

  > Brecht De Man, "[Evaluation of Implementations of the EBU R128 Loudness Measurement](http://www.aes.org/e-lib/browse.cfm?elib=19790),"
  > 145th International Convention of the Audio Engineering Society, October 2018.


pkgId: 584cf3c2fff05f780f34df10a58ab0668dfae69d6aa57ac9e869ccef0d1ff4ae
name: python-pyls-black
arch: src
version: 0.4.7
epoch: 0
release: 1
summary: Black plugin for the Python Language Server
url: https://github.com/rupert/pyls-black
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a3d8b250-0ada-44f0-9e4e-11afc5b198b0
location_href: 00004728-python-pyls_black/python-pyls-black-0.4.7-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/pyls-black.svg)](https://pypi.org/project/pyls-black/) [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)

  > [Black](https://github.com/ambv/black) plugin for the [Python Language Server](https://github.com/palantir/python-language-server).

  In the same `virtualenv` as `python-language-server`:

  ```shell
  pip3 install pyls-black
  ```

  To avoid unexpected results you should make sure `yapf` and `autopep8` are not installed.

  * `pyls-black` can either format an entire file or just the selected text.
  * The code will only be formatted if it is syntactically valid Python.
  * Text selections are treated as if they were a separate Python file.
    Unfortunately this means you can't format an indented block of code.
  * `pyls-black` will use your project's [pyproject.toml](https://github.com/ambv/black#pyprojecttoml) if it has one.

  See the [wiki](https://github.com/rupert/pyls-black/wiki) for instructions on how to use `pyls-black` with popular text editors.


pkgId: 47b15518e6204c9e548abec4314a3db8353fd2deefe6dbc997d1f0d8c23ee2da
name: python-pyls-spyder
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Spyder extensions for the python-lsp-server
url: https://github.com/spyder-ide/pyls-spyder
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-aceb7e00-d8ca-48e6-8210-5fae8f431962
location_href: 00004727-python-pyls-spyder/python-pyls-spyder-0.4.0-1.src.rpm
checksum_type: sha256
description:
  [![Project License - MIT](https://img.shields.io/pypi/l/pyls-spyder.svg)](https://raw.githubusercontent.com/spyder-ide/pyls-spyder/master/LICENSE)
  [![pypi version](https://img.shields.io/pypi/v/pyls-spyder.svg)](https://pypi.org/project/pyls-spyder/)
  [![conda version](https://img.shields.io/conda/vn/conda-forge/pyls-spyder.svg)](https://www.anaconda.com/download/)
  [![download count](https://img.shields.io/conda/dn/conda-forge/pyls-spyder.svg)](https://www.anaconda.com/download/)
  [![Downloads](https://pepy.tech/badge/pyls-spyder)](https://pepy.tech/project/pyls-spyder)
  [![PyPI status](https://img.shields.io/pypi/status/pyls-spyder.svg)](https://github.com/spyder-ide/pyls-spyder)
  ![PyLS-Spyder tests](https://github.com/spyder-ide/pyls-spyder/workflows/PyLS-Spyder%20tests/badge.svg)

  *Copyright © 2020– Spyder Project Contributors*



  Spyder extensions for the [python-lsp-server](https://github.com/python-lsp/python-lsp-server) (pylsp). This package provides Spyder-specific extras for the [Language Server Protocol](https://microsoft.github.io/language-server-protocol/specifications/specification-current/) (LSP) on Python, such as document symbol searching and others.



  To install pyls-spyder, you can use both conda or pip package managers:

  ```bash

  conda install pyls-spyder -c spyder-ide


  pip install pyls-spyder
  ```


  This package depends on the [python-lsp-server](https://github.com/python-lsp/python-lsp-server) to integrate the Spyder-specific extensions.



  To install and develop spyder-pyls locally, you will need to install the python-lsp-server:

  ```bash

  conda install python-lsp-server


  pip install python-lsp-server
  ```

  Then, you can install the package locally using pip:

  ```bash
  pip install -U -e .
  ```


  We use pytest to run tests as it follows:

  ```bash
  pytest -x -v pyls_spyder/tests
  ```



  |          LSP method           |              Spyder extensions                   |
  |:-----------------------------:|:------------------------------------------------:|
  | `textDocument/documentSymbol` | Find code cells `# %` and block comments `# --` |
  | `textDocument/foldingRange`   | Return code cells `# %` as code folding regions |


  This plugin can be configured by using the key `pyls_spyder` when calling `workspace/didChangeConfiguration` on the pyls. Each configuration option is described below:

  <table>
      <thead>
          <tr>
              <th>LSP method</th>
              <th>Configuration Key</th>
              <th>Type</th>
              <th>Description</th>
          </tr>
      </thead>
      <tbody>
          <tr>
              <td rowspan=2><code>textDocument/documentSymbol</code></td>
              <td><code>group_cells</code></td>
              <td><code>bool</code></td>
              <td>Enable/Disable code cell grouping according to the total number of leading percentages</td>
          </tr>
          <tr>
              <td><code>enable_block_comments</code></td>
              <td><code>bool</code></td>
              <td>Enable/disable block comment detection</td>
          </tr>
      </tbody>
  </table>


  Please see our [CHANGELOG](https://github.com/spyder-ide/pyls-spyder/blob/master/CHANGELOG.md) file to learn more about our new features and improvements.



  We follow PEP8 and PEP257 for all Python modules. We use MyPy type annotations for all functions and classes declared on this package. Feel free to send a PR or create an issue if you have any problem/question.


pkgId: 6676f3f9d35f8bc151b46f24e4ad2ad093344305cacbcf2781c5fe219af3d786
name: python-pymannkendall
arch: src
version: 1.4.3
epoch: 0
release: 1
summary: A python package for non-parametric Mann-Kendall family of trend tests.
url: https://github.com/mmhs013/pymannkendall
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cf02bc68-d0b3-4519-bf4c-998b48812934
location_href: 00010083-python-pymannkendall/python-pymannkendall-1.4.3-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/mmhs013/pyMannKendall.svg?branch=master)](https://travis-ci.com/mmhs013/pyMannKendall)
  [![PyPI](https://img.shields.io/pypi/v/pymannkendall.svg)](https://pypi.org/project/pymannkendall/)
  [![PyPI - License](https://img.shields.io/pypi/l/pymannkendall.svg)](https://pypi.org/project/pymannkendall/)
  [![PyPI - Status](https://img.shields.io/pypi/status/pymannkendall.svg)](https://pypi.org/project/pymannkendall/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pymannkendall.svg)](https://pypi.org/project/pymannkendall/)

  [![Downloads](https://pepy.tech/badge/pymannkendall)](https://pepy.tech/project/pymannkendall)
  [![Conda](https://img.shields.io/conda/dn/conda-forge/pymannkendall?label=conda-downloads)](https://anaconda.org/conda-forge/pymannkendall)

  [![Google Scholar](https://github.com/mmhs013/Citation_Parser/blob/main/images/gs_pymk_cite.svg?raw=true)](https://scholar.google.com/scholar?q=pyMannKendall%3A+a+python+package+for+non+parametric+Mann+Kendall+family+of+trend+tests.)
  [![Researchgate](https://github.com/mmhs013/Citation_Parser/blob/main/images/rg_pymk_cite.svg?raw=true)](https://www.researchgate.net/publication/334688255_pyMannKendall_a_python_package_for_non_parametric_Mann_Kendall_family_of_trend_tests)

  [![status](http://joss.theoj.org/papers/14903dbd55343be89105112e585d262a/status.svg)](http://joss.theoj.org/papers/14903dbd55343be89105112e585d262a)
  [![DOI](https://zenodo.org/badge/174495388.svg)](https://zenodo.org/badge/latestdoi/174495388)


  The Mann-Kendall Trend Test (sometimes called the MK test) is used to analyze time series data for consistently increasing or decreasing trends (monotonic trends). It is a non-parametric test, which means it works for all distributions (i.e. data doesn't have to meet the assumption of normality), but data should have no serial correlation. If the data has a serial correlation, it could affect in significant level (p-value). It could lead to misinterpretation. To overcome this problem, researchers proposed several modified Mann-Kendall tests (Hamed and Rao Modified MK Test, Yue and Wang Modified MK Test, Modified MK test using Pre-Whitening method, etc.). Seasonal Mann-Kendall test also developed to remove the effect of seasonality.

  Mann-Kendall Test is a powerful trend test, so several others modified Mann-Kendall tests like Multivariate MK Test, Regional MK Test, Correlated MK test, Partial MK Test, etc. were developed for the spacial condition. `pyMannkendal` is a pure Python implementation of non-parametric Mann-Kendall trend analysis, which bring together almost all types of Mann-Kendall Test. Currently, this package has 11 Mann-Kendall Tests and 2 sen's slope estimator function. Brief description of functions are below:

  1.	**Original Mann-Kendall test (*original_test*):** Original Mann-Kendall test is a nonparametric test, which does not consider serial correlation or seasonal effects.

  2.	**Hamed and Rao Modified MK Test (*hamed_rao_modification_test*):** This modified MK test proposed by *Hamed and Rao (1998)* to address serial autocorrelation issues. They suggested a variance correction approach to improve trend analysis. User can consider first n significant lag by insert lag number in this function. By default, it considered all significant lags.

  3.	**Yue and Wang Modified MK Test (*yue_wang_modification_test*):** This is also a variance correction method for considered serial autocorrelation proposed by *Yue, S., & Wang, C. Y. (2004)*. User can also set their desired significant n lags for the calculation.

  4.	**Modified MK test using Pre-Whitening method (*pre_whitening_modification_test*):** This test suggested by *Yue and Wang (2002)* to using Pre-Whitening the time series before the application of trend test.

  5.	**Modified MK test using Trend free Pre-Whitening method (*trend_free_pre_whitening_modification_test*):** This test also proposed by *Yue and Wang (2002)* to remove trend component and then Pre-Whitening the time series before application of trend test.

  6.	**Multivariate MK Test (*multivariate_test*):** This is an MK test for multiple parameters proposed by *Hirsch (1982)*. He used this method for seasonal mk test, where he considered every month as a parameter.

  7.	**Seasonal MK Test (*seasonal_test*):** For seasonal time series data, *Hirsch, R.M., Slack, J.R. and Smith, R.A. (1982)* proposed this test to calculate the seasonal trend.

  8.	**Regional MK Test (*regional_test*):** Based on*Hirsch (1982)* proposed seasonal mk test, *Helsel, D.R. and Frans, L.M., (2006)* suggest regional mk test to calculate the overall trend in a regional scale.

  9.	**Correlated Multivariate MK Test (*correlated_multivariate_test*):** This multivariate mk test proposed by *Hipel (1994)* where the parameters are correlated.

  10.	**Correlated Seasonal MK Test (*correlated_seasonal_test*):** This method proposed by *Hipel (1994)* used, when time series significantly correlated with the preceding one or more months/seasons.

  11.	**Partial MK Test (*partial_test*):** In a real event, many factors are affecting the main studied response parameter, which can bias the trend results. To overcome this problem, *Libiseller (2002)* proposed this partial mk test. It required two parameters as input, where, one is response parameter and other is an independent parameter.

  12.	**Theil-Sen's Slope Estimator (*sens_slope*):** This method proposed by *Theil (1950)* and *Sen (1968)* to estimate the magnitude of the monotonic trend. Intercept is calculate using *Conover, W.J. (1980)* method.

  13.	**Seasonal Theil-Sen's Slope Estimator (*seasonal_sens_slope*):** This method proposed by *Hipel (1994)* to estimate the magnitude of the monotonic trend, when data has seasonal effects. Intercept is calculate using *Conover, W.J. (1980)* method.



  All Mann-Kendall test functions have almost similar input parameters. Those are:

  - **x**:   a vector (list, numpy array or pandas series) data
  - **alpha**: significance level (0.05 is the default)
  - **lag**: No. of First Significant Lags (Only available in hamed_rao_modification_test and yue_wang_modification_test)
  - **period**: seasonal cycle. For monthly data it is 12, weekly data it is 52 (Only available in seasonal tests)

  And all Mann-Kendall tests return a named tuple which contained:

  - **trend**: tells the trend (increasing, decreasing or no trend)
  - **h**: True (if trend is present) or False (if the trend is absence)
  - **p**: p-value of the significance test
  - **z**: normalized test statistics
  - **Tau**: Kendall Tau
  - **s**: Mann-Kendal's score
  - **var_s**: Variance S
  - **slope**: Theil-Sen estimator/slope
  - **intercept**: intercept of Kendall-Theil Robust Line, for seasonal test, full period cycle consider as unit time step

  sen's slope function required data vector. seasonal sen's slope also has optional input period, which by the default value is 12. Both sen's slope function return only slope value.



  For the installation of `pyMannKendall`, the following packages are required:
  - [numpy](https://www.numpy.org/)
  - [scipy](https://www.scipy.org/)



  You can install `pyMannKendall` using pip. For Linux users

  ```python
  sudo pip install pymannkendall
  ```

  or, for Windows user

  ```python
  pip install pymannkendall
  ```

  or, you can use conda
  ```python
  conda install -c conda-forge pymannkendall
  ```

  or you can clone the repo and install it:

  ```bash
  git clone https://github.com/mmhs013/pymannkendall
  cd pymannkendall
  python setup.py install
  ```



  `pyMannKendall` is automatically tested using `pytest` package on each commit [here](https://travis-ci.org/mmhs013/pyMannKendall/), but the tests can be manually run:

  ```
  pytest -v
  ```



  A quick example of `pyMannKendall` usage is given below. Several more examples are provided [here](https://github.com/mmhs013/pyMannKendall/blob/master/Examples/Example_pyMannKendall.ipynb).

  ```python
  import numpy as np
  import pymannkendall as mk


  data = np.random.rand(360,1)

  result = mk.original_test(data)
  print(result)
  ```
  Output are like this:
  ```python
  Mann_Kendall_Test(trend='no trend', h=False, p=0.9507221701045581, z=0.06179991635055463, Tau=0.0021974620860414733, s=142.0, var_s=5205500.0, slope=1.0353584906597959e-05, intercept=0.5232692553379981)
  ```
  Whereas, the output is a named tuple, so you can call by name for specific result:
  ```python
  print(result.slope)
  ```
  or, you can directly unpack your results like this:
  ```python
  trend, h, p, z, Tau, s, var_s, slope, intercept = mk.original_test(data)
  ```



  [![Google Scholar](https://github.com/mmhs013/Citation_Parser/blob/main/images/gs_pymk_cite.svg?raw=true)](https://scholar.google.com/scholar?q=pyMannKendall%3A+a+python+package+for+non+parametric+Mann+Kendall+family+of+trend+tests.)
  [![Researchgate](https://github.com/mmhs013/Citation_Parser/blob/main/images/rg_pymk_cite.svg?raw=true)](https://www.researchgate.net/publication/334688255_pyMannKendall_a_python_package_for_non_parametric_Mann_Kendall_family_of_trend_tests)

  If you publish results for which you used `pyMannKendall`, please give credit by citing [Hussain et al., (2019)](https://doi.org/10.21105/joss.01556):

  > Hussain et al., (2019). pyMannKendall: a python package for non parametric Mann Kendall family of trend tests.. Journal of Open Source Software, 4(39), 1556, https://doi.org/10.21105/joss.01556


  ```
  @article{Hussain2019pyMannKendall,
  	journal = {Journal of Open Source Software},
  	doi = {10.21105/joss.01556},
  	issn = {2475-9066},
  	number = {39},
  	publisher = {The Open Journal},
  	title = {pyMannKendall: a python package for non parametric Mann Kendall family of trend tests.},
  	url = {http://dx.doi.org/10.21105/joss.01556},
  	volume = {4},
  	author = {Hussain, Md. and Mahmud, Ishtiak},
  	pages = {1556},
  	date = {2019-07-25},
  	year = {2019},
  	month = {7},
  	day = {25},
  }
  ```



  `pyMannKendall` is a community project and welcomes contributions. Additional information can be found in the [contribution guidelines](https://github.com/mmhs013/pyMannKendall/blob/master/CONTRIBUTING.md).




  `pyMannKendall` wishes to maintain a positive community. Additional details can be found in the [Code of Conduct](https://github.com/mmhs013/pyMannKendall/blob/master/CODE_OF_CONDUCT.md).




  1. Bari, S. H., Rahman, M. T. U., Hoque, M. A., & Hussain, M. M. (2016). Analysis of seasonal and annual rainfall trends in the northern region of Bangladesh. *Atmospheric Research*, 176, 148-158. doi:[10.1016/j.atmosres.2016.02.008](https://doi.org/10.1016/j.atmosres.2016.02.008)

  2. Conover, W.J., (1980). Some methods based on ranks (Chapter 5), [Practical nonparametric statistics (2nd Ed.)](https://www.wiley.com/en-us/Practical+Nonparametric+Statistics%2C+3rd+Edition-p-9780471160687), *John Wiley and Sons*.

  3. Cox, D. R., & Stuart, A. (1955). Some quick sign tests for trend in location and dispersion. *Biometrika*, 42(1/2), 80-95. doi:[10.2307/2333424](https://doi.org/10.2307/2333424)

  4. Hamed, K. H., & Rao, A. R. (1998). A modified Mann-Kendall trend test for autocorrelated data. *Journal of hydrology*, 204(1-4), 182-196. doi:[10.1016/S0022-1694(97)00125-X](https://doi.org/10.1016/S0022-1694(97)00125-X)

  5. Helsel, D. R., & Frans, L. M. (2006). Regional Kendall test for trend. *Environmental science & technology*, 40(13), 4066-4073. doi:[10.1021/es051650b](https://doi.org/10.1021/es051650b)

  6. Hipel, K. W., & McLeod, A. I. (1994). Time series modelling of water resources and environmental systems (Vol. 45). Elsevier.

  7. Hirsch, R. M., Slack, J. R., & Smith, R. A. (1982). Techniques of trend analysis for monthly water quality data. *Water resources research*, 18(1), 107-121. doi:[10.1029/WR018i001p00107](https://doi.org/10.1029/WR018i001p00107)

  8. Jacquelin Dietz, E., (1987). A comparison of robust estimators in simple linear regression: A comparison of robust estimators. Communications in Statistics-Simulation and Computation, 16(4), pp.1209-1227. doi: [10.1080/03610918708812645](https://doi.org/10.1080/03610918708812645)

  9. Kendall, M. (1975). Rank correlation measures. *Charles Griffin*, London, 202, 15.

  10. Libiseller, C., & Grimvall, A. (2002). Performance of partial Mann-Kendall tests for trend detection in the presence of covariates. *Environmetrics: The official journal of the International Environmetrics Society*, 13(1), 71-84. doi:[10.1002/env.507](https://doi.org/1010.1002/env.507)

  11. Mann, H. B. (1945). Nonparametric tests against trend. *Econometrica: Journal of the Econometric Society*, 245-259. doi:[10.2307/1907187](https://doi.org/10.2307/1907187)

  12. Sen, P. K. (1968). Estimates of the regression coefficient based on Kendall's tau. *Journal of the American statistical association*, 63(324), 1379-1389. doi:[10.1080/01621459.1968.10480934](https://doi.org/10.1080/01621459.1968.10480934)

  13. Theil, H. (1950). A rank-invariant method of linear and polynominal regression analysis (parts 1-3). In *Ned. Akad. Wetensch. Proc. Ser. A* (Vol. 53, pp. 1397-1412).

  14. Yue, S., & Wang, C. (2004). The Mann-Kendall test modified by effective sample size to detect trend in serially correlated hydrological series. *Water resources management*, 18(3), 201-218. doi:[10.1023/B:WARM.0000043140.61082.60](https://doi.org/10.1023/B:WARM.0000043140.61082.60)

  15. Yue, S., & Wang, C. Y. (2002). Applicability of prewhitening to eliminate the influence of serial correlation on the Mann-Kendall test. *Water resources research*, 38(6), 4-1. doi:[10.1029/2001WR000861](https://doi.org/10.1029/2001WR000861)

  16. Yue, S., Pilon, P., Phinney, B., & Cavadias, G. (2002). The influence of autocorrelation on the ability to detect trend in hydrological series. *Hydrological processes*, 16(9), 1807-1829. doi:[10.1002/hyp.1095](https://doi.org/10.1002/hyp.1095)


pkgId: 7d7caf6c24cc199a02cfff7aa58364d48861f772e949fc22df2aef528d8132e6
name: python-pymatreader
arch: src
version: 0.0.30
epoch: 0
release: 1
summary: Convenient reader for Matlab mat files
url: https://gitlab.com/obob/pymatreader
rpm_license: BSD (2 clause)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8deb2fd6-51ee-49cd-b7f4-074b9519690a
location_href: 00004731-python-pymatreader/python-pymatreader-0.0.30-1.src.rpm
checksum_type: sha256
description:
  A Python module to read Matlab files. This module works with both the old (< 7.3) and the new (>= 7.3) HDF5 based format. The output should be the same for both kinds of files.


  ```python
  from pymatreader import read_mat

  data = read_mat(filename)
  ```

  `data` is a python `dict` containing all variables of the mat file.


  Documentation can be found here: <http://pymatreader.readthedocs.io/en/latest/>


  The source code can be found here: <https://gitlab.com/obob/pymatreader>


  This module is developed by Dirk Gütlin & Thomas Hartmann at the Universität Salzburg. You are free to use, copy, modify, distribute it under the terms of the BSD 2 clause license.


pkgId: d1eda013a5dacabd468633296ab804c038edf3f613e0f73b1b20693e9b42474b
name: python-pymc3
arch: src
version: 3.11.5
epoch: 0
release: 1
url: http://github.com/pymc-devs/pymc3
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9465a416-b4eb-4af0-90b9-69fa85078e4e
location_href: 00004732-python-pymc3/python-pymc3-3.11.5-1.src.rpm
checksum_type: sha256
summary:
  Probabilistic Programming in Python: Bayesian Modeling and Probabilistic Machine Learning with Theano

description:
  There have been many questions and uncertainty around the future of PyMC3 since Theano
  stopped getting developed by the original authors, and we started experiments with a PyMC version based on tensorflow probability.
  Since then many things changed and we are happy to announce that PyMC3 will continue to rely on Theano,
  or rather its successors Theano-PyMC (`pymc3 <4)` and Aesara (`pymc3 >=4`).
  Check out <https://github.com/aesara-devs/aesara>`__) and specifically the latest developments on the `PyMC3 `main` branch <https://github.com/pymc-devs/pymc3/>`.


pkgId: 877cc2405efa1cb222ca7c001f39d31dd6ec5e17ea00700256325484c200d286
name: python-pymediainfo
arch: src
version: 6.0.1
epoch: 0
release: 1
summary: A Python wrapper for the mediainfo library.
url: https://github.com/sbraz/pymediainfo
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dc99c7e9-0e45-450e-96a8-4883422b2127
location_href: 00004734-python-pymediainfo/python-pymediainfo-6.0.1-1.src.rpm
checksum_type: sha256
description:
  This small package is a wrapper around the MediaInfo library.
  It works on Linux, Mac OS X and Windows and is tested with Python 3.7 to 3.11 and PyPy3.
  See https://pymediainfo.readthedocs.io/ for more information.


pkgId: 15aff7af869d62edea162c5c7289ff98d7f99904f5445ededb9be2bef6b71822
name: python-pymemcache
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: A comprehensive, fast, pure Python memcached client
url: https://github.com/pinterest/pymemcache
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-219fecbd-1dda-4a3e-858a-6b40fd2f4b4a
location_href: 00004736-python-pymemcache/python-pymemcache-4.0.0-1.src.rpm
checksum_type: sha256
description:
  A comprehensive, fast, pure-Python memcached client.
  pymemcache supports the following features:
  * Complete implementation of the memcached text protocol.
  * Connections using UNIX sockets, or TCP over IPv4 or IPv6.
  * Configurable timeouts for socket connect and send/recv calls.
  * Access to the "noreply" flag, which can significantly increase the speed of writes.
  * Flexible, modular and simple approach to serialization and deserialization.
  * The (optional) ability to treat network and memcached errors as cache misses.


pkgId: 86002401a5d03ff26ad01c7df51a4a0ae76f928d27fdeebd8d47552b321c39a0
name: python-pymilter
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: Python interface to sendmail milter API
url: https://www.pymilter.org/
rpm_license: GPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fff19a58-f8c5-43c4-8f04-560c06a17613
location_href: 00004738-python-pymilter/python-pymilter-1.0.5-1.src.rpm
checksum_type: sha256
description:
  This is a python extension module to enable python scripts to attach to
  Sendmail's libmilter API, enabling filtering of messages as they arrive.
  Since it's a script, you can do anything you want to the message - screen
  out viruses, collect statistics, add or modify headers, etc.  You can, at
  any point, tell Sendmail to reject, discard, or accept the message.

  Additional python modules provide for navigating and modifying MIME parts, and
  sending DSNs or doing CBVs.



  Python milter extension: https://pypi.python.org/pypi/pymilter/
  Python: http://www.python.org
  Sendmail: http://www.sendmail.org



   1. Build and install Sendmail, enabling libmilter (see libmilter/README).
   2. Build and install Python, enabling threading.
   3. Install this module: python setup.py --help
   4. Add these two lines to sendmail.cf[a]:

   O InputMailFilters=pythonfilter
   Xpythonfilter,        S=local:/home/username/pythonsock

   5. Run the sample.py example milter with: python sample.py
   Note that milters should almost certainly not run as root.

  That's it.  Incoming mail will cause the milter to print some things, and
  some email will be rejected (see the "header" method).  Edit and play.
  See spfmilter.py for a functional SPF milter, or see bms.py for an complex
  milter used in production.

  [a] This is for a quick test.  Your sendmail.cf in most distros will get
  overwritten whenever sendmail.mc is updated.  To make a milter permanent,
  add something like:
  ```
  INPUT_MAIL_FILTER(`pythonfilter', `S=local:/home/username/pythonsock, F=T, T=C:5m;S:20s;R:5m;E:5m')
  ```
  to sendmail.mc instead.



  First install Sendmail.  Make sure you read libmilter/README in the Sendmail
  source directory, and make sure you enable libmilter before you build.  The
  8.11 series had libmilter marked as FFR (For Future Release); 8.12
  officially supports libmilter, but it's still not built by default.

  Install Python, and enable threading in Modules/Setup.

  Install this miltermodule package; DistUtils Automatic Installation:

  $ python setup.py --help

  For versions of python prior to 2.0, you will need to download distutils
  separately or build manually.  You will need to download unittest
  separately to run the test programs.  The bdist_rpm distutils option seems
  not to work for python 2.0; upgrade to at least 2.1.1.

  Now that everything is installed, we need to tell sendmail that we're going
  to filter incoming email.  Add lines similar to the following to
  sendmail.cf:

  O InputMailFilters=pythonfilter
  Xpythonfilter,        S=local:/home/username/pythonsock

  The "O" line tells sendmail which filters to use in what order; here we're
  telling sendmail to use the filter named "pythonfilter".

  The next line, the "X" line (for "eXternal"), lists that filter along with
  some options associated with it.  In this case, we have the "S" option, which
  names the socket that sendmail will use to communicate with this particular
  milter.  This milter's socket is a unix-domain socket in the filesystem.
  See libmilter/README for the definitive list of options.

  NB: The name is specified in two places: here, in sendmail's cf file, and
  in the milter itself.  Make sure the two match.

  NB: The above lines can be added in your .mc file with this line:
  ```
  INPUT_MAIL_FILTER(`pythonfilter', `S=local:/home/username/pythonsock')
  ```
  For versions of sendmail prior to 8.12, you will need to enable
  `_FFR_MILTER` for the cf macros.  For example,

  m4 -D_FFR_MILTER ../m4/cf.m4 myconfig.mc > myconfig.cf



  The IPv6 protocol is supported if your operation system supports it
  and if sendmail was compiled with IPv6 support.  To determine if your
  sendmail supports IPv6, run "sendmail -d0" and check for the NETINET6
  compilation option.  To compile sendmail with IPv6 support, add this
  declaration to your site.config.m4 before building it:
  ```
  APPENDDEF(`confENVDEF', `-DNETINET6=1')
  ```
  IPv6 support can show up in two places; the communications socket
  between the milter and sendmail processes and in the host address
  argument to the connect() callback method.

  For sendmail to be able to accept IPv6 SMTP sessions, you must
  configure the daemon to listen on an IPv6 port.  Furthermore if you
  want to allow both IPv4 and IPv6 connections, some operating systems
  will require that each listens to different port numbers.  For an
  IPv6-only setup, your sendmail configuration should contain a line
  similar to (first line is for sendmail.mc, second is sendmail.cf):
  ```
  DAEMON_OPTIONS(`Name=MTA-v6, Family=inet6, Modify=C, Port=25')
  O DaemonPortOptions=Name=MTA-v6, Family=inet6, Modify=C, Port=25
  ```
  To allow sendmail and the milter process to communicate with each
  other over IPv6, you may use the "inet6" socket name prefix, as in:

  Xpythonfilter,        S=inet6:1234@fec0:0:0:7::5c

  The connect() callback method in the milter class will pass the
  IPv6-specific information in the 'hostaddr' argument as a tuple.  Note
  that the type of this value is dependent upon the protocol family, and
  is not compatible with IPv4 connections.  Therefore you should always
  check the family argument before attempting to use the hostaddr
  argument.  A quick example showing this follows:

    import socket

    class ipv6awareMilter(Milter.Milter):

       def connect(self,hostname,family,hostaddr):
  	if family==socket.AF_INET:
  	   ipaddress, port = hostaddr
  	elif family==socket.AF_INET6:
  	   ip6address, port, flowinfo, scopeid = hostaddr
  	elif family==socket.AF_UNIX:
  	   socketpath = hostaddr

  The hostname argument is always safe to use without interpreting the
  protocol family.  For IPv6 connections for which the hostname can not
  be determined the hostname will appear similar to the string
  "[IPv6:::1]" with the corresponding hostaddr[0] being "::1".  Refer to
  RFC 2553 for information on interpreting and using the flowinfo and
  scopeid socket attributes, both of which are integers.



  Jim Niemira (urmane@urmane.org) wrote the original C module and some quick
  and dirty python to use it.  Stuart D. Gathman (stuart@gathman.org) took that
  kludge and added threading and context objects to it, wrote a proper OO
  wrapper (Milter.py) that handles attachments, did lots of testing, packaged
  it with distutils, and generally transformed it from a quick hack to a
  real, usable Python extension.


pkgId: 16e0478d9574149b6515e3bcfb562da19c93eebf17f7efc2f24cf40f7ab9abad
name: python-pymitter
arch: src
version: 0.4.0
epoch: 0
release: 1
url: https://github.com/riga/pymitter
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0356235a-684d-46e6-928b-475389482e9c
location_href: 00013346-python-pymitter/python-pymitter-0.4.0-1.src.rpm
checksum_type: sha256
summary:
  Python port of the extended Node.js EventEmitter 2 approach providing namespaces, wildcards and TTL.

description:
  [![Package Status](https://img.shields.io/pypi/v/pymitter.svg?style=flat)](https://pypi.python.org/pypi/pymitter) [![License](https://img.shields.io/github/license/riga/pymitter.svg)](https://github.com/riga/pymitter/blob/master/LICENSE)
  [![Lint and test](https://github.com/riga/pymitter/actions/workflows/lint_and_test.yml/badge.svg)](https://github.com/riga/pymitter/actions/workflows/lint_and_test.yml)

  Python port of the extended Node.js EventEmitter 2 approach of https://github.com/asyncly/EventEmitter2 providing namespaces, wildcards and TTL.




  - Namespaces with wildcards
  - Times to listen (TTL)
  - Usage via decorators or callbacks
  - Coroutine support
  - Lightweight implementation, good performance




  *pymitter* is a registered [PyPI module](https://pypi.python.org/pypi/pymitter), so the installation with *pip* is quite easy:

  ```shell
  pip install pymitter
  ```

  The last version with Python 2 support was v0.3.2 ([tag](https://github.com/riga/pymitter/tree/v0.3.2), [PypI](https://pypi.org/project/pymitter/0.3.2)).






  ```python
  from pymitter import EventEmitter


  ee = EventEmitter()



  @ee.on("my_event")
  def handler1(arg):
      print("handler1 called with", arg)



  def handler2(arg):
      print("handler2 called with", arg)


  ee.on("my_other_event", handler2)



  @ee.on("my_third_event")
  async def handler3(arg):
      print("handler3 called with", arg)



  ee.emit("my_event", "foo")


  ee.emit("my_other_event", "bar")


  ee.emit("my_third_event", "baz")

  ```




  Wrapping `async` functions outside an event loop will start an internal event loop and calls to `emit` return synchronously.

  ```python
  from pymitter import EventEmitter


  ee = EventEmitter()



  @ee.on("my_event")
  async def handler1(arg):
      print("handler1 called with", arg)



  ee.emit("my_event", "foo")

  ```

  Wrapping `async` functions inside an event loop a will use the running event loop and `emit_async` is awaitable.

  ```python
  from pymitter import EventEmitter


  ee = EventEmitter()


  async def main():
      
      awaitable = ee.emit_async("my_event", "foo")
      

      await awaitable
      
  ```




  ```python
  from pymitter import EventEmitter


  ee = EventEmitter()


  @ee.once("my_event")
  def handler1():
      print("handler1 called")


  @ee.on("my_event", ttl=2)
  def handler2():
      print("handler2 called")


  ee.emit("my_event")



  ee.emit("my_event")


  ee.emit("my_event")

  ```




  ```python
  from pymitter import EventEmitter


  ee = EventEmitter(wildcard=True)


  @ee.on("my_event.foo")
  def handler1():
      print("handler1 called")


  @ee.on("my_event.bar")
  def handler2():
      print("handler2 called")


  @ee.on("my_event.*")
  def hander3():
      print("handler3 called")


  ee.emit("my_event.foo")



  ee.emit("my_event.bar")



  ee.emit("my_event.*")



  ```






  EventEmitter constructor. **Note**: always use *kwargs* for configuration.
  When *wildcard* is *True*, wildcards are used as shown in [this example](#wildcards).
  *delimiter* is used to seperate namespaces within events.
  If *new_listener* is *True*, the *"new_listener"* event is emitted every time a new listener is registered.
  Functions listening to this event are passed ``(func, event=None)``.
  *max_listeners* defines the maximum number of listeners per event.
  Negative values mean infinity.

  - #### ``on(event, func=None, ttl=-1)``
      Registers a function to an event.
      When *func* is *None*, decorator usage is assumed.
      *ttl* defines the times to listen. Negative values mean infinity.
      Returns the function.

  - #### ``once(event, func=None)``
      Registers a function to an event with ``ttl = 1``.
      When *func* is *None*, decorator usage is assumed.
      Returns the function.

  - #### ``on_any(func=None)``
      Registers a function that is called every time an event is emitted.
      When *func* is *None*, decorator usage is assumed.
      Returns the function.

  - #### ``off(event, func=None)``
      Removes a function that is registered to an event.
      When *func* is *None*, decorator usage is assumed.
      Returns the function.

  - #### ``off_any(func=None)``
      Removes a function that was registered via ``on_any()``.
      When *func* is *None*, decorator usage is assumed.
      Returns the function.

  - #### ``off_all()``
      Removes all functions of all events.

  - #### ``listeners(event)``
      Returns all functions that are registered to an event.
      Wildcards are not applied.

  - #### ``listeners_any()``
      Returns all functions that were registered using ``on_any()``.

  - #### ``listeners_all()``
      Returns all registered functions.

  - #### ``emit(event, *args, **kwargs)``
      Emits an event.
      All functions of events that match *event* are invoked with *args* and *kwargs* in the exact order of their registeration.
      Wildcards might be applied.
      There is no return value.




  - Source hosted at [GitHub](https://github.com/riga/pymitter)
  - Python module hostet at [PyPI](https://pypi.python.org/pypi/pymitter)
  - Report issues, questions, feature requests on [GitHub Issues](https://github.com/riga/pymitter/issues)


pkgId: 83e8757f823582cb11ed0f6d03f20a7f643c06fbd92a5d2c583f655249dab8f8
name: python-pymongo-debuginfo
arch: x86_64
version: 4.3.3
epoch: 0
release: 1
summary: Debug information for package python-pymongo
url: http://github.com/mongodb/mongo-python-driver
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-b58138cd-a34c-41de-a41d-e6fc7fac2145
rpm_sourcerpm: python-pymongo-4.3.3-1.src.rpm
location_href: 00009039-python-pymongo/python-pymongo-debuginfo-4.3.3-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pymongo.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 80488c1076bad291d7ea3d87a3f9202b4df06d16b0376372fe883b4c6469e8c5
name: python-pymongo-debugsource
arch: x86_64
version: 4.3.3
epoch: 0
release: 1
summary: Debug sources for package python-pymongo
url: http://github.com/mongodb/mongo-python-driver
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-b58138cd-a34c-41de-a41d-e6fc7fac2145
rpm_sourcerpm: python-pymongo-4.3.3-1.src.rpm
location_href: 00009039-python-pymongo/python-pymongo-debugsource-4.3.3-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pymongo.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 69efbfa50f05496346342eb310145df677825e8a8a582ebc0cf0d87e5cfc3880
name: python-pymorphy2
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: Morphological analyzer (POS tagger + inflection engine) for Russian language.
url: https://github.com/kmike/pymorphy2/
rpm_license: MIT license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7d304325-3b43-4e02-9a18-f93b88c5992c
location_href: 00011539-python-pymorphy2/python-pymorphy2-0.9.1-1.src.rpm
checksum_type: sha256
description:
  Morphological analyzer (POS tagger + inflection engine)
  for Russian and Ukrainian languages. License is MIT.
  * docs: https://pymorphy2.readthedocs.io
  * changelog: https://github.com/kmike/pymorphy2/blob/master/CHANGES.rst
  * source code: github_
  * bug tracker: https://github.com/kmike/pymorphy2/issues
  * support: https://groups.google.com/forum/?fromgroups#!forum/pymorphy


pkgId: d27a8a4dda1de880e7edd8a898324a8efb92bf477c739155b6c1c2c486793981
name: python-pymssql
arch: src
version: 2.2.7
epoch: 0
release: 1
summary: DB-API interface to Microsoft SQL Server for Python. (new Cython-based version)
url: https://pypi.org/project/pymssql/
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9ccf3474-9771-448b-b774-fdbfd5c43aab
location_href: 00004743-python-pymssql/python-pymssql-2.2.7-1.src.rpm
checksum_type: sha256
description:
  A simple database interface for `Python`_ that builds on top of `FreeTDS`_ to
  provide a Python DB-API (`PEP-249`_) interface to `Microsoft SQL Server`_.
  Detailed information on pymssql is available on the website:
  `pymssql.readthedocs.io <https://pymssql.readthedocs.io/en/stable/>`_
  New development is happening on GitHub at:
  `github.com/pymssql/pymssql <https://github.com/pymssql/pymssql>`_
  There is a Google Group for discussion at:
  `groups.google.com <https://groups.google.com/forum/?fromgroups#!forum/pymssql>`_


pkgId: 25d283fd9abd0ed5b9a2fb5f4b8187abe9b781d5d1b1e6f2b34c6985eb8d1e62
name: python-pymsteams
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Format messages and post to Microsoft Teams.
url: https://github.com/rveachkc/pymsteams
rpm_license: Apache
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7d987339-ead5-4bdd-a8af-c36fab394b02
location_href: 00009667-python-pymsteams/python-pymsteams-0.2.2-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/rveachkc/pymsteams/tree/master.svg?style=shield)](https://circleci.com/gh/rveachkc/pymsteams/tree/master) [![PyPI version](https://badge.fury.io/py/pymsteams.svg)](https://badge.fury.io/py/pymsteams)

  Python Wrapper Library to send requests to Microsoft Teams Webhooks.
  Microsoft refers to these messages as Connector Cards.  A message can be sent with only the main Connector Card, or additional sections can be included into the message.

  This library uses Webhook Connectors for Microsoft Teams.  Please visit the following Microsoft Documentation link for instructions on how to obtain the correct url for your Channel: https://dev.outlook.com/Connectors/GetStarted#creating-messages-through-office-365-connectors-in-microsoft-teams

  Please refer to the Microsoft Documentation for the most up to date screenshots.
  https://dev.outlook.com/connectors/reference



  Install with pip:

  ```bash
  pip install pymsteams
  ```

  Install with async capabilities (python 3.6+):

  ```bash
  pip install pymsteams[async]
  ```



  At time of writing, the latest release supported by Python 2 is [Version 0.1.16](https://github.com/rveachkc/pymsteams/releases/tag/0.1.16)





  This is the simplest implementation of pymsteams.  It will send a message to the teams webhook url with plain text in the message.

  ```python
  import pymsteams


  myTeamsMessage = pymsteams.connectorcard("<Microsoft Webhook URL>")


  myTeamsMessage.text("this is my text")


  myTeamsMessage.send()
  ```



  ```python
  import asyncio
  import pymsteams

  loop = asyncio.get_event_loop()


  myTeamsMessage = pymsteams.async_connectorcard("<Microsoft Webhook URL>")


  myTeamsMessage.text("This is my message")


  loop.run_until_complete(myTeamsMessage.send())
  ```

  Please visit the python asyncio documentation for more info on using asyncio and the event loop: https://docs.python.org/3/library/asyncio-eventloop.html





  ```python
  myTeamsMessage.title("This is my message title")
  ```


  ```python
  myTeamsMessage.addLinkButton("This is the button Text", "https://github.com/rveachkc/pymsteams/")
  ```


  This is useful in the event you need to post the same message to multiple rooms.
  ```python
  myTeamsMessage.newhookurl("<My New URL>")
  ```


  This sets the theme color of the card. The parameter is expected to be a hex color code without the hash or the string red.
  ```python
  myTeamsMessage.color("<Hex Color Code>")
  ```


  This is a simple print command to view your connector card message object before sending.
  ```python
  myTeamsMessage.printme()
  ```


  To create a section and add various formatting elements
  ```python

  myMessageSection = pymsteams.cardsection()


  myMessageSection.title("Section title")


  myMessageSection.activityTitle("my activity title")
  myMessageSection.activitySubtitle("my activity subtitle")
  myMessageSection.activityImage("http://i.imgur.com/c4jt321l.png")
  myMessageSection.activityText("This is my activity Text")


  myMessageSection.addFact("this", "is fine")
  myMessageSection.addFact("this is", "also fine")


  myMessageSection.text("This is my section text")


  myMessageSection.addImage("http://i.imgur.com/c4jt321l.png", ititle="This Is Fine")


  myTeamsMessage.addSection(myMessageSection)
  ```
  You may also add multiple sections to a connector card message as well.
  ```python

  Section1 = pymsteams.cardsection()
  Section1.text("My First Section")


  Section2 = pymsteams.cardsection()
  Section2.text("My Second Section")


  myTeamsMessage.addSection(Section1)
  myTeamsMessage.addSection(Section2)


  myTeamsMessage.send()
  ```

  To create a actions on which the user can interect with in MS Teams
  To find out more information on what actions can be used, please visit https://docs.microsoft.com/en-us/microsoftteams/platform/concepts/connectors/connectors-using#setting-up-a-custom-incoming-webhook

  ```python
  myTeamsMessage = pymsteams.connectorcard("<Microsoft Webhook URL>")

  myTeamsPotentialAction1 = pymsteams.potentialaction(_name = "Add a comment")
  myTeamsPotentialAction1.addInput("TextInput","comment","Add a comment here",False)
  myTeamsPotentialAction1.addAction("HttpPost","Add Comment","https://..."")

  myTeamsPotentialAction2 = pymsteams.potentialaction(_name = "Set due date")
  myTeamsPotentialAction2.addInput("DateInput","dueDate","Enter due date")
  myTeamsPotentialAction2.addAction("HttpPost","save","https://...")

  myTeamsPotentialAction3 = pymsteams.potentialaction(_name = "Change Status")
  myTeamsPotentialAction3.choices.addChoices("In progress","0")
  myTeamsPotentialAction3.choices.addChoices("Active","1")
  myTeamsPotentialAction3.addInput("MultichoiceInput","list","Select a status",False)
  myTeamsPotentialAction3.addAction("HttpPost","Save","https://...")

  myTeamsMessage.addPotentialAction(myTeamsPotentialAction1)
  myTeamsMessage.addPotentialAction(myTeamsPotentialAction2)
  myTeamsMessage.addPotentialAction(myTeamsPotentialAction3)

  myTeamsMessage.summary("Test Message")

  myTeamsMessage.send()
  ```


  ```python
  myTeamsMessage = pymsteams.connectorcard("<Microsoft Webhook URL>")

  myTeamsPotentialAction1 = pymsteams.potentialaction(_name = "Add a comment")

  myTeamsPotentialAction1.addInput("TextInput","comment","Add a comment here",False)

  myTeamsPotentialAction1.addAction("HttpPost","Add Comment","https://...", "{{comment.value}}")
  myTeamsMessage.addPotentialAction(myTeamsPotentialAction1)


  myTeamsMessage.summary("Test Message")

  myTeamsMessage.send()






  ```

  Please use Github issues to report any bugs or request enhancements.



  This module is really just a nice wrapper pointed at the Microsoft API. To help troubleshoot missing messages, the requests response content is saved to the connectorcard class attribute `last_http_response`.

  To get the last http status code:
  ```python
  import pymsteams

  myTeamsMessage = pymsteams.connectorcard("<Microsoft Webhook URL>")
  myTeamsMessage.text("this is my text")
  myTeamsMessage.send()

  last_status_code = myTeamsMessage.last_http_response.status_code
  ```

  More info on the Response Content is available in the requests documentation, [link](https://2.python-requests.org/en/master/user/quickstart/#response-content).



  If the call to the Microsoft Teams webhook service fails, a `TeamsWebhookException` will be thrown.



  In order to test in your environment with pytest, set the environment variable `MS_TEAMS_WEBHOOK` to the Microsoft Teams Webhook url you would like to use.

  Then, from the root of the repo, install the requirements and run pytest.

  ```bash
  pip install -r dev-requirements.txt
  MS_TEAMS_WEBHOOK=MicrosoftWebhookURL
  export MS_TEAMS_WEBHOOK
  pytest --cov=./pymsteams --cov-report=term-missing --cov-branch
  ```

  This will send two MS Teams messages describing how they are formatted.  Manually validate that the message comes through as expected.



  In some situations, a custom CA bundle must be used.  This can be set on class initialization, by setting the verify parameter.

  ```python
  import pymsteams


  msg = pymsteams.connectorcard("<Microsoft Webhook URL>", verify="/path/to/file")


  msg = pymsteams.connectorcard("<Microsoft Webhook URL>", verify=False)
  ```

  Set to either the path of a custom CA bundle or False to disable.

  The requests documentation can be referenced for full details: https://2.python-requests.org/en/master/user/advanced/#ssl-cert-verification


pkgId: 7bb2b24ddd4094b4d8f4de888a2c3148f942cae7e1ed0cb39667800b94d7da4f
name: python-pynetdicom
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: A Python implementation of the DICOM networking protocol
url: https://github.com/pydicom/pynetdicom
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6d212265-ef5a-4f3a-b221-c857324fc142
location_href: 00004745-python-pynetdicom/python-pynetdicom-2.0.2-1.src.rpm
checksum_type: sha256
description:
  A Python implementation of the `DICOM <http://dicom.nema.org>`_
  networking protocol, originally based on (legacy)
  `pynetdicom <https://github.com/patmun/pynetdicom_legacy>`_.


pkgId: 73e4b300d19354f814852b1665ef2a829b797581557a7511378ffc6dbaa53f05
name: python-pyngrok
arch: src
version: 5.2.1
epoch: 0
release: 1
summary: A Python wrapper for ngrok.
url: https://github.com/alexdlaird/pyngrok
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-589c8025-ad0d-4661-bdd4-7dd7c2a587cb
location_href: 00012107-python-pyngrok/python-pyngrok-5.2.1-1.src.rpm
checksum_type: sha256
description:
  <p align="center"><img alt="pyngrok - a Python wrapper for ngrok" src="https://pyngrok.readthedocs.io/en/latest/_images/logo.png" /></p>

  [![PyPI Version](https://badge.fury.io/py/pyngrok.svg)](https://badge.fury.io/py/pyngrok)
  [![CI/CD](https://github.com/alexdlaird/pyngrok/workflows/CI/CD/badge.svg)](https://github.com/alexdlaird/pyngrok/actions?query=workflow%3ACI%2FCD)
  [![Codecov](https://codecov.io/gh/alexdlaird/pyngrok/branch/main/graph/badge.svg)](https://codecov.io/gh/alexdlaird/pyngrok)
  [![Docs](https://readthedocs.org/projects/pyngrok/badge/?version=latest)](https://pyngrok.readthedocs.io/en/latest/?badge=latest)
  [![Python Versions](https://img.shields.io/pypi/pyversions/pyngrok.svg)](https://pypi.org/project/pyngrok/)
  [![PyPI License](https://img.shields.io/pypi/l/pyngrok.svg)](https://pypi.org/project/pyngrok/)
  [![Tweet](https://img.shields.io/twitter/url/http/shields.io.svg?style=social)](https://twitter.com/intent/tweet?text=Check+out+%23pyngrok%2C+a+Python+wrapper+for+%23ngrok+that+lets+you+programmatically+open+secure+%23tunnels+to+local+web+servers%2C+build+%23webhook+integrations%2C+enable+SSH+access%2C+test+chatbots%2C+demo+from+your+own+machine%2C+and+more.%0D%0A%0D%0A&url=https://github.com/alexdlaird/pyngrok&via=alexdlaird)

  `pyngrok` is a Python wrapper for `ngrok` that manages its own binary, making `ngrok` available via a convenient Python
  API.

  [ngrok](https://ngrok.com) is a reverse proxy tool that opens secure tunnels from public URLs to localhost, perfect
  for exposing local web servers, building webhook integrations, enabling SSH access, testing chatbots, demoing from
  your own machine, and more, and its made even more powerful with native Python integration through `pyngrok`.



  `pyngrok` is available on [PyPI](https://pypi.org/project/pyngrok/) and can be installed
  using `pip`:

  ```sh
  pip install pyngrok
  ```

  or `conda`:

  ```sh
  conda install -c conda-forge pyngrok
  ```

  That's it! `pyngrok` is now available as a package to our Python projects, and `ngrok` is now available from
  the command line.



  To open a tunnel, use the [`connect`](https://pyngrok.readthedocs.io/en/latest/api.html#pyngrok.ngrok.connect) method,
  which returns a `NgrokTunnel`, and this returned object has a reference to the public URL generated by `ngrok` in its
  `public_url` attribute.

  ```python
  from pyngrok import ngrok



  http_tunnel = ngrok.connect()


  ssh_tunnel = ngrok.connect(22, "tcp")
  ```

  The [`connect`](https://pyngrok.readthedocs.io/en/latest/api.html#pyngrok.ngrok.connect) method takes `kwargs` as
  well, which allows us to pass additional properties that are [supported by ngrok](https://ngrok.com/docs#tunnel-definitions).

  This package puts the default `ngrok` binary on our path, so all features of `ngrok` are
  available on the command line.

  ```sh
  ngrok http 80
  ```

  For details on how to fully leverage `ngrok` from the command line, see [ngrok's official documentation](https://ngrok.com/docs).



  For more advanced usage, `pyngrok`'s official documentation is available at [http://pyngrok.readthedocs.io](http://pyngrok.readthedocs.io).



  `pyngrok` is compatible with `ngrok` v2 and v3, but by default it will install v2. To install v3 instead,
  set `ngrok_version` in [`PyngrokConfig`](https://pyngrok.readthedocs.io/en/latest/api.html#pyngrok.conf.PyngrokConfig):

  ```python
  from pyngrok import conf

  conf.get_default().ngrok_version = "v3"
  ```



  The last version of `pyngrok` that supports Python 2.7 is 4.1.x, so we need to pin `pyngrok>=4.1,<4.2` if we still want
  to use `pyngrok` with this version of Python. Its legacy documentation can be found [here](https://pyngrok.readthedocs.io/en/4.1.x/).



  If you would like to get involved, be sure to review the [Contribution Guide](https://github.com/alexdlaird/pyngrok/blob/main/CONTRIBUTING.rst).

  Want to contribute financially? If you've found `pyngrok` useful, [a donation](https://www.paypal.me/alexdlaird) would
  also be greatly appreciated!


pkgId: e1f20f347b00596b55adb7ecfbfd349cb77260b1a05df879f75bc3947b3af57e
name: python-pynuvo
arch: src
version: 0.2
epoch: 0
release: 1
summary: Python API for talking to Nuvo multi zone amplifier
url: https://github.com/ejonesnospam/pynuvo
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7c5a8319-f9a8-4f80-8bd6-693ab13cf120
location_href: 00004748-python-pynuvo/python-pynuvo-0.2-1.src.rpm
checksum_type: sha256
description:
  Python3 interface implementation for Nuvo zone amplifier
   Initially developed/tested with older Concerto model
  *** Should/could also work with any Nuvo amp, via RS-232 serial, such NV-E6D


  This is for use with [Home-Assistant](http://home-assistant.io)


  ```python

  ```


pkgId: 2bbf9433eeea971f9779f3462af938acbb0cc4b324e6099d6988067c8bc17a15
name: python-pyobd
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: PyOBD - Open BYMA Data API
url: https://github.com/franco-lamas/PyOBD
rpm_license: GPL V3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8d39a95f-76b5-4e11-96d6-ac47883d7719
location_href: 00004750-python-pyobd/python-pyobd-0.1.7-1.src.rpm
checksum_type: sha256
description:
  PyOBD es una API para conectar cualquier script de Python con datos del mercado con 20 minutos de retraso provistos por Open BYMA Data, además permite la descarga de datos histórico. Fue desarrollada en conjunto por [Nacho Herrera](https://github.com/nacho-herrera), [St1tch](https://twitter.com/St1tch_BL) y [Franco Lamas](https://www.linkedin.com/in/franco-lamas/).



      from PyOBD import *
      PyOBD=openBYMAdata()



  Por el momento solo se encuentra disponible el plazo de 48hs que viene cargado por defecto



      PyOBD.get_bonds()



      PyOBD.get_short_term_bonds()


      PyOBD.get_corporateBonds()



      PyOBD.get_bluechips()



      PyOBD.get_galpones()



      PyOBD.get_cedears()



      PyOBD.indices()



      PyOBD.get_options()




      PyOBD.byma_news()



      PyOBD.isworkingDay()



      PyOBD.marketResume()



  La instalación vía pip aún no está disponible, únicamente desde el repositorio. Se requiere instalar [Git](https://git-scm.com/).

      pip install git+https://github.com/franco-lamas/PyOBD --upgrade --no-cache-dir



  *   Luego de las 2am se reinicia el servidor y cambia la estructura de datos.
  *   Luego de las 17 la sección de noticias se desconecta.




  *   Agregar más plazos
  *   Formatear links de noticias
  *   Dashboard de bonos IAMC
  *   Datos de empresas
  *   Históricos
  *   Balances históricos




  La información es mostrada “tal cual es”, puede ser incorrecta o contener errores, eso es responsabilidad de cada sitio. No somos responsables por el uso indebido de los Scripts.


pkgId: c82bfbb68a212991458e6a8e61afbaa0ebc5701f5a3df6714ae03774334f05ae
name: python-pyodbc
arch: src
version: 4.0.35
epoch: 0
release: 1
summary: DB API Module for ODBC
url: https://github.com/mkleehammer/pyodbc
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4aa5ad52-ecfe-4e40-951e-c92940d9c7f7
location_href: 00004752-python-pyodbc/python-pyodbc-4.0.35-1.src.rpm
checksum_type: sha256
description:
  [![Windows Status](https://ci.appveyor.com/api/projects/status/github/mkleehammer/pyodbc?branch=master&svg=true&passingText=Windows%20build)](https://ci.appveyor.com/project/mkleehammer/pyodbc)
  [![Ubuntu build](https://github.com/mkleehammer/pyodbc/actions/workflows/ubuntu_build.yml/badge.svg)](https://github.com/mkleehammer/pyodbc/actions/workflows/ubuntu_build.yml)
  [![PyPI](https://img.shields.io/pypi/v/pyodbc?color=brightgreen)](https://pypi.org/project/pyodbc/)

  pyodbc is an open source Python module that makes accessing ODBC databases simple.  It
  implements the [DB API 2.0](https://www.python.org/dev/peps/pep-0249) specification but is
  packed with even more Pythonic convenience.

  The easiest way to install is to use pip:

      pip install pyodbc

  If you are using Mac, you should be using `Homebrew` for installing pyodbc:

      brew install unixodbc
      pip install pyodbc

  Precompiled binary wheels are provided for most Python versions on Windows and macOS.  On other
  operating systems this will build from source.  Note, pyodbc contains C++ extensions so you will
  need a suitable C++ compiler on your computer to install pyodbc, for all operating systems.  See
  the [docs](https://github.com/mkleehammer/pyodbc/wiki/Install) for details.

  [Documentation](https://github.com/mkleehammer/pyodbc/wiki)

  [Release Notes](https://github.com/mkleehammer/pyodbc/releases)

  IMPORTANT: Python 2.7 support is being ended.  The pyodbc 4.x versions will be the last to
  support Python 2.7.  The pyodbc 5.x versions will only support Python 3.7 and above.


pkgId: 1583b89b82cc5c9dad4a09f82f2846a77379e547f6fa67ec77d62aadbfeec6f6
name: python-pyone
arch: src
version: 6.6.1
epoch: 0
release: 1
summary: Python Bindings for OpenNebula XML-RPC API
url: http://opennebula.io
rpm_license: http://www.apache.org/licenses/LICENSE-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-90957b3b-9775-4ad4-b61e-f83340e9fc58
location_href: 00004753-python-pyone/python-pyone-6.6.1-1.src.rpm
checksum_type: sha256
description:
  PyOne is an implementation of OpenNebula XML-RPC
  bindings in Python. It works as a proxy over the XML-RPC api and
  utilizes generateDS (https://www.davekuhlman.org/generateDS.html)
  to ecapsulate the xml response to Python objects.


pkgId: 65a6b07037ce79f2d8dd8f7d0ff2a83c973b1fa1df364f5e607c3b92de133c2a
name: python-pyopencl
arch: src
version: 2022.3.1
epoch: 0
release: 1
summary: Python wrapper for OpenCL
url: http://mathema.tician.de/software/pyopencl
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a365cb95-b7a4-4ee9-90a5-38dcfcd6a846
location_href: 00004754-python-pyopencl/python-pyopencl-2022.3.1-1.src.rpm
checksum_type: sha256
description:
  PyOpenCL lets you access GPUs and other massively parallel compute
  devices from Python. It tries to offer computing goodness in the
  spirit of its sister project `PyCUDA <https://mathema.tician.de/software/pycuda>`__:
  * Object cleanup tied to lifetime of objects. This idiom, often
    called `RAII <https://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization>`__
    in C++, makes it much easier to write correct, leak- and
    crash-free code.
  * Completeness. PyOpenCL puts the full power of OpenCL's API at
    your disposal, if you wish.  Every obscure ``get_info()`` query and
    all CL calls are accessible.
  * Automatic Error Checking. All CL errors are automatically
    translated into Python exceptions.
  * Speed. PyOpenCL's base layer is written in C++, so all the niceties
    above are virtually free.
  * Helpful and complete `Documentation <https://documen.tician.de/pyopencl>`__
    as well as a `Wiki <https://wiki.tiker.net/PyOpenCL>`__.
  * Liberal license. PyOpenCL is open-source under the
    `MIT license <https://en.wikipedia.org/wiki/MIT_License>`__
    and free for commercial, academic, and private use.
  * Broad support. PyOpenCL was tested and works with Apple's, AMD's, and Nvidia's
    CL implementations.
  Simple 4-step `install instructions <https://documen.tician.de/pyopencl/misc.html#installation>`__
  using Conda on Linux and macOS (that also install a working OpenCL implementation!)
  can be found in the `documentation <https://documen.tician.de/pyopencl/>`__.
  What you'll need if you do *not* want to use the convenient instructions above and
  instead build from source:
  * gcc/g++ new enough to be compatible with pybind11
    (see their `FAQ <https://pybind11.readthedocs.io/en/stable/faq.html>`__)
  * `numpy <https://numpy.org>`__, and
  * an OpenCL implementation. (See this `howto <https://wiki.tiker.net/OpenCLHowTo>`__
    for how to get one.)


pkgId: e08cf6712cb15ab97878af20c54096e2d837a6a777a116c202e99bfa40777fa0
name: python-pyopenuv
arch: src
version: 2023.2.0
epoch: 0
release: 1
summary: A simple Python API data from openuv.io
url: https://github.com/bachya/pyopenuv
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-53be68cb-4983-497f-8fe9-fe241dcfe99f
location_href: 00004757-python-pyopenuv/python-pyopenuv-2023.2.0-1.src.rpm
checksum_type: sha256
description:
  [![CI][ci-badge]][ci]
  [![PyPI][pypi-badge]][pypi]
  [![Version][version-badge]][version]
  [![License][license-badge]][license]
  [![Code Coverage][codecov-badge]][codecov]
  [![Maintainability][maintainability-badge]][maintainability]

  <a href="https://www.buymeacoffee.com/bachya1208P" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/default-orange.png" alt="Buy Me A Coffee" height="41" width="174"></a>

  `pyopenuv` is a simple Python library for retrieving UV-related information from
  [openuv.io][openuv].

  - [Installation](#installation)
  - [Python Versions](#python-versions)
  - [API Key](#api-key)
  - [Usage](#usage)
  - [Contributing](#contributing)



  ```bash
  pip install pyopenuv
  ```



  `pyopenuv` is currently supported on:

  - Python 3.9
  - Python 3.10
  - Python 3.11



  You can get an API key from [the OpenUV console][openuv-console].



  ```python
  import asyncio

  from pyopenuv import Client
  from pyopenuv.errors import OpenUvError


  async def main():
      client = Client(
          "<OPENUV_API_KEY>", "<LATITUDE>", "<LONGITUDE>", altitude="<ALTITUDE>"
      )

      try:
          
          print(await client.api_status())
          

          
          print(await client.uv_index())
          

          
          print(await client.uv_forecast())
          

          
          print(await client.uv_protection_window())
          

          
          print(await client.api_statistics())
          
      except OpenUvError as err:
          print(f"There was an error: {err}")


  asyncio.run(main())
  ```



  If you would prefer to not call `api_status` manually, you can configure the `Client` object
  to automatically check the status of the OpenUV API before executing any of the API
  methods—simply pass the `check_status_before_request` parameter:

  ```python
  import asyncio

  from pyopenuv import Client
  from pyopenuv.errors import ApiUnavailableError, OpenUvError


  async def main():
      client = Client(
          "<OPENUV_API_KEY>",
          "<LATITUDE>",
          "<LONGITUDE>",
          altitude="<ALTITUDE>",
          check_status_before_request=True,
      )

      try:
          print(await client.uv_index())
      except ApiUnavailableError:
          print("The API is unavailable")
      except OpenUvError as err:
          print(f"There was an error: {err}")


  asyncio.run(main())
  ```



  By default, the library creates a new connection to OpenUV with each coroutine. If you
  are calling a large number of coroutines (or merely want to squeeze out every second of
  runtime savings possible), an [`aiohttp`][aiohttp] `ClientSession` can be used for
  connection pooling:

  ```python
  import asyncio

  from aiohttp import ClientSession
  from pyopenuv import Client
  from pyopenuv.errors import OpenUvError


  async def main():
      async with ClientSession() as session:
          client = Client(
              "<OPENUV_API_KEY>",
              "<LATITUDE>",
              "<LONGITUDE>",
              altitude="<ALTITUDE>",
              session=session,
          )

          try:
              print(await client.uv_index())
          except OpenUvError as err:
              print(f"There was an error: {err}")


  asyncio.run(main())
  ```



  Thanks to all of [our contributors][contributors] so far!

  1. [Check for open features/bugs][issues] or [initiate a discussion on one][new-issue].
  2. [Fork the repository][fork].
  3. (_optional, but highly recommended_) Create a virtual environment: `python3 -m venv .venv`
  4. (_optional, but highly recommended_) Enter the virtual environment: `source ./.venv/bin/activate`
  5. Install the dev environment: `script/setup`
  6. Code your new feature or bug fix on a new branch.
  7. Write tests that cover your new functionality.
  8. Run tests and ensure 100% code coverage: `poetry run pytest --cov pyopenuv tests`
  9. Update `README.md` with any new documentation.
  10. Submit a pull request!

  [aiohttp]: https://github.com/aio-libs/aiohttp
  [ci-badge]: https://github.com/bachya/pyopenuv/workflows/CI/badge.svg
  [ci]: https://github.com/bachya/pyopenuv/actions
  [codecov-badge]: https://codecov.io/gh/bachya/pyopenuv/branch/dev/graph/badge.svg
  [codecov]: https://codecov.io/gh/bachya/pyopenuv
  [contributors]: https://github.com/bachya/pyopenuv/graphs/contributors
  [fork]: https://github.com/bachya/pyopenuv/fork
  [issues]: https://github.com/bachya/pyopenuv/issues
  [license-badge]: https://img.shields.io/pypi/l/pyopenuv.svg
  [license]: https://github.com/bachya/pyopenuv/blob/main/LICENSE
  [maintainability-badge]: https://api.codeclimate.com/v1/badges/a03c9e96f19a3dc37f98/maintainability
  [maintainability]: https://codeclimate.com/github/bachya/pyopenuv/maintainability
  [new-issue]: https://github.com/bachya/pyopenuv/issues/new
  [new-issue]: https://github.com/bachya/pyopenuv/issues/new
  [openuv]: https://openuv.io/
  [openuv-console]: https://www.openuv.io/console
  [pypi-badge]: https://img.shields.io/pypi/v/pyopenuv.svg
  [pypi]: https://pypi.python.org/pypi/pyopenuv
  [version-badge]: https://img.shields.io/pypi/pyversions/pyopenuv.svg
  [version]: https://pypi.python.org/pypi/pyopenuv


pkgId: a3e68a0aa8c847a4f9b74b3f3cf38a9f39af6fe1dcf771ff0a0a3dad89765654
name: python-pyotp
arch: src
version: 2.8.0
epoch: 0
release: 1
summary: Python One Time Password Library
url: https://github.com/pyotp/pyotp
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3af3974b-3cae-4091-9c5c-6fc9903fe5fd
location_href: 00004759-python-pyotp/python-pyotp-2.8.0-1.src.rpm
checksum_type: sha256
description:
  PyOTP is a Python library for generating and verifying one-time passwords. It can be used to implement two-factor (2FA)
  or multi-factor (MFA) authentication methods in web applications and in other systems that require users to log in.
  Open MFA standards are defined in `RFC 4226 <https://tools.ietf.org/html/rfc4226>`_ (HOTP: An HMAC-Based One-Time
  Password Algorithm) and in `RFC 6238 <https://tools.ietf.org/html/rfc6238>`_ (TOTP: Time-Based One-Time Password
  Algorithm). PyOTP implements server-side support for both of these standards. Client-side support can be enabled by
  sending authentication codes to users over SMS or email (HOTP) or, for TOTP, by instructing users to use `Google
  Authenticator <https://en.wikipedia.org/wiki/Google_Authenticator>`_, `Authy <https://www.authy.com/>`_, or another
  compatible app. Users can set up auth tokens in their apps easily by using their phone camera to scan `otpauth://
  <https://github.com/google/google-authenticator/wiki/Key-Uri-Format>`_ QR codes provided by PyOTP.
  Implementers should read and follow the `HOTP security requirements <https://tools.ietf.org/html/rfc4226#section-7>`_
  and `TOTP security considerations <https://tools.ietf.org/html/rfc6238#section-5>`_ sections of the relevant RFCs. At
  minimum, application implementers should follow this checklist:
  - Ensure transport confidentiality by using HTTPS
  - Ensure HOTP/TOTP secret confidentiality by storing secrets in a controlled access database
  - Deny replay attacks by rejecting one-time passwords that have been used by the client (this requires storing the most
    recently authenticated timestamp, OTP, or hash of the OTP in your database, and rejecting the OTP when a match is seen)
  - Throttle (rate limit) brute-force attacks against your application's login functionality (see RFC 4226, section 7.3)
  - When implementing a "greenfield" application, consider supporting
    `FIDO U2F <https://en.wikipedia.org/wiki/Universal_2nd_Factor>`_/`WebAuthn <https://www.w3.org/TR/webauthn/>`_ in
    addition to HOTP/TOTP. U2F uses asymmetric cryptography to avoid using a shared secret design, which strengthens your
    MFA solution against server-side attacks. Hardware U2F also sequesters the client secret in a dedicated single-purpose
    device, which strengthens your clients against client-side attacks. And by automating scoping of credentials to
    relying party IDs (application origin/domain names), U2F adds protection against phishing attacks. One implementation of
    FIDO U2F/WebAuthn is PyOTP's sister project, `PyWARP <https://github.com/pyauth/pywarp>`_.
  We also recommend that implementers read the
  `OWASP Authentication Cheat Sheet <https://github.com/OWASP/CheatSheetSeries/blob/master/cheatsheets/Authentication_Cheat_Sheet.md>`_ and
  `NIST SP 800-63-3: Digital Authentication Guideline <https://pages.nist.gov/800-63-3/>`_ for a high level overview of
  authentication best practices.


pkgId: f0af4f6139c557d76bc6236720f1ce7b971eafdf53d71400cb3025bc764af218
name: python-pyowm
arch: src
version: 3.3.0
epoch: 0
release: 1
summary: A Python wrapper around OpenWeatherMap web APIs
url: https://github.com/csparpa/pyowm
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3f5b6b5d-84f1-4c1f-8bd9-cc0d7b2d06cd
location_href: 00004760-python-pyowm/python-pyowm-3.3.0-1.src.rpm
checksum_type: sha256
description:
  [![logo](logos/180x180.png)](https://github.com/csparpa)


  **A Python wrapper around OpenWeatherMap web APIs**

  [![PyPI version](https://badge.fury.io/py/pyowm.svg)](https://badge.fury.io/py/pyowm)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/pyowm.svg)](https://img.shields.io/pypi/dm/pyowm.svg)
  <br>
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pyowm.svg)](https://img.shields.io/pypi/pyversions/pyowm.svg)
  <br>
  [![Latest Release Documentation](https://readthedocs.org/projects/pyowm/badge/?version=latest)](https://pyowm.readthedocs.io/en/latest/)
  [![Build Status](https://travis-ci.org/csparpa/pyowm.png?branch=develop)](https://travis-ci.org/csparpa/pyowm)
  [![Coverage Status](https://coveralls.io/repos/github/csparpa/pyowm/badge.svg?branch=develop)](https://coveralls.io/github/csparpa/pyowm?branch=master)
  <br>
  <a href="https://www.buymeacoffee.com/LmAl1n9" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/black_img.png" alt="Buy Me A Coffee" style="height: auto !important;width: auto !important;" ></a>
  [![Say Thanks!](https://img.shields.io/badge/Say%20Thanks-!-1EAEDB.svg)](https://saythanks.io/to/csparpa%40gmail.com)


  PyOWM is a client Python wrapper library for OpenWeatherMap (OWM) web APIs. It allows quick and easy consumption of OWM data from Python applications via a simple object model and in a human-friendly fashion.

  PyOWM runs on Python 3.7+

  **Former Dark Sky API users**: you can can use PyOWM to get [OpenWeatherMap's OneCall API](https://openweathermap.org/api/one-call-api) data as an easy replacement to Dark Sky


  With PyOWM you can integrate into your code any of the following OpenWeatherMap web APIs:

   - **Weather API v2.5** + **OneCall API**, providing current weather data, weather forecasts, weather history
   - **Agro API v1.0**, providing soil data and satellite imagery search and download
   - **Air Pollution API v3.0**, providing data about CO, O3, NO2 and SO2
   - **UV Index API v3.0**, providing data about Ultraviolet exposition
   - **Stations API v3.0**, allowing to create and manage meteostation and publish local weather measurements
   - **Weather Alerts API v3.0**, allowing to set triggers on weather conditions and areas and poll for spawned alerts
   - **Image tiles** for several map layers provided by OWM
   - **Geocoding API v1.0** allowing to perform direct/reverse geocoding



  Please **read the [FAQ](https://pyowm.readthedocs.io/en/latest/v3/faq.html)** before filing a new issue on GitHub! There are many common issues, therefore a fix for your issue might come easier than you think

   



  As OpenWeatherMap APIs need a valid API key to allow responses, *PyOWM won't work if you don't provide one*. This stands for both free and paid (pro) subscription plans.
  You can signup for a free API key [on the OWM website](https://home.openweathermap.org/users/sign_up)
  Please notice that the free API subscription plan is subject to requests throttling.



  With a free OWM API Key:

  ```python
  from pyowm import OWM
  from pyowm.utils import config
  from pyowm.utils import timestamps



  owm = OWM('your free OWM API key')
  mgr = owm.weather_manager()



  observation = mgr.weather_at_place('London,GB')
  w = observation.weather

  w.detailed_status         # 'clouds'
  w.wind()                  # {'speed': 4.6, 'deg': 330}
  w.humidity                # 87
  w.temperature('celsius')  # {'temp_max': 10.5, 'temp': 9.7, 'temp_min': 9.0}
  w.rain                    # {}
  w.heat_index              # None
  w.clouds                  # 75


  forecast = mgr.forecast_at_place('Milan,IT', 'daily')
  answer = forecast.will_be_clear_at(timestamps.tomorrow())



  config_dict = config.get_default_config_for_subscription_type('professional')
  owm = OWM('your paid OWM API key', config_dict)


  one_call_object = mgr.one_call(lat=52.5244, lon=13.4105)
  one_call_object.current.humidity
  ```



  Install with `pip` for your ease:

  ```shell
  $ pip install pyowm
  ```

  There are alternatives: _setuptools_, _Windows installers_ and common Linux package managers such as _Yaourt (Arch Linux)_
  _YaST/Zypper (OpenSuse)_ (please refer to the documentation for more detail)

  Eager to fetch the very latest updates to PyOWM? Install the development trunk (which might be unstable). Eg on Linux:

  ```shell
  $ git clone https://github.com/csparpa/pyowm.git
  $ cd pyowm && git checkout develop
  $ pip install -r requirements.txt && python setup.py install
  ```


  The library software API documentation is available on [Read the Docs](https://pyowm.readthedocs.io/en/latest/).

  The [Code recipes](https://pyowm.readthedocs.io/en/latest/v3/code-recipes.html) section comes in handy!




  Here are [some cool projects](https://github.com/csparpa/pyowm/wiki/Community-Projects-using-PyOWM) that use PyOWM

  Join the **[PyOWM public Slack team](https://pyowm.slack.com)** by signing up [here](http://pyowm-slackin.herokuapp.com/)

  _Contributors (coding, testing, packaging, reporting issues) are welcome!_ See the [the official documentation website](https://pyowm.readthedocs.io/) for details or the [CONTRIBUTING.md](https://github.com/csparpa/pyowm/blob/master/CONTRIBUTING.md) file for a quick primer.



  [MIT license](https://github.com/csparpa/pyowm/blob/master/LICENSE)


pkgId: 9e37e51dd48f84c8a20deb72f8cdb555d8fd0f6711c273779db072d6ec4dcd77
name: python-pypandoc
arch: src
version: 1.11
epoch: 0
release: 1
summary: Thin wrapper for pandoc.
url: https://github.com/JessicaTegner/pypandoc
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8867e5f3-e8fa-4948-9b83-3de058612fa7
location_href: 00004761-python-pypandoc/python-pypandoc-1.11-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/JessicaTegner/pypandoc/actions/workflows/ci.yaml/badge.svg)](https://github.com/JessicaTegner/pypandoc/actions/workflows/ci.yaml)
  [![GitHub Releases](https://img.shields.io/github/tag/JessicaTegner/pypandoc.svg)](https://github.com/JessicaTegner/pypandoc/releases)
  [![Pypandoc PyPI Version](https://img.shields.io/pypi/v/pypandoc?label=pypandoc+pypi+version)](https://pypi.org/project/pypandoc/)
  [![Pypandoc Binary PyPI Version](https://img.shields.io/pypi/v/pypandoc_binary?label=pypandoc+binary+pypi+version)](https://pypi.org/project/pypandoc_binary/)
  ![PyPandoc PyPi Downloads](https://img.shields.io/pypi/dm/pypandoc)
  ![PyPandoc Binary PyPI Downloads](https://img.shields.io/pypi/dm/pypandoc_binary)
  [![conda version](https://anaconda.org/conda-forge/pypandoc/badges/version.svg)](https://anaconda.org/conda-forge/pypandoc/)
  [![Development Status](https://img.shields.io/pypi/status/pypandoc.svg)](https://pypi.python.org/pypi/pypandoc/)
  [![PyPandoc Python version](https://img.shields.io/pypi/pyversions/pypandoc.svg)](https://pypi.python.org/pypi/pypandoc/)
  [![PyPandoc Binary Python version](https://img.shields.io/pypi/pyversions/pypandoc_binary.svg)](https://pypi.python.org/pypi/pypandoc_binary/)
  ![License](https://img.shields.io/pypi/l/pypandoc.svg)

  Pypandoc provides a thin wrapper for [pandoc](https://pandoc.org), a universal
  document converter.



  Pypandoc uses pandoc, so it needs an available installation of pandoc. Pypandoc provides 2 packages, "pypandoc" and "pypandoc_binary", with the second one including pandoc out of the box.
  The 2 packages are identical, with the only difference being that one includes pandoc, while the other don't.

  If pandoc is already installed (i.e. pandoc is in the `PATH`), pypandoc uses the version with the
  higher version number, and if both are the same, the already installed version. See [Specifying the location of pandoc binaries](#specifying-the-location-of-pandoc-binaries) for more.

  To use pandoc filters, you must have the relevant filters installed on your machine.



  If you [want to install pandoc yourself](#Installing-pandoc) or are on a unsupported platform, you'll need to install "pypandoc" and  [install pandoc manually](#Installing-pandoc)

  ```
  pip install pypandoc
  ```


  If you want pandoc included out of the box, you can utilize our pypandoc_binary package, which are identical to the "pypandoc" package, but with pandoc included.

  ```
  pip install pypandoc_binary
  ```

  Prebuilt [wheels for Windows and Mac OS X](https://pypi.python.org/pypi/pypandoc_binary/)

  If you use Linux and have [your own wheelhouse](https://wheel.readthedocs.org/en/latest/#usage),
  you can build a wheel which include pandoc with
  `python setup_binary.py download_pandoc; python setup.py bdist_wheel`. Be aware that this works only
  on 64bit intel systems, as we only download it from the
  [official releases](https://github.com/jgm/pandoc/releases).



  Pypandoc is included in [conda-forge](https://conda-forge.github.io/). The conda packages will
  also install the pandoc package, so pandoc is available in the installation.

  Install via `conda install -c conda-forge pypandoc`.

  You can also add the channel to your conda config via
  `conda config --add channels conda-forge`. This makes it possible to
  use `conda install pypandoc` directly and also lets you update via `conda update pypandoc`.



  If you don't already have pandoc on your system, or have installed the pypandoc_binary package, which includes pandoc, you need to install pandoc by yourself.



  Installing via pypandoc is possible on Windows, Mac OS X or Linux (Intel-based, 64-bit):

  ```python
  pip install pypandoc
  from pypandoc.pandoc_download import download_pandoc


  download_pandoc()
  ```

  The default install location is included in the search path for pandoc, so you
  don't need to add it to the `PATH`.

  By default, the latest pandoc version is installed. If you want to specify your own version, say 1.19.1, use `download_pandoc(version='1.19.1')` instead.



  Installing manually via the system mechanism is also possible. Such installation mechanism
  make pandoc available on many more platforms:

  - Ubuntu/Debian: `sudo apt-get install pandoc`
  - Fedora/Red Hat: `sudo yum install pandoc`
  - Arch: `sudo pacman -S pandoc`
  - Mac OS X with Homebrew: `brew install pandoc pandoc-citeproc Caskroom/cask/mactex`
  - Machine with Haskell: `cabal-install pandoc`
  - Windows: There is an installer available
    [here](https://pandoc.org/installing.html)
  - [FreeBSD with pkg:](https://www.freshports.org/textproc/hs-pandoc/) `pkg install hs-pandoc`
  - Or see [Pandoc - Installing pandoc](https://pandoc.org/installing.html)

  Be aware that not all install mechanisms put pandoc in the `PATH`, so you either
  have to change the `PATH` yourself or set the full `PATH` to pandoc in
  `PYPANDOC_PANDOC`. See the next section for more information.



  You can point to a specific pandoc version by setting the environment variable
  `PYPANDOC_PANDOC` to the full `PATH` to the pandoc binary
  (`PYPANDOC_PANDOC=/home/x/whatever/pandoc` or `PYPANDOC_PANDOC=c:\pandoc\pandoc.exe`).
  If this environment variable is set, this is the only place where pandoc is searched for.

  In certain cases, e.g. pandoc is installed but a web server with its own user
  cannot find the binaries, it is useful to specify the location at runtime:

  ```python
  import os
  os.environ.setdefault('PYPANDOC_PANDOC', '/home/x/whatever/pandoc')
  ```



  There are two basic ways to use pypandoc: with input files or with input
  strings.


  ```python
  import pypandoc


  output = pypandoc.convert_file('somefile.md', 'rst')


  output = pypandoc.convert_file('somefile.txt', 'rst', format='md')



  output = pypandoc.convert_text('# some title', 'rst', format='md')

  ```

  `convert_text` expects this string to be unicode or utf-8 encoded bytes. `convert_*` will always
  return a unicode string.

  It's also possible to directly let pandoc write the output to a file. This is the only way to
  convert to some output formats (e.g. odt, docx, epub, epub3, pdf). In that case `convert_*()` will
  return an empty string.

  ```python
  import pypandoc

  output = pypandoc.convert_file('somefile.md', 'docx', outputfile="somefile.docx")
  assert output == ""
  ```


  It's also possible to specify multiple input files to pandoc, either as absolute paths, relative paths or file patterns.

  ```python
  import pypandoc


  pypandoc.convert_file('chapters/*.md', 'docx', outputfile="somefile.docx")


  pypandoc.convert_file(['book1/*.md', 'book2/*.md'], 'docx', outputfile="somefile.docx")


  pypandoc.convert_file(['D:/book_front.md', 'book2/*.md'], 'docx', outputfile="somefile.docx")
  ```


  pathlib is also supported.

  ```python
  import pypandoc
  from pathlib import Path


  input = Path('somefile.md')
  output = input.with_suffix('.docx')
  pypandoc.convert_file(input, 'docx', outputfile=output)


  pypandoc.convert_file(Path('chapters').glob('*.md'), 'docx', outputfile="somefile.docx")


  pypandoc.convert_file([*Path('book1').glob('*.md'), *Path('book2').glob('*.md')], 'docx', outputfile="somefile.docx")

  ```

  In addition to `format`, it is possible to pass `extra_args`.
  That makes it possible to access various pandoc options easily.

  ```python
  output = pypandoc.convert_text(
      '<h1>Primary Heading</h1>',
      'md', format='html',
      extra_args=['--atx-headers'])

  output = pypandoc.convert_text(
      '# Primary Heading',
      'html', format='md',
      extra_args=['--base-header-level=2'])

  ```

  pypandoc now supports easy addition of
  [pandoc filters](https://pandoc.org/scripting.html).

  ```python
  filters = ['pandoc-citeproc']
  pdoc_args = ['--mathjax',
               '--smart']
  output = pypandoc.convert_file(filename,
                                 to='html5',
                                 format='md',
                                 extra_args=pdoc_args,
                                 filters=filters)
  ```

  Please pass any filters in as a list and not as a string.

  Please refer to `pandoc -h` and the
  [official documentation](https://pandoc.org/MANUAL.html) for further details.



  Pandoc supports custom formatting though `-V` parameter. In order to use it through
  pypandoc, use code such as this:

  ```python
  output = pypandoc.convert_file('demo.md', 'pdf', outputfile='demo.pdf',
    extra_args=['-V', 'geometry:margin=1.5cm'])
  ```

  > Note: it's important to separate `-V` and its argument within a list like that or else
  it won't work. This gotcha has to do with the way
  [`subprocess.Popen`](https://docs.python.org/2/library/subprocess.html#subprocess.Popen) works.



  Pypandoc logs messages using the [Python logging library](https://docs.python.org/3/library/logging.html).
  By default, it will send messages to the console, including any messages
  generated by Pandoc. If desired, this behaviour can be changed by adding
  [handlers](https://docs.python.org/3/library/logging.html#handler-objects) to
  the pypandoc logger **before calling any functions**. For example, to mute all
  logging add a [null handler](https://docs.python.org/3/library/logging.handlers.html#nullhandler):

  ```python
  import logging
  logging.getLogger('pypandoc').addHandler(logging.NullHandler())
  ```



  As it can be useful sometimes to check what pandoc version is available at your system or which
  particular pandoc binary is used by pypandoc. For that, pypandoc provides the following
  utility functions. Example:

  ```
  print(pypandoc.get_pandoc_version())
  print(pypandoc.get_pandoc_path())
  print(pypandoc.get_pandoc_formats())
  ```



  * [pydocverter](https://github.com/msabramo/pydocverter) is a client for a service called
  [Docverter](https://www.docverter.com), which offers pandoc as a service (plus some extra goodies).
  * See [pyandoc](https://pypi.python.org/pypi/pyandoc/) for an alternative implementation of a pandoc
  wrapper from Kenneth Reitz. This one hasn't been active in a while though.
  * See [panflute](https://github.com/sergiocorreia/panflute) which provides `convert_text` similar to pypandoc's. Its focus is on writing and running pandoc filters though.



  Contributions are welcome. When opening a PR, please keep the following guidelines in mind:

  1. Before implementing, please open an issue for discussion.
  2. Make sure you have tests for the new logic.
  3. Make sure your code passes `flake8 pypandoc/*.py tests.py`
  4. Add yourself to contributors at `README.md` unless you are already there. In that case tweak your contributions.

  Note that for citeproc tests to pass you'll need to have [pandoc-citeproc](https://github.com/jgm/pandoc-citeproc) installed. If you installed a prebuilt wheel or conda package, it is already included.



  * [Jessica Tegner](https://github.com/JessicaTegner) - New maintainer as of 1. Juli 2021
  * [Valentin Haenel](https://github.com/esc) - String conversion fix
  * [Daniel Sanchez](https://github.com/ErunamoJAZZ) - Automatic parsing of input/output formats
  * [Thomas G.](https://github.com/coldfix) - Python 3 support
  * [Ben Jao Ming](https://github.com/benjaoming) - Fail gracefully if pandoc is missing
  * [Ross Crawford-d'Heureuse](https://github.com/rosscdh) - Encode input in UTF-8 and add Django
    example
  * [Michael Chow](https://github.com/machow) - Decode output in UTF-8
  * [Janusz Skonieczny](https://github.com/wooyek) - Support Windows newlines and allow encoding to
    be specified.
  * [gabeos](https://github.com/gabeos) - Fix help parsing
  * [Marc Abramowitz](https://github.com/msabramo) - Make `setup.py` fail hard if pandoc is
    missing, Travis, Dockerfile, PyPI badge, Tox, PEP-8, improved documentation
  * [Daniel L.](https://github.com/mcktrtl) - Add `extra_args` example to README
  * [Amy Guy](https://github.com/rhiaro) - Exception handling for unicode errors
  * [Florian Eßer](https://github.com/flesser) - Allow Markdown extensions in output format
  * [Philipp Wendler](https://github.com/PhilippWendler) - Allow Markdown extensions in input format
  * [Jan Katins](https://github.com/jankatins) - Handling output to a file, Travis to work on newer version of pandoc, return code checking, get_pandoc_version. Helped to fix the Travis build, new `convert_*` API. Former maintainer of pypandoc
  * [Aaron Gonzales](https://github.com/xysmas) - Added better filter handling
  * [David Lukes](https://github.com/dlukes) - Enabled input from non-plain-text files and made sure tests clean up template files correctly if they fail
  * [valholl](https://github.com/valholl) - Set up licensing information correctly and include examples to distribution version
  * [Cyrille Rossant](https://github.com/rossant) - Fixed bug by trimming out stars in the list of pandoc formats. Helped to fix the Travis build.
  * [Paul Osborne](https://github.com/posborne) - Don't require pandoc to install pypandoc.
  * [Felix Yan](https://github.com/felixonmars) - Added installation instructions for Arch Linux.
  * [Kolen Cheung](https://github.com/ickc) - Implement `_get_pandoc_urls` for installing arbitrary version as well as the latest version of pandoc. Minor: README, Travis, setup.py.
  * [Rebecca Heineman](https://github.com/burgerbecky) - Added scanning code for finding pandoc in Windows
  * [Andrew Barraford](https://github.com/abarrafo) - Download destination.
  * [Jesse Widner](https://github.com/jwidner) & [Dominic Thorn](https://github.com/domvwt) - Add support for lua filters
  * [Alex Kneisel](https://github.com/hey-thanks/) - Added pathlib.Path support to convert_file.
  * [Juho Vepsäläinen](https://github.com/bebraw/) - Creator and former maintainer of pypandoc




  Pypandoc is available under MIT license. See LICENSE for more details. Pandoc itself is [available under the GPL2 license](https://github.com/jgm/pandoc/blob/master/COPYING.md).


pkgId: cfc9d0b6f2fc44eacbed4dd118829df242adf473bf9065269c76567fa68cdc6d
name: python-pypcapkit
arch: src
version: 0.16.3
epoch: 0
release: 1
summary: Python multi-engine PCAP analyse kit.
url: https://github.com/JarryShaw/PyPCAPKit
rpm_license: BSD 3-Clause License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d56d2937-7a19-4fa0-8455-cfba83946d23
location_href: 00004762-python-pypcapkit/python-pypcapkit-0.16.3-1.src.rpm
checksum_type: sha256
description:
     For any technical and/or maintenance information,
     please kindly refer to the |docs|_.
  The PyPCAPKit project is an open source Python program focus
  on `PCAP`_ parsing and analysis, which works as a stream PCAP file extractor.
  With support of `DictDumper`_, it shall support multiple
  output report formats.


pkgId: 341910e6ddc35a8169558e98629bdc8e71d384bff24c4df38d863566a9bf83a3
name: python-pypdftk
arch: src
version: 0.5
epoch: 0
release: 1
summary: Python wrapper for PDFTK
url: http://github.com/revolunet/pypdftk
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e0b33f2f-3435-4a03-a8c8-a3ca9f5ccbff
location_href: 00014096-python-pypdftk/python-pypdftk-0.5-1.src.rpm
checksum_type: sha256
description:
  Python module to drive the awesome [pdftk][0] binary.
  Proudly brought to you by the [revolunet][1] team and `awesome
  contributors`_


pkgId: b965569acbdc11c60e9f4757369aa2773492a0df7127e3046d826925c9250d8f
name: python-pyperclip
arch: src
version: 1.8.2
epoch: 0
release: 1
summary: A cross-platform clipboard module for Python. (Only handles plain text for now.)
url: https://github.com/asweigart/pyperclip
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-56e35e94-c5a4-4cba-8608-e405a182258b
location_href: 00004763-python-pyperclip/python-pyperclip-1.8.2-1.src.rpm
checksum_type: sha256
description:
      >>> import pyperclip
      >>> pyperclip.copy('The text to be copied to the clipboard.')
      >>> pyperclip.paste()
      'The text to be copied to the clipboard.'
  Currently only handles plaintext.
  On Windows, no additional modules are needed.
  On Mac, this module makes use of the pbcopy and pbpaste commands, which should come with the os.
  On Linux, this module makes use of the xclip or xsel commands, which should come with the os. Otherwise run "sudo apt-get install xclip" or "sudo apt-get install xsel" (Note: xsel does not always seem to work.)
  Otherwise on Linux, you will need the gtk or PyQt4 modules installed.


pkgId: c918484aaa5164bf7b9c97e3bd7ff968e4b59e495cddcdcd2d9e6327fdd19c2d
name: python-pyphi
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Python library for computing integrated information.
url: http://github.com/wmayner/pyphi
rpm_license: GNU General Public License v3.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d4a8fc46-6bb8-4097-89d0-6dfe1c8efaaa
location_href: 00004766-python-pyphi/python-pyphi-1.2.0-1.src.rpm
checksum_type: sha256
description:
  Mayner WGP, Marshall W, Albantakis L, Findlay G, Marchman R, Tononi G. (2018)
  [PyPhi: A toolbox for integrated information
  theory](https://doi.org/10.1371/journal.pcbi.1006343). PLOS Computational


pkgId: 474e77cf4c8e0bd14565b3fb6fe0de7ef9420e4f4dc887aff31f0e608af54516
name: python-pypika-tortoise
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: Forked from pypika and streamline just for tortoise-orm
url: https://github.com/tortoise/pypika-tortoise
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d888002a-376c-4652-a2e6-9d51da984b27
location_href: 00013764-python-pypika-tortoise/python-pypika-tortoise-0.1.6-1.src.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/pypi/v/pypika-tortoise.svg?style=flat)](https://pypi.python.org/pypi/pypika-tortoise)
  [![image](https://img.shields.io/github/license/tortoise/pypika-tortoise)](https://github.com/tortoise/pypika-tortoise)
  [![image](https://github.com/tortoise/pypika-tortoise/workflows/pypi/badge.svg)](https://github.com/tortoise/pypika-tortoise/actions?query=workflow:pypi)
  [![image](https://github.com/tortoise/pypika-tortoise/workflows/ci/badge.svg)](https://github.com/tortoise/pypika-tortoise/actions?query=workflow:ci)

  Forked from [pypika](https://github.com/kayak/pypika) and streamline just for tortoise-orm.



  The original repo include many databases that tortoise-orm don't need, and which aims to be a perfect sql builder and
  should consider more compatibilities, but tortoise-orm is not, and we need add new features and update it ourselves.



  Delete many codes that tortoise-orm don't need, and add features just tortoise-orm considers to.



  Nothing, because this repo keeps the original struct and code.



  - [pypika](https://github.com/kayak/pypika), a python SQL query builder that exposes the full richness of the SQL
    language using a syntax that reflects the resulting query.



  This project is licensed under the [Apache-2.0](./LICENSE) License.


pkgId: 1fc86c64f076fc3d3b7ec59bb025c314638c73124cfac804a10c2f0f732ef502
name: python-pypillowfight
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Library containing various image processing algorithms
url: https://gitlab.gnome.org/World/OpenPaperwork/libpillowfight#readme
rpm_license: GPLv2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ac3f4672-a6ae-422b-adce-c55e76804bff
location_href: 00004767-python-pypillowfight/python-pypillowfight-0.3.0-1.src.rpm
checksum_type: sha256
description:
  Library containing various image processing algorithms: Automatic Color Equalization, Unpaper's algorithms, Stroke Width Transformation, etc


pkgId: 0974d730681a52b20830ba979e17539d2a48294da9b271ee1f38ebc225a000da
name: python-pypinyin
arch: src
version: 0.48.0
epoch: 0
release: 1
summary: 汉字拼音转换模块/工具.
url: https://github.com/mozillazg/python-pinyin
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-33a822ee-bdce-4db9-b9c6-15c4a41441e2
location_href: 00013096-python-pypinyin/python-pypinyin-0.48.0-1.src.rpm
checksum_type: sha256
description:
  |Build| |GitHubAction| |Coverage| |Pypi version| |PyPI downloads| |DOI|
  将汉字转为拼音。可以用于汉字注音、排序、检索(`Russian translation`_) 。
  最初版本的代码参考了 `hotoo/pinyin <https://github.com/hotoo/pinyin>`__ 的实现。
  * Documentation: https://pypinyin.readthedocs.io/
  * GitHub: https://github.com/mozillazg/python-pinyin
  * License: MIT license
  * PyPI: https://pypi.org/project/pypinyin
  * Python version: 2.7, pypy, pypy3, 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 3.10, 3.11


pkgId: fb6c45ded1e2c287d82cc36e1c7821615596c8a1284f652a891e36ef05a386d9
name: python-pypng
arch: src
version: 0.20220715.0
epoch: 0
release: 1
summary: Pure Python library for saving and loading PNG images
url: https://gitlab.com/drj11/pypng
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ef3daebf-cdfa-4aea-a04c-52ae5b4c152a
location_href: 00004768-python-pypng/python-pypng-0.20220715.0-1.src.rpm
checksum_type: sha256
description:
  drj@pobox.com




  PNG module for Python. PyPNG is written entirely in Python.

  - PyPNG home page: https://gitlab.com/drj11/pypng/
  - PyPNG Documentation: https://pypng.readthedocs.io/en/latest/
  - PyPNG mailing list: https://groups.google.com/forum/#!forum/pypng-users




      import png
      png.from_array([[255, 0, 0, 255],
                      [0, 255, 255, 0]], 'L').save("small_smiley.png")

  After that, try `import png` then `help(png)`.
  Also, lickable HTML documentation appears in the `html/` directory.
  If HTML is no good then you could try the ReST sources
  in the `man/` directory.




  PyPNG is pure Python and has no dependencies.
  It requires Python 3.5 or any compatible higher version.

  To install PyPNG package via pip use:

      python -m pip install git+https://gitlab.com/drj11/pypng@pypng-0.20220715.0

  After install use

      `import png`

  to access the `png` module in your Python program.

  You can also install from source using `setuptools`.
  PyPNG uses `setup.cfg` and `pyproject.toml` to record its
  configuration.

  To install from (version controlled) sources using a suitable
  version of `pip`:

  `cd` into the directory and execute the command:

      python -m pip install .

  PyPNG is so simple, that you don't need installation tools.
  You can copy `code/png.py` wherever you like.
  It's intended that you can copy `png.py` into
  your application and distribute it.
  The following `curl` command should copy the latest version into
  your current directory:

      curl -LO https://gitlab.com/drj11/pypng/-/raw/main/code/png.py




  (For issues see https://gitlab.com/drj11/pypng/-/issues/ )






  Development moved to gitlab: https://gitlab.com/drj11/pypng

  If you pass an empty file to PyPNG
  it now raises the builtin Python exception `EOFError`.
  This should make it easier to diagnose _empty file_ problems separately
  from genuine format errors
  (which use `png.FormatError`).
  This is a slightly breaking change to the API.

  New `prirowpng` tool to join PNG images in a row left-to-right
  (old internal `pipcat` tool).

  New `pricolpng` tool to join PNG images in a column top-to-bottom.

  Support for plain PGM files (magic number P2) added to `pripamtopng`.

  New `priplan9topng` tool to convert from Plan 9 image format to PNG.
  In reality this has been lurking in the codebase for years, but
  has recently been converted to Python 3.
  The author has only a limited collection of Plan 9 images,
  which limits the testing that can be done.
  The author welcomes bug reports for Plan 9 images.

  The `priplan9topng` tool has an even more experimental option
  `--font` which converts Plan 9 subfont files to a sequence of
  PNG files.




  Support for Python 2 is dropped.
  Python 3.5 and onwards are supported.
  Some of the ancillary tools are modified to work on Python 3.

  Installs via wheel files.

  `prichunkpng` command line tool now has some new options to add
  chunks:
  - `--iccprofile` to add a `iCCP` chunk (ICC Profile);
  - `--physical` to add a `pHYs` chunk,
    specifying the intended pixel size;
  - `--sigbit` to add a `sBIT` chunk,
    specifying the encoded significant bits;
  - `--transparent` to add a `tRNS` chunk,
    specifying the transparent colour.

  `priditherpng` command line tool standardised and
  converted to Python 3.

  `pripngtopam` tool now has a `--plain` option to output plain PGM
  and PPM formats. The `topam` part of the name is a bit of a
  misnomer: when possible (L and RGB PNG files) the tool will
  output either a PGM (grey) or a PPM (RGB) file. Essentially all
  tools that can process a PAM file can also process a PGM or a
  PPM file. PAM files cannot be _plain_ so using the option
  will raise an error in the case where a true PAM file is
  written.

  Better error messages when you write the wrong number of rows.

  (Slightly experimentally) running the `png` module as a command
  line tool, with `python -m png`, will report the version and
  file location of the `png` module.




  Support for earlier versions of Python is dropped.
  Python 3.4 and onwards are supported.
  Python 2.7 also works, but this is the last
  release to support any version of Python 2.

  Cython code is removed, which simplifies the implementation.

  Removed the (optional) dependency `setuptools`.

  Changed the default for `png.Writer` to be greyscale.

  Removed 3D support from `.from_array()`.




  Support for earlier versions of Python is dropped in order to
  simplify the code.
  From the Python 3.x series all versions from 3.2 onward are supported.
  From the 2.x series only Python 2.6 and 2.7 are supported.

  Code cleaned.
  Tests renamed and more organised.
  Generally Flake 8 compliant.
  Fewer special cases for ancient versions of Python.

  The row length is checked when writing PNG files.
  Previously it was possible to write badly formed PNG files
  by passing in rows of the wrong length.

  `pHYS` chunk is now processed.

  The `Writer()` interface now supports source pixels
  that have a different bitdepth for each channel.
  To exploit this, pass in a tuple for the bitdepth argument.

  Ancillary tools regularised and simplified.

  `pripamtopng` command line tool converts NetPBM PNM/PAM files to PNG.
  Previously `png.py` did this.
  Note that only one input file is converted,
  if you have intensity and opacity in separate files,
  you have two options:
  either use `pamstack` to convert them into a single PAM file and
  convert that, or
  convert each file to PNG, then use `priweavepng` to weave them together.
  Both will work.

  `pripngtopam` command line tool converts PNG to NetPBM PNM/PAM file.
  Previously `png.py` did this.

  `python -m pngsuite` is now a command line tool to
  write various images from the PNG suite of test images.
  Previously this was possible using `gen`.

  `priweavepng` command line tool performs channel extraction across
  multiple images.
  This is a more general version of `pipstack` (which has been removed),
  and is inspired by `pamstack` from NetPBM.

  The `--interlace` option available on many previous tools is
  now only available on `priweavepng`,
  making it the preferred tool for generating interlaced PNGs.

  `prichunkpng` command line tool adds and deletes chunks and
  "intelligently" knows about transparent, gamma, background chunks.
  It is the preferred tool for adding those chunks,
  which was previously possible using various options of other tools.

  `gen` has been renamed to `priforgepng`.

  `priforgepng` uses centre pixel sampling, which means that a 256 pixel
  wide 8-bit gradient takes on all possible 256 values.
  It also improves output for very small images.

  `priforgepng` uses `Fraction` for internal maths meaning that
  the stripe patterns are accurate and do not have loose pixels.

  `priforgepng` only outputs greyscale PNG files
  (but see next item for a feature to generate colour PNGs).

  `priforgepng` can output multiple PNGs onto the same stream.
  This aligns well with a feature of `priweavepng` which
  accepts multiple PNGs from stdin.
  LA, RGB, and RGBA test images can be generated by
  piping `priforgepng` into `priweavepng`:
  `priforgepng RTL RTR RBR | priweavepng - - -`
  will generate an RGB PNG.




  Thanks to `github.com/sean-duffy`,
  `.from_array()` can now take a 3D array.

  Converting to PNMs was broken in Python 3; this is now fixed.
  Issue 26: https://gitlab.com/drj11/pypng/-/issues/26




  Various fixes when running on Python 3 and Windows.
  Merging pull requests from `github.com/ironfroggy` and
  `github.com/techtonik`,
  and merging by hand a commit from `github.com/Scondo`.




  Compatible with nose: `nosetests png.py` now works.

  Allow any "file-like" object as an input.

  Handle newlines in `texttopng`.




  Fixed various URLs to point at github.com instead of googlecode.




  When using `png.py` as a command line tool,
  it can now produce non-square test images.

  PyPNG now installs "out of the box" on Python 3 on a plain install
  (previously `distribute` or `pip` was required).

  PyPNG welcomes the following community contributions:

    Joaquín Cuenca Abela speeds up PNG reading when Cython is available.

    Josh Bleecher Snyder adds a lenient mode
    which has relaxed checksum checking.

    nathan@dunfield.info fixed a problem writing files
    when using the command line tool on Windows (Issue 62).

  The following issues have been fixed:

    On github:

    Issue 6: Palette processing is annoying

    On googlecode:

    Issue 62: Problem writing PNG files on Windows

  Development has moved from googlecode to github.
  All issues below here, and the one immediately above,
  are from the googlecode issue tracker.
  All newer issue should be on github.




  PyPNG now installs "out of the box" on Python 3.
  Thanks to simon.sapin@kozea.fr and nathan@dunfield.info for the patch.

  The following issues have been fixed:

    Issue 63: setup.py does not use 2to3
    Issue 64: Typo in documentation




  PyPNG now works on Python 3 if you use the `2to3` tool.
  Fix for converting grey images to RGBA.

  The following issues have been fixed:

    Issue 60: Greyscale images not properly being converted to RGBA
    Issue 61: Doesn't work on Python 3




  Added the "How Fast is PyPNG" section to the documentation.
  Changed it so that more PNG formats return their rows as
  Python `array.array` instances.




  Fix for read_flat method (broken for ages).

  The following issues have been fixed:

    Issue 56:  read_flat broken




  Tentative fix for a deprecation warning on 64-bit Python 2.5 systems.
  Conversion tool for Plan 9 images.

  Issue 54 (below) is tentative.
  The PyPNG developers have been unable to reproduce the error
  (as it seems to be on 64-bit Python 2.5 systems);
  any user reports would be most welcome.

  The following issues have been fixed:

    Issue 54:  Deprecation warnings when using pypng.
    Issue 55:  Cannot convert Plan 9 images.




  Mostly more robust to dodgy input PNGs,
  as a result of testing with `brokensuite`.
  One fixed bug was a critical:
  an infinite loop for a least one input (Issue 52 below).

  The following issues have been fixed:

    Issue 47:  Leading blanks when using write_packed.
    Issue 48:  pipdither fails when input has no gamma chunk.
    Issue 49:  pipdither fail with 1-bit input.
    Issue 50:  pipchunk adds second gamma chunk.
    Issue 51:  piprgb and pipasgrey fail for color mapped images.
    Issue 52:  Some inputs cause infinite loop.




  Better documentation (in `html/ex.html` mostly) for NumPy integration.

  The following issues have been fixed:

    Issue 46:  Unclear how to get PNG pixel data into and out of NumPy.




  NumPy integer types now work.

  The following issues have been fixed:

    Issue 44:  Cannot use numpy.uint16 for pixel values.




  `sBIT` chunks are now handled,
  meaning that PyPNG can handle any (single) bit depth from 1 to 16
  from end to end.

  The following issues have been fixed:

    Issue 28:  Does not add sBIT chunk.
    Issue 36:  Ignores sBIT chunk when present.




  PyPNG now works on Python 2.2
  (significant for Symbian users as PyS60 is based on Python 2.2).
  Not all features are supported on Python 2.2.

  The following issues have been fixed:

    Issue 16:  Source and doc uses 'K' where it should use 'L'.
    Issue 32:  Does not accept packed data.
    Issue 33:  Cannot create greyscale PNG with transparency.
    Issue 35:  Does not work on Python 2.2.




  Handling PAM files allows end to end handling of alpha channels in
  workflows that involve both Netpbm formats and PNG.
  PyPNG now works in Python 2.3.

  The following issues have been fixed:

    Issue 14:  Does not read PAM files.
    Issue 15:  Does not write PAM files.
    Issue 25:  Incorrect handling of tRNS chunk.
    Issue 26:  asRGBA8 method crashes out for color type 2 images.
    Issue 27:  Fails on Python 2.3.




  Lickable HTML documentation is now provided (see the html/ directory),
  generated by Sphinx.

  The following issues have been fixed:

    Issue 8:  Documentation is not lickable.
    Issue 9:  Advantage over PIL is not clear.
    Issue 19: Bogus message for PNM inputs with unsupported maxval
    Issue 20: Cannot write large PNG files




  Stuff happened.




  - .../ - top-level crud (like this README, and setup.py).
  - .../asset - assets (needed for testing)
  - .../code/ - the Python code.
  - .../man/ - manuals (in source/plain-text).
  - .../proc/ - documented procedures (release procedure).




  - Python: www.python.org
  - PNG: http://www.w3.org/TR/PNG/


pkgId: d31ef1bc492ed21400151027d5abbef4175de5c0798b8251504a592743e182a6
name: python-pyppeteer
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: Headless chrome/chromium automation library (unofficial port of puppeteer)
url: https://github.com/pyppeteer/pyppeteer
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-12463144-4aa3-4837-92b9-e79808052123
location_href: 00009678-python-pyppeteer/python-pyppeteer-1.0.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/pyppeteer.svg)](https://pypi.python.org/pypi/pyppeteer)
  [![PyPI version](https://img.shields.io/pypi/pyversions/pyppeteer.svg)](https://pypi.python.org/pypi/pyppeteer)
  [![Documentation](https://img.shields.io/badge/docs-latest-brightgreen.svg)](https://pyppeteer.github.io/pyppeteer/)
  [![CircleCI](https://circleci.com/gh/pyppeteer/pyppeteer.svg?style=shield)](https://circleci.com/gh/pyppeteer/pyppeteer)
  [![codecov](https://codecov.io/gh/pyppeteer/pyppeteer/branch/dev/graph/badge.svg)](https://codecov.io/gh/pyppeteer/pyppeteer)
  _Note: this is a continuation of the [pyppeteer project](https://github.com/miyakogi/pyppeteer)_. Before undertaking any sort of developement, it is highly recommended that you take a look at [#16](https://github.com/pyppeteer/pyppeteer/pull/16) for the ongoing effort to update this library to avoid duplicating efforts.
  Unofficial Python port of [puppeteer](https://github.com/GoogleChrome/puppeteer) JavaScript (headless) chrome/chromium browser automation library.
  * Free software: MIT license (including the work distributed under the Apache 2.0 license)
  * Documentation: https://pyppeteer.github.io/pyppeteer/

  pyppeteer requires Python >= 3.6
  Install with `pip` from PyPI:
  ```
  pip install pyppeteer
  ```
  Or install the latest version from [this github repo](https://github.com/pyppeteer/pyppeteer/):
  ```
  pip install -U git+https://github.com/pyppeteer/pyppeteer@dev
  ```

  > **Note**: When you run pyppeteer for the first time, it downloads the latest version of Chromium (~150MB) if it is not found on your system. If you don't prefer this behavior, ensure that a suitable Chrome binary is installed. One way to do this is to run `pyppeteer-install` command before prior to using this library.
  Full documentation can be found [here](https://pyppeteer.github.io/pyppeteer/reference.html). [Puppeteer's documentation](https://github.com/GoogleChrome/puppeteer/blob/master/docs/api.md#) and [its troubleshooting guide](https://github.com/GoogleChrome/puppeteer/blob/master/docs/troubleshooting.md) are also great resources for pyppeteer users.

  Open web page and take a screenshot:
  ```py
  import asyncio
  from pyppeteer import launch
  async def main():
      browser = await launch()
      page = await browser.newPage()
      await page.goto('https://example.com')
      await page.screenshot({'path': 'example.png'})
      await browser.close()
  asyncio.get_event_loop().run_until_complete(main())
  ```
  Evaluate javascript on a page:
  ```py
  import asyncio
  from pyppeteer import launch
  async def main():
      browser = await launch()
      page = await browser.newPage()
      await page.goto('https://example.com')
      await page.screenshot({'path': 'example.png'})
      dimensions = await page.evaluate('''() => {
          return {
              width: document.documentElement.clientWidth,
              height: document.documentElement.clientHeight,
              deviceScaleFactor: window.devicePixelRatio,
          }
      }''')
      print(dimensions)
      
      await browser.close()
  asyncio.get_event_loop().run_until_complete(main())
  ```

  pyppeteer strives to replicate the puppeteer API as close as possible, however, fundamental differences between Javascript and Python make this difficult to do precisely. More information on specifics can be found in the [documentation](https://pyppeteer.github.io/pyppeteer/reference.html).

  puppeteer uses an object for passing options to functions/methods. pyppeteer methods/functions accept both dictionary (python equivalent to JavaScript's objects) and keyword arguments for options.
  Dictionary style options (similar to puppeteer):
  ```python
  browser = await launch({'headless': True})
  ```
  Keyword argument style options (more pythonic, isn't it?):
  ```python
  browser = await launch(headless=True)
  ```

  In python, `$` is not a valid identifier. The equivalent methods to Puppeteer's `$`, `$$`, and `$x` methods are listed below, along with some shorthand methods for your convenience:
  | puppeteer | pyppeteer              | pyppeteer shorthand |
  |-----------|-------------------------|----------------------|
  | Page.$()  | Page.querySelector()    | Page.J()             |
  | Page.$$() | Page.querySelectorAll() | Page.JJ()            |
  | Page.$x() | Page.xpath()            | Page.Jx()            |

  puppeteer's version of `evaluate()` takes a JavaScript function or a string representation of a JavaScript expression. pyppeteer takes string representation of JavaScript expression or function. pyppeteer will try to automatically detect if the string is function or expression, but it will fail sometimes. If an expression is erroneously treated as function and an error is raised, try setting `force_expr` to `True`, to force pyppeteer to treat the string as expression.

  Get a page's `textContent`:
  ```python
  content = await page.evaluate('document.body.textContent', force_expr=True)
  ```
  Get an element's `textContent`:
  ```python
  element = await page.querySelector('h1')
  title = await page.evaluate('(element) => element.textContent', element)
  ```

  See [projects](https://github.com/pyppeteer/pyppeteer/projects)


pkgId: 8019ed2882f7491b38441762364aaab0c0ecc001ac9634228ae53d62359fad7e
name: python-pyppmd-debuginfo
arch: x86_64
version: 1.0.0
epoch: 0
release: 1
summary: Debug information for package python-pyppmd
url: http://github.com/miurahr/pyppmd
rpm_license: LGPL-2.1-or-later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-cefe6591-8ca7-439a-8cfe-7011e1d8869e
rpm_sourcerpm: python-pyppmd-1.0.0-1.src.rpm
location_href: 00010474-python-pyppmd/python-pyppmd-debuginfo-1.0.0-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pyppmd.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: bd31706316a110738ac3b1f37bd5020cd6bab100a8263d47c991b88431f24549
name: python-pyppmd-debugsource
arch: x86_64
version: 1.0.0
epoch: 0
release: 1
summary: Debug sources for package python-pyppmd
url: http://github.com/miurahr/pyppmd
rpm_license: LGPL-2.1-or-later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-cefe6591-8ca7-439a-8cfe-7011e1d8869e
rpm_sourcerpm: python-pyppmd-1.0.0-1.src.rpm
location_href: 00010474-python-pyppmd/python-pyppmd-debugsource-1.0.0-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pyppmd.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: e4d14c3e74388f20aed9d34b070ed2c8a8d826c90a4d9a3df1652daa78bdad3a
name: python-pyprocdev
arch: src
version: 0.2
epoch: 0
release: 1
summary: Python interface to /proc/devices
url: UNKNOWN
rpm_license: GPL 2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b018b4a0-cd6c-4f19-b22c-069deea5264d
location_href: 00004769-python-pyprocdev/python-pyprocdev-0.2-1.src.rpm
checksum_type: sha256
description:
  This package supplies a Python interface to the /proc/devices file.
  To use, instantiate the ProcDev class and invoke its methods. ::
      >>> from pyprocdev import *
      >>> procdev = ProcDev()
      >>> procdev.majors(DeviceTypes.BLOCK)
      [8, 9, 11, 65, 66, 67, 68, 69, 70, 71, 128, 129, 130, 131, 132, 133, 134, 135, 253, 254, 259]
      >>> procdev.majors(DeviceTypes.CHARACTER)
      [1, 4, 5, 7, 10, 13, 14, 21, 29, 99, 116, 128, 136, 162, 166, 180, 188, 189, 202, 203, 226, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254]
      >>> procdev.drivers(DeviceTypes.BLOCK)
      frozenset(['md', 'sr', 'device-mapper', 'blkext', 'mdp', 'sd'])
      >>> procdev.get_driver(DeviceTypes.BLOCK, 8)
      'sd'
      >>> procdev.get_majors(DeviceTypes.BLOCK, 'sd')
      [8, 65, 66, 67, 68, 69, 70, 71, 128, 129, 130, 131, 132, 133, 134, 135]


pkgId: e36d162d77e66606cfea30aa30c7c1ab438d7a0af488717a6692524b36e35178
name: python-pyproj
arch: src
version: 3.4.1
epoch: 0
release: 1
summary: Python interface to PROJ (cartographic projections and coordinate transformations library)
url: https://github.com/pyproj4/pyproj
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a33cf587-d05f-4521-b965-3947431b01e8
location_href: 00004770-python-pyproj/python-pyproj-3.4.1-1.src.rpm
checksum_type: sha256
description:
  ![Pyproj logo](docs/media/logo.png)



  Python interface to [PROJ](http://proj.org) (cartographic projections and coordinate transformations library).

  <p align="center">
  <a href="https://gitter.im/pyproj4-pyproj/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge"><img alt="Join the chat at https://gitter.im/pyproj4-pyproj/community" src="https://badges.gitter.im/pyproj4-pyproj/community.svg"></a>
  <a href="#contributors"><img alt="All Contributors" src="https://img.shields.io/badge/all_contributors-56-orange.svg?style=flat-square"></a>
  <a href="https://ci.appveyor.com/project/snowman2/pyproj"><img alt="Appveyor Build Status" src="https://ci.appveyor.com/api/projects/status/v2ypts9j76doa9ey/branch/main?svg=true"></a>
  <a href="https://github.com/pyproj4/pyproj/actions?query=workflow%3ATests"><img alt="GitHub Actions Build Status" src="https://github.com/pyproj4/pyproj/workflows/Tests/badge.svg"></a>
  <a href="https://codecov.io/gh/pyproj4/pyproj"><img alt="Codecov Status" src="https://codecov.io/gh/pyproj4/pyproj/branch/main/graph/badge.svg"></a>
  <a href="https://badge.fury.io/py/pyproj"><img alt="PyPI" src="https://badge.fury.io/py/pyproj.svg"></a>
  <a href="https://pepy.tech/project/pyproj"><img alt="Downloads" src="https://pepy.tech/badge/pyproj"></a>
  <a href="https://anaconda.org/conda-forge/pyproj"><img alt="Anaconda-Server Badge" src="https://anaconda.org/conda-forge/pyproj/badges/version.svg"></a>
  <a href="https://github.com/python/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>
  <a href="https://github.com/pre-commit/pre-commit"><img alt="pre-commit" src="https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white"></a>
  <a href="https://zenodo.org/badge/latestdoi/28607354"><img alt="DOI" src="https://zenodo.org/badge/28607354.svg"></a>
  </p>




  - Stable: http://pyproj4.github.io/pyproj/stable/
  - Latest: https://pyproj4.github.io/pyproj/latest/



  - Report bugs/feature requests: https://github.com/pyproj4/pyproj/issues
  - Ask questions: https://github.com/pyproj4/pyproj/discussions
  - Ask developer questions: https://gitter.im/pyproj4-pyproj/community
  - Ask the GIS community: https://gis.stackexchange.com/questions/tagged/pyproj



  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tr>
      <td align="center"><a href="https://github.com/jswhit"><img src="https://avatars2.githubusercontent.com/u/579593?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Jeff Whitaker</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=jswhit" title="Documentation">📖</a> <a href="https://github.com/pyproj4/pyproj/commits?author=jswhit" title="Tests">⚠️</a> <a href="https://github.com/pyproj4/pyproj/commits?author=jswhit" title="Code">💻</a> <a href="#example-jswhit" title="Examples">💡</a> <a href="#ideas-jswhit" title="Ideas, Planning, & Feedback">🤔</a> <a href="https://github.com/pyproj4/pyproj/pulls?q=is%3Apr+reviewed-by%3Ajswhit" title="Reviewed Pull Requests">👀</a> <a href="#question-jswhit" title="Answering Questions">💬</a> <a href="#maintenance-jswhit" title="Maintenance">🚧</a> <a href="#infra-jswhit" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="https://github.com/pyproj4/pyproj/issues?q=author%3Ajswhit" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/snowman2"><img src="https://avatars3.githubusercontent.com/u/8699967?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Alan D. Snow</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=snowman2" title="Documentation">📖</a> <a href="https://github.com/pyproj4/pyproj/commits?author=snowman2" title="Tests">⚠️</a> <a href="https://github.com/pyproj4/pyproj/commits?author=snowman2" title="Code">💻</a> <a href="#example-snowman2" title="Examples">💡</a> <a href="#maintenance-snowman2" title="Maintenance">🚧</a> <a href="#infra-snowman2" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="#ideas-snowman2" title="Ideas, Planning, & Feedback">🤔</a> <a href="https://github.com/pyproj4/pyproj/pulls?q=is%3Apr+reviewed-by%3Asnowman2" title="Reviewed Pull Requests">👀</a> <a href="#question-snowman2" title="Answering Questions">💬</a> <a href="https://github.com/pyproj4/pyproj/issues?q=author%3Asnowman2" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/micahcochran"><img src="https://avatars0.githubusercontent.com/u/7433104?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Micah Cochran</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=micahcochran" title="Documentation">📖</a> <a href="https://github.com/pyproj4/pyproj/commits?author=micahcochran" title="Tests">⚠️</a> <a href="https://github.com/pyproj4/pyproj/commits?author=micahcochran" title="Code">💻</a> <a href="#maintenance-micahcochran" title="Maintenance">🚧</a> <a href="#infra-micahcochran" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="https://github.com/pyproj4/pyproj/pulls?q=is%3Apr+reviewed-by%3Amicahcochran" title="Reviewed Pull Requests">👀</a> <a href="#question-micahcochran" title="Answering Questions">💬</a> <a href="https://github.com/pyproj4/pyproj/issues?q=author%3Amicahcochran" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://jorisvandenbossche.github.io/"><img src="https://avatars2.githubusercontent.com/u/1020496?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Joris Van den Bossche</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=jorisvandenbossche" title="Documentation">📖</a> <a href="https://github.com/pyproj4/pyproj/commits?author=jorisvandenbossche" title="Code">💻</a> <a href="#ideas-jorisvandenbossche" title="Ideas, Planning, & Feedback">🤔</a> <a href="https://github.com/pyproj4/pyproj/pulls?q=is%3Apr+reviewed-by%3Ajorisvandenbossche" title="Reviewed Pull Requests">👀</a> <a href="#question-jorisvandenbossche" title="Answering Questions">💬</a> <a href="https://github.com/pyproj4/pyproj/issues?q=author%3Ajorisvandenbossche" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=jorisvandenbossche" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://github.com/cjmayo"><img src="https://avatars1.githubusercontent.com/u/921089?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Chris Mayo</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=cjmayo" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://www.petrel.org"><img src="https://avatars1.githubusercontent.com/u/2298266?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Charles Karney</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=cffk" title="Code">💻</a> <a href="https://github.com/pyproj4/pyproj/commits?author=cffk" title="Tests">⚠️</a></td>
      <td align="center"><a href="http://www.justaprogrammer.net/profile/justin"><img src="https://avatars3.githubusercontent.com/u/146930?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Justin Dearing</b></sub></a><br /><a href="#infra-zippy1981" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/jdkloe"><img src="https://avatars3.githubusercontent.com/u/1906112?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Jos de Kloe</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=jdkloe" title="Code">💻</a> <a href="https://github.com/pyproj4/pyproj/commits?author=jdkloe" title="Tests">⚠️</a> <a href="https://github.com/pyproj4/pyproj/issues?q=author%3Ajdkloe" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/georgeouzou"><img src="https://avatars3.githubusercontent.com/u/16732042?v=4?s=100" width="100px;" alt=""/><br /><sub><b>George Ouzounoudis</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=georgeouzou" title="Code">💻</a> <a href="#ideas-georgeouzou" title="Ideas, Planning, & Feedback">🤔</a></td>
      <td align="center"><a href="https://github.com/djhoese"><img src="https://avatars3.githubusercontent.com/u/1828519?v=4?s=100" width="100px;" alt=""/><br /><sub><b>David Hoese</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/pulls?q=is%3Apr+reviewed-by%3Adjhoese" title="Reviewed Pull Requests">👀</a> <a href="#ideas-djhoese" title="Ideas, Planning, & Feedback">🤔</a> <a href="#platform-djhoese" title="Packaging/porting to new platform">📦</a> <a href="https://github.com/pyproj4/pyproj/commits?author=djhoese" title="Documentation">📖</a> <a href="https://github.com/pyproj4/pyproj/commits?author=djhoese" title="Tests">⚠️</a> <a href="https://github.com/pyproj4/pyproj/commits?author=djhoese" title="Code">💻</a></td>
      <td align="center"><a href="http://mitkin.github.io"><img src="https://avatars3.githubusercontent.com/u/3927849?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Mikhail Itkin</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=mitkin" title="Code">💻</a></td>
      <td align="center"><a href="http://dopplershift.github.io"><img src="https://avatars2.githubusercontent.com/u/221526?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Ryan May</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=dopplershift" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/artttt"><img src="https://avatars3.githubusercontent.com/u/4626281?v=4?s=100" width="100px;" alt=""/><br /><sub><b>artttt</b></sub></a><br /><a href="#ideas-artttt" title="Ideas, Planning, & Feedback">🤔</a></td>
      <td align="center"><a href="http://ocefpaf.github.io/python4oceanographers"><img src="https://avatars1.githubusercontent.com/u/950575?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Filipe</b></sub></a><br /><a href="#infra-ocefpaf" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="https://github.com/pyproj4/pyproj/commits?author=ocefpaf" title="Code">💻</a> <a href="#platform-ocefpaf" title="Packaging/porting to new platform">📦</a> <a href="https://github.com/pyproj4/pyproj/commits?author=ocefpaf" title="Documentation">📖</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/heitorPB"><img src="https://avatars2.githubusercontent.com/u/13461702?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Heitor</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=heitorPB" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/sebastic"><img src="https://avatars3.githubusercontent.com/u/4605306?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Bas Couwenberg</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=sebastic" title="Code">💻</a> <a href="#platform-sebastic" title="Packaging/porting to new platform">📦</a> <a href="https://github.com/pyproj4/pyproj/commits?author=sebastic" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://github.com/nickeubank"><img src="https://avatars0.githubusercontent.com/u/9683693?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Nick Eubank</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=nickeubank" title="Code">💻</a></td>
      <td align="center"><a href="https://www.math.uwaterloo.ca/~mdunphy/"><img src="https://avatars3.githubusercontent.com/u/9088426?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Michael Dunphy</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=mdunphy" title="Documentation">📖</a></td>
      <td align="center"><a href="http://matthew.dynevor.org"><img src="https://avatars2.githubusercontent.com/u/67612?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Matthew Brett</b></sub></a><br /><a href="#infra-matthew-brett" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="#platform-matthew-brett" title="Packaging/porting to new platform">📦</a></td>
      <td align="center"><a href="https://naboa.de"><img src="https://avatars1.githubusercontent.com/u/10531844?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Jakob de Maeyer </b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=jdemaeyer" title="Code">💻</a></td>
      <td align="center"><a href="https://gitter.im"><img src="https://avatars2.githubusercontent.com/u/8518239?v=4?s=100" width="100px;" alt=""/><br /><sub><b>The Gitter Badger</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=gitter-badger" title="Documentation">📖</a></td>
    </tr>
    <tr>
      <td align="center"><a href="http://lizards.opensuse.org/author/bmwiedemann/"><img src="https://avatars3.githubusercontent.com/u/637990?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Bernhard M. Wiedemann</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=bmwiedemann" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/ReallyNiceGuy"><img src="https://avatars0.githubusercontent.com/u/6545730?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Marco Aurélio da Costa</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=ReallyNiceGuy" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/ChrisBarker-NOAA"><img src="https://avatars2.githubusercontent.com/u/916576?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Christopher H. Barker</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=ChrisBarker-NOAA" title="Code">💻</a></td>
      <td align="center"><a href="https://evers.dev/"><img src="https://avatars3.githubusercontent.com/u/13132571?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Kristian Evers</b></sub></a><br /><a href="#question-kbevers" title="Answering Questions">💬</a> <a href="#ideas-kbevers" title="Ideas, Planning, & Feedback">🤔</a> <a href="https://github.com/pyproj4/pyproj/commits?author=kbevers" title="Documentation">📖</a></td>
      <td align="center"><a href="http://www.spatialys.com/en/about/"><img src="https://avatars2.githubusercontent.com/u/1192433?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Even Rouault</b></sub></a><br /><a href="#question-rouault" title="Answering Questions">💬</a></td>
      <td align="center"><a href="https://github.com/cgohlke"><img src="https://avatars3.githubusercontent.com/u/483428?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Christoph Gohlke</b></sub></a><br /><a href="#platform-cgohlke" title="Packaging/porting to new platform">📦</a> <a href="#question-cgohlke" title="Answering Questions">💬</a> <a href="https://github.com/pyproj4/pyproj/issues?q=author%3Acgohlke" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=cgohlke" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://github.com/chrrrisw"><img src="https://avatars0.githubusercontent.com/u/5555320?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Chris Willoughby</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=chrrrisw" title="Code">💻</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/glostis"><img src="https://avatars0.githubusercontent.com/u/25295717?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Guillaume Lostis</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=glostis" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/edpop"><img src="https://avatars3.githubusercontent.com/u/13479292?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Eduard Popov</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=edpop" title="Documentation">📖</a></td>
      <td align="center"><a href="http://www.personal.psu.edu/jar339"><img src="https://avatars2.githubusercontent.com/u/7864460?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Joe Ranalli</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/issues?q=author%3Ajranalli" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=jranalli" title="Code">💻</a> <a href="https://github.com/pyproj4/pyproj/commits?author=jranalli" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://github.com/gberardinelli"><img src="https://avatars0.githubusercontent.com/u/13799588?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Greg Berardinelli</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/issues?q=author%3Agberardinelli" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=gberardinelli" title="Code">💻</a> <a href="#ideas-gberardinelli" title="Ideas, Planning, & Feedback">🤔</a> <a href="https://github.com/pyproj4/pyproj/commits?author=gberardinelli" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://github.com/mraspaud"><img src="https://avatars1.githubusercontent.com/u/167802?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Martin Raspaud</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/issues?q=author%3Amraspaud" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=mraspaud" title="Code">💻</a> <a href="https://github.com/pyproj4/pyproj/commits?author=mraspaud" title="Tests">⚠️</a> <a href="#ideas-mraspaud" title="Ideas, Planning, & Feedback">🤔</a></td>
      <td align="center"><a href="https://sites.google.com/site/mwtoews/"><img src="https://avatars1.githubusercontent.com/u/895458?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Mike Taves</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=mwtoews" title="Tests">⚠️</a></td>
      <td align="center"><a href="http://davidhaberthür.ch"><img src="https://avatars2.githubusercontent.com/u/1651235?v=4?s=100" width="100px;" alt=""/><br /><sub><b>David Haberthür</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=habi" title="Documentation">📖</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/mmodenesi"><img src="https://avatars2.githubusercontent.com/u/5569789?v=4?s=100" width="100px;" alt=""/><br /><sub><b>mmodenesi</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/issues?q=author%3Ammodenesi" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=mmodenesi" title="Code">💻</a> <a href="https://github.com/pyproj4/pyproj/commits?author=mmodenesi" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://www.indigoag.com/"><img src="https://avatars0.githubusercontent.com/u/48448372?v=4?s=100" width="100px;" alt=""/><br /><sub><b>jacob-indigo</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/issues?q=author%3Ajacob-indigo" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=jacob-indigo" title="Code">💻</a></td>
      <td align="center"><a href="https://rahulporuri.github.io"><img src="https://avatars0.githubusercontent.com/u/1926457?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Poruri Sai Rahul</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=rahulporuri" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://medium.com/@underchemist"><img src="https://avatars1.githubusercontent.com/u/5283998?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Yann-Sebastien Tremblay-Johnston</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=underchemist" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/odidev"><img src="https://avatars2.githubusercontent.com/u/40816837?v=4?s=100" width="100px;" alt=""/><br /><sub><b>odidev</b></sub></a><br /><a href="#platform-odidev" title="Packaging/porting to new platform">📦</a></td>
      <td align="center"><a href="https://github.com/idanmiara"><img src="https://avatars.githubusercontent.com/u/26349741?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Idan Miara</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=idanmiara" title="Code">💻</a> <a href="https://github.com/pyproj4/pyproj/commits?author=idanmiara" title="Documentation">📖</a> <a href="#example-idanmiara" title="Examples">💡</a> <a href="https://github.com/pyproj4/pyproj/commits?author=idanmiara" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://github.com/direvus"><img src="https://avatars.githubusercontent.com/u/312229?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Brendan Jurd</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=direvus" title="Documentation">📖</a> <a href="#design-direvus" title="Design">🎨</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://www.metoffice.gov.uk/"><img src="https://avatars.githubusercontent.com/u/2051656?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Bill Little</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=bjlittle" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/gerritholl"><img src="https://avatars.githubusercontent.com/u/500246?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Gerrit Holl</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=gerritholl" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/Kirill888"><img src="https://avatars.githubusercontent.com/u/1428024?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Kirill Kouzoubov</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=Kirill888" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/hemberger"><img src="https://avatars.githubusercontent.com/u/846186?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Dan Hemberger</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/issues?q=author%3Ahemberger" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=hemberger" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/martinfleis"><img src="https://avatars.githubusercontent.com/u/36797143?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Martin Fleischmann</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/issues?q=author%3Amartinfleis" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=martinfleis" title="Code">💻</a> <a href="https://github.com/pyproj4/pyproj/commits?author=martinfleis" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://github.com/orontee"><img src="https://avatars.githubusercontent.com/u/2065954?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Matthias Meulien</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=orontee" title="Code">💻</a> <a href="https://github.com/pyproj4/pyproj/issues?q=author%3Aorontee" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/iboates"><img src="https://avatars.githubusercontent.com/u/13814358?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Isaac Boates</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=iboates" title="Code">💻</a> <a href="https://github.com/pyproj4/pyproj/issues?q=author%3Aiboates" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=iboates" title="Tests">⚠️</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/kdpenner"><img src="https://avatars.githubusercontent.com/u/9297904?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Kyle Penner</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=kdpenner" title="Code">💻</a> <a href="https://github.com/pyproj4/pyproj/issues?q=author%3Akdpenner" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=kdpenner" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/paulcochrane"><img src="https://avatars.githubusercontent.com/u/18310598?v=4?s=100" width="100px;" alt=""/><br /><sub><b>paulcochrane</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=paulcochrane" title="Code">💻</a> <a href="https://github.com/pyproj4/pyproj/commits?author=paulcochrane" title="Documentation">📖</a> <a href="https://github.com/pyproj4/pyproj/commits?author=paulcochrane" title="Tests">⚠️</a> <a href="https://github.com/pyproj4/pyproj/issues?q=author%3Apaulcochrane" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/vot4anto"><img src="https://avatars.githubusercontent.com/u/56338190?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Antonio Ettorre</b></sub></a><br /><a href="#platform-vot4anto" title="Packaging/porting to new platform">📦</a></td>
      <td align="center"><a href="https://github.com/DWesl"><img src="https://avatars.githubusercontent.com/u/22566757?v=4?s=100" width="100px;" alt=""/><br /><sub><b>DWesl</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/commits?author=DWesl" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/molinav"><img src="https://avatars.githubusercontent.com/u/9979942?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Víctor Molina García</b></sub></a><br /><a href="#platform-molinav" title="Packaging/porting to new platform">📦</a></td>
      <td align="center"><a href="https://github.com/skogler"><img src="https://avatars.githubusercontent.com/u/1032405?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Samuel Kogler</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/issues?q=author%3Askogler" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=skogler" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/shadchin"><img src="https://avatars.githubusercontent.com/u/61256?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Alexander Shadchin</b></sub></a><br /><a href="https://github.com/pyproj4/pyproj/issues?q=author%3Ashadchin" title="Bug reports">🐛</a> <a href="https://github.com/pyproj4/pyproj/commits?author=shadchin" title="Code">💻</a></td>
    </tr>
  </table>

  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->

  <!-- ALL-CONTRIBUTORS-LIST:END -->

  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!


pkgId: 95130e7b332130457cd5fa3450c48ccc7f008f4ce9f1cc47211d13ad28c6ef3e
name: python-pyqtgraph
arch: src
version: 0.13.2
epoch: 0
release: 1
summary: Scientific Graphics and GUI Library for Python
url: http://www.pyqtgraph.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e3b62b39-3946-4170-8c9b-6812ae3308b4
location_href: 00004777-python-pyqtgraph/python-pyqtgraph-0.13.2-1.src.rpm
checksum_type: sha256
description:
  PyQtGraph is a pure-python graphics and GUI library built on PyQt5/PySide2 and
  numpy.

  It is intended for use in mathematics / scientific / engineering applications.
  Despite being written entirely in python, the library is very fast due to its
  heavy leverage of numpy for number crunching, Qt's GraphicsView framework for
  2D display, and OpenGL for 3D display.


pkgId: bccefc37582cddc00adbdaa4ab9b3c78463cea078a3dc56786a4dcc12b1b89ef
name: python-pyquery
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: A jquery-like library for python
url: https://github.com/gawel/pyquery
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-252af59f-1d38-4e2d-9f45-bb0890e866d9
location_href: 00009653-python-pyquery/python-pyquery-2.0.0-1.src.rpm
checksum_type: sha256
description:
  pyquery allows you to make jquery queries on xml documents.
  The API is as much as possible similar to jquery. pyquery uses lxml for fast
  xml and html manipulation.
  This is not (or at least not yet) a library to produce or interact with
  javascript code. I just liked the jquery API and I missed it in python so I
  told myself "Hey let's make jquery in python". This is the result.
  The `project`_ is being actively developed on a git repository on Github. I
  have the policy of giving push access to anyone who wants it and then reviewing
  what they do. So if you want to contribute just email me.
  Please report bugs on the `github
  <https://github.com/gawel/pyquery/issues>`_ issue
  tracker.
  I've spent hours maintaining this software, with love.
  Please consider tipping if you like it:
  BTC: 1PruQAwByDndFZ7vTeJhyWefAghaZx9RZg
  ETH: 0xb6418036d8E06c60C4D91c17d72Df6e1e5b15CE6
  LTC: LY6CdZcDbxnBX9GFBJ45TqVj8NykBBqsmT
     >>> (urlopen, your_url, path_to_html_file) = getfixture('readme_fixt')


pkgId: 481c851f5b184c9570e17caf87a63842cf2c72e6544bf3e328076a4554ca9dd3
name: python-pyrad
arch: src
version: 2.4
epoch: 0
release: 1
summary: RADIUS tools
url: https://github.com/pyradius/pyrad
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8172bb13-0817-46fd-be04-f824424ea4a9
location_href: 00004778-python-pyrad/python-pyrad-2.4-1.src.rpm
checksum_type: sha256
description:
  pyrad is an implementation of a RADIUS client/server as described in RFC2865.
  It takes care of all the details like building RADIUS packets, sending
  them and decoding responses.
  Here is an example of doing a authentication request::
      from __future__ import print_function
      from pyrad.client import Client
      from pyrad.dictionary import Dictionary
      import pyrad.packet
      srv = Client(server="localhost", secret=b"Kah3choteereethiejeimaeziecumi",
                   dict=Dictionary("dictionary"))
      
      req = srv.CreateAuthPacket(code=pyrad.packet.AccessRequest,
                                 User_Name="wichert", NAS_Identifier="localhost")
      req["User-Password"] = req.PwCrypt("password")
      
      reply = srv.SendPacket(req)
      if reply.code == pyrad.packet.AccessAccept:
          print("access accepted")
      else:
          print("access denied")
      print("Attributes returned by server:")
      for i in reply.keys():
          print("%s: %s" % (i, reply[i]))


pkgId: e1a02a5c8b26c781a061c1c805f23350d8fda7944a771897db88ba6fa9620460
name: python-pyramid-tm
arch: src
version: 2.5
epoch: 0
release: 1
summary: A package which allows Pyramid requests to join the active transaction
url: https://github.com/Pylons/pyramid_tm
rpm_license: BSD-derived (Repoze)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9bbb406a-b331-4192-a955-63dd25eb10ea
location_href: 00004782-python-pyramid-tm/python-pyramid-tm-2.5-1.src.rpm
checksum_type: sha256
description:
  ``pyramid_tm`` is a package which allows Pyramid requests to join
  the active transaction as provided by the `transaction
  <https://pypi.org/project/transaction/>`_ package.
  See `https://docs.pylonsproject.org/projects/pyramid_tm/en/latest/
  <https://docs.pylonsproject.org/projects/pyramid_tm/en/latest/>`_
  or ``docs/index.rst`` in this distribution for detailed
  documentation.


pkgId: 08e0c276f99c5e039b355cd88950b5dd107245c1d4c36e1d9d66c57b0e251fb3
name: python-pyre-check
arch: src
version: 0.9.18
epoch: 0
release: 1
summary: A performant type checker for Python
url: https://pyre-check.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b4e84c64-59dc-433b-8ddd-74ace9d053ad
location_href: 00013697-python-pyre-check/python-pyre-check-0.9.18-1.src.rpm
checksum_type: sha256
description:
  [![lint](https://github.com/facebook/pyre-check/workflows/lint/badge.svg)](https://github.com/facebook/pyre-check/actions/workflows/lint.yml)
  [![tests](https://github.com/facebook/pyre-check/workflows/tests/badge.svg)](https://github.com/facebook/pyre-check/actions/workflows/tests.yml)
  [![pyre](https://github.com/facebook/pyre-check/workflows/pyre/badge.svg)](https://github.com/facebook/pyre-check/actions/workflows/pyre.yml)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![Gitter](https://badges.gitter.im/pyre-check/community.svg)](https://gitter.im/pyre-check/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)

  <p align="center">
    <img src="https://raw.githubusercontent.com/facebook/pyre-check/main/logo.png">
  </p>

  Pyre is a performant type checker for Python compliant with [PEP 484](https://www.python.org/dev/peps/pep-0484/). Pyre can analyze codebases with millions of lines of code incrementally – providing instantaneous feedback to developers as they write code. You can try it out on examples in [the Pyre Playground](https://pyre-check.org/play).

  Pyre ships with **Pysa**, a security focused static analysis tool we've built on top of Pyre that reasons about data flows in Python applications. Please refer to our [documentation](https://pyre-check.org/docs/pysa-quickstart) to get started with our security analysis.

  Pysa is also available on the [GitHub Marketplace as a Github Action](https://github.com/marketplace/actions/pysa-action)


  To get started, you need [Python 3.6 or later](https://www.python.org/getit/) and [watchman](https://facebook.github.io/watchman/) working on your system. On *MacOS* you can get everything with [homebrew](https://brew.sh/):
  ```bash
  $ brew install python3 watchman
  ```
  On *Ubuntu*, *Mint*, or *Debian*; use `apt-get` and [homebrew](https://brew.sh/):
  ```bash
  $ sudo apt-get install python3 python3-pip python3-venv
  $ brew install watchman
  ```
  We tested Pyre on *Ubuntu 18.04.5 LTS*, *CentOS 7*, as well as *OSX 10.11* and later.


  We start by creating an empty project directory and setting up a virtual environment:

  ```bash
  $ mkdir my_project && cd my_project
  $ python3 -m venv ~/.venvs/venv
  $ source ~/.venvs/venv/bin/activate
  (venv) $ pip install pyre-check
  ```

  Next, we teach Pyre about our new project:
  ```bash
  (venv) $ pyre init
  ```
  This command will set up a configuration for Pyre (`.pyre_configuration`) as well as watchman (`.watchmanconfig`) in your project's directory. Accept the defaults for now – you can change them later if necessary.


  We are now ready to run Pyre:
  ```bash
  (venv) $ echo "i: int = 'string'" > test.py
  (venv) $ pyre
   ƛ Found 1 type error!
  test.py:1:0 Incompatible variable type [9]: i is declared to have type `int` but is used as type `str`.
  ```
  This first invocation will start a daemon listening for filesystem changes – type checking your project incrementally as you make edits to the code. You will notice that subsequent invocations of `pyre` will be faster than the first one.

  For more detailed documentation, see https://pyre-check.org.



  See [CONTRIBUTING.md](CONTRIBUTING.md) for how to help out.



  Pyre is licensed under the MIT license.


pkgId: 1a0858a2403c30420a71064f210c67c664b78cbde5d6accd6dd23a7119fab533
name: python-pyre-extensions
arch: src
version: 0.0.30
epoch: 0
release: 1
summary: Type system extensions for use with the pyre type checker
url: https://pyre-check.org
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-97835a94-5df0-4e75-8a64-8df1f30572c8
location_href: 00013645-python-pyre-extensions/python-pyre-extensions-0.0.30-1.src.rpm
checksum_type: sha256
description:
  This module defines extensions to the standard “typing” module that are supported by the [Pyre typechecker](https://pypi.org/project/pyre-check/).


  Function to make assumptions about `Optional`s explicit. The function will raise an
  assertion error if passed `None` and return the value otherwise.


  `ParameterSpecification`s are a special kind of type variable that captures callable parameter
  specifications (known as argspecs in the runtime and inspect library) instead of types, allowing
  the typing of decorators which transform the return type of the given callable.
  For example:
  ```
  from typing import TypeVar, Callable, List
  from pyre_extensions import ParameterSpecification
  TParams = ParameterSpecification("TParams")
  TReturn = TypeVar("TReturn")
  def unwrap(f: Callable[TParams, List[TReturn]]) -> Callable[TParams, TReturn]:
      def inner(*args: TParams.args, **kwargs: TParams.kwargs) -> TReturn:
          return f(*args, **kwargs)[0]

      return inner
  @unwrap
  def foo(x: int, y: str, z: bool = False) -> List[int]:
      return [1, 2, 3]
  ```
  decorates foo into a callable that returns int, but still has the same parameters, including their
  names and whether they are required.

  These `ParameterSpecification` variables also have two special properties, `args` and `kwargs`,
  which correspond to the positional and keyword arguments for a specific call to the
  `ParameterSpecification` function.  Because the division of parameters into these two argument
  collections can be different each invocation, these special annotations can only be used in one
  manner: together, in a function definition, as `*args` and `**kwargs` with no other parameters
  listed.


  The `safe_json` module provides a type-safe way to parse JSON. It is meant as a drop-in replacement
  for the builtin `json` module but instead of returning an object of undefined shape (i.e. `Any`)
  allows you to specify the shape of the JSON you're expecting. The parser will validate whether the
  input matches the expected type and raise an exception if it does not.


  For trivial JSON structures you can use builtin types:

  ```python
  >>> from pyre_extensions import safe_json
  >>> from typing import List, Dict
  >>> safe_json.loads("[1, 2, 3]", List[int])
  [1, 2, 3]
  >>> safe_json.loads("[1, 2, 3]", List[str])

  >>> safe_json.loads('{"key": "value"}', Dict[str, str])
  {'key': 'value'}
  >>> safe_json.loads('{"key": "value"}', Dict[str, int])

  ```

  For more complicated, nested structures, typed dictionaries are the way to go:
  ```python
  >>> from typing import TypedDict
  >>> class Movie(TypedDict):
  ...     name: str
  ...     year: int
  ...
  >>> safe_json.loads('{"name": "Blade Runner", "year": 1982 }', Movie)
  {'name': 'Blade Runner', 'year': 1982}
  >>> safe_json.loads('{"name": "Blade Runner", "year": "1982" }', Movie)

  ```

  Validate if data is expected type:
  ```python
  >>> from pyre_extensions import safe_json
  >>> from typing import List, Dict
  >>> data = {"foo": 23}
  >>> safe_json.validate(data, Dict[str, str])

  >>> safe_json.validate(data, Dict[str, int])
  {"foo": 23}
  ```


pkgId: 8d119ac277581fa6a9a881c5d8102e789960ca078a6eb90e39f4e51090e115bd
name: python-pyreadline
arch: src
version: 2.1
epoch: 0
release: 1
summary: A python implmementation of GNU readline.
url: http://ipython.org/pyreadline.html
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6b83c1c0-6d40-474d-aa9c-5f8d7bd8d600
location_href: 00010029-python-pyreadline/python-pyreadline-2.1-1.src.rpm
checksum_type: sha256
description:
  The pyreadline package is a python implementation of GNU readline functionality
  it is based on the ctypes based UNC readline package by Gary Bishop.
  It is not complete. It has been tested for use with windows 2000 and windows xp.

  * pyreadline 2.1 <2015-09-16>

    This is a bugfix release to make pyreadline work with python 3.5.

    Contributors to this release:

      - Jörgen Stenarson, maintainer
      - kivhift, improved error message for running on non windows platforms
      - zooba, made helpful suggestions to make it work for python 3.5

    Version 2.1 of pyreadline has been verfied for Python 2.7, and 3.4, 3.5.


  Features:
   *  keyboard text selection and copy/paste
   *  Shift-arrowkeys for text selection
   *  Control-c can be used for copy activate with allow_ctrl_c(True) in config file
   *  Double tapping ctrl-c will raise a KeyboardInterrupt, use ctrl_c_tap_time_interval(x)
      where x is your preferred tap time window, default 0.3 s.
   *  paste pastes first line of content on clipboard.
   *  ipython_paste, pastes tab-separated data as list of lists or numpy array if all data is numeric
   *  paste_mulitline_code pastes multi line code, removing any empty lines.


   The latest development version is always available at the IPython github
   repository_.

  .. _repository: https://github.com/pyreadline/pyreadline.git


pkgId: 1013abf0911d050d01810739a6d41c3530f2885c7e19200892287427142edfa4
name: python-pyriemann
arch: src
version: 0.4
epoch: 0
release: 1
summary: Biosignals classification with Riemannian geometry
url: https://pyriemann.readthedocs.io
rpm_license: BSD (3-clause)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9120fa02-b4e2-4451-9b84-b2c6dcdc5502
location_href: 00004785-python-pyriemann/python-pyriemann-0.4-1.src.rpm
checksum_type: sha256
description:
  [![Code PythonVersion](https://img.shields.io/badge/python-3.7%20%7C%203.8%20%7C%203.9-blue)](https://img.shields.io/badge/python-3.7%20%7C%203.8%20%7C%203.9-blue)
  [![PyPI version](https://badge.fury.io/py/pyriemann.svg)](https://badge.fury.io/py/pyriemann)
  [![Build Status](https://github.com/pyRiemann/pyRiemann/workflows/testing/badge.svg?branch=master&event=push)](https://github.com/pyRiemann/pyRiemann/actions)
  [![codecov](https://codecov.io/gh/pyRiemann/pyRiemann/branch/master/graph/badge.svg)](https://codecov.io/gh/pyRiemann/pyRiemann)
  [![Documentation Status](https://readthedocs.org/projects/pyriemann/badge/?version=latest)](http://pyriemann.readthedocs.io/en/latest/?badge=latest)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.593816.svg)](https://doi.org/10.5281/zenodo.593816)
  [![Downloads](https://pepy.tech/badge/pot)](https://pepy.tech/project/pyriemann)

  pyRiemann is a Python machine learning package based on [scikit-learn](http://scikit-learn.org/stable/modules/classes.html) API.
  It provides a high-level interface for processing and classification of multivariate time series
  through the Riemannian geometry of symmetric positive definite (SPD) matrices.

  pyRiemann aims at being a generic package for multivariate time series classification
  but has been designed around multichannel biosignals (like EEG, MEG or EMG) manipulation applied to brain-computer interface (BCI),
  transforming multichannel time series into covariance matrices, and classifying them using the Riemannian geometry of SPD matrices [[1]](#1).

  For BCI applications, studied paradigms are motor imagery [[2]](#2) [[3]](#3), event-related potentials (ERP) [[4]](#4) and steady-state visually evoked potentials (SSVEP) [[5]](#5).
  Using extended labels, API allows transfer learning between sessions or subjects [[6]](#6).

  This code is BSD-licenced (3 clause).



  The documentation is available on http://pyriemann.readthedocs.io/en/latest/





  ```
  pip install pyriemann
  ```
  or using pip+git for the latest version of the code :

  ```
  pip install git+https://github.com/pyRiemann/pyRiemann
  ```

  Anaconda is not currently supported, if you want to use anaconda, you need to create a virtual environment in anaconda,
  activate it and use the above command to install it.



  For the latest version, you can install the package from the sources using the setup.py script

  ```
  python setup.py install
  ```

  or in developer mode to be able to modify the sources.

  ```
  python setup.py develop
  ```



  Most of the functions mimic the scikit-learn API, and therefore can be directly used with sklearn.
  For example, for cross-validation classification of EEG signal using the MDM algorithm described in [[2]](#2), it is easy as:

  ```python
  import pyriemann
  from sklearn.model_selection import cross_val_score


  X = ... # EEG data, in format n_epochs x n_channels x n_times
  y = ... # labels


  cov = pyriemann.estimation.Covariances().fit_transform(X)


  mdm = pyriemann.classification.MDM()

  accuracy = cross_val_score(mdm, cov, y)

  print(accuracy.mean())

  ```

  You can also pipeline methods using sklearn pipeline framework.
  For example, to classify EEG signal using a SVM classifier in the tangent space, described in [[3]](#3):

  ```python
  from pyriemann.estimation import Covariances
  from pyriemann.tangentspace import TangentSpace

  from sklearn.pipeline import make_pipeline
  from sklearn.svm import SVC
  from sklearn.model_selection import cross_val_score


  X = ... # EEG data, in format n_epochs x n_channels x n_times
  y = ... # labels


  covest = Covariances()
  ts = TangentSpace()
  svc = SVC(kernel='linear')
  clf = make_pipeline(covest, ts, svc)


  accuracy = cross_val_score(clf, X, y)

  print(accuracy.mean())

  ```

  **Check out the example folder for more examples !**



  The package aims at adopting the [scikit-learn](http://scikit-learn.org/stable/developers/contributing.html#contributing-code)
  and [MNE-Python](https://mne.tools/stable/install/contributing.html) conventions as much as possible.
  See their contribution guidelines before contributing to the repository.



  If you make a modification, run the test suite before submitting a pull request

  ```
  pytest
  ```



  ```bibtex
  @software{pyriemann,
    author       = {Alexandre Barachant and
                    Quentin Barthélemy and
                    Jean-Rémi King and
                    Alexandre Gramfort and
                    Sylvain Chevallier and
                    Pedro L. C. Rodrigues and
                    Emanuele Olivetti and
                    Vladislav Goncharenko and
                    Gabriel Wagner vom Berg and
                    Ghiles Reguig and
                    Arthur Lebeurrier and
                    Erik Bjäreholt and
                    Maria Sayu Yamamoto and
                    Pierre Clisson and
                    Marie-Constance Corsi},
    title        = {pyRiemann/pyRiemann: v0.3},
    month        = jul,
    year         = 2022,
    publisher    = {Zenodo},
    version      = {v0.3},
    doi          = {10.5281/zenodo.7547583},
    url          = {https://doi.org/10.5281/zenodo.7547583}
  }
  ```



  <a id="1">[1]</a>
  M. Congedo, A. Barachant and R. Bhatia, "Riemannian geometry for EEG-based brain-computer interfaces; a primer and a review".
  Brain-Computer Interfaces, 4.3, pp. 155-174, 2017. [link](https://hal.science/hal-01570120/document)

  <a id="2">[2]</a>
  A. Barachant, S. Bonnet, M. Congedo and C. Jutten, "Multiclass Brain-Computer Interface Classification by Riemannian Geometry".
  IEEE Transactions on Biomedical Engineering, vol. 59, no. 4, pp. 920-928, 2012. [link](https://hal.archives-ouvertes.fr/hal-00681328)

  <a id="3">[3]</a>
  A. Barachant, S. Bonnet, M. Congedo and C. Jutten, "Classification of covariance matrices using a Riemannian-based kernel for BCI applications".
  Neurocomputing, 112, pp. 172-178, 2013. [link](https://hal.archives-ouvertes.fr/hal-00820475/)

  <a id="4">[4]</a>
  A. Barachant and M. Congedo, "A Plug&Play P300 BCI Using Information Geometry".
  Research report, 2014. [link](http://arxiv.org/abs/1409.0107)

  <a id="5">[5]</a>
  EK. Kalunga, S. Chevallier, Q. Barthélemy, K. Djouani, E. Monacelli and Y. Hamam, "Online SSVEP-based BCI using Riemannian geometry".
  Neurocomputing, 191, pp. 55-68, 2014. [link](https://hal.science/hal-01351623/file/Kalunga-Chevallier-Barthelemy-Online%20SSVEP-based%20BCI%20using%20Riemannian%20Geometry-Neurocomputing-16.pdf)

  <a id="6">[6]</a>
  PLC. Rodrigues, C. Jutten and M. Congedo, "Riemannian Procrustes analysis: transfer learning for brain-computer interfaces".
  IEEE Transactions on Biomedical Engineering, vol. 66, no. 8, pp. 2390-2401, 2018. [link](https://hal.archives-ouvertes.fr/hal-01971856)


pkgId: 889157af14da04e5af59b335a7b4aa42ee6c11117b2b15a628a4f9661fc6d6d8
name: python-pyro-api
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Generic API for dispatch to Pyro backends.
url: https://github.com/pyro-ppl/pyro-api
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a2abfc7e-bf75-45d5-9c5c-7f14f0e62320
location_href: 00012223-python-pyro-api/python-pyro-api-0.1.2-1.src.rpm
checksum_type: sha256
description:
  For testing API compatibility on different backends, install pytest and other test dependencies that includes backends like [funsor](https://github.com/pyro-ppl/funsor) and [numpyro](https://github.com/pyro-ppl/numpyro) and run the test suite:
  ```
  pip install -e .[test]
  pytest -vs
  ```
  This library has no dependencies and can easily be installed for testing your particular Pyro backend
  implementation. You can use the following pattern and test your backend on models in the `pyroapi.testing`
  module.
  ```python
  from pyro_api.dispatch import pyro_backend
  from pyro_api.testing import MODELS

  with pyro_backend(handlers='my_backend.handlers',
                    distributions='my_backend.distributions',
      
      for model in MODELS:
          f = MODELS[model]()
          model, model_args = f['model'], f.get('model_args', ())
          model(*model_args)
  ```


pkgId: 009c674eb1f0527c734ba0d645a99b593788be6636cfa6ebd36ba1f29826ce2c
name: python-pyroute2
arch: src
version: 0.7.6
epoch: 0
release: 1
summary: Python Netlink library
url: https://github.com/svinota/pyroute2
rpm_license: GPL-2.0-or-later OR Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-16fdc945-e98c-43c8-80db-1a66ffcf5ea6
location_href: 00010804-python-pyroute2/python-pyroute2-0.7.6-1.src.rpm
checksum_type: sha256
description:
  Pyroute2 is a pure Python **netlink** library. The core requires only Python
  stdlib, no 3rd party libraries. The library was started as an RTNL protocol
  implementation, so the name is **pyroute2**, but now it supports many netlink
  protocols. Some supported netlink families and protocols:
  * **rtnl**, network settings --- addresses, routes, traffic controls
  * **nfnetlink** --- netfilter API
  * **ipq** --- simplest userspace packet filtering, iptables QUEUE target
  * **devlink** --- manage and monitor devlink-enabled hardware
  * **generic** --- generic netlink families
  * **uevent** --- same uevent messages as in udev
  Netfilter API:
  * **ipset** --- IP sets
  * **nftables** --- packet filtering
  * **nfct** --- connection tracking
  Generic netlink:
  * **ethtool** --- low-level network interface setup
  * **wireguard** --- VPN setup
  * **nl80211** --- wireless functions API (basic support)
  * **taskstats** --- extended process statistics
  * **acpi_events** --- ACPI events monitoring
  * **thermal_events** --- thermal events monitoring
  * **VFS_DQUOT** --- disk quota events monitoring
  On the low level the library provides socket objects with an
  extended API. The additional functionality aims to:
  * Help to open/bind netlink sockets
  * Discover generic netlink protocols and multicast groups
  * Construct, encode and decode netlink and PF_ROUTE messages


pkgId: 0f2e471627f86af61291438453aa02ac5d720b988e22aba9da15dff5191758c8
name: python-pyroute2.core
arch: src
version: 0.6.13
epoch: 0
release: 1
summary: Python Netlink library: the core
url: https://github.com/svinota/pyroute2
rpm_license: dual license GPLv2+ and Apache v2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-603c6d14-28d7-4e96-bba6-f3d2eebe0310
location_href: 00011668-python-pyroute2-core/python-pyroute2.core-0.6.13-1.src.rpm
checksum_type: sha256
description:
  PyRoute2 is a pure Python **netlink** library.
  This is the core package, it implements the netlink parser and several netlink
  sockets, including RTNL (IPRoute), WireGuard, MPTCP etc.


pkgId: 2c34ca42419cff52b231b01ecaa15b314a7a2d270c39bdeeeed104c3461d3507
name: python-pyroute2.ipdb
arch: src
version: 0.6.13
epoch: 0
release: 1
summary: Python Netlink library: IPDB module
url: https://github.com/svinota/pyroute2
rpm_license: dual license GPLv2+ and Apache v2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-123266c7-feed-4db3-a9ee-837e6c0c2e18
location_href: 00011722-python-pyroute2-ipdb/python-pyroute2.ipdb-0.6.13-1.src.rpm
checksum_type: sha256
description:
  PyRoute2 is a pure Python **netlink** library.
  IPDB module is approaching its end of life.
  Details: <https://github.com/svinota/pyroute2/discussions/788>


pkgId: a0b0042a70ba8d8788b24af7c277c8f85dba286e04b7d5b11713acedd50e9485
name: python-pyroute2.nslink
arch: src
version: 0.6.13
epoch: 0
release: 1
summary: Python Netlink library: NetNS, NSPopen and remote modules
url: https://github.com/svinota/pyroute2
rpm_license: dual license GPLv2+ and Apache v2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f057491a-ac30-481e-b43d-ab03a2ea7756
location_href: 00011720-python-pyroute2-nslink/python-pyroute2.nslink-0.6.13-1.src.rpm
checksum_type: sha256
description:
  PyRoute2 is a pure Python **netlink** library.
  This module provides NetNS, NSPopen and RemoteSocket classes.


pkgId: e5e53d51c093ef96f667152c594c634aa4fc288911d4296fe4034f76f42c3fcc
name: python-pyrsistent
arch: src
version: 0.19.3
epoch: 0
release: 1
summary: Persistent/Functional/Immutable data structures
url: https://github.com/tobgu/pyrsistent/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b68b5c57-5562-4896-82ce-3d5f8fdb58b0
location_href: 00008938-python-pyrsistent/python-pyrsistent-0.19.3-1.src.rpm
checksum_type: sha256
description:
  Pyrsistent is a number of persistent collections (by some referred to as functional data structures). Persistent in
  the sense that they are immutable.
  All methods on a data structure that would normally mutate it instead return a new copy of the structure containing the
  requested updates. The original structure is left untouched.
  This will simplify the reasoning about what a program does since no hidden side effects ever can take place to these
  data structures. You can rest assured that the object you hold a reference to will remain the same throughout its
  lifetime and need not worry that somewhere five stack levels below you in the darkest corner of your application
  someone has decided to remove that element that you expected to be there.
  Pyrsistent is influenced by persistent data structures such as those found in the standard library of Clojure. The
  data structures are designed to share common elements through path copying.
  It aims at taking these concepts and make them as pythonic as possible so that they can be easily integrated into any python
  program without hassle.
  If you want use literal syntax to define them in your code rather
  than function calls check out Pyrthon_. Be aware, that one is experimental, unmaintained and alpha software.
  If you cannot find the persistent data structure you're looking for here you may want to take a look at
  Pyrsistent_extras_ which is maintained by @mingmingrr. If you still don't find what you're looking for please
  open an issue for discussion. If we agree that functionality is missing you may want to go ahead and create
  a Pull Request implement the missing functionality.


pkgId: 6627ae10a467cac80769ef44df52d7511f2650440254a0aabce7cae5c3ba6539
name: python-pyrsistent-debuginfo
arch: x86_64
version: 0.19.3
epoch: 0
release: 1
summary: Debug information for package python-pyrsistent
url: https://github.com/tobgu/pyrsistent/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-b68b5c57-5562-4896-82ce-3d5f8fdb58b0
rpm_sourcerpm: python-pyrsistent-0.19.3-1.src.rpm
location_href: 00008938-python-pyrsistent/python-pyrsistent-debuginfo-0.19.3-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pyrsistent.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 0d0fc185a288e26026b089b99b5418f1a912505580cf202dbd0fe9e1ad5ce5be
name: python-pyrsistent-debugsource
arch: x86_64
version: 0.19.3
epoch: 0
release: 1
summary: Debug sources for package python-pyrsistent
url: https://github.com/tobgu/pyrsistent/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-b68b5c57-5562-4896-82ce-3d5f8fdb58b0
rpm_sourcerpm: python-pyrsistent-0.19.3-1.src.rpm
location_href: 00008938-python-pyrsistent/python-pyrsistent-debugsource-0.19.3-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pyrsistent.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 7f7e792280ab65401ddfa8dbb6258be9977f403d539560904004926bdf42c38b
name: python-pyrtlsdr
arch: src
version: 0.2.93
epoch: 0
release: 1
summary: A Python wrapper for librtlsdr (a driver for Realtek RTL2832U based SDR's)
url: https://github.com/pyrtlsdr/pyrtlsdr
rpm_license: GPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fb537a5b-49f4-4abb-be1a-de885be4c98e
location_href: 00004788-python-pyrtlsdr/python-pyrtlsdr-0.2.93-1.src.rpm
checksum_type: sha256
description:
  A Python wrapper for librtlsdr (a driver for Realtek RTL2832U based SDR's)

  [![PyPI](https://img.shields.io/pypi/v/pyrtlsdr)](https://pypi.org/project/pyrtlsdr) ![GitHub Workflow Status](https://img.shields.io/github/workflow/status/pyrtlsdr/pyrtlsdr/Python%20package) ![PyPI - Downloads](https://img.shields.io/pypi/dm/pyrtlsdr) [![Coveralls](https://img.shields.io/coveralls/github/pyrtlsdr/pyrtlsdr)](https://coveralls.io/github/pyrtlsdr/pyrtlsdr)



  pyrtlsdr is a simple Python interface to devices supported by the RTL-SDR project, which turns certain USB DVB-T dongles
  employing the Realtek RTL2832U chipset into low-cost, general purpose software-defined radio receivers. It wraps many of the
  functions in the [librtlsdr library](https://github.com/librtlsdr/librtlsdr) including asynchronous read support
  and also provides a more Pythonic API.



  * Documentation:
    * https://pyrtlsdr.readthedocs.io/
  * Releases:
    * https://pypi.org/project/pyrtlsdr/
  * Source code and project home:
    * https://github.com/pyrtlsdr/pyrtlsdr
  * Releases for `librtlsdr`:
    * https://github.com/librtlsdr/librtlsdr/releases



  pyrtlsdr can be installed by downloading the source files and running `python setup.py install`, or using [pip](https://pip.pypa.io/en/stable/) and
  `pip install pyrtlsdr`.

  All functions in librtlsdr are accessible via librtlsdr.py and a Pythonic interface is available in rtlsdr.py (recommended).
  Some documentation can be found in docstrings in the latter file.





  ```python
  from rtlsdr import RtlSdr

  sdr = RtlSdr()


  sdr.sample_rate = 2.048e6  # Hz
  sdr.center_freq = 70e6     # Hz
  sdr.freq_correction = 60   # PPM
  sdr.gain = 'auto'

  print(sdr.read_samples(512))
  ```



  ```python
  from pylab import *
  from rtlsdr import *

  sdr = RtlSdr()


  sdr.sample_rate = 2.4e6
  sdr.center_freq = 95e6
  sdr.gain = 4

  samples = sdr.read_samples(256*1024)
  sdr.close()


  psd(samples, NFFT=1024, Fs=sdr.sample_rate/1e6, Fc=sdr.center_freq/1e6)
  xlabel('Frequency (MHz)')
  ylabel('Relative power (dB)')

  show()
  ```


  ![](https://i.imgur.com/hFhg8.png "Resulting Plot")

  See the files 'demo_waterfall.py' and 'test.py' for more examples.


  *(added in v2.5.6)*
  ```python
  from rtlsdr import RtlSdr


  serial_numbers = RtlSdr.get_device_serial_addresses()


  device_index = RtlSdr.get_device_index_by_serial('00000001')

  sdr = RtlSdr(device_index)



  sdr = RtlSdr(serial_number='00000001')
  ```


  Most devices by default have the same serial number: '0000001'. This can be set
  to a custom value by using the [rtl_eeprom][rtl_eeprom] utility packaged with `librtlsdr`.

  [rtl_eeprom]: https://manpages.ubuntu.com/manpages/trusty/man1/rtl_eeprom.1.html



  Two new submodules are available for testing: **rtlsdraio**, which adds native Python 3 asynchronous support (asyncio module), and **rtlsdrtcp** which adds a TCP server/client for accessing a device over the network. See the respective modules in the rtlsdr folder for more details and feel free to test and report any bugs!


  Note that the rtlsdraio module is automatically imported and adds `stream()` and `stop()` methods to the normal `RtlSdr` class. It also requires the new `async`/`await` syntax introduced in Python 3.5+.

  The syntax is basically:

  ```python
  import asyncio
  from rtlsdr import RtlSdr

  async def streaming():
      sdr = RtlSdr()

      async for samples in sdr.stream():
          
          

      
      await sdr.stop()

      
      sdr.close()

  loop = asyncio.get_event_loop()
  loop.run_until_complete(streaming())
  ```


  The `RtlSdrTcpServer` class is meant to be connected physically to an SDR dongle and communicate with an instance of `RtlSdrTcpClient`. The client is intended to function as closely as possible to the base RtlSdr class (as if it had a physical dongle attached to it).

  Both of these classes have the same arguments as the base `RtlSdr` class with the addition of `hostname` and `port`:
  ```python
  server = RtlSdrTcpServer(hostname='192.168.1.100', port=12345)
  server.run_forever()

  ```
  ```python

  client = RtlSdrTcpClient(hostname='192.168.1.100', port=12345)
  client.center_freq = 2e6
  data = client.read_samples()
  ```


  On platforms where the `librtlsdr` library cannot be installed/compiled, it is possible to import the `RtlSdrTcpClient` only by setting the environment variable `"RTLSDR_CLIENT_MODE"` to `"true"`. If this is set, no other modules will be available.

  *Feature added in v0.2.4*




  * Windows/Linux/OSX
  * Python 2.7.x/3.3+
  * [librtlsdr](https://github.com/librtlsdr/librtlsdr/releases)
  * **Optional**: NumPy (wraps samples in a more convenient form)

  matplotlib is also useful for plotting data. The librtlsdr binaries (rtlsdr.dll in Windows and librtlsdr.so in Linux)
  should be in the pyrtlsdr directory, or a system path. Note that these binaries may have additional dependencies.



  There are a few remaining functions in librtlsdr that haven't been wrapped yet. It's a simple process if there's an additional
  function you need to add support for, and please send a pull request if you'd like to share your changes.



  * Some operating systems (Linux, OS X) seem to result in libusb buffer issues when performing small reads. Try reading 1024
  (or higher powers of two) samples at a time if you have problems.

  * If you're having librtlsdr import errors:
    * **Windows**: Make sure all the librtlsdr DLL files (librtlsdr.dll, libusb-1.0.dll) are in your system path, or the same folder
  as this README file. Also make sure you have all of *their* dependencies (e.g. libgcc_s_dw2-1.dll or possibly the Visual Studio runtime files). If rtl_sdr.exe
  works, then you should be okay. Also note that you can't mix the 64 bit version of Python with 32 bit builds of librtlsdr, and vice versa.
    * **Linux**: Make sure your LD_LIBRARY_PATH environment variable contains the directory where the librtlsdr.so.0 library is located. You can do this in a shell with (for example): `export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib`. See [this issue](https://github.com/roger-/pyrtlsdr/issues/7) for more details.



  All of the code contained here is licensed by the GNU General Public License v3.



  Credit to dbasden for his earlier wrapper [python-librtlsdr](https://github.com/dbasden/python-librtlsdr) and all the
  contributors on GitHub.

  Copyright (C) 2013 by Roger <https://github.com/pyrtlsdr/pyrtlsdr>


pkgId: b52be4258c491da4d5d418b223cf52a3b33a636bc97e84f384146be1285c21ea
name: python-pysb
arch: src
version: 1.14.0
epoch: 0
release: 1
summary: Python Systems Biology modeling framework
url: http://pysb.org/
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-50dc19d0-6cce-425f-b945-8ba8b4723d4d
location_href: 00004789-python-pysb/python-pysb-1.14.0-1.src.rpm
checksum_type: sha256
description:
  Python Systems Biology modeling framework
  http://pysb.org/
  PySB (pronounced "Pie Ess Bee") is a framework for building rule-based
  mathematical models of biochemical systems. It works nicely with
  scientific Python libraries such as NumPy, SciPy and SymPy for model
  simulation and analysis.


pkgId: df4824cb51891f5c7b5e76110527f8c8a36d84f834b14576a6d02e32f41cdb91
name: python-pyscreenshot
arch: src
version: 3.1
epoch: 0
release: 1
summary: python screenshot
url: https://github.com/ponty/pyscreenshot
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1866482c-8da5-48ca-8855-5f9b4b471729
location_href: 00011789-python-pyscreenshot/python-pyscreenshot-3.1-1.src.rpm
checksum_type: sha256
description:
  The pyscreenshot module is obsolete in most cases.
  It was created because PIL ImageGrab module worked on Windows only,
  but now Linux and macOS are also supported.
  There are some features in pyscreenshot which can be useful in special cases:
  flexible backends, Wayland support, sometimes better performance, optional subprocessing.

  The module can be used to copy the contents of the screen to a Pillow image memory using various back-ends.
  Replacement for the ImageGrab Module.

  Documentation: https://github.com/ponty/pyscreenshot/tree/3.1


pkgId: 7a853624978eb84d9740f9e09f3c29e8d219907a3c3ecf2ee90704fc8471cd39
name: python-pysctp
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: pysctp is a python module for the SCTP protocol stack and library
url: https://github.com/p1sec/pysctp
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-111907fe-b9bd-40c5-bf61-11618b7eff30
location_href: 00004793-python-pysctp/python-pysctp-0.7.2-1.src.rpm
checksum_type: sha256
description:
  pysctp is a python wrapper for the SCTP protocol stack and library. On Mac OS X you will need the SCTP NKE (Kernel Extensions). On Linux systems, you need an SCTP-aware kernel (most are) and install the following packages (debian): apt install libsctp-dev libsctp1 lksctp-tools


pkgId: e84d0f6d4ccba12c9eca4685fba659085aad42955163c907f1e58665d54286a8
name: python-pyserial-asyncio
arch: src
version: 0.6
epoch: 0
release: 1
summary: Python Serial Port Extension - Asynchronous I/O support
url: https://github.com/pyserial/pyserial-asyncio
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f1441f29-633a-4f3e-9f1c-aac72d4efd6a
location_href: 00004795-python-pyserial-asyncio/python-pyserial-asyncio-0.6-1.src.rpm
checksum_type: sha256
description:
  Async I/O extension package for the Python Serial Port Extension for OSX, Linux, BSD

  - Documentation: http://pyserial-asyncio.readthedocs.io
  - Project Homepage: https://github.com/pyserial/pyserial-asyncio


pkgId: afb7a56a8aa71eba5bdc4032d9b877244e213fe3fb826f22ace81778a96ef907
name: python-pysftp
arch: src
version: 0.2.9
epoch: 0
release: 1
summary: A friendly face on SFTP
url: https://bitbucket.org/dundeemt/pysftp
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-73ad9d83-3488-4d13-b7f7-5d514d342665
location_href: 00009153-python-pysftp/python-pysftp-0.2.9-1.src.rpm
checksum_type: sha256
description:
  A simple interface to SFTP.  The module offers high level abstractions and
  task based routines to handle your SFTP needs.  Checkout the Cook Book, in the
  docs, to see what pysftp can do for you.


pkgId: c2bcf2d50d9476d0f8e2072a1e487d2155c7009a7bfaebbf5c5cde205bbbe7e3
name: python-pysha3-debuginfo
arch: x86_64
version: 1.0.2
epoch: 0
release: 1
summary: Debug information for package python-pysha3
url: https://github.com/tiran/pysha3
rpm_license: PSFL (Keccak: CC0 1.0 Universal)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-62823697-2e68-45b9-9ca6-ef289348727c
rpm_sourcerpm: python-pysha3-1.0.2-1.src.rpm
location_href: 00011547-python-pysha3/python-pysha3-debuginfo-1.0.2-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pysha3.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 2cede7929afba655a6f072e311f191aa2c3bfbb40ea328669b05de1124a62589
name: python-pysha3-debugsource
arch: x86_64
version: 1.0.2
epoch: 0
release: 1
summary: Debug sources for package python-pysha3
url: https://github.com/tiran/pysha3
rpm_license: PSFL (Keccak: CC0 1.0 Universal)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-62823697-2e68-45b9-9ca6-ef289348727c
rpm_sourcerpm: python-pysha3-1.0.2-1.src.rpm
location_href: 00011547-python-pysha3/python-pysha3-debugsource-1.0.2-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pysha3.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 573da5ae2e5f53642bdd00a4b22474aad6686449782f73f37f84f460c1330f38
name: python-pyshark
arch: src
version: 0.5.3
epoch: 0
release: 1
summary: Python wrapper for tshark, allowing python packet parsing using wireshark dissectors
url: https://github.com/KimiNewt/pyshark
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-66235062-1083-4611-a3c2-2bde24906dd7
location_href: 00004796-python-pyshark/python-pyshark-0.5.3-1.src.rpm
checksum_type: sha256
description:
  Python wrapper for tshark, allowing python packet parsing using wireshark dissectors.

  See https://github.com/KimiNewt/pyshark/ for documentation.


pkgId: 79c53d37e90a545641726581aadf12f66ddf4b154e9834551b966c0daa48e83c
name: python-pyshorteners
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: A Python lib to wrap and consume the most used shorteners APIs
url: https://github.com/ellisonleao/pyshorteners/
rpm_license: GPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b3277290-6d25-47f7-a35a-121fdb920577
location_href: 00011307-python-pyshorteners/python-pyshorteners-1.0.1-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">
      <img src="https://blog.shareaholic.com/wp-content/uploads/2015/06/shortlink.png" alt="logo"/><br>
      pyshorteners
  </h1>

  <hr/>

  <p align="center">
      <a href="https://github.com/ellisonleao/pyshorteners/actions"><img src="https://github.com/ellisonleao/pyshorteners/workflows/build/badge.svg" alt="Travis"/></a>
      <a href="https://saythanks.io/to/ellisonleao"><img src="https://img.shields.io/badge/Say%20Thanks-!-1EAEDB.svg" alt=""/></a>
      <a href="https://pyshorteners.readthedocs.io/en/latest/"><img src="https://img.shields.io/pypi/dw/pyshorteners.svg" alt="Download stats"/></a>
  </p>

  A simple URL shortening API wrapper Python library.



      pip install pyshorteners



  https://pyshorteners.readthedocs.io/en/latest/


pkgId: 8bbcede6f9f30b86edf2451e1a58fa183f110f89d3e024e886ed657b7c306c38
name: python-pyshp
arch: src
version: 2.3.1
epoch: 0
release: 1
summary: Pure Python read/write support for ESRI Shapefile format
url: https://github.com/GeospatialPython/pyshp
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-10dfda2b-8bdd-41b3-b090-758e3c52d0aa
location_href: 00004797-python-pyshp/python-pyshp-2.3.1-1.src.rpm
checksum_type: sha256
description:
  The Python Shapefile Library (PyShp) reads and writes ESRI Shapefiles in pure Python.

  ![pyshp logo](http://4.bp.blogspot.com/_SBi37QEsCvg/TPQuOhlHQxI/AAAAAAAAAE0/QjFlWfMx0tQ/S350/GSP_Logo.png "PyShp")

  ![build status](https://github.com/GeospatialPython/pyshp/actions/workflows/build.yml/badge.svg)

  - **Author**: [Joel Lawhead](https://github.com/GeospatialPython)
  - **Maintainers**: [Karim Bahgat](https://github.com/karimbahgat)
  - **Version**: 2.3.0
  - **Date**: 30 April, 2022
  - **License**: [MIT](https://github.com/GeospatialPython/pyshp/blob/master/LICENSE.TXT)



  - [Overview](#overview)
  - [Version Changes](#version-changes)
  - [The Basics](#the-basics)
  	- [Reading Shapefiles](#reading-shapefiles)
  		- [The Reader Class](#the-reader-class)
  			- [Reading Shapefiles from Local Files](#reading-shapefiles-from-local-files)
  			- [Reading Shapefiles from Zip Files](#reading-shapefiles-from-zip-files)
  			- [Reading Shapefiles from URLs](#reading-shapefiles-from-urls)
  			- [Reading Shapefiles from File-Like Objects](#reading-shapefiles-from-file-like-objects)
  			- [Reading Shapefiles Using the Context Manager](#reading-shapefiles-using-the-context-manager)
  			- [Reading Shapefile Meta-Data](#reading-shapefile-meta-data)
  		- [Reading Geometry](#reading-geometry)
  		- [Reading Records](#reading-records)
  		- [Reading Geometry and Records Simultaneously](#reading-geometry-and-records-simultaneously)
  	- [Writing Shapefiles](#writing-shapefiles)
  		- [The Writer Class](#the-writer-class)
  			- [Writing Shapefiles to Local Files](#writing-shapefiles-to-local-files)
  			- [Writing Shapefiles to File-Like Objects](#writing-shapefiles-to-file-like-objects)
  			- [Writing Shapefiles Using the Context Manager](#writing-shapefiles-using-the-context-manager)
  			- [Setting the Shape Type](#setting-the-shape-type)
  		- [Adding Records](#adding-records)
  		- [Adding Geometry](#adding-geometry)
  		- [Geometry and Record Balancing](#geometry-and-record-balancing)
  - [Advanced Use](#advanced-use)
      - [Common Errors and Fixes](#common-errors-and-fixes)
          - [Warnings and Logging](#warnings-and-logging)
          - [Shapefile Encoding Errors](#shapefile-encoding-errors)
  	- [Reading Large Shapefiles](#reading-large-shapefiles)
  		- [Iterating through a shapefile](#iterating-through-a-shapefile)
  		- [Limiting which fields to read](#limiting-which-fields-to-read)
  		- [Attribute filtering](#attribute-filtering)
  		- [Spatial filtering](#spatial-filtering)
  	- [Writing large shapefiles](#writing-large-shapefiles)
  		- [Merging multiple shapefiles](#merging-multiple-shapefiles)
  		- [Editing shapefiles](#editing-shapefiles)
  	- [3D and Other Geometry Types](#3d-and-other-geometry-types)
      	- [Shapefiles with measurement (M) values](#shapefiles-with-measurement-m-values)
  		- [Shapefiles with elevation (Z) values](#shapefiles-with-elevation-z-values)
  		- [3D MultiPatch Shapefiles](#3d-multipatch-shapefiles)
  - [Testing](#testing)
  - [Contributors](#contributors)




  The Python Shapefile Library (PyShp) provides read and write support for the
  Esri Shapefile format. The Shapefile format is a popular Geographic
  Information System vector data format created by Esri. For more information
  about this format please read the well-written "ESRI Shapefile Technical
  Description - July 1998" located at [http://www.esri.com/library/whitepapers/p
  dfs/shapefile.pdf](http://www.esri.com/library/whitepapers/pdfs/shapefile.pdf)
  . The Esri document describes the shp and shx file formats. However a third
  file format called dbf is also required. This format is documented on the web
  as the "XBase File Format Description" and is a simple file-based database
  format created in the 1960's. For more on this specification see: [http://www.clicketyclick.dk/databases/xbase/format/index.html](http://www.clicketyclick.dk/databases/xbase/format/index.html)

  Both the Esri and XBase file-formats are very simple in design and memory
  efficient which is part of the reason the shapefile format remains popular
  despite the numerous ways to store and exchange GIS data available today.

  Pyshp is compatible with Python 2.7-3.x.

  This document provides examples for using PyShp to read and write shapefiles. However
  many more examples are continually added to the blog [http://GeospatialPython.com](http://GeospatialPython.com),
  and by searching for PyShp on [https://gis.stackexchange.com](https://gis.stackexchange.com).

  Currently the sample census blockgroup shapefile referenced in the examples is available on the GitHub project site at
  [https://github.com/GeospatialPython/pyshp](https://github.com/GeospatialPython/pyshp). These
  examples are straight-forward and you can also easily run them against your
  own shapefiles with minimal modification.

  Important: If you are new to GIS you should read about map projections.
  Please visit: [https://github.com/GeospatialPython/pyshp/wiki/Map-Projections](https://github.com/GeospatialPython/pyshp/wiki/Map-Projections)

  I sincerely hope this library eliminates the mundane distraction of simply
  reading and writing data, and allows you to focus on the challenging and FUN
  part of your geospatial project.








  - Fix recently introduced issue where Reader/Writer closes file-like objects provided by user (#244)





  - Added support for pathlib and path-like shapefile filepaths (@mwtoews).
  - Allow reading individual file extensions via filepaths.



  - Simplified setup and deployment (@mwtoews)
  - Faster shape access when missing shx file
  - Switch to named logger (see #240)



  - More robust handling of corrupt shapefiles (fixes #235)
  - Fix errors when writing to individual file-handles (fixes #237)
  - Revert previous decision to enforce geojson output ring orientation (detailed explanation at https://github.com/SciTools/cartopy/issues/2012)
  - Fix test issues in environments without network access (@sebastic, @musicinmybrain).





  - Read shapefiles directly from zipfiles.
  - Read shapefiles directly from urls.
  - Allow fast extraction of only a subset of dbf fields through a `fields` arg.
  - Allow fast filtering which shapes to read from the file through a `bbox` arg.



  - More examples and restructuring of README.
  - More informative Shape to geojson warnings (see #219).
  - Add shapefile.VERBOSE flag to control warnings verbosity (default True).
  - Shape object information when calling repr().
  - Faster ring orientation checks, enforce geojson output ring orientation.



  - Remove null-padding at end of some record character fields.
  - Fix dbf writing error when the number of record list or dict entries didn't match the number of fields.
  - Handle rare garbage collection issue after deepcopy (https://github.com/mattijn/topojson/issues/120)
  - Fix bug where records and shapes would be assigned incorrect record number (@karanrn)
  - Fix typos in docs (@timgates)





  - Fix recent bug in geojson hole-in-polygon checking (see #205)
  - Misc fixes to allow geo interface dump to json (eg dates as strings)
  - Handle additional dbf date null values, and return faulty dates as unicode (see #187)
  - Add writer target typecheck
  - Fix bugs to allow reading shp/shx/dbf separately
  - Allow delayed shapefile loading by passing no args
  - Fix error with writing empty z/m shapefile (@mcuprjak)
  - Fix signed_area() so ignores z/m coords
  - Enforce writing the 11th field name character as null-terminator (only first 10 are used)
  - Minor README fixes
  - Added more tests





  - Fix issue where warnings.simplefilter('always') changes global warning behavior [see #203]





  - Handle shapes with no coords and represent as geojson with no coords (GeoJSON null-equivalent)
  - Expand testing to Python 3.6, 3.7, 3.8 and PyPy; drop 3.3 and 3.4 [@mwtoews]
  - Added pytest testing [@jmoujaes]



  - Fix incorrect geo interface handling of multipolygons with complex exterior-hole relations [see #202]
  - Enforce shapefile requirement of at least one field, to avoid writing invalid shapefiles [@Jonty]
  - Fix Reader geo interface including DeletionFlag field in feature properties [@nnseva]
  - Fix polygons not being auto closed, which was accidentally dropped
  - Fix error for null geometries in feature geojson
  - Misc docstring cleanup [@fiveham]





  - Added back read/write support for unicode field names.
  - Improved Record representation
  - More support for geojson on Reader, ShapeRecord, ShapeRecords, and shapes()



  - Fixed error when reading optional m-values
  - Fixed Record attribute autocomplete in Python 3
  - Misc readme cleanup



  The newest version of PyShp, version 2.0 introduced some major new improvements.
  A great thanks to all who have contributed code and raised issues, and for everyone's
  patience and understanding during the transition period.
  Some of the new changes are incompatible with previous versions.
  Users of the previous version 1.x should therefore take note of the following changes
  (Note: Some contributor attributions may be missing):



  - Full support for unicode text, with custom encoding, and exception handling.
    - Means that the Reader returns unicode, and the Writer accepts unicode.
  - PyShp has been simplified to a pure input-output library using the Reader and Writer classes, dropping the Editor class.
  - Switched to a new streaming approach when writing files, keeping memory-usage at a minimum:
    - Specify filepath/destination and text encoding when creating the Writer.
    - The file is written incrementally with each call to shape/record.
    - Adding shapes is now done using dedicated methods for each shapetype.
  - Reading shapefiles is now more convenient:
    - Shapefiles can be opened using the context manager, and files are properly closed.
    - Shapefiles can be iterated, have a length, and supports the geo interface.
    - New ways of inspecting shapefile metadata by printing. [@megies]
    - More convenient accessing of Record values as attributes. [@philippkraft]
    - More convenient shape type name checking. [@megies]
  - Add more support and documentation for MultiPatch 3D shapes.
  - The Reader "elevation" and "measure" attributes now renamed "zbox" and "mbox", to make it clear they refer to the min/max values.
  - Better documentation of previously unclear aspects, such as field types.



  - More reliable/robust:
    - Fixed shapefile bbox error for empty or point type shapefiles. [@mcuprjak]
    - Reading and writing Z and M type shapes is now more robust, fixing many errors, and has been added to the documentation. [@ShinNoNoir]
    - Improved parsing of field value types, fixed errors and made more flexible.
    - Fixed bug when writing shapefiles with datefield and date values earlier than 1900 [@megies]
  - Fix some geo interface errors, including checking polygon directions.
  - Bug fixes for reading from case sensitive file names, individual files separately, and from file-like objects. [@gastoneb, @kb003308, @erickskb]
  - Enforce maximum field limit. [@mwtoews]




  Before doing anything you must import the library.


  	>>> import shapefile

  The examples below will use a shapefile created from the U.S. Census Bureau
  Blockgroups data set near San Francisco, CA and available in the git
  repository of the PyShp GitHub site.







  To read a shapefile create a new "Reader" object and pass it the name of an
  existing shapefile. The shapefile format is actually a collection of three
  files. You specify the base filename of the shapefile or the complete filename
  of any of the shapefile component files.


  	>>> sf = shapefile.Reader("shapefiles/blockgroups")

  OR


  	>>> sf = shapefile.Reader("shapefiles/blockgroups.shp")

  OR


  	>>> sf = shapefile.Reader("shapefiles/blockgroups.dbf")

  OR any of the other 5+ formats which are potentially part of a shapefile. The
  library does not care about file extensions. You can also specify that you only
  want to read some of the file extensions through the use of keyword arguments:


  	>>> sf = shapefile.Reader(dbf="shapefiles/blockgroups.dbf")



  If your shapefile is wrapped inside a zip file, the library is able to handle that too, meaning you don't have to worry about unzipping the contents:


  	>>> sf = shapefile.Reader("shapefiles/blockgroups.zip")

  If the zip file contains multiple shapefiles, just specify which shapefile to read by additionally specifying the relative path after the ".zip" part:


  	>>> sf = shapefile.Reader("shapefiles/blockgroups_multishapefile.zip/blockgroups2.shp")



  Finally, you can use all of the above methods to read shapefiles directly from the internet, by giving a url instead of a local path, e.g.:


  	>>> # from a zipped shapefile on website
  	>>> sf = shapefile.Reader("https://biogeo.ucdavis.edu/data/diva/rrd/NIC_rrd.zip")

  	>>> # from a shapefile collection of files in a github repository
  	>>> sf = shapefile.Reader("https://github.com/nvkelso/natural-earth-vector/blob/master/110m_cultural/ne_110m_admin_0_tiny_countries.shp?raw=true")

  This will automatically download the file(s) to a temporary location before reading, saving you a lot of time and repetitive boilerplate code when you just want quick access to some external data.



  You can also load shapefiles from any Python file-like object using keyword
  arguments to specify any of the three files. This feature is very powerful and
  allows you to custom load shapefiles from arbitrary storage formats, such as a protected url or zip file, a serialized object, or in some cases a database.


  	>>> myshp = open("shapefiles/blockgroups.shp", "rb")
  	>>> mydbf = open("shapefiles/blockgroups.dbf", "rb")
  	>>> r = shapefile.Reader(shp=myshp, dbf=mydbf)

  Notice in the examples above the shx file is never used. The shx file is a
  very simple fixed-record index for the variable-length records in the shp
  file. This file is optional for reading. If it's available PyShp will use the
  shx file to access shape records a little faster but will do just fine without
  it.



  The "Reader" class can be used as a context manager, to ensure open file
  objects are properly closed when done reading the data:

      >>> with shapefile.Reader("shapefiles/blockgroups.shp") as shp:
      ...     print(shp)
      shapefile Reader
          663 shapes (type 'POLYGON')
          663 records (44 fields)



  Shapefiles have a number of attributes for inspecting the file contents.
  A shapefile is a container for a specific type of geometry, and this can be checked using the
  shapeType attribute.


  	>>> sf = shapefile.Reader("shapefiles/blockgroups.dbf")
  	>>> sf.shapeType
  	5

  Shape types are represented by numbers between 0 and 31 as defined by the
  shapefile specification and listed below. It is important to note that the numbering system has
  several reserved numbers that have not been used yet, therefore the numbers of
  the existing shape types are not sequential:

  - NULL = 0
  - POINT = 1
  - POLYLINE = 3
  - POLYGON = 5
  - MULTIPOINT = 8
  - POINTZ = 11
  - POLYLINEZ = 13
  - POLYGONZ = 15
  - MULTIPOINTZ = 18
  - POINTM = 21
  - POLYLINEM = 23
  - POLYGONM = 25
  - MULTIPOINTM = 28
  - MULTIPATCH = 31

  Based on this we can see that our blockgroups shapefile contains
  Polygon type shapes. The shape types are also defined as constants in
  the shapefile module, so that we can compare types more intuitively:


  	>>> sf.shapeType == shapefile.POLYGON
  	True

  For convenience, you can also get the name of the shape type as a string:


  	>>> sf.shapeTypeName == 'POLYGON'
  	True

  Other pieces of meta-data that we can check include the number of features
  and the bounding box area the shapefile covers:


  	>>> len(sf)
  	663
  	>>> sf.bbox
  	[-122.515048, 37.652916, -122.327622, 37.863433]

  Finally, if you would prefer to work with the entire shapefile in a different
  format, you can convert all of it to a GeoJSON dictionary, although you may lose
  some information in the process, such as z- and m-values:


  	>>> sf.__geo_interface__['type']
  	'FeatureCollection'



  A shapefile's geometry is the collection of points or shapes made from
  vertices and implied arcs representing physical locations. All types of
  shapefiles just store points. The metadata about the points determine how they
  are handled by software.

  You can get a list of the shapefile's geometry by calling the shapes()
  method.


  	>>> shapes = sf.shapes()

  The shapes method returns a list of Shape objects describing the geometry of
  each shape record.


  	>>> len(shapes)
  	663

  To read a single shape by calling its index use the shape() method. The index
  is the shape's count from 0. So to read the 8th shape record you would use its
  index which is 7.


  	>>> s = sf.shape(7)
  	>>> s
  	Shape #7: POLYGON

  	>>> # Read the bbox of the 8th shape to verify
  	>>> # Round coordinates to 3 decimal places
  	>>> ['%.3f' % coord for coord in s.bbox]
  	['-122.450', '37.801', '-122.442', '37.808']

  Each shape record (except Points) contains the following attributes. Records of
  shapeType Point do not have a bounding box 'bbox'.


  	>>> for name in dir(shapes[3]):
  	...     if not name.startswith('_'):
  	...         name
  	'bbox'
  	'oid'
  	'parts'
  	'points'
  	'shapeType'
  	'shapeTypeName'

    * `oid`: The shape's index position in the original shapefile.


  		>>> shapes[3].oid
  		3

    * `shapeType`: an integer representing the type of shape as defined by the
  	  shapefile specification.


  		>>> shapes[3].shapeType
  		5

    * `shapeTypeName`: a string representation of the type of shape as defined by shapeType. Read-only.


  		>>> shapes[3].shapeTypeName
  		'POLYGON'

    * `bbox`: If the shape type contains multiple points this tuple describes the
  	  lower left (x,y) coordinate and upper right corner coordinate creating a
  	  complete box around the points. If the shapeType is a
  	  Null (shapeType == 0) then an AttributeError is raised.


  		>>> # Get the bounding box of the 4th shape.
  		>>> # Round coordinates to 3 decimal places
  		>>> bbox = shapes[3].bbox
  		>>> ['%.3f' % coord for coord in bbox]
  		['-122.486', '37.787', '-122.446', '37.811']

    * `parts`: Parts simply group collections of points into shapes. If the shape
  	  record has multiple parts this attribute contains the index of the first
  	  point of each part. If there is only one part then a list containing 0 is
  	  returned.


  		>>> shapes[3].parts
  		[0]

    * `points`: The points attribute contains a list of tuples containing an
  	  (x,y) coordinate for each point in the shape.


  		>>> len(shapes[3].points)
  		173
  		>>> # Get the 8th point of the fourth shape
  		>>> # Truncate coordinates to 3 decimal places
  		>>> shape = shapes[3].points[7]
  		>>> ['%.3f' % coord for coord in shape]
  		['-122.471', '37.787']

  In most cases, however, if you need to do more than just type or bounds checking, you may want
  to convert the geometry to the more human-readable [GeoJSON format](http://geojson.org),
  where lines and polygons are grouped for you:


  	>>> s = sf.shape(0)
  	>>> geoj = s.__geo_interface__
  	>>> geoj["type"]
  	'MultiPolygon'

  The results from the shapes() method similarly supports converting to GeoJSON:


  	>>> shapes.__geo_interface__['type']
  	'GeometryCollection'

  Note: In some cases, if the conversion from shapefile geometry to GeoJSON encountered any problems
  or potential issues, a warning message will be displayed with information about the affected
  geometry. To ignore or suppress these warnings, you can disable this behavior by setting the
  module constant VERBOSE to False:


  	>>> shapefile.VERBOSE = False




  A record in a shapefile contains the attributes for each shape in the
  collection of geometries. Records are stored in the dbf file. The link between
  geometry and attributes is the foundation of all geographic information systems.
  This critical link is implied by the order of shapes and corresponding records
  in the shp geometry file and the dbf attribute file.

  The field names of a shapefile are available as soon as you read a shapefile.
  You can call the "fields" attribute of the shapefile as a Python list. Each
  field is a Python list with the following information:

    * Field name: the name describing the data at this column index.
    * Field type: the type of data at this column index. Types can be:
         * "C": Characters, text.
  	   * "N": Numbers, with or without decimals.
  	   * "F": Floats (same as "N").
  	   * "L": Logical, for boolean True/False values.
  	   * "D": Dates.
  	   * "M": Memo, has no meaning within a GIS and is part of the xbase spec instead.
    * Field length: the length of the data found at this column index. Older GIS
  	   software may truncate this length to 8 or 11 characters for "Character"
  	   fields.
    * Decimal length: the number of decimal places found in "Number" fields.

  To see the fields for the Reader object above (sf) call the "fields"
  attribute:


  	>>> fields = sf.fields

  	>>> assert fields == [("DeletionFlag", "C", 1, 0), ["AREA", "N", 18, 5],
  	... ["BKG_KEY", "C", 12, 0], ["POP1990", "N", 9, 0], ["POP90_SQMI", "N", 10, 1],
  	... ["HOUSEHOLDS", "N", 9, 0],
  	... ["MALES", "N", 9, 0], ["FEMALES", "N", 9, 0], ["WHITE", "N", 9, 0],
  	... ["BLACK", "N", 8, 0], ["AMERI_ES", "N", 7, 0], ["ASIAN_PI", "N", 8, 0],
  	... ["OTHER", "N", 8, 0], ["HISPANIC", "N", 8, 0], ["AGE_UNDER5", "N", 8, 0],
  	... ["AGE_5_17", "N", 8, 0], ["AGE_18_29", "N", 8, 0], ["AGE_30_49", "N", 8, 0],
  	... ["AGE_50_64", "N", 8, 0], ["AGE_65_UP", "N", 8, 0],
  	... ["NEVERMARRY", "N", 8, 0], ["MARRIED", "N", 9, 0], ["SEPARATED", "N", 7, 0],
  	... ["WIDOWED", "N", 8, 0], ["DIVORCED", "N", 8, 0], ["HSEHLD_1_M", "N", 8, 0],
  	... ["HSEHLD_1_F", "N", 8, 0], ["MARHH_CHD", "N", 8, 0],
  	... ["MARHH_NO_C", "N", 8, 0], ["MHH_CHILD", "N", 7, 0],
  	... ["FHH_CHILD", "N", 7, 0], ["HSE_UNITS", "N", 9, 0], ["VACANT", "N", 7, 0],
  	... ["OWNER_OCC", "N", 8, 0], ["RENTER_OCC", "N", 8, 0],
  	... ["MEDIAN_VAL", "N", 7, 0], ["MEDIANRENT", "N", 4, 0],
  	... ["UNITS_1DET", "N", 8, 0], ["UNITS_1ATT", "N", 7, 0], ["UNITS2", "N", 7, 0],
  	... ["UNITS3_9", "N", 8, 0], ["UNITS10_49", "N", 8, 0],
  	... ["UNITS50_UP", "N", 8, 0], ["MOBILEHOME", "N", 7, 0]]

  The first field of a dbf file is always a 1-byte field called "DeletionFlag",
  which indicates records that have been deleted but not removed. However,
  since this flag is very rarely used, PyShp currently will return all records
  regardless of their deletion flag, and the flag is also not included in the list of
  record values. In other words, the DeletionFlag field has no real purpose, and
  should in most cases be ignored. For instance, to get a list of all fieldnames:


  	>>> fieldnames = [f[0] for f in sf.fields[1:]]

  You can get a list of the shapefile's records by calling the records() method:


  	>>> records = sf.records()

  	>>> len(records)
  	663

  To read a single record call the record() method with the record's index:


  	>>> rec = sf.record(3)

  Each record is a list-like Record object containing the values corresponding to each field in
  the field list (except the DeletionFlag). A record's values can be accessed by positional indexing or slicing.
  For example in the blockgroups shapefile the 2nd and 3rd fields are the blockgroup id
  and the 1990 population count of that San Francisco blockgroup:


  	>>> rec[1:3]
  	['060750601001', 4715]

  For simpler access, the fields of a record can also accessed via the name of the field,
  either as a key or as an attribute name. The blockgroup id (BKG_KEY) of the blockgroups shapefile
  can also be retrieved as:


      >>> rec['BKG_KEY']
      '060750601001'

      >>> rec.BKG_KEY
      '060750601001'

  The record values can be easily integrated with other programs by converting it to a field-value dictionary:


  	>>> dct = rec.as_dict()
  	>>> sorted(dct.items())
  	[('AGE_18_29', 1467), ('AGE_30_49', 1681), ('AGE_50_64', 92), ('AGE_5_17', 848), ('AGE_65_UP', 30), ('AGE_UNDER5', 597), ('AMERI_ES', 6), ('AREA', 2.34385), ('ASIAN_PI', 452), ('BKG_KEY', '060750601001'), ('BLACK', 1007), ('DIVORCED', 149), ('FEMALES', 2095), ('FHH_CHILD', 16), ('HISPANIC', 416), ('HOUSEHOLDS', 1195), ('HSEHLD_1_F', 40), ('HSEHLD_1_M', 22), ('HSE_UNITS', 1258), ('MALES', 2620), ('MARHH_CHD', 79), ('MARHH_NO_C', 958), ('MARRIED', 2021), ('MEDIANRENT', 739), ('MEDIAN_VAL', 337500), ('MHH_CHILD', 0), ('MOBILEHOME', 0), ('NEVERMARRY', 703), ('OTHER', 288), ('OWNER_OCC', 66), ('POP1990', 4715), ('POP90_SQMI', 2011.6), ('RENTER_OCC', 3733), ('SEPARATED', 49), ('UNITS10_49', 49), ('UNITS2', 160), ('UNITS3_9', 672), ('UNITS50_UP', 0), ('UNITS_1ATT', 302), ('UNITS_1DET', 43), ('VACANT', 93), ('WHITE', 2962), ('WIDOWED', 37)]

  If at a later point you need to check the record's index position in the original
  shapefile, you can do this through the "oid" attribute:


  	>>> rec.oid
  	3



  You may want to examine both the geometry and the attributes for a record at
  the same time. The shapeRecord() and shapeRecords() method let you do just
  that.

  Calling the shapeRecords() method will return the geometry and attributes for
  all shapes as a list of ShapeRecord objects. Each ShapeRecord instance has a
  "shape" and "record" attribute. The shape attribute is a Shape object as
  discussed in the first section "Reading Geometry". The record attribute is a
  list-like object containing field values as demonstrated in the "Reading Records" section.


  	>>> shapeRecs = sf.shapeRecords()

  Let's read the blockgroup key and the population for the 4th blockgroup:


  	>>> shapeRecs[3].record[1:3]
  	['060750601001', 4715]

  The results from the shapeRecords() method is a list-like object that can be easily converted
  to GeoJSON through the _\_geo_interface\_\_:


  	>>> shapeRecs.__geo_interface__['type']
  	'FeatureCollection'

  The shapeRecord() method reads a single shape/record pair at the specified index.
  To get the 4th shape record from the blockgroups shapefile use the third index:


  	>>> shapeRec = sf.shapeRecord(3)
  	>>> shapeRec.record[1:3]
  	['060750601001', 4715]

  Each individual shape record also supports the _\_geo_interface\_\_ to convert it to a GeoJSON feature:


  	>>> shapeRec.__geo_interface__['type']
  	'Feature'






  PyShp tries to be as flexible as possible when writing shapefiles while
  maintaining some degree of automatic validation to make sure you don't
  accidentally write an invalid file.

  PyShp can write just one of the component files such as the shp or dbf file
  without writing the others. So in addition to being a complete shapefile
  library, it can also be used as a basic dbf (xbase) library. Dbf files are a
  common database format which are often useful as a standalone simple database
  format. And even shp files occasionally have uses as a standalone format. Some
  web-based GIS systems use an user-uploaded shp file to specify an area of
  interest. Many precision agriculture chemical field sprayers also use the shp
  format as a control file for the sprayer system (usually in combination with
  custom database file formats).



  To create a shapefile you begin by initiating a new Writer instance, passing it
  the file path and name to save to:


  	>>> w = shapefile.Writer('shapefiles/test/testfile')
  	>>> w.field('field1', 'C')

  File extensions are optional when reading or writing shapefiles. If you specify
  them PyShp ignores them anyway. When you save files you can specify a base
  file name that is used for all three file types. Or you can specify a name for
  one or more file types:


  	>>> w = shapefile.Writer(dbf='shapefiles/test/onlydbf.dbf')
  	>>> w.field('field1', 'C')

  In that case, any file types not assigned will not
  save and only file types with file names will be saved.



  Just as you can read shapefiles from python file-like objects you can also
  write to them:


  	>>> try:
  	...     from StringIO import StringIO
  	... except ImportError:
  	...     from io import BytesIO as StringIO
  	>>> shp = StringIO()
  	>>> shx = StringIO()
  	>>> dbf = StringIO()
  	>>> w = shapefile.Writer(shp=shp, shx=shx, dbf=dbf)
  	>>> w.field('field1', 'C')
  	>>> w.record()
  	>>> w.null()
  	>>> w.close()

  	>>> # To read back the files you could call the "StringIO.getvalue()" method later.
  	>>> assert shp.getvalue()
  	>>> assert shx.getvalue()
  	>>> assert dbf.getvalue()

  	>>> # In fact, you can read directly from them using the Reader
  	>>> r = shapefile.Reader(shp=shp, shx=shx, dbf=dbf)
  	>>> len(r)
  	1





  The "Writer" class automatically closes the open files and writes the final headers once it is garbage collected.
  In case of a crash and to make the code more readable, it is nevertheless recommended
  you do this manually by calling the "close()" method:


  	>>> w.close()

  Alternatively, you can also use the "Writer" class as a context manager, to ensure open file
  objects are properly closed and final headers written once you exit the with-clause:


  	>>> with shapefile.Writer("shapefiles/test/contextwriter") as w:
  	... 	w.field('field1', 'C')
  	... 	pass



  The shape type defines the type of geometry contained in the shapefile. All of
  the shapes must match the shape type setting.

  There are three ways to set the shape type:
    * Set it when creating the class instance.
    * Set it by assigning a value to an existing class instance.
    * Set it automatically to the type of the first non-null shape by saving the shapefile.

  To manually set the shape type for a Writer object when creating the Writer:


  	>>> w = shapefile.Writer('shapefiles/test/shapetype', shapeType=3)
  	>>> w.field('field1', 'C')

  	>>> w.shapeType
  	3

  OR you can set it after the Writer is created:


  	>>> w.shapeType = 1

  	>>> w.shapeType
  	1




  Before you can add records you must first create the fields that define what types of
  values will go into each attribute.

  There are several different field types, all of which support storing None values as NULL.

  Text fields are created using the 'C' type, and the third 'size' argument can be customized to the expected
  length of text values to save space:


  	>>> w = shapefile.Writer('shapefiles/test/dtype')
  	>>> w.field('TEXT', 'C')
  	>>> w.field('SHORT_TEXT', 'C', size=5)
  	>>> w.field('LONG_TEXT', 'C', size=250)
  	>>> w.null()
  	>>> w.record('Hello', 'World', 'World'*50)
  	>>> w.close()

  	>>> r = shapefile.Reader('shapefiles/test/dtype')
  	>>> assert r.record(0) == ['Hello', 'World', 'World'*50]

  Date fields are created using the 'D' type, and can be created using either
  date objects, lists, or a YYYYMMDD formatted string.
  Field length or decimal have no impact on this type:


  	>>> from datetime import date
  	>>> w = shapefile.Writer('shapefiles/test/dtype')
  	>>> w.field('DATE', 'D')
  	>>> w.null()
  	>>> w.null()
  	>>> w.null()
  	>>> w.null()
  	>>> w.record(date(1898,1,30))
  	>>> w.record([1998,1,30])
  	>>> w.record('19980130')
  	>>> w.record(None)
  	>>> w.close()

  	>>> r = shapefile.Reader('shapefiles/test/dtype')
  	>>> assert r.record(0) == [date(1898,1,30)]
  	>>> assert r.record(1) == [date(1998,1,30)]
  	>>> assert r.record(2) == [date(1998,1,30)]
  	>>> assert r.record(3) == [None]

  Numeric fields are created using the 'N' type (or the 'F' type, which is exactly the same).
  By default the fourth decimal argument is set to zero, essentially creating an integer field.
  To store floats you must set the decimal argument to the precision of your choice.
  To store very large numbers you must increase the field length size to the total number of digits
  (including comma and minus).


  	>>> w = shapefile.Writer('shapefiles/test/dtype')
  	>>> w.field('INT', 'N')
  	>>> w.field('LOWPREC', 'N', decimal=2)
  	>>> w.field('MEDPREC', 'N', decimal=10)
  	>>> w.field('HIGHPREC', 'N', decimal=30)
  	>>> w.field('FTYPE', 'F', decimal=10)
  	>>> w.field('LARGENR', 'N', 101)
  	>>> nr = 1.3217328
  	>>> w.null()
  	>>> w.null()
  	>>> w.record(INT=nr, LOWPREC=nr, MEDPREC=nr, HIGHPREC=-3.2302e-25, FTYPE=nr, LARGENR=int(nr)*10**100)
  	>>> w.record(None, None, None, None, None, None)
  	>>> w.close()

  	>>> r = shapefile.Reader('shapefiles/test/dtype')
  	>>> assert r.record(0) == [1, 1.32, 1.3217328, -3.2302e-25, 1.3217328, 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000]
  	>>> assert r.record(1) == [None, None, None, None, None, None]


  Finally, we can create boolean fields by setting the type to 'L'.
  This field can take True or False values, or 1 (True) or 0 (False).
  None is interpreted as missing.


  	>>> w = shapefile.Writer('shapefiles/test/dtype')
  	>>> w.field('BOOLEAN', 'L')
  	>>> w.null()
  	>>> w.null()
  	>>> w.null()
  	>>> w.null()
  	>>> w.null()
  	>>> w.null()
  	>>> w.record(True)
  	>>> w.record(1)
  	>>> w.record(False)
  	>>> w.record(0)
  	>>> w.record(None)
  	>>> w.record("Nonesense")
  	>>> w.close()

  	>>> r = shapefile.Reader('shapefiles/test/dtype')
  	>>> r.record(0)
  	Record #0: [True]
  	>>> r.record(1)
  	Record #1: [True]
  	>>> r.record(2)
  	Record #2: [False]
  	>>> r.record(3)
  	Record #3: [False]
  	>>> r.record(4)
  	Record #4: [None]
  	>>> r.record(5)
  	Record #5: [None]

  You can also add attributes using keyword arguments where the keys are field names.


  	>>> w = shapefile.Writer('shapefiles/test/dtype')
  	>>> w.field('FIRST_FLD','C','40')
  	>>> w.field('SECOND_FLD','C','40')
  	>>> w.null()
  	>>> w.null()
  	>>> w.record('First', 'Line')
  	>>> w.record(FIRST_FLD='First', SECOND_FLD='Line')
  	>>> w.close()



  Geometry is added using one of several convenience methods. The "null" method is used
  for null shapes, "point" is used for point shapes, "multipoint" is used for multipoint shapes, "line" for lines,
  "poly" for polygons.

  **Adding a Null shape**

  A shapefile may contain some records for which geometry is not available, and may be set using the "null" method.
  Because Null shape types (shape type 0) have no geometry the "null" method is called without any arguments.


  	>>> w = shapefile.Writer('shapefiles/test/null')
  	>>> w.field('name', 'C')

  	>>> w.null()
  	>>> w.record('nullgeom')

  	>>> w.close()

  **Adding a Point shape**

  Point shapes are added using the "point" method. A point is specified by an x and
  y value.


  	>>> w = shapefile.Writer('shapefiles/test/point')
  	>>> w.field('name', 'C')

  	>>> w.point(122, 37)
  	>>> w.record('point1')

  	>>> w.close()

  **Adding a MultiPoint shape**

  If your point data allows for the possibility of multiple points per feature, use "multipoint" instead.
  These are specified as a list of xy point coordinates.


  	>>> w = shapefile.Writer('shapefiles/test/multipoint')
  	>>> w.field('name', 'C')

  	>>> w.multipoint([[122,37], [124,32]])
  	>>> w.record('multipoint1')

  	>>> w.close()

  **Adding a LineString shape**

  For LineString shapefiles, each shape is given as a list of one or more linear features.
  Each of the linear features must have at least two points.


  	>>> w = shapefile.Writer('shapefiles/test/line')
  	>>> w.field('name', 'C')

  	>>> w.line([
  	...			[[1,5],[5,5],[5,1],[3,3],[1,1]], # line 1
  	...			[[3,2],[2,6]] # line 2
  	...			])

  	>>> w.record('linestring1')

  	>>> w.close()

  **Adding a Polygon shape**

  Similarly to LineString, Polygon shapes consist of multiple polygons, and must be given as a list of polygons.
  The main difference is that polygons must have at least 4 points and the last point must be the same as the first.
  It's also okay if you forget to repeat the first point at the end; PyShp automatically checks and closes the polygons
  if you don't.

  It's important to note that for Polygon shapefiles, your polygon coordinates must be ordered in a clockwise direction.
  If any of the polygons have holes, then the hole polygon coordinates must be ordered in a counterclockwise direction.
  The direction of your polygons determines how shapefile readers will distinguish between polygon outlines and holes.


  	>>> w = shapefile.Writer('shapefiles/test/polygon')
  	>>> w.field('name', 'C')

  	>>> w.poly([
  	...	        [[113,24], [112,32], [117,36], [122,37], [118,20]], # poly 1
  	...	        [[116,29],[116,26],[119,29],[119,32]], # hole 1
  	...         [[15,2], [17,6], [22,7]]  # poly 2
  	...        ])
  	>>> w.record('polygon1')

  	>>> w.close()

  **Adding from an existing Shape object**

  Finally, geometry can be added by passing an existing "Shape" object to the "shape" method.
  You can also pass it any GeoJSON dictionary or _\_geo_interface\_\_ compatible object.
  This can be particularly useful for copying from one file to another:


  	>>> r = shapefile.Reader('shapefiles/test/polygon')

  	>>> w = shapefile.Writer('shapefiles/test/copy')
  	>>> w.fields = r.fields[1:] # skip first deletion field

  	>>> # adding existing Shape objects
  	>>> for shaperec in r.iterShapeRecords():
  	...     w.record(*shaperec.record)
  	...     w.shape(shaperec.shape)

  	>>> # or GeoJSON dicts
  	>>> for shaperec in r.iterShapeRecords():
  	...     w.record(*shaperec.record)
  	...     w.shape(shaperec.shape.__geo_interface__)

  	>>> w.close()




  Because every shape must have a corresponding record it is critical that the
  number of records equals the number of shapes to create a valid shapefile. You
  must take care to add records and shapes in the same order so that the record
  data lines up with the geometry data. For example:


  	>>> w = shapefile.Writer('shapefiles/test/balancing', shapeType=shapefile.POINT)
  	>>> w.field("field1", "C")
  	>>> w.field("field2", "C")

  	>>> w.record("row", "one")
  	>>> w.point(1, 1)

  	>>> w.record("row", "two")
  	>>> w.point(2, 2)

  To help prevent accidental misalignment PyShp has an "auto balance" feature to
  make sure when you add either a shape or a record the two sides of the
  equation line up. This way if you forget to update an entry the
  shapefile will still be valid and handled correctly by most shapefile
  software. Autobalancing is NOT turned on by default. To activate it set
  the attribute autoBalance to 1 or True:


      >>> w.autoBalance = 1
  	>>> w.record("row", "three")
  	>>> w.record("row", "four")
  	>>> w.point(4, 4)

  	>>> w.recNum == w.shpNum
  	True

  You also have the option of manually calling the balance() method at any time
  to ensure the other side is up to date. When balancing is used
  null shapes are created on the geometry side or records
  with a value of "NULL" for each field is created on the attribute side.
  This gives you flexibility in how you build the shapefile.
  You can create all of the shapes and then create all of the records or vice versa.


      >>> w.autoBalance = 0
  	>>> w.record("row", "five")
  	>>> w.record("row", "six")
  	>>> w.record("row", "seven")
  	>>> w.point(5, 5)
  	>>> w.point(6, 6)
  	>>> w.balance()

  	>>> w.recNum == w.shpNum
  	True

  If you do not use the autoBalance() or balance() method and forget to manually
  balance the geometry and attributes the shapefile will be viewed as corrupt by
  most shapefile software.







  Below we list some commonly encountered errors and ways to fix them.



  By default, PyShp chooses to be transparent and provide the user with logging information and warnings about non-critical issues when reading or writing shapefiles. This behavior is controlled by the module constant `VERBOSE` (which defaults to True). If you would rather suppress this information, you can simply set this to False:


  	>>> shapefile.VERBOSE = False

  All logging happens under the namespace `shapefile`. So another way to suppress all PyShp warnings would be to alter the logging behavior for that namespace:


  	>>> import logging
  	>>> logging.getLogger('shapefile').setLevel(logging.ERROR)



  PyShp supports reading and writing shapefiles in any language or character encoding, and provides several options for decoding and encoding text.
  Most shapefiles are written in UTF-8 encoding, PyShp's default encoding, so in most cases you don't have to specify the encoding.
  If you encounter an encoding error when reading a shapefile, this means the shapefile was likely written in a non-utf8 encoding.
  For instance, when working with English language shapefiles, a common reason for encoding errors is that the shapefile was written in Latin-1 encoding.
  For reading shapefiles in any non-utf8 encoding, such as Latin-1, just
  supply the encoding option when creating the Reader class.


  	>>> r = shapefile.Reader("shapefiles/test/latin1.shp", encoding="latin1")
  	>>> r.record(0) == [2, u'Ñandú']
  	True

  Once you have loaded the shapefile, you may choose to save it using another more supportive encoding such
  as UTF-8. Assuming the new encoding supports the characters you are trying to write, reading it back in
  should give you the same unicode string you started with.


  	>>> w = shapefile.Writer("shapefiles/test/latin_as_utf8.shp", encoding="utf8")
  	>>> w.fields = r.fields[1:]
  	>>> w.record(*r.record(0))
  	>>> w.null()
  	>>> w.close()

  	>>> r = shapefile.Reader("shapefiles/test/latin_as_utf8.shp", encoding="utf8")
  	>>> r.record(0) == [2, u'Ñandú']
  	True

  If you supply the wrong encoding and the string is unable to be decoded, PyShp will by default raise an
  exception. If however, on rare occasion, you are unable to find the correct encoding and want to ignore
  or replace encoding errors, you can specify the "encodingErrors" to be used by the decode method. This
  applies to both reading and writing.


  	>>> r = shapefile.Reader("shapefiles/test/latin1.shp", encoding="ascii", encodingErrors="replace")
  	>>> r.record(0) == [2, u'�and�']
  	True





  Despite being a lightweight library, PyShp is designed to be able to read shapefiles of any size, allowing you to work with hundreds of thousands or even millions
  of records and complex geometries.



  As an example, let's load this Natural Earth shapefile of more than 4000 global administrative boundary polygons:


  	>>> sf = shapefile.Reader("https://github.com/nvkelso/natural-earth-vector/blob/master/10m_cultural/ne_10m_admin_1_states_provinces?raw=true")

  When first creating the Reader class, the library only reads the header information
  and leaves the rest of the file contents alone. Once you call the records() and shapes()
  methods however, it will attempt to read the entire file into memory at once.
  For very large files this can result in MemoryError. So when working with large files
  it is recommended to use instead the iterShapes(), iterRecords(), or iterShapeRecords()
  methods instead. These iterate through the file contents one at a time, enabling you to loop
  through them while keeping memory usage at a minimum.


  	>>> for shape in sf.iterShapes():
  	...     # do something here
  	...     pass

  	>>> for rec in sf.iterRecords():
  	...     # do something here
  	...     pass

  	>>> for shapeRec in sf.iterShapeRecords():
  	...     # do something here
  	...     pass

  	>>> for shapeRec in sf: # same as iterShapeRecords()
  	...     # do something here
  	...     pass



  By default when reading the attribute records of a shapefile, pyshp unpacks and returns the data for all of the dbf fields, regardless of whether you actually need that data or not. To limit which field data is unpacked when reading each record and speed up processing time, you can specify the `fields` argument to any of the methods involving record data. Note that the order of the specified fields does not matter, the resulting records will list the specified field values in the order that they appear in the original dbf file. For instance, if we are only interested in the country and name of each admin unit, the following is a more efficient way of iterating through the file:


  	>>> fields = ["geonunit", "name"]
  	>>> for rec in sf.iterRecords(fields=fields):
  	... 	# do something
  	... 	pass
  	>>> rec
  	Record #4595: ['Birgu', 'Malta']



  In many cases, we aren't interested in all entries of a shapefile, but rather only want to retrieve a small subset of records by filtering on some attribute. To avoid wasting time reading records and shapes that we don't need, we can start by iterating only the records and fields of interest, check if the record matches some condition as a way to filter the data, and finally load the full record and shape geometry for those that meet the condition:


  	>>> filter_field = "geonunit"
  	>>> filter_value = "Eritrea"
  	>>> for rec in sf.iterRecords(fields=[filter_field]):
  	...     if rec[filter_field] == filter_value:
  	... 		# load full record and shape
  	... 		shapeRec = sf.shapeRecord(rec.oid)
  	... 		shapeRec.record["name"]
  	'Debubawi Keyih Bahri'
  	'Debub'
  	'Semenawi Keyih Bahri'
  	'Gash Barka'
  	'Maekel'
  	'Anseba'

  Selectively reading only the necessary data in this way is particularly useful for efficiently processing a limited subset of data from very large files or when looping through a large number of files, especially if they contain large attribute tables or complex shape geometries.



  Another common use-case is that we only want to read those records that are located in some region of interest. Because the shapefile stores the bounding box of each shape separately from the geometry data, it's possible to quickly retrieve all shapes that might overlap a given bounding box region without having to load the full shape geometry data for every shape. This can be done by specifying the `bbox` argument to any of the record or shape methods:


  	>>> bbox = [36.423, 12.360, 43.123, 18.004] # ca bbox of Eritrea
  	>>> fields = ["geonunit","name"]
  	>>> for shapeRec in sf.iterShapeRecords(bbox=bbox, fields=fields):
  	... 	shapeRec.record
  	Record #368: ['Afar', 'Ethiopia']
  	Record #369: ['Tadjourah', 'Djibouti']
  	Record #375: ['Obock', 'Djibouti']
  	Record #376: ['Debubawi Keyih Bahri', 'Eritrea']
  	Record #1106: ['Amhara', 'Ethiopia']
  	Record #1107: ['Gedarif', 'Sudan']
  	Record #1108: ['Tigray', 'Ethiopia']
  	Record #1414: ['Sa`dah', 'Yemen']
  	Record #1415: ['`Asir', 'Saudi Arabia']
  	Record #1416: ['Hajjah', 'Yemen']
  	Record #1417: ['Jizan', 'Saudi Arabia']
  	Record #1598: ['Debub', 'Eritrea']
  	Record #1599: ['Red Sea', 'Sudan']
  	Record #1600: ['Semenawi Keyih Bahri', 'Eritrea']
  	Record #1601: ['Gash Barka', 'Eritrea']
  	Record #1602: ['Kassala', 'Sudan']
  	Record #1603: ['Maekel', 'Eritrea']
  	Record #2037: ['Al Hudaydah', 'Yemen']
  	Record #3741: ['Anseba', 'Eritrea']

  This functionality means that shapefiles can be used as a bare-bones spatially indexed database, with very fast bounding box queries for even the largest of shapefiles. Note that, as with all spatial indexing, this method does not guarantee that the *geometries* of the resulting matches overlap the queried region, only that their *bounding boxes* overlap.





  Similar to the Reader class, the shapefile Writer class uses a streaming approach to keep memory
  usage at a minimum and allow writing shapefiles of arbitrarily large sizes. The library takes care of this under-the-hood by immediately
  writing each geometry and record to disk the moment they
  are added using shape() or record(). Once the writer is closed, exited, or garbage
  collected, the final header information is calculated and written to the beginning of
  the file.



  This means that it's possible to merge hundreds or thousands of shapefiles, as
  long as you iterate through the source files to avoid loading everything into
  memory. The following example copies the contents of a shapefile to a new file 10 times:

  	>>> # create writer
  	>>> w = shapefile.Writer('shapefiles/test/merge')

  	>>> # copy over fields from the reader
  	>>> r = shapefile.Reader("shapefiles/blockgroups")
  	>>> for field in r.fields[1:]:
  	...     w.field(*field)

  	>>> # copy the shapefile to writer 10 times
  	>>> repeat = 10
  	>>> for i in range(repeat):
  	...     r = shapefile.Reader("shapefiles/blockgroups")
  	...     for shapeRec in r.iterShapeRecords():
  	...         w.record(*shapeRec.record)
  	...         w.shape(shapeRec.shape)

  	>>> # check that the written file is 10 times longer
  	>>> len(w) == len(r) * 10
  	True

  	>>> # close the writer
  	>>> w.close()

  In this trivial example, we knew that all files had the exact same field names, ordering, and types. In other scenarios, you will have to additionally make sure that all shapefiles have the exact same fields in the same order, and that they all contain the same geometry type.



  If you need to edit a shapefile you would have to read the
  file one record at a time, modify or filter the contents, and write it back out. For instance, to create a copy of a shapefile that only keeps a subset of relevant fields:

  	>>> # create writer
  	>>> w = shapefile.Writer('shapefiles/test/edit')

  	>>> # define which fields to keep
  	>>> keep_fields = ['BKG_KEY', 'MEDIANRENT']

  	>>> # copy over the relevant fields from the reader
  	>>> r = shapefile.Reader("shapefiles/blockgroups")
  	>>> for field in r.fields[1:]:
  	...     if field[0] in keep_fields:
  	...         w.field(*field)

  	>>> # write only the relevant attribute values
  	>>> for shapeRec in r.iterShapeRecords(fields=keep_fields):
  	...     w.record(*shapeRec.record)
  	...     w.shape(shapeRec.shape)

  	>>> # close writer
  	>>> w.close()



  Most shapefiles store conventional 2D points, lines, or polygons. But the shapefile format is also capable
  of storing various other types of geometries as well, including complex 3D surfaces and objects.



  Measured shape types are shapes that include a measurement value at each vertex, for instance
  speed measurements from a GPS device. Shapes with measurement (M) values are added with the following
  methods: "pointm", "multipointm", "linem", and "polygonm". The M-values are specified by adding a
  third M value to each XY coordinate. Missing or unobserved M-values are specified with a None value,
  or by simply omitting the third M-coordinate.


  	>>> w = shapefile.Writer('shapefiles/test/linem')
  	>>> w.field('name', 'C')

  	>>> w.linem([
  	...			[[1,5,0],[5,5],[5,1,3],[3,3,None],[1,1,0]], # line with one omitted and one missing M-value
  	...			[[3,2],[2,6]] # line without any M-values
  	...			])

  	>>> w.record('linem1')

  	>>> w.close()

  Shapefiles containing M-values can be examined in several ways:

  	>>> r = shapefile.Reader('shapefiles/test/linem')

  	>>> r.mbox # the lower and upper bound of M-values in the shapefile
  	[0.0, 3.0]

  	>>> r.shape(0).m # flat list of M-values
  	[0.0, None, 3.0, None, 0.0, None, None]




  Elevation shape types are shapes that include an elevation value at each vertex, for instance elevation from a GPS device.
  Shapes with elevation (Z) values are added with the following methods: "pointz", "multipointz", "linez", and "polyz".
  The Z-values are specified by adding a third Z value to each XY coordinate. Z-values do not support the concept of missing data,
  but if you omit the third Z-coordinate it will default to 0. Note that Z-type shapes also support measurement (M) values added
  as a fourth M-coordinate. This too is optional.


  	>>> w = shapefile.Writer('shapefiles/test/linez')
  	>>> w.field('name', 'C')

  	>>> w.linez([
  	...			[[1,5,18],[5,5,20],[5,1,22],[3,3],[1,1]], # line with some omitted Z-values
  	...			[[3,2],[2,6]], # line without any Z-values
  	...			[[3,2,15,0],[2,6,13,3],[1,9,14,2]] # line with both Z- and M-values
  	...			])

  	>>> w.record('linez1')

  	>>> w.close()

  To examine a Z-type shapefile you can do:

  	>>> r = shapefile.Reader('shapefiles/test/linez')

  	>>> r.zbox # the lower and upper bound of Z-values in the shapefile
  	[0.0, 22.0]

  	>>> r.shape(0).z # flat list of Z-values
  	[18.0, 20.0, 22.0, 0.0, 0.0, 0.0, 0.0, 15.0, 13.0, 14.0]



  Multipatch shapes are useful for storing composite 3-Dimensional objects.
  A MultiPatch shape represents a 3D object made up of one or more surface parts.
  Each surface in "parts" is defined by a list of XYZM values (Z and M values optional), and its corresponding type is
  given in the "partTypes" argument. The part type decides how the coordinate sequence is to be interpreted, and can be one
  of the following module constants: TRIANGLE_STRIP, TRIANGLE_FAN, OUTER_RING, INNER_RING, FIRST_RING, or RING.
  For instance, a TRIANGLE_STRIP may be used to represent the walls of a building, combined with a TRIANGLE_FAN to represent
  its roof:

  	>>> from shapefile import TRIANGLE_STRIP, TRIANGLE_FAN

  	>>> w = shapefile.Writer('shapefiles/test/multipatch')
  	>>> w.field('name', 'C')

  	>>> w.multipatch([
  	...				 [[0,0,0],[0,0,3],[5,0,0],[5,0,3],[5,5,0],[5,5,3],[0,5,0],[0,5,3],[0,0,0],[0,0,3]], # TRIANGLE_STRIP for house walls
  	...				 [[2.5,2.5,5],[0,0,3],[5,0,3],[5,5,3],[0,5,3],[0,0,3]], # TRIANGLE_FAN for pointed house roof
  	...				 ],
  	...				 partTypes=[TRIANGLE_STRIP, TRIANGLE_FAN]) # one type for each part

  	>>> w.record('house1')

  	>>> w.close()

  For an introduction to the various multipatch part types and examples of how to create 3D MultiPatch objects see [this
  ESRI White Paper](http://downloads.esri.com/support/whitepapers/ao_/J9749_MultiPatch_Geometry_Type.pdf).





  The testing framework is pytest, and the tests are located in test_shapefile.py.
  This includes an extensive set of unit tests of the various pyshp features,
  and tests against various input data. Some of the tests that require
  internet connectivity will be skipped in offline testing environments.
  In the same folder as README.md and shapefile.py, from the command line run
  ```
  $ python -m pytest
  ```

  Additionally, all the code and examples located in this file, README.md,
  is tested and verified with the builtin doctest framework.
  A special routine for invoking the doctest is run when calling directly on shapefile.py.
  In the same folder as README.md and shapefile.py, from the command line run
  ```
  $ python shapefile.py
  ```

  Linux/Mac and similar platforms will need to run `$ dos2unix README.md` in order
  to correct line endings in README.md.



  ```
  Atle Frenvik Sveen
  Bas Couwenberg
  Ben Beasley
  Casey Meisenzahl
  Charles Arnold
  David A. Riggs
  davidh-ssec
  Evan Heidtmann
  ezcitron
  fiveham
  geospatialpython
  Hannes
  Ignacio Martinez Vazquez
  Jason Moujaes
  Jonty Wareing
  Karim Bahgat
  karanrn
  Kyle Kelley
  Louis Tiao
  Marcin Cuprjak
  mcuprjak
  Micah Cochran
  Michael Davis
  Michal Čihař
  Mike Toews
  Miroslav Šedivý
  Nilo
  pakoun
  Paulo Ernesto
  Raynor Vliegendhart
  Razzi Abuissa
  RosBer97
  Ross Rogers
  Ryan Brideau
  Tim Gates
  Tobias Megies
  Tommi Penttinen
  Uli Köhler
  Vsevolod Novikov
  Zac Miller
  ```


pkgId: 5353e1928b6be5c5cbc4b06504756da786891c49e2986265958ca89943a448fc
name: python-pyshtools
arch: src
version: 4.10.1
epoch: 0
release: 1
summary: SHTOOLS - Spherical Harmonic Tools
url: https://shtools.github.io/SHTOOLS/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d1477f80-8bd7-4508-9496-141ab68b94ae
location_href: 00004798-python-pyshtools/python-pyshtools-4.10.1-1.src.rpm
checksum_type: sha256
description:
  |Documentation| |DOI| |Paper| |Binder| |Chat on matrix| |Chat at gitter|
  |Twitter| |Mastodon Follow|

  SHTOOLS/pyshtools is a Fortran-95/Python library that can be used for
  spherical harmonic transforms, multitaper spectral analyses, expansions
  of gridded data into Slepian basis functions, and standard operations on
  global gravitational and magnetic field data.

  FEATURES
  ~~~~~~~~

  -  Supports all standard normalizations and phase conventions of the
     spherical harmonic functions.

  -  Effortless conversion between real and complex harmonics, between
     phase conventions, and between 4π normalized, Schmidt
     semi-normalized, orthonormalized, and unnormalized harmonics.

  -  Use of both regularly sampled geographic grids and grids appropriate
     for Gauss-Legendre quadrature.

  -  Spherical harmonic transforms proven to be accurate up to about
     degree 2800 for the Fortran 95 code, and beyond using the DUCC0
     backend.

  -  Perform localized multitaper spectral analyses, or expand gridded
     data in terms of localized Slepian basis functions.

  -  Support for standard data and file formats, including *xarray* and
     *netcdf*.

  -  Import research-grade gravity, topography, and magnetic field
     datasets with a single command.

  -  Creation of publication quality maps using
     `Cartopy <https://scitools.org.uk/cartopy>`__ and
     `pygmt <https://www.pygmt.org/>`__.

  -  OpenMP compatible and OpenMP thread-safe versions of the Fortran
     routines.

  INSTALLATION
  ~~~~~~~~~~~~

  pyshtools (for Python)
  ^^^^^^^^^^^^^^^^^^^^^^

  Install using ``conda``:

  .. code:: bash

     conda install -c conda-forge pyshtools  # Linux and macOS only
     conda update -c conda-forge pyshtools  # to upgrade a pre-existing installation

  Install using ``pip``:

  .. code:: bash

     pip install pyshtools
     pip install --upgrade pyshtools  # to upgrade a pre-existing installation
     pip install pyshtools --no-binary pyshtools  # build from source
     pip install git+https://github.com/SHTOOLS/SHTOOLS@develop  # install the develop branch from source

  For developers, install the requirements

  .. code:: bash

     
     sudo apt-get install g++ gfortran libfftw3-dev libblas-dev liblapack-dev
     
     brew install fftw
     sudo port install fftw-3
     

  then clone the shtools repo and install manually:

  .. code:: bash

     git clone https://github.com/SHTOOLS/SHTOOLS.git
     cd shtools
     git checkout develop
     pip install -e .  # install into the shtools folder and link to the active python environment

  SHTOOLS (for Fortran 95)
  ^^^^^^^^^^^^^^^^^^^^^^^^

  Install using the `brew <http://brew.sh/>`__ package manager (macOS,
  linux, windows):

  .. code:: bash

     brew install shtools

  Install using the `macports <https://www.macports.org/>`__ package
  manager (macOS)

  .. code:: bash

     sudo port install shtools

  Install from source. Clone or download the shtools repo, and then
  execute one (or both) of the following commands in the shtools
  directory:

  .. code:: bash

     make fortran
     make fortran-mp  # for OpenMP Fortran routines

  Further installation instructions and options can be found in the `web
  documentation <https://shtools.github.io/SHTOOLS/>`__.

  HOW TO USE
  ~~~~~~~~~~

  SHTOOLS can be invoked in any Fortran 95 or Python program. The core
  software is written in Fortran 95, and Python wrappers and dedicated
  classes allow simple access to the fortran-compiled routines. A variety
  of Python tutorials and guides are included that demonstrate the major
  features of the library.

  To get started, click on the following Python tutorials and then run
  them interactively in Binder:

  -  `Spherical harmonic coefficients and
     grids <https://nbviewer.jupyter.org/github/SHTOOLS/SHTOOLS/blob/master/examples/notebooks/grids-and-coefficients.ipynb>`__
  -  `Localization windows and spectral
     analysis <https://nbviewer.jupyter.org/github/SHTOOLS/SHTOOLS/blob/master/examples/notebooks/localized-spectral-analysis.ipynb>`__
  -  `Gravity and magnetic
     fields <https://nbviewer.jupyter.org/github/SHTOOLS/SHTOOLS/blob/master/examples/notebooks/gravity-and-magnetic-fields.ipynb>`__
  -  `Plotting
     maps <https://nbviewer.jupyter.org/github/SHTOOLS/SHTOOLS/blob/master/examples/notebooks/plotting-maps.ipynb>`__

  DEVELOPERS
  ~~~~~~~~~~

  We work on the ``develop`` branch and only push releases to ``master``.
  Please base all pull requests on ``develop``.

  REFERENCE
  ~~~~~~~~~

  Mark A. Wieczorek and Matthias Meschede (2018). SHTools — Tools for
  working with spherical harmonics, *Geochemistry, Geophysics,
  Geosystems*, 19, 2574-2592,
  doi:`10.1029/2018GC007529 <https://doi.org/10.1029/2018GC007529>`__.

  .. |Documentation| image:: https://img.shields.io/badge/documentation-shtools.github.io%2FSHTOOLS%2F-yellow.svg
     :target: https://shtools.github.io/SHTOOLS/
  .. |DOI| image:: https://zenodo.org/badge/doi/10.5281/zenodo.592762.svg
     :target: https://doi.org/10.5281/zenodo.592762
  .. |Paper| image:: https://img.shields.io/badge/paper-10.1029/2018GC007529-orange.svg
     :target: https://doi.org/10.1029/2018GC007529
  .. |Binder| image:: https://mybinder.org/badge_logo.svg
     :target: https://mybinder.org/v2/gh/SHTOOLS/SHTOOLS/master?filepath=examples%2Fnotebooks%2F
  .. |Chat on matrix| image:: https://img.shields.io/badge/chat-on_%5Bmatrix%5D-4bb596.svg
     :target: https://matrix.to/#/#pyshtools:matrix.org?via=matrix.org&via=gitter.im
  .. |Chat at gitter| image:: https://badges.gitter.im/SHTOOLS/SHTOOLS.svg
     :target: https://gitter.im/SHTOOLS/SHTOOLS?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
  .. |Twitter| image:: https://img.shields.io/twitter/follow/pyshtools.svg?style=social&label=Follow
     :target: https://twitter.com/intent/follow?screen_name=pyshtools
  .. |Mastodon Follow| image:: https://img.shields.io/mastodon/follow/108112567255227248?domain=https%3A%2F%2Ffosstodon.org&style=social
     :target: https://fosstodon.org/users/shtools/remote_follow


pkgId: 1febc258853a6123b34398e81cd7ca6c0c2310c765369d8c75f44225cc40bc41
name: python-pysimdjson
arch: src
version: 5.0.2
epoch: 0
release: 1
summary: simdjson bindings for python
url: https://github.com/TkTech/pysimdjson
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f9aeeb01-1b15-4759-9608-c4f7d4f63b79
location_href: 00011853-python-pysimdjson/python-pysimdjson-5.0.2-1.src.rpm
checksum_type: sha256
description:
  ![PyPI - License](https://img.shields.io/pypi/l/pysimdjson.svg?style=flat-square)
  ![Tests](https://github.com/TkTech/pysimdjson/workflows/Run%20tests/badge.svg)



  Python bindings for the [simdjson][] project, a SIMD-accelerated JSON parser.
  If SIMD instructions are unavailable a fallback parser is used, making
  pysimdjson safe to use anywhere.

  Bindings are currently tested on OS X, Linux, and Windows for Python version
  3.6 to 3.9.



  The latest documentation can be found at https://pysimdjson.tkte.ch.

  If you've checked out the source code (for example to review a PR), you can
  build the latest documentation by running `cd docs && make html`.



  pysimdjson compares well against most libraries. The full benchmarks can be
  found in its sister project [json_benchmark][].

  [simdjson]: https://github.com/lemire/simdjson
  [json_benchmark]: https://github.com/tktech/json_benchmark


