# packages

pkgId: 0be3e582aff40a76bef18bdeea1bf9ff6016da1bd423637ace12dd60720ef384
name: python-strsimpy
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: A library implementing different string similarity and distance measures
url: https://github.com/luozhouyang/python-string-similarity
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6c291d45-0ab4-4c26-8534-1a8192557cd5
location_href: 00012011-python-strsimpy/python-strsimpy-0.2.1-1.src.rpm
checksum_type: sha256
description:
  ![Python package](https://github.com/luozhouyang/python-string-similarity/workflows/Python%20package/badge.svg)
  [![PyPI version](https://badge.fury.io/py/strsimpy.svg)](https://badge.fury.io/py/strsimpy)
  [![Python](https://img.shields.io/pypi/pyversions/strsimpy.svg?style=plastic)](https://badge.fury.io/py/strsimpy)

  Python3.x implementation of [tdebatty/java-string-similarity](https://github.com/tdebatty/java-string-similarity)


  A library implementing different string similarity and distance measures. A dozen of algorithms (including Levenshtein edit distance and sibblings, Jaro-Winkler, Longest Common Subsequence, cosine similarity etc.) are currently implemented. Check the summary table below for the complete list...

  - [python-string-similarity](#python-string-similarity)
    - [Download](#download)
    - [Overview](#overview)
    - [Normalized, metric, similarity and distance](#normalized-metric-similarity-and-distance)
      - [(Normalized) similarity and distance](#normalized-similarity-and-distance)
      - [Metric distances](#metric-distances)
    - [Shingles (n-gram) based similarity and distance](#shingles-n-gram-based-similarity-and-distance)
    - [Levenshtein](#levenshtein)
    - [Normalized Levenshtein](#normalized-levenshtein)
    - [Weighted Levenshtein](#weighted-levenshtein)
    - [Damerau-Levenshtein](#damerau-levenshtein)
    - [Optimal String Alignment](#optimal-string-alignment)
    - [Jaro-Winkler](#jaro-winkler)
    - [Longest Common Subsequence](#longest-common-subsequence)
    - [Metric Longest Common Subsequence](#metric-longest-common-subsequence)
    - [N-Gram](#n-gram)
    - [Shingle (n-gram) based algorithms](#shingle-n-gram-based-algorithms)
      - [Q-Gram](#q-gram)
      - [Cosine similarity](#cosine-similarity)
      - [Jaccard index](#jaccard-index)
      - [Sorensen-Dice coefficient](#sorensen-dice-coefficient)
      - [Overlap coefficient (i.e., Szymkiewicz-Simpson)](#overlap-coefficient-ie-szymkiewicz-simpson)
    - [Experimental](#experimental)
      - [SIFT4](#sift4)
    - [Users](#users)




  From pypi:

  ```bash

  pip install -U strsimpy
  ```



  The main characteristics of each implemented algorithm are presented below. The "cost" column gives an estimation of the computational cost to compute the similarity between two strings of length m and n respectively.

  |  									|  						| Normalized? 	| Metric?	| Type    | Cost | Typical usage |
  | --------					|-------			|-------------	|-------- | ------  | ---- | ---   |
  | [Levenshtein](#levenshtein)		|distance 				| No 			| Yes 		|         | O(m*n) <sup>1</sup> |  |
  | [Normalized Levenshtein](#normalized-levenshtein)	|distance<br>similarity	| Yes 			| No 		| 	      | O(m*n) <sup>1</sup> |  |
  | [Weighted Levenshtein](#weighted-levenshtein)		|distance 				| No 			| No 		| 	      | O(m*n) <sup>1</sup> | OCR |
  | [Damerau-Levenshtein](#damerau-levenshtein) <sup>3</sup> 	|distance 				| No 			| Yes 		| 	      | O(m*n) <sup>1</sup> |  |
  | [Optimal String Alignment](#optimal-string-alignment) <sup>3</sup> |distance | No 			| No 		| 	      | O(m*n) <sup>1</sup> |  |
  | [Jaro-Winkler](#jaro-winkler) 		|similarity<br>distance	| Yes  			| No 		| 	      | O(m*n) | typo correction |
  | [Longest Common Subsequence](#longest-common-subsequence) 		|distance 				| No 			| No 		| 	      | O(m*n) <sup>1,2</sup> | diff utility, GIT reconciliation |
  | [Metric Longest Common Subsequence](#metric-longest-common-subsequence) |distance   			| Yes 			| Yes  		| 	      | O(m*n) <sup>1,2</sup> |  |
  | [N-Gram](#n-gram)	 				|distance				| Yes  			| No 		| 	      | O(m*n) |  |
  | [Q-Gram](#q-gram) 				|distance  			 	| No  			| No 		| Profile | O(m+n) |  |
  | [Cosine similarity](#cosine-similarity) 				|similarity<br>distance | Yes  			| No  		| Profile | O(m+n) |  |
  | [Jaccard index](#jaccard-index)				|similarity<br>distance | Yes  			| Yes  		| Set	  | O(m+n) |  |
  | [Sorensen-Dice coefficient](#sorensen-dice-coefficient) 	|similarity<br>distance | Yes 			| No 		| Set	  | O(m+n) |  |
  | [Overlap coefficient](#overlap-coefficient-ie-szymkiewicz-simpson) 	|similarity<br>distance | Yes 			| No 		| Set	  | O(m+n) |  |

  [1] In this library, Levenshtein edit distance, LCS distance and their sibblings are computed using the **dynamic programming** method, which has a cost O(m.n). For Levenshtein distance, the algorithm is sometimes called **Wagner-Fischer algorithm** ("The string-to-string correction problem", 1974). The original algorithm uses a matrix of size m x n to store the Levenshtein distance between string prefixes.

  If the alphabet is finite, it is possible to use the **method of four russians** (Arlazarov et al. "On economic construction of the transitive closure of a directed graph", 1970) to speedup computation. This was published by Masek in 1980 ("A Faster Algorithm Computing String Edit Distances"). This method splits the matrix in blocks of size t x t. Each possible block is precomputed to produce a lookup table. This lookup table can then be used to compute the string similarity (or distance) in O(nm/t). Usually, t is choosen as log(m) if m > n. The resulting computation cost is thus O(mn/log(m)). This method has not been implemented (yet).

  [2] In "Length of Maximal Common Subsequences", K.S. Larsen proposed an algorithm that computes the length of LCS in time O(log(m).log(n)). But the algorithm has a memory requirement O(m.n²) and was thus not implemented here.

  [3] There are two variants of Damerau-Levenshtein string distance: Damerau-Levenshtein with adjacent transpositions (also sometimes called unrestricted Damerau–Levenshtein distance) and Optimal String Alignment (also sometimes called restricted edit distance). For Optimal String Alignment, no substring can be edited more than once.


  Although the topic might seem simple, a lot of different algorithms exist to measure text similarity or distance. Therefore the library defines some interfaces to categorize them.



  - StringSimilarity : Implementing algorithms define a similarity between strings (0 means strings are completely different).
  - NormalizedStringSimilarity : Implementing algorithms define a similarity between 0.0 and 1.0, like Jaro-Winkler for example.
  - StringDistance : Implementing algorithms define a distance between strings (0 means strings are identical), like Levenshtein for example. The maximum distance value depends on the algorithm.
  - NormalizedStringDistance : This interface extends StringDistance. For implementing classes, the computed distance value is between 0.0 and 1.0. NormalizedLevenshtein is an example of NormalizedStringDistance.

  Generally, algorithms that implement NormalizedStringSimilarity also implement NormalizedStringDistance, and similarity = 1 - distance. But there are a few exceptions, like N-Gram similarity and distance (Kondrak)...


  The MetricStringDistance interface : A few of the distances are actually metric distances, which means that verify the triangle inequality d(x, y) <= d(x,z) + d(z,y). For example, Levenshtein is a metric distance, but NormalizedLevenshtein is not.

  A lot of nearest-neighbor search algorithms and indexing structures rely on the triangle inequality.


  A few algorithms work by converting strings into sets of n-grams (sequences of n characters, also sometimes called k-shingles). The similarity or distance between the strings is then the similarity or distance between the sets.

  Some of them, like jaccard, consider strings as sets of shingles, and don't consider the number of occurences of each shingle. Others, like cosine similarity, work using what is sometimes called the profile of the strings, which takes into account the number of occurences of each shingle.

  For these algorithms, another use case is possible when dealing with large datasets:
  1. compute the set or profile representation of all the strings
  2. compute the similarity between sets or profiles


  The Levenshtein distance between two words is the minimum number of single-character edits (insertions, deletions or substitutions) required to change one word into the other.

  It is a metric string distance. This implementation uses dynamic programming (Wagner–Fischer algorithm), with only 2 rows of data. The space requirement is thus O(m) and the algorithm runs in O(m.n).

  ```python
  from strsimpy.levenshtein import Levenshtein

  levenshtein = Levenshtein()
  print(levenshtein.distance('My string', 'My $string'))
  print(levenshtein.distance('My string', 'My $string'))
  print(levenshtein.distance('My string', 'My $string'))

  ```



  This distance is computed as levenshtein distance divided by the length of the longest string. The resulting value is always in the interval [0.0 1.0] but it is not a metric anymore!

  The similarity is computed as 1 - normalized distance.

  ```python
  from strsimpy.normalized_levenshtein import NormalizedLevenshtein

  normalized_levenshtein = NormalizedLevenshtein()
  print(normalized_levenshtein.distance('My string', 'My $string'))
  print(normalized_levenshtein.distance('My string', 'My $string'))
  print(normalized_levenshtein.distance('My string', 'My $string'))

  print(normalized_levenshtein.similarity('My string', 'My $string'))
  print(normalized_levenshtein.similarity('My string', 'My $string'))
  print(normalized_levenshtein.similarity('My string', 'My $string'))

  ```


  An implementation of Levenshtein that allows to define different weights for different character substitutions.

  This algorithm is usually used for optical character recognition (OCR) applications. For OCR, the cost of substituting P and R is lower then the cost of substituting P and M for example because because from and OCR point of view P is similar to R.

  It can also be used for keyboard typing auto-correction. Here the cost of substituting E and R is lower for example because these are located next to each other on an AZERTY or QWERTY keyboard. Hence the probability that the user mistyped the characters is higher.

  ```python
  from strsimpy.weighted_levenshtein import WeightedLevenshtein


  def insertion_cost(char):
      return 1.0


  def deletion_cost(char):
      return 1.0


  def substitution_cost(char_a, char_b):
      if char_a == 't' and char_b == 'r':
          return 0.5
      return 1.0

  weighted_levenshtein = WeightedLevenshtein(
      substitution_cost_fn=substitution_cost,
      insertion_cost_fn=insertion_cost,
      deletion_cost_fn=deletion_cost)
  print(weighted_levenshtein.distance('String1', 'String2'))

  ```


  Similar to Levenshtein, Damerau-Levenshtein distance with transposition (also sometimes calls unrestricted Damerau-Levenshtein distance) is the minimum number of operations needed to transform one string into the other, where an operation is defined as an insertion, deletion, or substitution of a single character, or a **transposition of two adjacent characters**.

  It does respect triangle inequality, and is thus a metric distance.

  This is not to be confused with the optimal string alignment distance, which is an extension where no substring can be edited more than once.

  ```python
  from strsimpy.damerau import Damerau

  damerau = Damerau()
  print(damerau.distance('ABCDEF', 'ABDCEF'))
  print(damerau.distance('ABCDEF', 'BACDFE'))
  print(damerau.distance('ABCDEF', 'ABCDE'))
  print(damerau.distance('ABCDEF', 'BCDEF'))
  print(damerau.distance('ABCDEF', 'ABCGDEF'))
  print(damerau.distance('ABCDEF', 'POIU'))

  ```

  Will produce:

  ```
  1.0
  2.0
  1.0
  1.0
  1.0
  6.0
  ```


  The Optimal String Alignment variant of Damerau–Levenshtein (sometimes called the restricted edit distance) computes the number of edit operations needed to make the strings equal under the condition that **no substring is edited more than once**, whereas the true Damerau–Levenshtein presents no such restriction.
  The difference from the algorithm for Levenshtein distance is the addition of one recurrence for the transposition operations.

  Note that for the optimal string alignment distance, the triangle inequality does not hold and so it is not a true metric.

  ```python
  from strsimpy.optimal_string_alignment import OptimalStringAlignment

  optimal_string_alignment = OptimalStringAlignment()
  print(optimal_string_alignment.distance('CA', 'ABC'))

  ```

  Will produce:

  ```
  3.0
  ```


  Jaro-Winkler is a string edit distance that was developed in the area of record linkage (duplicate detection) (Winkler, 1990). The Jaro–Winkler distance metric is designed and best suited for short strings such as person names, and to detect typos.

  Jaro-Winkler computes the similarity between 2 strings, and the returned value lies in the interval [0.0, 1.0].
  It is (roughly) a variation of Damerau-Levenshtein, where the substitution of 2 close characters is considered less important then the substitution of 2 characters that a far from each other.

  The distance is computed as 1 - Jaro-Winkler similarity.

  ```python
  from strsimpy.jaro_winkler import JaroWinkler

  jarowinkler = JaroWinkler()
  print(jarowinkler.similarity('My string', 'My tsring'))
  print(jarowinkler.similarity('My string', 'My ntrisg'))

  ```

  will produce:

  ```
  0.9740740740740741
  0.8962962962962963
  ```



  The longest common subsequence (LCS) problem consists in finding the longest subsequence common to two (or more) sequences. It differs from problems of finding common substrings: unlike substrings, subsequences are not required to occupy consecutive positions within the original sequences.

  It is used by the diff utility, by Git for reconciling multiple changes, etc.

  The LCS distance between strings X (of length n) and Y (of length m) is n + m - 2 |LCS(X, Y)|
  min = 0
  max = n + m

  LCS distance is equivalent to Levenshtein distance when only insertion and deletion is allowed (no substitution), or when the cost of the substitution is the double of the cost of an insertion or deletion.

  This class implements the dynamic programming approach, which has a space requirement O(m.n), and computation cost O(m.n).

  In "Length of Maximal Common Subsequences", K.S. Larsen proposed an algorithm that computes the length of LCS in time O(log(m).log(n)). But the algorithm has a memory requirement O(m.n²) and was thus not implemented here.

  ```python
  from strsimpy.longest_common_subsequence import LongestCommonSubsequence
  lcs = LongestCommonSubsequence()
  print(lcs.distance('AGCAT', 'GAC'))
  4
  print(lcs.length('AGCAT', 'GAC'))
  2
  print(lcs.distance('AGCAT', 'AGCT'))
  1
  print(lcs.length('AGCAT', 'AGCT'))
  4

  ```


  Distance metric based on Longest Common Subsequence, from the notes "An LCS-based string metric" by Daniel Bakkelund.
  http://heim.ifi.uio.no/~danielry/StringMetric.pdf

  The distance is computed as 1 - |LCS(s1, s2)| / max(|s1|, |s2|)

  ```python
  from strsimpy.metric_lcs import MetricLCS

  metric_lcs = MetricLCS()
  s1 = 'ABCDEFG'
  s2 = 'ABCDEFHJKL'




  print(metric_lcs.distance(s1, s2))




  print(metric_lcs.distance('ABDEF', 'ABDIF'))

  ```

  will produce:

  ```
  0.4
  0.19999999999999996
  ```




  Normalized N-Gram distance as defined by Kondrak, "N-Gram Similarity and Distance", String Processing and Information Retrieval, Lecture Notes in Computer Science Volume 3772, 2005, pp 115-126.

  http://webdocs.cs.ualberta.ca/~kondrak/papers/spire05.pdf

  The algorithm uses affixing with special character '\n' to increase the weight of first characters. The normalization is achieved by dividing the total similarity score the original length of the longest word.

  In the paper, Kondrak also defines a similarity measure, which is not implemented (yet).

  ```python
  from strsimpy.ngram import NGram

  twogram = NGram(2)
  print(twogram.distance('ABCD', 'ABTUIO'))

  s1 = 'Adobe CreativeSuite 5 Master Collection from cheap 4zp'
  s2 = 'Adobe CreativeSuite 5 Master Collection from cheap d1x'
  fourgram = NGram(4)
  print(fourgram.distance(s1, s2))

  ```


  A few algorithms work by converting strings into sets of n-grams (sequences of n characters, also sometimes called k-shingles). The similarity or distance between the strings is then the similarity or distance between the sets.

  The cost for computing these similarities and distances is mainly domnitated by k-shingling (converting the strings into sequences of k characters). Therefore there are typically two use cases for these algorithms:

  Directly compute the distance between strings:

  ```python
  from strsimpy.qgram import QGram

  qgram = QGram(2)
  print(qgram.distance('ABCD', 'ABCE'))

  ```

  Or, for large datasets, pre-compute the profile of all strings. The similarity can then be computed between profiles:

  ```python
  from strsimpy.cosine import Cosine

  cosine = Cosine(2)
  s0 = 'My first string'
  s1 = 'My other string...'
  p0 = cosine.get_profile(s0)
  p1 = cosine.get_profile(s1)
  print(cosine.similarity_profiles(p0, p1))

  ```

  Pay attention, this only works if the same KShingling object is used to parse all input strings !



  Q-gram distance, as defined by Ukkonen in "Approximate string-matching with q-grams and maximal matches"
  http://www.sciencedirect.com/science/article/pii/0304397592901434

  The distance between two strings is defined as the L1 norm of the difference of their profiles (the number of occurences of each n-gram): SUM( |V1_i - V2_i| ). Q-gram distance is a lower bound on Levenshtein distance, but can be computed in O(m + n), where Levenshtein requires O(m.n)



  The similarity between the two strings is the cosine of the angle between these two vectors representation, and is computed as V1 . V2 / (|V1| * |V2|)

  Distance is computed as 1 - cosine similarity.


  Like Q-Gram distance, the input strings are first converted into sets of n-grams (sequences of n characters, also called k-shingles), but this time the cardinality of each n-gram is not taken into account. Each input string is simply a set of n-grams. The Jaccard index is then computed as |V1 inter V2| / |V1 union V2|.

  Distance is computed as 1 - similarity.
  Jaccard index is a metric distance.


  Similar to Jaccard index, but this time the similarity is computed as 2 * |V1 inter V2| / (|V1| + |V2|).

  Distance is computed as 1 - similarity.


  Very similar to Jaccard and Sorensen-Dice measures, but this time the similarity is computed as |V1 inter V2| / Min(|V1|,|V2|). Tends to yield higher similarity scores compared to the other overlapping coefficients. Always returns the highest similarity score (1) if one given string is the subset of the other.

  Distance is computed as 1 - similarity.




  SIFT4 is a general purpose string distance algorithm inspired by JaroWinkler and Longest Common Subsequence. It was developed to produce a distance measure that matches as close as possible to the human perception of string distance. Hence it takes into account elements like character substitution, character distance, longest common subsequence etc. It was developed using experimental testing, and without theoretical background.

  ```python
  from strsimpy import SIFT4

  s = SIFT4()


  s.distance('This is the first string', 'And this is another string') # 11.0

  s.distance('Lorem ipsum dolor sit amet, consectetur adipiscing elit.', 'Amet Lorm ispum dolor sit amet, consetetur adixxxpiscing elit.', maxoffset=10)
  ```


  * [StringSimilarity.NET](https://github.com/feature23/StringSimilarity.NET) a .NET port of java-string-similarity

  Use java-string-similarity in your project and want it to be mentioned here? Don't hesitate to drop me a line!


pkgId: f64aadca465c890c82ea1eb0da369f434d96805a45522ecc73ad078ed9a3c848
name: python-stuf
arch: src
version: 0.9.16
epoch: 0
release: 1
url: https://bitbucket.org/lcrees/stuf
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4fa48b90-cf6e-4d74-945e-9fcc51c369c6
location_href: 00005236-python-stuf/python-stuf-0.9.16-1.src.rpm
checksum_type: sha256
summary:
  Normal, default, ordered, chained, restricted, counter, and frozen dictionaries with attribute-style access.

description:
  A collection of Python dictionary types that support attribute-style access.
  Includes *defaultdict*,  *OrderedDict*, restricted, *ChainMap*, *Counter*, and
  frozen implementations plus miscellaneous utilities for writing Python software.


pkgId: e84da9abbe98cee05369118a1be22245efcba9e2b5d7e0831f5e9139d524f9d0
name: python-subarulink
arch: src
version: 0.7.5
epoch: 0
release: 1
summary: A package for interacting with Subaru Starlink Remote Services API.
url: https://github.com/G-Two/subarulink
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4c062e4a-c907-4bdf-867c-fac8b81f2441
location_href: 00005237-python-subarulink/python-subarulink-0.7.5-1.src.rpm
checksum_type: sha256
description:
  A python package for interacting with [Subaru STARLINK](https://www.subaru.com/owners/starlink/safety-security.html) remote vehicle services to obtain information about a vehicle as well as actuate exposed features such as locks, horn, lights and remote start. This package requires an active subscription to Subaru's STARLINK service, which is currently only available in the United States and Canada.

  This package was developed primarily for enabling [Home Assistant](https://www.home-assistant.io/) integration, however it may also be used for standalone applications.  A basic python console application is included as an example.

  This package supports Subaru STARLINK equipped vehicles with active service plans. A [MySubaru](https://www.mysubaru.com) account must be setup prior to using this package. The features available will depend on the model year and type of service plan (Safety Plus or Safety/Security Plus).


  | Model Year   | Safety Plus | Security Plus |
  |--------------|-------------|---------------|
  | 2016-2018    |  No Support | Remote Lock/Unlock <br> Remote Horn and/or Lights <br> Remote Vehicle Locator <br> Odometer (updated every 500 miles)
  | 2019+        |  Tire Pressure# <br> Fuel Economy# <br> Fuel Range# <br> Odometer#     |Remote Lock/Unlock <br> Remote Horn and/or Lights <br> Remote Vehicle Locator <br> Remote Engine Start w/ Climate Control <br> PHEV Start Charge* <br> Door/Window Status** <br> Tire Pressure <br> Fuel Economy <br> Fuel Range <br> Odometer

  \# Unclear how often this is updated <br>
  \* Plug-In hybrid only <br>
  \*\* Support varies by model

  **NOTE:**  This project was developed based upon analysis of the official MySubaru Android app. Subaru has no official public API; therefore, this library may stop working at any time without warning.  Use at your own risk.




  There is a Home Assistant [custom component](https://github.com/G-Two/homeassistant-subaru) that uses this package and allows users to add Subaru STARLINK integration to their Home Assistant instance.

  In addition, as of 2021.3, Home Assistant Core includes the [Subaru integration](https://www.home-assistant.io/integrations/subaru/) that uses this package. Due to the required incremental additions required by Home Assistant Core, only the sensor and lock platforms are supported at this time. Additional PRs are pending to add full functionality. Users that desire the most recent features should continue using the custom component.


  To use this module's included standalone console application or include the package in an application, install from PyPI:

      $ pip install subarulink

  For API documentation, see [DEVELOPERS.md](DEVELOPERS.md)


  The PyPI installation includes a basic console application.  The application can either be run interactively or used to issue a single command.  The single command function requires a working config file to function properly (config file is automatically created during the first interactive run).  Note that not all exposed functions are supported by all vehicles. Consult your subscription details to determine which commands apply to your vehicle.

  ```
  usage: subarulink [-h] [-i] [-c CONFIG_FILE] [-v {0,1,2}]
             {status,lock,unlock,lights,horn,locate,remote_start,remote_stop,charge}
             ...

  optional arguments:
    -h, --help            show this help message and exit
    -i, --interactive     interactive mode
    -c CONFIG_FILE, --config CONFIG_FILE
                          specify config file (default is ~/.config/subarulink/subarulink.cfg
    -v {0,1,2}, --verbosity {0,1,2}
                          verbosity level: 0=error[default] 1=info 2=debug

  command:
    execute single command and exit

    {status,lock,unlock,lights,horn,locate,remote_start,remote_stop,charge}
      status              get vehicle status information
      lock                lock doors
      unlock              unlock doors
      lights              turn on lights
      horn                sound horn
      locate              locate vehicle
      remote_start        remote engine start
      remote_stop         remote engine stop
      charge              start PHEV charging
  ```
  STARLINK accounts with multiple vehicles will need to specify the VIN for single commands.  This can be done in two ways:
  - Set a default VIN while in interactive mode, which will be saved to the configuration file and used for all single commands
  - Specify a VIN from the command line with --vin.  This will override the default VIN in the configuration file
  Accounts with only one vehicle do not need to specify a VIN


  A JSON file is used for configuration. A user provided file can be passed to the CLI via the `--config`. If no config file is provided, two default locations are searched for. First is `~/.subarulink.cfg` and if that is not found, `$XDG_CONFIG_HOME/subarulink/subarulink.cfg` will be used.



  Aggressively polling the vehicle location with subarulink.Controller.update(vin) may discharge the auxiliary battery (in a PHEV).  Intermittent (every 2 hours) use isn't a problem, but polling at 5 minute intervals will drain the auxiliary battery fully after a few consecutive non-driving days.  The vehicle does report the auxiliary battery voltage with every update, so this can be avoided.

  Effects of aggressive polling on the battery of a gasoline-only vehicle are unknown.


  Sensor data is only sent by the vehicle during certain events (e.g. engine shutdown or a user requested location update) and should not be relied on to indicate a vehicle's real time status. If more recent data is desired, then the user must initiate a location update which will update the data for all sensors (exception: tire pressures will only be updated if the vehicle is in motion).


  Options exposed by the API don't necessarily represent the remote capability of the vehicle. Selecting options not supported by your vehicle will either be ignored or cause the remote command to fail.

  Known examples include:
  - Crosstreks with front heated seats cannot be activated remotely. The option is ignored by the telematics provider and/or vehicle.
  - Crosstrek PHEVs do not support `climateZoneFrontAirVolume = AUTO` or `climateZoneFrontAirMode = AUTO`. Selecting these will cause the command to fail at the telematics gateway or the vehicle.

  Best practice is to create presets in the official mobile app or website to ensure they are compatible with your vehicle. Any presets created through official means are automatically available to this package.


  The data returned by the Subaru API is sometimes invalid. The returned data is checked for erroneous values.  If they are invalid, the local cache will retain the last sane value.


  Some of the fields that would be useful are always reported back as "UNKNOWN".  Examples include door lock state, window state (on some vehicles), etc.


  - Inspired by the [teslajsonpy](https://github.com/zabuldon/teslajsonpy) package
  - Thanks to all the Subaru owners that have provided feedback and data from their vehicles


  - The most recent "g3" telematics generation appears to support more functions (e.g. tailgate unlocking and more useful sensor data). If you have a newer vehicle, please post debug logs (after sanitizing personal info) in the discussion area or open a new issue to ensure this package uses all the data that is provided by your vehicle.
  - Feature additions and code quality contributions are always welcome.


pkgId: 9c1afb4952e626f9fb647f7349568d64574eadde54fba295c9320c6d8e387c1f
name: python-subprocess32
arch: src
version: 3.5.4
epoch: 0
release: 1
summary: A backport of the subprocess module from Python 3 for use on 2.x.
url: https://github.com/google/python-subprocess32
rpm_license: PSF license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-02b2ab17-46f7-494c-aa74-b8f86514d672
location_href: 00009467-python-subprocess32/python-subprocess32-3.5.4-1.src.rpm
checksum_type: sha256
description:
  This is a backport of the subprocess standard library module from
  Python 3.2 - 3.5 for use on Python 2.

  It includes bugfixes and some new features.  On POSIX systems it is
  guaranteed to be reliable when used in threaded applications.
  It includes timeout support from Python 3.3 and the run() API from 3.5
  but otherwise matches 3.2's API.

  It has not been tested by the author on Windows.

  On Python 3, it merely redirects the subprocess32 name to subprocess.


pkgId: defded804ba088eee1070467c19e9060d522c7a987f874cc4a4689399cb25894
name: python-subvertpy
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: Alternative Python bindings for Subversion
url: https://jelmer.uk/subvertpy
rpm_license: LGPLv2.1 or later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b7462119-dbfe-4a19-836b-db8148f84d0f
location_href: 00005240-python-subvertpy/python-subvertpy-0.11.0-1.src.rpm
checksum_type: sha256
description:
  subvertpy covers more of the APIs than python-svn. It provides a more
  "Pythonic" API than python-subversion, which wraps the Subversion C API pretty
  much directly. Neither provide a hookable server-side.


pkgId: e0b411df713dbfe2e16028da26f89769e864338d165e665c0ff96c79c592e0a8
name: python-suds-py3
arch: src
version: 1.4.5.0
epoch: 0
release: 1
summary: Lightweight SOAP client
url: https://github.com/cackharot/suds-py3
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-789ee7b5-c476-4886-9b1e-69b0fad1a2cd
location_href: 00009977-python-suds-py3/python-suds-py3-1.4.5.0-1.src.rpm
checksum_type: sha256
description:
  The "suds-p3" is a lightweight soap-based client for python3
      licensed under LGPL. This is a mirror of http://svn.fedorahosted.org/svn/suds/trunk/
      supporting Python3 and some fixes.


pkgId: 47dfe832891b76271e9e9cf0c0fd25ebbfba029b1a01ada08ed16aaa25140756
name: python-suntime
arch: src
version: 1.2.5
epoch: 0
release: 1
summary: Simple sunset and sunrise time calculation python library
url: https://github.com/SatAgro/suntime
rpm_license: LGPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fa13f210-4efd-4d35-93fe-9a00c58d525d
location_href: 00009636-python-suntime/python-suntime-1.2.5-1.src.rpm
checksum_type: sha256
description:
  Simple sunset and sunrise time calculation python library.



  Using pip:

      pip3 install suntime

  Or download and type:

      python3 setup.py install



  You can use the library to get UTC and local time sunrise and sunset times typing:

  ```python3
  import datetime
  from suntime import Sun, SunTimeException

  latitude = 51.21
  longitude = 21.01

  sun = Sun(latitude, longitude)


  today_sr = sun.get_sunrise_time()
  today_ss = sun.get_sunset_time()
  print('Today at Warsaw the sun raised at {} and get down at {} UTC'.
        format(today_sr.strftime('%H:%M'), today_ss.strftime('%H:%M')))


  abd = datetime.date(2014, 10, 3)
  abd_sr = sun.get_local_sunrise_time(abd)
  abd_ss = sun.get_local_sunset_time(abd)
  print('On {} the sun at Warsaw raised at {} and get down at {}.'.
        format(abd, abd_sr.strftime('%H:%M'), abd_ss.strftime('%H:%M')))


  latitude = 87.55
  longitude = 0.1
  sun = Sun(latitude, longitude)
  try:
      abd_sr = sun.get_local_sunrise_time(abd)
      abd_ss = sun.get_local_sunset_time(abd)
      print('On {} at somewhere in the north the sun raised at {} and get down at {}.'.
            format(abd, abd_sr.strftime('%H:%M'), abd_ss.strftime('%H:%M')))
  except SunTimeException as e:
      print("Error: {0}.".format(e))
  ```



  Copyright © 2019 SatAgro Sp. z o.o. and contributors:

  * Krzysztof Stopa ([kstopa](https://github.com/kstopa))
  * Andrey Kobyshev ([yokotoka](https://github.com/yokotoka))
  * Matthias ([palto42](https://github.com/plato42))
  * Hadrien Bertrand ([hbertrand](https://github.com/hbertrand))


  This file is part of SunTime library for python (SunTime).

  SunTime is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or any later version.

  SunTime 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 Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License along with CAMS tools. If not, see http://www.gnu.org/licenses/.


pkgId: 94f387fde46bcd9c9587100f6abb98191d567d813d8368b086462cd842947bcc
name: python-superlance
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: superlance plugins for supervisord
url: https://github.com/Supervisor/superlance
rpm_license: BSD-derived (http://www.repoze.org/LICENSE.txt)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-896ca02f-92dc-4dff-908b-27e2de57f309
location_href: 00012841-python-superlance/python-superlance-2.0.0-1.src.rpm
checksum_type: sha256
description:
  Superlance is a package of plugin utilities for monitoring and controlling
  processes that run under `supervisor <http://supervisord.org>`_.
  Please see ``docs/index.rst`` for complete documentation.


pkgId: 9c80daff0aa6f1b71d1a3e3c3b68ce0b1358bd97826510c8f787acec8b6fdc69
name: python-supermercado
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Supercharged mercantile
url: https://github.com/mapbox/supermercado
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-35a7fab4-1db3-416d-b922-5598d702e6cb
location_href: 00010870-python-supermercado/python-supermercado-0.2.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/mapbox/supermercado.svg?branch=master)](https://travis-ci.org/mapbox/supermercado) [![codecov.io](https://codecov.io/github/mapbox/supermercado/coverage.svg?token=qkqtUNdabO&branch=master)](https://codecov.io/github/mapbox/supermercado?branch=master)
  `supermercado` extends the functionality of [`mercantile`](https://github.com/mapbox/mercantile) with additional commands


pkgId: 637801916cd6fdd4a2fc25566fa98d22e26cb49320234d07924252001e4f6a29
name: python-supersmoother
arch: src
version: 0.4
epoch: 0
release: 1
summary: Python implementation of Friedman's Supersmoother
url: http://github.com/jakevdp/supersmoother
rpm_license: BSD 3-clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-adc80e60-ded1-4148-87c1-c479966b66b3
location_href: 00005242-python-supersmoother/python-supersmoother-0.4-1.src.rpm
checksum_type: sha256
description:
  This is an efficient implementation of Friedman's SuperSmoother based in
  Python. It makes use of numpy for fast numerical computation.
  For more information, see the github project page:
  http://github.com/jakevdp/supersmoother


pkgId: 1fc027af49fdccebc49947bbf2908828f793f56053b446633b6e9e98e9acda75
name: python-supervisor
arch: src
version: 4.2.5
epoch: 0
release: 1
summary: A system for controlling process state under UNIX
url: http://supervisord.org/
rpm_license: BSD-derived (http://www.repoze.org/LICENSE.txt)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5cdbda8e-649c-4101-849a-b11426bc6524
location_href: 00009698-python-supervisor/python-supervisor-4.2.5-1.src.rpm
checksum_type: sha256
description:
  Supervisor is a client/server system that allows its users to
  control a number of processes on UNIX-like operating systems.


pkgId: 0a12d194ba0d83e727a95d3dd927535f1937b21ad2e24b015e1a7bded9903f4f
name: python-sure
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: utility belt for automated testing in python for python
url: http://github.com/gabrielfalcao/sure
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-06edf424-89fc-4a51-86ea-11f244e9988f
location_href: 00011119-python-sure/python-sure-2.0.1-1.src.rpm
checksum_type: sha256
description:
  An idiomatic testing library for python with powerful and flexible assertions, created by `Gabriel Falcão <https://github.com/gabrielfalcao>`_.
  Sure's developer experience is inspired and modeled after `RSpec Expectations
  <http://rspec.info/documentation/3.5/rspec-expectations/>`_ and
  `should.js <https://github.com/shouldjs/should.js>`_.


pkgId: ff9125a583c2ecb520f081076619858a5ea4aca212ee6c560e73c78957bfc455
name: python-sushy
arch: src
version: 4.4.2
epoch: 0
release: 1
summary: Sushy is a small Python library to communicate with Redfish based systems
url: https://docs.openstack.org/sushy/latest/
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f7143234-5f1b-41a4-b43f-6c0a46b0f309
location_href: 00005243-python-sushy/python-sushy-4.4.2-1.src.rpm
checksum_type: sha256
description:
  Sushy is a Python library to communicate with `Redfish`_ based systems.
  The goal of the library is to be extremely simple, small, have as few
  dependencies as possible and be very conservative when dealing with BMCs
  by issuing just enough requests to it (BMCs are very flaky).
  Therefore, the scope of the library has been limited to what is supported
  by the `OpenStack Ironic <https://wiki.openstack.org/wiki/Ironic>`_
  project. As the project grows and more features from `Redfish`_ are
  needed we can expand Sushy to fulfill those requirements.
  * Free software: Apache license
  * Includes Redfish registry files licensed under
      Creative Commons Attribution 4.0 License:
      https://creativecommons.org/licenses/by/4.0/
  * Documentation: https://docs.openstack.org/sushy/latest/
  * Usage: https://docs.openstack.org/sushy/latest/reference/usage.html
  * Source: https://opendev.org/openstack/sushy
  * Bugs: https://storyboard.openstack.org/#!/project/960


pkgId: 9b49e143020d6963bf3846630c61b9f0a9985b3d16a559eb11141c0d76d975fd
name: python-svg.path
arch: src
version: 6.2
epoch: 0
release: 1
summary: SVG path objects and parser
url: https://github.com/regebro/svg.path
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-89681f6e-0d5a-47c1-ac71-bad855b18cbd
location_href: 00005246-python-svg-path/python-svg.path-6.2-1.src.rpm
checksum_type: sha256
description:
  svg.path is a collection of objects that implement the different path
  commands in SVG, and a parser for SVG path definitions.


pkgId: f8dd6c4b1587c8aa5572e8e9f4761dc25fcd7d4bf767e2a24dbb07ade0229edc
name: python-svgwrite
arch: src
version: 1.4.3
epoch: 0
release: 1
summary: A Python library to create SVG drawings.
url: http://github.com/mozman/svgwrite.git
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0022b07c-bd74-464c-8e6c-2eeee89c9c20
location_href: 00005247-python-svgwrite/python-svgwrite-1.4.3-1.src.rpm
checksum_type: sha256
description:
  This package is inactive! No new features will be added, there will
  be no change of behavior, just bugfixes will be merged.


pkgId: 02919d0378663d245ce979bdee06ff028ef29cdce1405ffd2f1f9c89b70b2d73
name: python-sword
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: A fast, sharp, Python C extension for data mining.
url: https://github.com/jweinst1/sword
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-998c2d3b-8937-4270-9505-69f5a718dd5d
location_href: 00005250-python-sword/python-sword-0.0.3-1.src.rpm
checksum_type: sha256
description:
  *A Fast Data Mining C Library for Python*



  `sword` is a Python C Extension for making data mining and data searching super fast. It's designed to
  give you amazing performance in the comfort and simplicity of Python. `sword` offers a wide array of tools
  to parse and search tabular data, csv, xml, and much more.



  `sword` is still in the active development phase. It currently supports some CSV functionality. More detailed
  and rich features will be released in coming patch releases.




  `sword` currently provides the following functions:





  This function reads a single CSV row from a string, and returns a tuple containing:

  * The list containing the row elements.
  * The remaining unread string.

  *Example:*

  ```py
  >>> import sword
  >>> sword.csv_read_row("54.7,32.6,54.7\n")
  ([b'54.7', b'32.6', b'54.7'], b'\n')
  ```



  Counts the number of rows in a CSV-string

  *Exmaple:*

  ```py
  >>> import sword
  >>> sword.csv_count_rows("1,2\n3,4\n5,5,5,5\n")
  3
  ```




  Counts the number of columns in a CSv-string

  *Example:*

  ```py
  >>> import sword
  >>> sword.csv_count_cols("1,2,3,4\n")
  4
  ```


pkgId: 3b7e5dee9d8ee9d4b1771070a79cfeb26082b621872927763cd9370957e2542b
name: python-sybil
arch: src
version: 4.0.1
epoch: 0
release: 1
summary: Automated testing for the examples in your code and documentation.
url: https://github.com/simplistix/sybil
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e0eae8f8-23c3-4581-81d3-0f5e2e39a484
location_href: 00005251-python-sybil/python-sybil-4.0.1-1.src.rpm
checksum_type: sha256
description:
  |CircleCI|_ |Docs|_
  This library provides a way to check examples in your code and documentation by parsing
  them from their source and evaluating the parsed examples as part of
  your normal test run. Integration is provided for the main Python test
  runners.
  The `documentation <https://sybil.readthedocs.io/>`__ is the best place to start.


pkgId: aa297725101fd5e4421befc988241168e0fc33cb8fb93ecabe5d774e1377eb28
name: python-sympy
arch: src
version: 1.11.1
epoch: 0
release: 1
summary: Computer algebra system (CAS) in Python
url: https://sympy.org
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3edcfbd0-3716-4a75-8daa-5070f022b3a3
location_href: 00005252-python-sympy/python-sympy-1.11.1-1.src.rpm
checksum_type: sha256
description:
  [![pypi version](https://img.shields.io/pypi/v/sympy.svg)](https://pypi.python.org/pypi/sympy)
  [![Build status](https://secure.travis-ci.org/sympy/sympy.svg?branch=master)](https://travis-ci.org/sympy/sympy)
  [![Join the chat at https://gitter.im/sympy/sympy](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/sympy/sympy?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
  [![Zenodo Badge](https://zenodo.org/badge/18918/sympy/sympy.svg)](https://zenodo.org/badge/latestdoi/18918/sympy/sympy)
  [![Downloads](https://pepy.tech/badge/sympy/month)](https://pepy.tech/project/sympy)
  [![GitHub Issues](https://img.shields.io/badge/issue_tracking-github-blue.svg)](https://github.com/sympy/sympy/issues)
  [![Git Tutorial](https://img.shields.io/badge/PR-Welcome-%23FF8300.svg?)](https://git-scm.com/book/en/v2/GitHub-Contributing-to-a-Project)
  [![Powered by NumFocus](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](https://numfocus.org)
  [![Commits since last release](https://img.shields.io/github/commits-since/sympy/sympy/latest.svg?longCache=true&style=flat-square&logo=git&logoColor=fff)](https://github.com/sympy/sympy/releases)

  [![SymPy Banner](https://github.com/sympy/sympy/raw/master/banner.svg)](https://sympy.org/)


  See the [AUTHORS](AUTHORS) file for the list of authors.

  And many more people helped on the SymPy mailing list, reported bugs,
  helped organize SymPy's participation in the Google Summer of Code, the
  Google Highly Open Participation Contest, Google Code-In, wrote and
  blogged about SymPy...

  License: New BSD License (see the [LICENSE](LICENSE) file for details) covers all
  files in the sympy repository unless stated otherwise.

  Our mailing list is at
  <https://groups.google.com/forum/?fromgroups#!forum/sympy>.

  We have a community chat at [Gitter](https://gitter.im/sympy/sympy). Feel
  free to ask us anything there. We have a very welcoming and helpful
  community.



  The recommended installation method is through Anaconda,
  <https://www.anaconda.com/download/>

  You can also get the latest version of SymPy from
  <https://pypi.python.org/pypi/sympy/>

  To get the git version do

      $ git clone https://github.com/sympy/sympy.git

  For other options (tarballs, debs, etc.), see
  <https://docs.sympy.org/dev/install.html>.



  For in-depth instructions on installation and building the
  documentation, see the [SymPy Documentation Style Guide](https://docs.sympy.org/dev/documentation-style-guide.html).

  Everything is at:

  <https://docs.sympy.org/>

  You can generate everything at the above site in your local copy of
  SymPy by:

      $ cd doc
      $ make html

  Then the docs will be in <span class="title-ref">\_build/html</span>. If
  you don't want to read that, here is a short usage:

  From this directory, start Python and:

  ``` python
  >>> from sympy import Symbol, cos
  >>> x = Symbol('x')
  >>> e = 1/cos(x)
  >>> print(e.series(x, 0, 10))
  1 + x**2/2 + 5*x**4/24 + 61*x**6/720 + 277*x**8/8064 + O(x**10)
  ```

  SymPy also comes with a console that is a simple wrapper around the
  classic python console (or IPython when available) that loads the SymPy
  namespace and executes some common commands for you.

  To start it, issue:

      $ bin/isympy

  from this directory, if SymPy is not installed or simply:

      $ isympy

  if SymPy is installed.



  SymPy has a hard dependency on the [mpmath](http://mpmath.org/) library
  (version \>= 0.19). You should install it first, please refer to the
  mpmath installation guide:

  <https://github.com/fredrik-johansson/mpmath#1-download--installation>

  To install SymPy using PyPI, run the following command:

      $ pip install sympy

  To install SymPy using Anaconda, run the following command:

      $ conda install -c anaconda sympy

  To install SymPy from GitHub source, first clone SymPy using `git`:

      $ git clone https://github.com/sympy/sympy.git

  Then, in the `sympy` repository that you cloned, simply run:

      $ python setup.py install

  See <https://docs.sympy.org/dev/install.html> for more information.



  We welcome contributions from anyone, even if you are new to open
  source. Please read our [Introduction to Contributing](https://github.com/sympy/sympy/wiki/Introduction-to-contributing)
  page and the [SymPy Documentation Style Guide](https://docs.sympy.org/dev/documentation-style-guide.html). If you
  are new and looking for some way to contribute, a good place to start is
  to look at the issues tagged [Easy to Fix](https://github.com/sympy/sympy/issues?q=is%3Aopen+is%3Aissue+label%3A%22Easy+to+Fix%22).

  Please note that all participants in this project are expected to follow
  our Code of Conduct. By participating in this project you agree to abide
  by its terms. See [CODE\_OF\_CONDUCT.md](CODE_OF_CONDUCT.md).



  To execute all tests, run:

      $./setup.py test

  in the current directory.

  For the more fine-grained running of tests or doctests, use `bin/test`
  or respectively `bin/doctest`. The master branch is automatically tested
  by Travis CI.

  To test pull requests, use
  [sympy-bot](https://github.com/sympy/sympy-bot).



  The parser and lexer were generated with the [ANTLR4](http://antlr4.org)
  toolchain in `sympy/parsing/latex/_antlr` and checked into the repo.
  Presently, most users should not need to regenerate these files, but
  if you plan to work on this feature, you will need the `antlr4`
  command-line tool (and you must ensure that it is in your `PATH`).
  One way to get it is:

      $ conda install -c conda-forge antlr=4.10.1

  Alternatively, follow the instructions on the ANTLR website and download
  the `antlr-4.10.1-complete.jar`. Then export the `CLASSPATH` as instructed
  and instead of creating `antlr4` as an alias, make it an executable file
  with the following contents:
  ``` bash

  java -jar /usr/local/lib/antlr-4.10.1-complete.jar "$@"
  ```

  After making changes to `sympy/parsing/latex/LaTeX.g4`, run:

      $ ./setup.py antlr



  To clean everything (thus getting the same tree as in the repository):

      $ ./setup.py clean

  You can also clean things with git using:

      $ git clean -Xdf

  which will clear everything ignored by `.gitignore`, and:

      $ git clean -df

  to clear all untracked files. You can revert the most recent changes in
  git with:

      $ git reset --hard

  WARNING: The above commands will all clear changes you may have made,
  and you will lose them forever. Be sure to check things with `git
  status`, `git diff`, `git clean -Xn`, and `git clean -n` before doing any
  of those.



  Our issue tracker is at <https://github.com/sympy/sympy/issues>. Please
  report any bugs that you find. Or, even better, fork the repository on
  GitHub and create a pull request. We welcome all changes, big or small,
  and we will help you make the pull request if you are new to git (just
  ask on our mailing list or Gitter Channel). If you further have any queries, you can find answers
  on Stack Overflow using the [sympy](https://stackoverflow.com/questions/tagged/sympy) tag.



  SymPy was started by Ondřej Čertík in 2005, he wrote some code during
  the summer, then he wrote some more code during summer 2006. In February
  2007, Fabian Pedregosa joined the project and helped fix many things,
  contributed documentation, and made it alive again. 5 students (Mateusz
  Paprocki, Brian Jorgensen, Jason Gedge, Robert Schwarz, and Chris Wu)
  improved SymPy incredibly during summer 2007 as part of the Google
  Summer of Code. Pearu Peterson joined the development during the summer
  2007 and he has made SymPy much more competitive by rewriting the core
  from scratch, which has made it from 10x to 100x faster. Jurjen N.E. Bos
  has contributed pretty-printing and other patches. Fredrik Johansson has
  written mpmath and contributed a lot of patches.

  SymPy has participated in every Google Summer of Code since 2007. You
  can see <https://github.com/sympy/sympy/wiki#google-summer-of-code> for
  full details. Each year has improved SymPy by bounds. Most of SymPy's
  development has come from Google Summer of Code students.

  In 2011, Ondřej Čertík stepped down as lead developer, with Aaron
  Meurer, who also started as a Google Summer of Code student, taking his
  place. Ondřej Čertík is still active in the community but is too busy
  with work and family to play a lead development role.

  Since then, a lot more people have joined the development and some
  people have also left. You can see the full list in doc/src/aboutus.rst,
  or online at:

  <https://docs.sympy.org/dev/aboutus.html#sympy-development-team>

  The git history goes back to 2007 when development moved from svn to hg.
  To see the history before that point, look at
  <https://github.com/sympy/sympy-old>.

  You can use git to see the biggest developers. The command:

      $ git shortlog -ns

  will show each developer, sorted by commits to the project. The command:

      $ git shortlog -ns --since="1 year"

  will show the top developers from the last year.



  To cite SymPy in publications use

  > Meurer A, Smith CP, Paprocki M, Čertík O, Kirpichev SB, Rocklin M,
  > Kumar A, Ivanov S, Moore JK, Singh S, Rathnayake T, Vig S, Granger BE,
  > Muller RP, Bonazzi F, Gupta H, Vats S, Johansson F, Pedregosa F, Curry
  > MJ, Terrel AR, Roučka Š, Saboo A, Fernando I, Kulal S, Cimrman R,
  > Scopatz A. (2017) SymPy: symbolic computing in Python. *PeerJ Computer
  > Science* 3:e103 <https://doi.org/10.7717/peerj-cs.103>

  A BibTeX entry for LaTeX users is

  ``` bibtex
  @article{10.7717/peerj-cs.103,
   title = {SymPy: symbolic computing in Python},
   author = {Meurer, Aaron and Smith, Christopher P. and Paprocki, Mateusz and \v{C}ert\'{i}k, Ond\v{r}ej and Kirpichev, Sergey B. and Rocklin, Matthew and Kumar, Amit and Ivanov, Sergiu and Moore, Jason K. and Singh, Sartaj and Rathnayake, Thilina and Vig, Sean and Granger, Brian E. and Muller, Richard P. and Bonazzi, Francesco and Gupta, Harsh and Vats, Shivam and Johansson, Fredrik and Pedregosa, Fabian and Curry, Matthew J. and Terrel, Andy R. and Rou\v{c}ka, \v{S}t\v{e}p\'{a}n and Saboo, Ashutosh and Fernando, Isuru and Kulal, Sumith and Cimrman, Robert and Scopatz, Anthony},
   year = 2017,
   month = Jan,
   keywords = {Python, Computer algebra system, Symbolics},
   abstract = {
              SymPy is an open-source computer algebra system written in pure Python. It is built with a focus on extensibility and ease of use, through both interactive and programmatic applications. These characteristics have led SymPy to become a popular symbolic library for the scientific Python ecosystem. This paper presents the architecture of SymPy, a description of its features, and a discussion of select submodules. The supplementary material provides additional examples and further outlines details of the architecture and features of SymPy.
           },
   volume = 3,
   pages = {e103},
   journal = {PeerJ Computer Science},
   issn = {2376-5992},
   url = {https://doi.org/10.7717/peerj-cs.103},
   doi = {10.7717/peerj-cs.103}
  }
  ```

  SymPy is BSD licensed, so you are free to use it whatever you like, be
  it academic, commercial, creating forks or derivatives, as long as you
  copy the BSD statement if you redistribute it (see the LICENSE file for
  details). That said, although not required by the SymPy license, if it
  is convenient for you, please cite SymPy when using it in your work and
  also consider contributing all your changes back, so that we can
  incorporate it and all of us will benefit in the end.


pkgId: 4e74ef0f3caa3d2372786249ee05be0409d003586c2703d83d079f2acd97e512
name: python-sysv-ipc
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: System V IPC primitives (semaphores, shared memory and message queues) for Python
url: http://semanchuk.com/philip/sysv_ipc/
rpm_license: http://creativecommons.org/licenses/BSD/
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f5cc8f5d-0114-49df-b59d-6d02c1eb1781
location_href: 00005255-python-sysv_ipc/python-sysv-ipc-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Sysv_ipc gives Python programs access to System V semaphores, shared memory
  and message queues. Most (all?) Unixes (including OS X) support System V IPC.
  Windows+Cygwin 1.7 might also work.

  Sample code is included.

  sysv_ipc is free software (free as in speech and free as in beer) released
  under a 3-clause BSD license. Complete licensing information is available in
  the LICENSE file.

  You might also be interested in the similar POSIX IPC module at:
  http://semanchuk.com/philip/posix_ipc/


pkgId: 1461c33f05e8081addc010f4fd3703bb4b120c44c327c4c43a83edf3cea0f4ce
name: python-ta
arch: src
version: 0.10.2
epoch: 0
release: 1
summary: Technical Analysis Library in Python
url: https://github.com/bukosabino/ta
rpm_license: The MIT License (MIT)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f11747e5-72b5-4672-8ea0-cf5a6cbbc606
location_href: 00011465-python-ta/python-ta-0.10.2-1.src.rpm
checksum_type: sha256
description:
  It is a Technical Analysis library to financial time series datasets. You can use to do feature engineering. It is built on Python Pandas library.


pkgId: 39d795f3350d29ed624df64149f5e4811961e539ec1c663bc1fd3b190f4b245b
name: python-tableauserverclient
arch: src
version: 0.25
epoch: 0
release: 1
summary: A Python module for working with the Tableau Server REST API.
url: https://pypi.org/project/tableauserverclient/
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4c866dd3-5607-43db-a0d2-9cdd9a12ecf1
location_href: 00009276-python-tableauserverclient/python-tableauserverclient-0.25-1.src.rpm
checksum_type: sha256
description:
  [![Tableau Supported](https://img.shields.io/badge/Support%20Level-Tableau%20Supported-53bd92.svg)](https://www.tableau.com/support-levels-it-and-developer-tools) [![Build Status](https://github.com/tableau/server-client-python/actions/workflows/run-tests.yml/badge.svg)](https://github.com/tableau/server-client-python/actions)
  [![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Ftableau%2Fserver-client-python.svg?type=shield)](https://app.fossa.com/projects/git%2Bgithub.com%2Ftableau%2Fserver-client-python?ref=badge_shield)

  Use the Tableau Server Client (TSC) library to increase your productivity as you interact with the Tableau Server REST API. With the TSC library you can do almost everything that you can do with the REST API, including:

  * Publish workbooks and data sources.
  * Create users and groups.
  * Query projects, sites, and more.

  This repository contains Python source code for the library and sample files showing how to use it. As of May 2022, Python versions 3.7 and up are supported.

  To see sample code that works directly with the REST API (in Java, Python, or Postman), visit the [REST API Samples](https://github.com/tableau/rest-api-samples) repo.

  For more information on installing and using TSC, see the documentation:
  <https://tableau.github.io/server-client-python/docs/>




  [![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Ftableau%2Fserver-client-python.svg?type=large)](https://app.fossa.com/projects/git%2Bgithub.com%2Ftableau%2Fserver-client-python?ref=badge_large)

rpm_license:
  The MIT License (MIT)  Copyright (c) 2022 Tableau  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: ccf11c7a0ba613a021d9fc471e194372fd359b1938c34476a1257430465d5210
name: python-tables
arch: src
version: 3.8.0
epoch: 0
release: 1
summary: Hierarchical datasets for Python
url: https://www.pytables.org
rpm_license: BSD 3-Clause License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b4b25bcd-b969-4e34-a8c9-a1fc644aa684
location_href: 00005256-python-tables/python-tables-3.8.0-1.src.rpm
checksum_type: sha256
description:
  PyTables is a package for managing hierarchical datasets and
  designed to efficiently cope with extremely large amounts of
  data. PyTables is built on top of the HDF5 library and the
  NumPy package and features an object-oriented interface
  that, combined with C-code generated from Cython sources,
  makes of it a fast, yet extremely easy to use tool for
  interactively save and retrieve large amounts of data.


pkgId: 2e68f286f3d0e6284cb567b4548cae29040ac9cacaf70d9d2db31146dd5e68c2
name: python-tableschema
arch: src
version: 1.20.2
epoch: 0
release: 1
summary: A utility library for working with Table Schema in Python
url: https://github.com/frictionlessdata/tableschema-py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3efed00c-886b-4e31-a2d4-074ee4747244
location_href: 00010742-python-tableschema/python-tableschema-1.20.2-1.src.rpm
checksum_type: sha256
description:
  [![Travis](https://travis-ci.org/frictionlessdata/tableschema-py.svg?branch=master)](https://travis-ci.org/frictionlessdata/tableschema-py)
  [![Coveralls](http://img.shields.io/coveralls/frictionlessdata/tableschema-py.svg?branch=master)](https://coveralls.io/r/frictionlessdata/tableschema-py?branch=master)
  [![PyPi](https://img.shields.io/pypi/v/tableschema.svg)](https://pypi.python.org/pypi/tableschema)
  [![Github](https://img.shields.io/badge/github-master-brightgreen)](https://github.com/frictionlessdata/tableschema-py)
  [![Gitter](https://img.shields.io/gitter/room/frictionlessdata/chat.svg)](https://gitter.im/frictionlessdata/chat)

  A Python implementation of the [Table Schema](http://specs.frictionlessdata.io/table-schema/) standard.

  > **[Important Notice]** We have released [Frictionless Framework](https://github.com/frictionlessdata/frictionless-py). This framework provides improved `tableschema` functionality extended to be a complete data solution. The change in not breaking for the existing software so no actions are required. Please read the [Migration Guide](https://framework.frictionlessdata.io/docs/development/migration) from `tableschema` to Frictionless Framework.
  > - we continue to bug-fix `tableschema@1.x` in this [repository](https://github.com/frictionlessdata/tableschema-py) as well as it's available on [PyPi](https://pypi.org/project/tableschema/) as it was before
  > - please note that `frictionless@3.x` version's API, we're working on at the moment, is not stable
  > - we will release `frictionless@4.x` by the end of 2020 to be the first SemVer/stable version



  - `Table` to work with data tables described by Table Schema
  - `Schema` representing Table Schema
  - `Field` representing Table Schema field
  - `validate` to validate Table Schema
  - `infer` to infer Table Schema from data
  - built-in command-line interface to validate and infer schemas
  - storage/plugins system to connect tables to different storage backends like SQL Database



  <!--TOC-->

    - [Getting Started](#getting-started)
      - [Installation](#installation)
    - [Documentation](#documentation)
      - [Introduction](#introduction)
      - [Working with Table](#working-with-table)
      - [Working with Schema](#working-with-schema)
      - [Working with Field](#working-with-field)
    - [API Reference](#api-reference)
      - [`cli`](#cli)
      - [`Table`](#table)
      - [`Schema`](#schema)
      - [`Field`](#field)
      - [`Storage`](#storage)
      - [`validate`](#validate)
      - [`infer`](#infer)
      - [`FailedCast`](#failedcast)
      - [`DataPackageException`](#datapackageexception)
      - [`TableSchemaException`](#tableschemaexception)
      - [`LoadError`](#loaderror)
      - [`ValidationError`](#validationerror)
      - [`CastError`](#casterror)
      - [`IntegrityError`](#integrityerror)
      - [`UniqueKeyError`](#uniquekeyerror)
      - [`RelationError`](#relationerror)
      - [`UnresolvedFKError`](#unresolvedfkerror)
      - [`StorageError`](#storageerror)
    - [Experimental](#experimental)
    - [Contributing](#contributing)
    - [Changelog](#changelog)

  <!--TOC-->





  The package uses semantic versioning. It means that major versions  could include breaking changes. It's highly recommended to specify `tableschema` version range in your `setup/requirements` file e.g. `tableschema>=1.0,<2.0`.

  ```bash
  $ pip install tableschema
  ```





  Let's start with a simple example:

  ```python
  from tableschema import Table


  table = Table('path.csv', schema='schema.json')


  print(table.schema.descriptor)


  for keyed_row in table.iter(keyed=True):
      print(keyed_row)
  ```



  A table is a core concept in a tabular data world. It represents data with metadata (Table Schema). Let's see how we can use it in practice.

  Consider we have some local csv file. It could be inline data or from a remote link - all supported by the `Table` class (except local files for in-brower usage of course). But say it's `data.csv` for now:

  ```csv
  city,location
  london,"51.50,-0.11"
  paris,"48.85,2.30"
  rome,N/A
  ```

  Let's create and read a table instance. We use the static `Table.load` method and the `table.read` method with the `keyed` option to get an array of keyed rows:

  ```python
  table = Table('data.csv')
  table.headers # ['city', 'location']
  table.read(keyed=True)





  ```

  As we can see, our locations are just strings. But they should be geopoints. Also, Rome's location is not available, but it's just a string `N/A` instead of `None`. First we have to infer Table Schema:

  ```python
  table.infer()
  table.schema.descriptor




  table.read(keyed=True)

  ```

  Let's fix the "not available" location. There is a `missingValues` property in Table Schema specification. As a first try we set `missingValues` to `N/A` in `table.schema.descriptor`. The schema descriptor can be changed in-place, but all changes should also be committed using `table.schema.commit()`:

  ```python
  table.schema.descriptor['missingValues'] = 'N/A'
  table.schema.commit()
  table.schema.valid # false
  table.schema.errors

  ```

  As a good citizens we've decided to check our schema descriptor's validity. And it's not valid! We should use an array for the `missingValues` property. Also, don't forget to include "empty string" as a valid missing value:

  ```python
  table.schema.descriptor['missingValues'] = ['', 'N/A']
  table.schema.commit()
  table.schema.valid # true
  ```

  All good. It looks like we're ready to read our data again:

  ```python
  table.read(keyed=True)





  ```

  Now we see that:
  - locations are arrays with numeric latitude and longitude
  - Rome's location is a native Python `None`

  And because there are no errors after reading, we can be sure that our data is valid against our schema. Let's save it:

  ```python
  table.schema.save('schema.json')
  table.save('data.csv')
  ```

  Our `data.csv` looks the same because it has been stringified back to `csv` format. But now we have `schema.json`:

  ```json
  {
      "fields": [
          {
              "name": "city",
              "type": "string",
              "format": "default"
          },
          {
              "name": "location",
              "type": "geopoint",
              "format": "default"
          }
      ],
      "missingValues": [
          "",
          "N/A"
      ]
  }

  ```

  If we decide to improve it even more we could update the schema file and then open it again. But now providing a schema path:

  ```python
  table = Table('data.csv', schema='schema.json')

  ```

  As already mentioned a given schema can be used to *validate* data (see the [Schema](#schema) section for schema specification details). In default mode invalid data rows immediately trigger an [exception](#exceptions) in the `table.iter()`/`table.write()` methods.

  Suppose this schema-invalid local file `invalid_data.csv`:
  ```csv
  key,value
  zero,0
  one,not_an_integer
  two,2
  ```

  We're going to validate the data against the following schema:
  ```python
  table = Table(
      'invalid_data.csv',
      schema={'fields': [{'name': 'key'}, {'name': 'value', 'type': 'integer'}]})
  ```

  Iterating over the data triggers an exception due to the failed cast of `'not_an_integer'` to `int`:
  ```python
  for row in table.iter():
      print(row)




  ```

  Hint: The row number count starts with 1 and also includes header lines.

  (Note: You can optionally switch off `iter()`/`read()` value casting using the cast parameter, see reference below.)

  By providing a custom exception handler (a callable) to those methods you can treat occurring exceptions at your own discretion, i.e. to "fail late" and e.g. gather a validation report on the whole data:

  ```python
  errors = []
  def exc_handler(exc, row_number=None, row_data=None, error_data=None):
      errors.append((exc, row_number, row_data, error_data))

  for row in table.iter(exc_handler=exc_handler):
      print(row)





  print(errors)





  ```

  Note that

  - Data rows are yielded even though the data is schema-invalid; this is due to our custom expression handler choosing not to raise exceptions (but rather collect them in the errors list).
  - Data field values that can't get casted properly (if `iter()`/`read()` cast parameter is set to True, which is the default) are wrapped into a `FailedCast` "value holder". This allows for distinguishing uncasted values from successfully casted values on the data consumer side. `FailedCast` instances can only get yielded when custom exception handling is in place.
  - The custom exception handler callable must support a function signature as specified in the `iter()`/`read()` sections of the `Table` class API reference.



  A model of a schema with helpful methods for working with the schema and supported data. Schema instances can be initialized with a schema source as a url to a JSON file or a JSON object. The schema is initially validated (see [validate](#validate) below). By default validation errors will be stored in `schema.errors` but in a strict mode it will be instantly raised.

  Let's create a blank schema. It's not valid because `descriptor.fields` property is required by the [Table Schema](http://specs.frictionlessdata.io/table-schema/) specification:

  ```python
  schema = Schema()
  schema.valid # false
  schema.errors

  ```

  To avoid creating a schema descriptor by hand we will use a `schema.infer` method to infer the descriptor from given data:

  ```python
  schema.infer([
    ['id', 'age', 'name'],
    ['1','39','Paul'],
    ['2','23','Jimmy'],
    ['3','36','Jane'],
    ['4','28','Judy'],
  ])
  schema.valid # true
  schema.descriptor





  ```

  Now we have an inferred schema and it's valid. We can cast data rows against our schema. We provide a string input which will be cast correspondingly:

  ```python
  schema.cast_row(['5', '66', 'Sam'])

  ```

  But if we try provide some missing value to the `age` field, the cast will fail because the only valid "missing" value is an empty string. Let's update our schema:

  ```python
  schema.cast_row(['6', 'N/A', 'Walt'])

  schema.descriptor['missingValues'] = ['', 'N/A']
  schema.commit()
  schema.cast_row(['6', 'N/A', 'Walt'])

  ```

  We can save the schema to a local file, and resume work on it at any time by loading it from that file:

  ```python
  schema.save('schema.json')
  schema = Schema('schema.json')
  ```



  ```python
  from tableschema import Field


  field = Field({'name': 'name', 'type': 'number'})


  field.cast_value('12345') # -> 12345
  ```

  Data values can be cast to native Python objects with a Field instance. Type instances can be initialized with [field descriptors](https://specs.frictionlessdata.io/table-schema/). This allows formats and constraints to be defined.

  Casting a value will check the value is of the expected type, is in the correct format, and complies with any constraints imposed by a schema. E.g. a date value (in ISO 8601 format) can be cast with a DateType instance. Values that can't be cast will raise an `InvalidCastError` exception.

  Casting a value that doesn't meet the constraints will raise a `ConstraintError` exception.




  ```python
  cli()
  ```
  Command-line interface

  ```
  Usage: tableschema [OPTIONS] COMMAND [ARGS]...

  Options:
    --help  Show this message and exit.

  Commands:
    infer     Infer a schema from data.
    info      Return info on this version of Table Schema
    validate  Validate that a supposed schema is in fact a Table Schema.
  ```



  ```python
  Table(self,
        source,
        schema=None,
        strict=False,
        post_cast=[],
        storage=None,
        **options)
  ```
  Table representation

  __Arguments__
  - __source (str/list[])__: data source one of:
      - local file (path)
      - remote file (url)
      - array of arrays representing the rows
  - __schema (any)__: data schema in all forms supported by `Schema` class
  - __strict (bool)__: strictness option to pass to `Schema` constructor
  - __post_cast (function[])__: list of post cast processors
  - __storage (None)__: storage name like `sql` or `bigquery`
  - __options (dict)__: `tabulator` or storage's options

  __Raises__
  - `TableSchemaException`: raises on any error




  Table's SHA256 hash if it's available.

  If it's already read using e.g. `table.read`, otherwise returns `None`.
  In the middle of an iteration it returns hash of already read contents

  __Returns__

  `str/None`: SHA256 hash




  Table's headers is available

  __Returns__

  `str[]`: headers




  Returns schema class instance if available

  __Returns__

  `Schema`: schema




  Table's size in BYTES if it's available

  If it's already read using e.g. `table.read`, otherwise returns `None`.
  In the middle of an iteration it returns size of already read contents

  __Returns__

  `int/None`: size in BYTES




  ```python
  table.iter(keyed=False,
             extended=False,
             cast=True,
             integrity=False,
             relations=False,
             foreign_keys_values=False,
             exc_handler=None)
  ```
  Iterates through the table data and emits rows cast based on table schema.

  __Arguments__


      keyed (bool):
          yield keyed rows in a form of `{header1: value1, header2: value2}`
          (default is false; the form of rows is `[value1, value2]`)

      extended (bool):
          yield extended rows in a for of `[rowNumber, [header1, header2], [value1, value2]]`
          (default is false; the form of rows is `[value1, value2]`)

      cast (bool):
          disable data casting if false
          (default is true)

      integrity (dict):
          dictionary in a form of `{'size': <bytes>, 'hash': '<sha256>'}`
          to check integrity of the table when it's read completely.
          Both keys are optional.

      relations (dict):
          dictionary of foreign key references in a form
          of `{resource1: [{field1: value1, field2: value2}, ...], ...}`.
          If provided, foreign key fields will checked and resolved
          to one of their references (/!\ one-to-many fk are not completely resolved).

      foreign_keys_values (dict):
          three-level dictionary of foreign key references optimized
          to speed up validation process in a form of
          `{resource1: {(fk_field1, fk_field2): {(value1, value2): {one_keyedrow}, ... }}}`.
          If not provided but relations is true, it will be created
          before the validation process by *index_foreign_keys_values* method

      exc_handler (func):
          optional custom exception handler callable.
          Can be used to defer raising errors (i.e. "fail late"), e.g.
          for data validation purposes. Must support the signature below

  __Custom exception handler__


  ```python
  def exc_handler(exc, row_number=None, row_data=None, error_data=None):
      '''Custom exception handler (example)

      
          exc(Exception):
              Deferred exception instance
          row_number(int):
              Data row number that triggers exception exc
          row_data(OrderedDict):
              Invalid data row source data
          error_data(OrderedDict):
              Data row source data field subset responsible for the error, if
              applicable (e.g. invalid primary or foreign key fields). May be
              identical to row_data.
      '''
      
  ```

  __Raises__
  - `TableSchemaException`: base class of any error
  - `CastError`: data cast error
  - `IntegrityError`: integrity checking error
  - `UniqueKeyError`: unique key constraint violation
  - `UnresolvedFKError`: unresolved foreign key reference error

  __Returns__

  `Iterator[list]`: yields rows




  ```python
  table.read(keyed=False,
             extended=False,
             cast=True,
             limit=None,
             integrity=False,
             relations=False,
             foreign_keys_values=False,
             exc_handler=None)
  ```
  Read the whole table and return as array of rows

  > It has the same API as `table.iter` except for

  __Arguments__
  - __limit (int)__: limit count of rows to read and return

  __Returns__

  `list[]`: returns rows




  ```python
  table.infer(limit=100,
              confidence=0.75,
              missing_values=[''],
              guesser_cls=None,
              resolver_cls=None)
  ```
  Infer a schema for the table.

  It will infer and set Table Schema to `table.schema` based on table data.

  __Arguments__
  - __limit (int)__: limit rows sample size
  - __confidence (float)__: how many casting errors are allowed (as a ratio, between 0 and 1)
  - __missing_values (str[])__: list of missing values (by default `['']`)
  - __guesser_cls (class)__: you can implement inferring strategies by
           providing type-guessing and type-resolving classes [experimental]
  - __resolver_cls (class)__: you can implement inferring strategies by
           providing type-guessing and type-resolving classes [experimental]

  __Returns__

  `dict`: Table Schema descriptor




  ```python
  table.save(target, storage=None, **options)
  ```
  Save data source to file locally in CSV format with `,` (comma) delimiter

  > To save schema use `table.schema.save()`

  __Arguments__
  - __target (str)__: saving target (e.g. file path)
  - __storage (None/str)__: storage name like `sql` or `bigquery`
  - __options (dict)__: `tabulator` or storage options

  __Raises__
  - `TableSchemaException`: raises an error if there is saving problem

  __Returns__

  `True/Storage`: returns true or storage instance




  ```python
  table.index_foreign_keys_values(relations)
  ```
  Creates a three-level dictionary of foreign key references

  We create them optimized to speed up validation process in a form of
  `{resource1: {(fk_field1, fk_field2): {(value1, value2): {one_keyedrow}, ... }}}`.

  For each foreign key of the schema it will iterate through the corresponding
  `relations['resource']` to create an index (i.e. a dict) of existing values
  for the foreign fields and store on keyed row for each value combination.

  The optimization relies on the indexation of possible values for one foreign key
  in a hashmap to later speed up resolution.

  This method is public to allow creating the index once to apply it
  on multiple tables charing the same schema
  (typically [grouped resources in datapackage](https://github.com/frictionlessdata/datapackage-py#group))

  __Notes__

  - the second key of the output is a tuple of the foreign fields,
      a proxy identifier of the foreign key
  - the same relation resource can be indexed multiple times
      as a schema can contain more than one Foreign Keys
      pointing to the same resource

  __Arguments__
  - __relations (dict)__:
          dict of foreign key references in a form of
          `{resource1: [{field1: value1, field2: value2}, ...], ...}`.
          It must contain all resources pointed in the foreign keys schema definition.

  __Returns__

  `dict`:
          returns a three-level dictionary of foreign key references
          optimized to speed up validation process in a form of
          `{resource1: {(fk_field1, fk_field2): {(value1, value2): {one_keyedrow}, ... }}})`



  ```python
  Schema(self, descriptor={}, strict=False)
  ```
  Schema representation

  __Arguments__
  - __descriptor (str/dict)__: schema descriptor one of:
          - local path
          - remote url
          - dictionary
  - __strict (bool)__: flag to specify validation behaviour:
          - if false, errors will not be raised but instead collected in `schema.errors`
          - if true, validation errors are raised immediately

  __Raises__
  - `TableSchemaException`: raise any error that occurs during the process




  Schema's descriptor

  __Returns__

  `dict`: descriptor




  Validation errors

  Always empty in strict mode.

  __Returns__

  `Exception[]`: validation errors




  Schema's field names

  __Returns__

  `str[]`: an array of field names




  Schema's fields

  __Returns__

  `Field[]`: an array of field instances




  Schema's foreign keys

  __Returns__

  `dict[]`: foreign keys




  Schema's field names

  __Returns__

  `str[]`: an array of field names




  Schema's missing values

  __Returns__

  `str[]`: missing values




  Schema's primary keys

  __Returns__

  `str[]`: primary keys




  Validation status

  Always true in strict mode.

  __Returns__

  `bool`: validation status




  ```python
  schema.get_field(name)
  ```
  Get schema's field by name.

  > Use `table.update_field` if you want to modify the field descriptor

  __Arguments__
  - __name (str)__: schema field name

  __Returns__

  `Field/None`: `Field` instance or `None` if not found




  ```python
  schema.get_field(name)
  ```
  Get schema's field by name.

  > Use `table.update_field` if you want to modify the field descriptor

  __Arguments__
  - __name (str)__: schema field name

  __Returns__

  `Field/None`: `Field` instance or `None` if not found




  ```python
  schema.add_field(descriptor)
  ```
  Add new field to schema.

  The schema descriptor will be validated with newly added field descriptor.

  __Arguments__
  - __descriptor (dict)__: field descriptor

  __Raises__
  - `TableSchemaException`: raises any error that occurs during the process

  __Returns__

  `Field/None`: added `Field` instance or `None` if not added




  ```python
  schema.update_field(name, update)
  ```
  Update existing descriptor field by name

  __Arguments__
  - __name (str)__: schema field name
  - __update (dict)__: update to apply to field's descriptor

  __Returns__

  `bool`: true on success and false if no field is found to be modified




  ```python
  schema.remove_field(name)
  ```
  Remove field resource by name.

  The schema descriptor will be validated after field descriptor removal.

  __Arguments__
  - __name (str)__: schema field name

  __Raises__
  - `TableSchemaException`: raises any error that occurs during the process

  __Returns__

  `Field/None`: removed `Field` instances or `None` if not found




  ```python
  schema.cast_row(row, fail_fast=False, row_number=None, exc_handler=None)
  ```
  Cast row based on field types and formats.

  __Arguments__
  - __row (any[]__: data row as an array of values

  __Returns__

  `any[]`: returns cast data row




  ```python
  schema.infer(rows,
               headers=1,
               confidence=0.75,
               guesser_cls=None,
               resolver_cls=None)
  ```
  Infer and set `schema.descriptor` based on data sample.

  __Arguments__
  - __rows (list[])__: array of arrays representing rows.
  - __headers (int/str[])__: data sample headers (one of):
        - row number containing headers (`rows` should contain headers rows)
        - array of headers (`rows` should NOT contain headers rows)
  - __confidence (float)__: how many casting errors are allowed (as a ratio, between 0 and 1)
  - __guesser_cls (class)__: you can implement inferring strategies by
           providing type-guessing and type-resolving classes [experimental]
  - __resolver_cls (class)__: you can implement inferring strategies by
           providing type-guessing and type-resolving classes [experimental]

  __Returns__

  `dict`: Table Schema descriptor




  ```python
  schema.commit(strict=None)
  ```
  Update schema instance if there are in-place changes in the descriptor.

  __Example__


  ```python
  from tableschema import Schema
  descriptor = {'fields': [{'name': 'my_field', 'title': 'My Field', 'type': 'string'}]}
  schema = Schema(descriptor)
  print(schema.get_field('my_field').descriptor['type']) # string


  schema.descriptor['fields'][0]['type'] = 'number'

  schema.update_field('my_field', {'title': 'My Pretty Field'}) # True


  print(schema.get_field('my_field').descriptor['type']) # string
  print(schema.get_field('my_field').descriptor['title']) # My Field


  schema.commit()
  print(schema.get_field('my_field').descriptor['type']) # number
  print(schema.get_field('my_field').descriptor['title']) # My Pretty Field

  ```

  __Arguments__
  - __strict (bool)__: alter `strict` mode for further work

  __Raises__
  - `TableSchemaException`: raises any error that occurs during the process

  __Returns__

  `bool`: true on success and false if not modified




  ```python
  schema.save(target, ensure_ascii=True)
  ```
  Save schema descriptor to target destination.

  __Arguments__
  - __target (str)__: path where to save a descriptor

  __Raises__
  - `TableSchemaException`: raises any error that occurs during the process

  __Returns__

  `bool`: true on success




  ```python
  Field(self, descriptor, missing_values=[''], schema=None)
  ```
  Field representaion

  __Arguments__
  - __descriptor (dict)__: schema field descriptor
  - __missingValues (str[])__: an array with string representing missing values

  __Raises__
  - `TableSchemaException`: raises any error that occurs during the process




  Field constraints

  __Returns__

  `dict`: dict of field constraints




  Fields's descriptor

  __Returns__

  `dict`: descriptor




  Field format

  __Returns__

  `str`: field format




  Field's missing values

  __Returns__

  `str[]`: missing values




  Field name

  __Returns__

  `str`: field name




  Whether field is required

  __Returns__

  `bool`: true if required




  Returns a schema instance if the field belongs to some schema

  __Returns__

  `Schema`: field's schema




  Field type

  __Returns__

  `str`: field type




  ```python
  field.cast_value(value, constraints=True)
  ```
  Cast given value according to the field type and format.

  __Arguments__
  - __value (any)__: value to cast against field
  - __constraints (boll/str[])__: gets constraints configuration
          - it could be set to true to disable constraint checks
          - it could be an Array of constraints to check e.g. ['minimum', 'maximum']

  __Raises__
  - `TableSchemaException`: raises any error that occurs during the process

  __Returns__

  `any`: returns cast value




  ```python
  field.test_value(value, constraints=True)
  ```
  Test whether value is compliant to the field.

  __Arguments__
  - __value (any)__: value to cast against field
  - __constraints (bool/str[])__: constraints configuration

  __Returns__

  `bool`: returns if value is compliant to the field



  ```python
  Storage(self, **options)
  ```
  Storage factory/interface

  __For users__


  > Use `Storage.connect` to instantiate a storage

  For instantiation of concrete storage instances,
  `tableschema.Storage` provides a unified factory method `connect`
  (which uses the plugin system under the hood):

  ```python

  from tableschema import Storage

  storage = Storage.connect('sql', **options)
  storage.create('bucket', descriptor)
  storage.write('bucket', rows)
  storage.read('bucket')
  ```

  __For integrators__


  The library includes interface declaration to implement tabular `Storage`.
  This interface allow to use different data storage systems like SQL
  with `tableschema.Table` class (load/save) as well as on the data package level:

  ![Storage](https://raw.githubusercontent.com/frictionlessdata/tableschema-py/master/data/storage.png)

  An implementor must follow `tableschema.Storage` interface
  to write his own storage backend. Concrete storage backends
  could include additional functionality specific to conrete storage system.
  See `plugins` below to know how to integrate custom storage plugin into your workflow.




  Return list of storage bucket names.

  A `bucket` is a special term which has almost the same meaning as `table`.
  You should consider `bucket` as a `table` stored in the `storage`.

  __Raises__
  - `exceptions.StorageError`: raises on any error

  __Returns__

  `str[]`: return list of bucket names




  ```python
  storage.connect(name, **options)
  ```
  Create tabular `storage` based on storage name.

  > This method is statis: `Storage.connect()`

  __Arguments__
  - __name (str)__: storage name like `sql`
  - __options (dict)__: concrete storage options

  __Raises__
  - `StorageError`: raises on any error

  __Returns__

  `Storage`: returns `Storage` instance




  ```python
  storage.create(bucket, descriptor, force=False)
  ```
  Create one/multiple buckets.

  __Arguments__
  - __bucket (str/list)__: bucket name or list of bucket names
  - __descriptor (dict/dict[])__: schema descriptor or list of descriptors
  - __force (bool)__: whether to delete and re-create already existing buckets

  __Raises__
  - `exceptions.StorageError`: raises on any error




  ```python
  storage.delete(bucket=None, ignore=False)
  ```
  Delete one/multiple/all buckets.

  __Arguments__
  - __bucket (str/list/None)__: bucket name or list of bucket names to delete.
          If `None`, all buckets will be deleted
  - __descriptor (dict/dict[])__: schema descriptor or list of descriptors
  - __ignore (bool)__: don't raise an error on non-existent bucket deletion

  __Raises__
  - `exceptions.StorageError`: raises on any error




  ```python
  storage.describe(bucket, descriptor=None)
  ```
  Get/set bucket's Table Schema descriptor

  __Arguments__
  - __bucket (str)__: bucket name
  - __descriptor (dict/None)__: schema descriptor to set

  __Raises__
  - `exceptions.StorageError`: raises on any error

  __Returns__

  `dict`: returns Table Schema descriptor




  ```python
  storage.iter(bucket)
  ```
  Return an iterator of typed values based on the schema of this bucket.

  __Arguments__
  - __bucket (str)__: bucket name

  __Raises__
  - `exceptions.StorageError`: raises on any error

  __Returns__

  `list[]`: yields data rows




  ```python
  storage.read(bucket)
  ```
  Read typed values based on the schema of this bucket.

  __Arguments__
  - __bucket (str)__: bucket name
  __Raises__
  - `exceptions.StorageError`: raises on any error
  __Returns__

  `list[]`: returns data rows




  ```python
  storage.write(bucket, rows)
  ```
  This method writes data rows into `storage`.

  It should store values of unsupported types as strings internally (like csv does).

  __Arguments__
  - __bucket (str)__: bucket name
  - __rows (list[])__: data rows to write

  __Raises__
  - `exceptions.StorageError`: raises on any error



  ```python
  validate(descriptor)
  ```
  Validate descriptor

  __Arguments__
  - __dict__: descriptor

  __Raises__
  - `ValidationError`: on validation errors

  __Returns__

  `bool`: True



  ```python
  infer(source,
        headers=1,
        limit=100,
        confidence=0.75,
        missing_values=[''],
        guesser_cls=None,
        resolver_cls=None,
        **options)
  ```
  Infer source schema.

  __Arguments__
  - __source (any)__: source as path, url or inline data
  - __headers (int/str[])__: headers rows number or headers list
  - __confidence (float)__: how many casting errors are allowed (as a ratio, between 0 and 1)
  - __missing_values (str[])__: list of missing values (by default `['']`)
  - __guesser_cls (class)__: you can implement inferring strategies by
          providing type-guessing and type-resolving classes [experimental]
  - __resolver_cls (class)__: you can implement inferring strategies by
          providing type-guessing and type-resolving classes [experimental]

  __Raises__
  - `TableSchemaException`: raises any error that occurs during the process

  __Returns__

  `dict`: returns schema descriptor



  ```python
  FailedCast(self, value)
  ```
  Wrap an original data field value that failed to be properly casted.

  FailedCast allows for further processing/yielding values but still be able
  to distinguish uncasted values on the consuming side.

  Delegates attribute access and the basic rich comparison methods to the
  underlying object. Supports default user-defined classes hashability i.e.
  is hashable based on object identity (not based on the wrapped value).

  __Arguments__
  - __value (any)__: value



  ```python
  DataPackageException(self, message, errors=[])
  ```
  Base class for all DataPackage/TableSchema exceptions.

  If there are multiple errors, they can be read from the exception object:

  ```python
  try:
      
  except DataPackageException as exception:
      if exception.multiple:
          for error in exception.errors:
              
  ```




  List of nested errors

  __Returns__

  `DataPackageException[]`: list of nested errors




  Whether it's a nested exception

  __Returns__

  `bool`: whether it's a nested exception




  ```python
  TableSchemaException(self, message, errors=[])
  ```
  Base class for all TableSchema exceptions.



  ```python
  LoadError(self, message, errors=[])
  ```
  All loading errors.



  ```python
  ValidationError(self, message, errors=[])
  ```
  All validation errors.



  ```python
  CastError(self, message, errors=[])
  ```
  All value cast errors.



  ```python
  IntegrityError(self, message, errors=[])
  ```
  All integrity errors.



  ```python
  UniqueKeyError(self, message, errors=[])
  ```
  Unique key constraint violation (CastError subclass)



  ```python
  RelationError(self, message, errors=[])
  ```
  All relations errors.



  ```python
  UnresolvedFKError(self, message, errors=[])
  ```
  Unresolved foreign key reference error (RelationError subclass).



  ```python
  StorageError(self, message, errors=[])
  ```
  All storage errors.



  > This API is experimental and can be changed/removed in the future

  There is an experimental environment variable `TABLESCHEMA_PRESERVE_MISSING_VALUES` which, if it is set, affects how data casting works.

  By default, missing values are resolved to `None` values. When this flag is set, missing values are passed through as it is. For example:

  > missing_values.py

  ```python
  from tableschema import Field

  field = Field({'type': 'number'}, missing_values=['-'])
  print(field.cast_value('3'))
  print(field.cast_value('-'))
  ```

  Running this script in different modes:

  ```bash
  $ python missing_values.py
  3
  None
  $ TABLESCHEMA_PRESERVE_MISSING_VALUES=1 python missing_values.py
  3
  -
  ```

  The flags affects all the library's APIs and software built on top of `tableschema`. For example, Data Package Pipelines:

  ```bash
  $ TABLESCHEMA_PRESERVE_MISSING_VALUES=1 dpp run ./my_pipeline
  ```



  > The project follows the [Open Knowledge International coding standards](https://github.com/okfn/coding-standards).

  Recommended way to get started is to create and activate a project virtual environment.
  To install package and development dependencies into active environment:

  ```bash
  $ make install
  ```

  To run tests with linting and coverage:

  ```bash
  $ make test
  ```



  Here described only breaking and the most important changes. The full changelog and documentation for all released versions can be found in the nicely formatted [commit history](https://github.com/frictionlessdata/tableschema-py/commits/master).



  - Added --json flag to the CLI (#287)



  - Deduplicate field names if guessing in infer



  - Publish `field.ERROR/cast_function/check_functions`



  - Added `schema.missing_values` and `field.missing_values`



  - Fixed the way we parse `geopoint`:
      - as a string it can be in 3 forms ("default", "array", "object") BUT
      - as native object it can only be a list/tuple



  - Added an experimental `TABLESCHEMA_PRESERVE_MISSING_VALUES` environment variable flag



  - Allow providing custom guesser and resolver to `table.infer` and `infer`



  - Added `missing_values` argument to the `infer` function (#269)



  - Support optional custom exception handling for table.iter/read (#259)



  - Added `preserve_missing_values` parameter to `field.cast_value`



  - Added an ability to check table's integrity while reading



  - Implemented the `table.size` and `table.hash` properties



  - Added `table.index_foreign_keys_values` and improved foreign key checks performance



  - Added `field.schema` property



  - In `strict` mode raise an exception if there are problems in field construction



  - Allow providing custom guesser and resolver to schema infer



  - Added `schema.update_field` method



  - Support datetime with no time for date casting



  - Support floats like 1.0 for integer casting



  - Added the `confidence` parameter to `infer`



  - The library has been rebased on the Frictionless Data specs v1 - https://frictionlessdata.io/specs/table-schema/


pkgId: 8aafc535319520df1f347ad817eb5ffef2e7dfa827d22d09e0de15fa71f68471
name: python-tablib
arch: src
version: 3.3.0
epoch: 0
release: 1
summary: Format agnostic tabular data library (XLS, JSON, YAML, CSV)
url: https://tablib.readthedocs.io
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4d053a30-8011-4387-ab52-cddae7e8a95b
location_href: 00005257-python-tablib/python-tablib-3.3.0-1.src.rpm
checksum_type: sha256
description:
  [![Jazzband](https://jazzband.co/static/img/badge.svg)](https://jazzband.co/)
  [![PyPI version](https://img.shields.io/pypi/v/tablib.svg)](https://pypi.org/project/tablib/)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/tablib.svg)](https://pypi.org/project/tablib/)
  [![PyPI downloads](https://img.shields.io/pypi/dm/tablib.svg)](https://pypistats.org/packages/tablib)
  [![GitHub Actions status](https://github.com/jazzband/tablib/workflows/Test/badge.svg)](https://github.com/jazzband/tablib/actions)
  [![codecov](https://codecov.io/gh/jazzband/tablib/branch/master/graph/badge.svg)](https://codecov.io/gh/jazzband/tablib)
  [![GitHub](https://img.shields.io/github/license/jazzband/tablib.svg)](LICENSE)

      _____         ______  ___________ ______
      __  /_______ ____  /_ ___  /___(_)___  /_
      _  __/_  __ `/__  __ \__  / __  / __  __ \
      / /_  / /_/ / _  /_/ /_  /  _  /  _  /_/ /
      \__/  \__,_/  /_.___/ /_/   /_/   /_.___/


  Tablib is a format-agnostic tabular dataset library, written in Python.

  Output formats supported:

  - Excel (Sets + Books)
  - JSON (Sets + Books)
  - YAML (Sets + Books)
  - Pandas DataFrames (Sets)
  - HTML (Sets)
  - Jira (Sets)
  - TSV (Sets)
  - ODS (Sets)
  - CSV (Sets)
  - DBF (Sets)

  Note that tablib *purposefully* excludes XML support. It always will. (Note: This is a
  joke. Pull requests are welcome.)

  Tablib documentation is graciously hosted on https://tablib.readthedocs.io

  It is also available in the ``docs`` directory of the source distribution.

  Make sure to check out [Tablib on PyPI](https://pypi.org/project/tablib/)!



  Please see the [contributing guide](https://github.com/jazzband/tablib/blob/master/.github/CONTRIBUTING.md).








  - Add support for Python 3.11 (#525).
  - ODS export: integers/floats/decimals are exported as numbers (#527).





  - Support solo CR in text input imports (#518).





  - Dropped Python 3.6 support (#513).



  - Corrected order of arguments to a regex call in `safe_xlsx_sheet_title` (#510).





  - Add support for Python 3.10 (#504).
  - The csv, xls, and xlsx formats gained support for the `skip_lines` keyword
    argument for their `import_set()` method to be able to skip the nth first
    lines of a read file (#497).



  - Avoided mutable parameter defaults (#494).
  - Specify build backend for editable installs (#501).
  - Doubled sample size passed to `csv.Sniffer()` in `_csv.detect()` (#503).





  - Dropped Python 3.5 support.
  - JSON-exported data is no longer forced to ASCII characters.
  - YAML-exported data is no longer forced to ASCII characters.



  - Added Python 3.9 support.
  - Added read_only option to xlsx file reader (#482).



  - Prevented crash in rst export with only-space strings (#469).





  - The `Row.lpush/rpush` logic was reversed. `lpush` was appending while `rpush`
    and `append` were prepending. This was fixed (reversed behavior). If you
    counted on the broken behavior, please update your code (#453).



  - Fixed minimal openpyxl dependency version to 2.6.0 (#457).
  - Dates from xls files are now read as Python datetime objects (#373).
  - Allow import of "ragged" xlsx files (#465).



  - When importing an xlsx file, Tablib will now read cell values instead of formulas (#462).





  - Upcoming breaking change in Tablib 2.0.0: the `Row.lpush/rpush` logic is reversed.
    `lpush` is appending while `rpush` and `append` are prepending. The broken behavior
    will remain in Tablib 1.x and will be fixed (reversed) in Tablib 2.0.0 (#453). If you
    count on the broken behavior, please update your code when you upgrade to Tablib 2.x.



  - Tablib is now able to import CSV content where not all rows have the same
    length. Missing columns on any line receive the empty string (#226).





  - Dropped Python 2 support
  - Dependencies are now all optional. To install `tablib` as before with all
    possible supported formats, run `pip install tablib[all]`



  - Formats can now be dynamically registered through the
    `tablib.formats.registry.refister` API (#256).
  - Tablib methods expecting data input (`detect_format`, `import_set`,
    `Dataset.load`, `Databook.load`) now accepts file-like objects in addition
    to raw strings and bytestrings (#440).



  - Fixed a crash when exporting an empty string with the ReST format (#368)
  - Error cells from imported .xls files contain now the error string (#202)





  - The 0.14.x series will be the last to support Python 2



  - Dropped Python 3.4 support



  - Added Python 3.7 and 3.8 support
  - The project is now maintained by the Jazzband team, https://jazzband.co
  - Improved format autodetection and added autodetection for the odf format.
  - Added search to all documentation pages
  - Open xlsx workbooks in read-only mode (#316)
  - Unpin requirements
  - Only install backports.csv on Python 2



  - Fixed `DataBook().load` parameter ordering (first stream, then format).
  - Fixed a regression for xlsx exports where non-string values were forced to
    strings (#314)
  - Fixed xlsx format detection (which was often detected as `xls` format)



  - Added reStructuredText output capability (#336)
  - Added Jira output capability
  - Stopped calling openpyxl deprecated methods (accessing cells, removing sheets)
    (openpyxl minimal version is now 2.4.0)
  - Fixed a circular dependency issue in JSON output (#332)
  - Fixed Unicode error for the CSV export on Python 2 (#215)
  - Removed usage of optional `ujson` (#311)
  - Dropped Python 3.3 support



  - Favor `Dataset.export(<format>)` over `Dataset.<format>` syntax in docs
  - Make Panda dependency optional



  - Add initial Panda DataFrame support
  - Dropped Python 2.6 support



  - Use `yaml.safe_load` for importing yaml.



  - Use built-in `json` package if available
  - Support Python 3.5+ in classifiers



  - Fixed textual representation for Dataset with no headers
  - Handle decimal types



  - Release fix.





  - Fix export only formats.
  - Fix for xlsx output.





  - Fixed packaging error on Python 3.






  - Added LaTeX table export format (`Dataset.latex`).
  - Support for dBase (DBF) files (`Dataset.dbf`).



  - New import/export interface (`Dataset.export()`, `Dataset.load()`).
  - CSV custom delimiter support (`Dataset.export('csv', delimiter='$')`).
  - Adding ability to remove duplicates to all rows in a dataset (`Dataset.remove_duplicates()`).
  - Added a mechanism to avoid `datetime.datetime` issues when serializing data.
  - New `detect_format()` function (mostly for internal use).
  - Update the vendored unicodecsv to fix `None` handling.
  - Only freeze the headers row, not the headers columns (xls).



  - `detect()` function removed.



  - Fix XLSX import.
  - Bugfix for `Dataset.transpose().transpose()`.




  * Unicode Column Headers
  * ALL the bugfixes!



  * Bugfixes



  * Bugfixes



  * Dataset API Changes
  * `stack_rows` => `stack`, `stack_columns` => `stack_cols`
  * column operations have their own methods now (`append_col`, `insert_col`)
  * List-style `pop()`
  * Redis-style `rpush`, `lpush`, `rpop`, `lpop`, `rpush_col`, and `lpush_col`



  * OpenDocument Spreadsheet support (.ods)
  * Full Unicode TSV support




  * Full XLSX Support!
  * Pickling Bugfix
  * Compat Module




  * `seperators` renamed to `separators`
  * Full unicode CSV support




  * Python 3.1, Python 3.2 Support (same code base!)
  * Formatter callback support
  * Various bug fixes





  * Python 2.5 Support!
  * Tox Testing for 2.5, 2.6, 2.7
  * AnyJSON Integrated
  * OrderedDict support
  * Caved to community pressure (spaces)




  * Databook duplication leak fix.
  * HTML Table output.
  * Added column sorting.




  * Transpose method added to Datasets.
  * New frozen top row in Excel output.
  * Pickling support for Datasets and Rows.
  * Support for row/column stacking.




  * Minor reference shadowing bugfix.




  * Massive documentation update!
  * Tablib.org!
  * Row tagging and Dataset filtering!
  * Column insert/delete support
  * Column append API change (header required)
  * Internal Changes (Row object and use thereof)




  * New import system. All dependencies attempt to load from site-packages,
    then fallback on tenderized modules.




  * Updated XLS output: Only wrap if '\\n' in cell.




  * Ability to append new column passing a callable
    as the value that will be applied to every row.




  * Added alignment wrapping to written cells.
  * Added separator support to XLS.




  * Packaging Fix




  * New format plugin system!
  * Imports! ELEGANT Imports!
  * Tests. Lots of tests.




  * Reverting methods back to properties.
  * Windows bug compensated in documentation.




  * Renamed DataBook Databook for consistency.
  * Export properties changed to methods (XLS filename / StringIO bug).
  * Optional Dataset.xls(path='filename') support (for writing on windows).
  * Added utf-8 on the worksheet level.




  * Updated unicode export for XLS.
  * More exhaustive unit tests.




  * Added Dataset.append() support for columns.




  * Fixed Dataset.append() error on empty dataset.
  * Updated Dataset.headers property w/ validation.
  * Added Testing Fixtures.



  * Packaging hotfixes.




  * Public Release.
  * Export Support for XLS, JSON, YAML, and CSV.
  * DataBook Export for XLS, JSON, and YAML.
  * Python Dict Property Support.


pkgId: db7a958ceb39916e4c5a40e107622d79f8021d77e4080567003ab5153b36ae6d
name: python-tabulate
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: Pretty-print tabular data
url: https://github.com/astanin/python-tabulate
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f89823f9-e4ae-4a7f-9e8d-0377726d2cae
location_href: 00005258-python-tabulate/python-tabulate-0.9.0-1.src.rpm
checksum_type: sha256
description:
  Pretty-print tabular data in Python, a library and a command-line
  utility.
  The main use cases of the library are:
  -   printing small tables without hassle: just one function call,
      formatting is guided by the data itself
  -   authoring tabular data for lightweight plain-text markup: multiple
      output formats suitable for further editing or transformation
  -   readable presentation of mixed textual and numeric data: smart
      column alignment, configurable number formatting, alignment by a
      decimal point


pkgId: 6e97ebdb02cb0e934cbbb9140b06a9a85f51dbd15d9465eee5a9e91147e2500d
name: python-tambo
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: A command line object dispatcher
url: UNKNOWN
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-45c91429-0b00-4fad-976b-61bbbd86992e
location_href: 00005264-python-tambo/python-tambo-0.4.0-1.src.rpm
checksum_type: sha256
description:
  Use *any* argument parser you want for *each* sub-command. Easily manage each
  command as a self-contained application.


pkgId: aa7cae5c472459a529ad432e90c21d812a8e615612c1af538d2400f1b53efc96
name: python-tamr-unify-client
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: Python Client for the Tamr API
url: https://tamr-client.readthedocs.io/en/stable/
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-22b928cd-950b-4f85-ad50-053a0d338dfc
location_href: 00014094-python-tamr-unify-client/python-tamr-unify-client-1.6.0-1.src.rpm
checksum_type: sha256
description:
  *Quick links:*
  **[Docs](https://tamr-client.readthedocs.io/en/stable/)** |
  **[Contributing](https://tamr-client.readthedocs.io/en/stable/contributor-guide.html)** |


pkgId: 1aa6e39140ec4d3ed2cf89b8e4bcce2732d6c063b36ed74176d845f4b31fcafb
name: python-tardis-dev
arch: src
version: 2.0.0a13
epoch: 0
release: 1
summary: Python client for tardis.dev - historical tick-level cryptocurrency market data replay API.
url: https://github.com/tardis-dev/tardis-python
rpm_license: MPL-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7b436e35-fd27-4ed7-a2ac-e19f57d0761c
location_href: 00013817-python-tardis-dev/python-tardis-dev-2.0.0a13-1.src.rpm
checksum_type: sha256
description:
  [![PyPi](https://img.shields.io/pypi/v/tardis-client.svg)](https://pypi.org/project/tardis-client/)
  [![Python](https://img.shields.io/pypi/pyversions/tardis-client.svg)](https://pypi.org/project/tardis-client/)
  <a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>

  Python client for [tardis.dev](https://tardis.dev) - historical tick-level cryptocurrency market data replay API.
  Provides fast, high level and developer friendly wrapper for more low level [HTTP API](https://docs.tardis.dev/api#http-api) with local file based caching build in.



  Requires Python 3.7.0+ installed.

  ```sh
  pip install tardis-client
  ```



  ```python
  import asyncio
  from tardis_client import TardisClient, Channel

  async def replay():
      tardis_client = TardisClient()

      
      
      messages = tardis_client.replay(
          exchange="bitmex",
          from_date="2019-06-01",
          to_date="2019-06-02",
          filters=[Channel(name="trade", symbols=["XBTUSD","ETHUSD"]), Channel("orderBookL2", ["XBTUSD"])],
      )

      
      
      
      async for local_timestamp, message in messages:
          
          
          print(message)

  asyncio.run(replay())
  ```
  [![Try on repl.it](https://repl-badge.jajoosam.repl.co/try.png)](https://repl.it/@TardisThad/tardis-python-client-example)



  `tardis-client` package provides `TardisClient` and `Channel` classes.

  ```python
  from tardis_client import TardisClient, Channel
  ```



  Optional client constructor parameters.

  | name                   | type     | default value               | description                                                                                                                                                     |
  | ---------------------- | -------- | --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  | `api_key` (optional)   | `string` | `""`                        | optional `string` containing API key for [tardis.dev](https://tardis.dev) API. If not provided only first day of each month of data is accessible (free access) |
  | `cache_dir` (optional) | `string` | `<os.tmpdir>/.tardis-cache` | optional `string` with path to local dir that will be used as cache location. If not provided default `temp` dir for given OS will be used.                     |

  Example:

  ```python

  tardis_client = TardisClient()


  tardis_client = TardisClient(api_key="YOUR_API_KEY")


  tardis_client = TardisClient(cache_dir="./cache")
  ```

  - ### `tardis_client.clear_cache()`

    Removes local file cache dir and it's contents.

    Example:

    ```python
    tardis_client = TardisClient()

    tardis_client.clear_cache()
    ```

  - ### `tardis_client.replay(exchange, from_date, to_date, filters=[])`

    Replays historical market data messages for given replay arguments.

    Returns [Async Generator](https://rickyhan.com/jekyll/update/2018/01/27/python36.html) with named tuples (`namedtuple("Response", ["local_timestamp", "message"])`).

    - `local_timestamp` is a Python datetime object specyfying when message has been received from the exchange real-time data feed.

    - `message` is Python dict with parsed JSON that has exactly the same format as message provided by particular exchange's real-time data feed.

      

      | name                 | type                              | default value | description                                                                                                                                                                                  |
      | -------------------- | --------------------------------- | ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
      | `exchange`           | `string`                          | -             | requested exchange name - see [allowed exchanges](https://github.com/tardis-dev/python-client/blob/master/tardis_client/consts.py#L1) list                                                   |
      | `from_date`          | `string`                          | -             | requested UTC start date of data feed - [valid ISO date string](https://docs.python.org/3/library/datetime.html#datetime.date.fromisoformat), eg: `2019-04-05` or `2019-05-05T00:00:00`      |
      | `to_date`            | `string`                          | -             | requested UTC end date of data feed - [valid ISO date string](https://docs.python.org/3/library/datetime.html#datetime.date.fromisoformat), eg: `2019-04-05` or `2019-05-05T00:00:00`        |
      | `filters` (optional) | [`List[Channel]`](#channel-class) | []            | optional filters of requested data feed. Use [/exchanges/:exchange](https://docs.tardis.dev/api#exchanges-exchange) API call to get allowed channel names and symbols for requested exchange |

      

      `Channel` class constructor parameters.

      | name      | type           | description                                                                                                                                         |
      | --------- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
      | `name`    | `string`       | Use [/exchanges/:exchange](https://docs.tardis.dev/api#exchanges-exchange) API call to get allowed channel names and symbols for requested exchange |
      | `symbols` | `List[string]` | Use [/exchanges/:exchange](https://docs.tardis.dev/api#exchanges-exchange) API call to get allowed channel names and symbols for requested exchange |

      ```python
      Channel(name="trade", symbols=["XBTUSD","ETHUSD"])
      Channel("orderBookL2", ["XBTUSD"])
      ```





  `tardis-client` uses Python logging on `DEBUG` level for that purpose. In doubt please create issue in this repository with steps how to reproduce the issue.



  Check out [API docs](https://docs.tardis.dev/api).



  MPL-2.0


pkgId: ed2f02f72e134f2e141c5d0ed657ed3ed67111d49b66633fb17ee470760b0d11
name: python-taskipy
arch: src
version: 1.10.4
epoch: 0
release: 1
summary: tasks runner for python projects
url: https://github.com/taskipy/taskipy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-12e14f9b-8c10-4a3e-b0ef-e464c90402dc
location_href: 00012419-python-taskipy/python-taskipy-1.10.4-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://github.com/illBeRoy/taskipy/raw/master/logo.svg" width="150" />
  </p>

  - [General](#general)
  - [Requirements](#requirements)
  - [Usage](#usage)
    - [Installation](#installation)
    - [Adding Tasks](#adding-tasks)
    - [Running Tasks](#running-tasks)
    - [Passing Command Line Args to Tasks](#passing-command-line-args-to-tasks)
    - [Composing Tasks](#composing-tasks)
      - [Grouping Subtasks Together](#grouping-subtasks-together)
      - [Pre Task Hook](#pre-task-hook)
      - [Post Task Hook](#post-task-hook)
    - [Using Variables](#using-variables)
      - [String Formatting](#string-formatting)
      - [Always Use Variables](#always-use-variables)
      - [Recursive Variables](#recursive-variables)
    - [Using Taskipy Without Poetry](#using-taskipy-without-poetry)
      - [Installing With PIP](#installing-with-pip)
      - [Running Tasks](#running-tasks-1)
    - [Advanced Use Cases](#advanced-use-cases)
  - [Maintainers :construction:](#maintainers-construction)
  - [Contributors :sparkles:](#contributors-sparkles)



  [![pypi](https://img.shields.io/pypi/v/taskipy?style=flat-square)](https://pypi.org/project/taskipy/)
  [![pypi-downloads](https://img.shields.io/pypi/dm/taskipy?style=flat-square)](https://pypi.org/project/taskipy/)
  [![ci](https://img.shields.io/github/workflow/status/illberoy/taskipy/Taskipy%20Test%20CI?style=flat-square)](https://github.com/illBeRoy/taskipy/actions?query=workflow%3A%22Taskipy+Test+CI%22)
  [![All Contributors](https://img.shields.io/github/all-contributors/illberoy/taskipy?color=orange&style=flat-square)](#contributors-)

  **The complementary task runner for python.**

  Every development pipeline has tasks, such as `test`, `lint` or `publish`. With taskipy, you can define those tasks in one file and run them with a simple command.

  For instance, instead of running the following command:

  ```bash
  python -m unittest tests/test_*.py
  ```

  You can create a task called `test` and simply run:

  ```bash
  poetry run task test
  ```

  Or (if you're not using poetry):

  ```bash
  task test
  ```

  In addition, you can compose tasks and group them together, and also create dependencies between them.

  This project is heavily inspired by npm's [run script command](https://docs.npmjs.com/cli/run-script).



  Python 3.6 or newer.

  Your project directory should include a valid `pyproject.toml` file, as specified in [PEP-518](https://www.python.org/dev/peps/pep-0518/).





  To install taskipy as a dev dependency, simply run:

  ```bash
  poetry add --dev taskipy
  ```



  In your `pyproject.toml` file, add a new section called `[tool.taskipy.tasks]`.

  The section is a key-value map, from the names of the task to the actual command that should be run in the shell.

  There are two ways to define tasks. The easy way is to simply write the command down as a string:

  __pyproject.toml__

  ```toml
  [tool.taskipy.tasks]
  test = "python -m unittest tests/test_*.py"
  lint = "pylint tests taskipy"
  ```

  Alternatively, you can define tasks more explicitly by declaring both the command and a helpful description using an inline table:

  __pyproject.toml__

  ```toml
  [tool.taskipy.tasks]
  test = { cmd = "python -m unittest tests/test_*.py", help = "runs all unit tests" }
  lint = { cmd = "pylint tests taskipy", help = "confirms code style using pylint" }
  ```

  The explicit notation is more verbose, but provides better context to anyone who uses the task.



  In order to run a task, run the following command in your terminal:

  ```bash
  $ poetry run task test
  ```

  You can also list all existing tasks by running the following:

  ```bash
  $ poetry run task --list
  test                python -m unittest tests/test_*.py
  lint                pylint tests taskipy
  ```

  If you declared your task explicitly, you will see the description of the task by the side of the task's name:

  ```bash
  $ poetry run task --list
  test                runs all unit tests
  lint                confirms code style using pylint
  ```



  If you want to pass command line arguments to tasks (positional or named), simply append them to the end of the task command.

  For example, running the above task like this:

  ```bash
  poetry run task test -h
  ```

  Is equivalent to running:

  ```bash
  python -m unittest tests/test_*.py -h
  ```

  And will show unittest's help instead of actually running it.

  > ⚠️ Note: if you are using pre \ post hooks, do notice that arguments are not passed to them, only to the task itself.





  Some tasks are composed of multiple subtasks. Instead of writing plain shell commands and stringing them together, you can break them down into multiple subtasks:

  ```toml
  [tool.taskipy.tasks]
  lint_pylint = "pylint tests taskipy"
  lint_mypy = "mypy tests taskipy"
  ```

  And then create a composite task:

  ```toml
  [tool.taskipy.tasks]
  lint = "task lint_pylint && task lint_mypy"
  lint_pylint = "pylint tests taskipy"
  lint_mypy = "mypy tests taskipy"
  ```



  Tasks might also depend on one another. For example, tests might require some binaries to be built. Take the two following commands, for instance:

  ```toml
  [tool.taskipy.tasks]
  test = "python -m unittest tests/test_*.py"
  build = "make ."
  ```

  You could make tests depend on building, by using the **pretask hook**:

  ```toml
  [tool.taskipy.tasks]
  pre_test = "task build"
  test = "python -m unittest tests/test_*.py"
  build = "make ."
  ```

  The pretask hook looks for `pre_<task_name>` task for a given `task_name`. It will run it before running the task itself. If the pretask fails, then taskipy will exit without running the task itself.



  From time to time, you might want to run a task in conjuction with another. For example, you might want to run linting after a successful test run. Take the two following commands, for instance:

  ```toml
  [tool.taskipy.tasks]
  test = "python -m unittest tests/test_*.py"
  lint = "pylint tests taskipy"
  ```

  You could make tests trigger linting, by using the **posttask hook**:

  ```toml
  [tool.taskipy.tasks]
  test = "python -m unittest tests/test_*.py"
  post_test = "task lint"
  lint = "pylint tests taskipy"
  ```

  The posttask hook looks for `post_<task_name>` task for a given `task_name`. It will run it after running the task itself. If the task failed, then taskipy will not run the posttask hook.



  In some cases, you might find yourself passing the same arguments over and over again. Let us take a look at the following tasks:

  ```toml
  [tool.taskipy.tasks]
  lint = "pylint path/to/my_module"
  black = "black path/to/my_module"
  ```

  As you can see, we provide the same path argument to both `pylint` and `black`.

  In order to encourage DRY and improve your ability to change these values later on, taskipy actually lets you declare and reuse variables in your tasks:

  ```toml
  [tool.taskipy.variables]
  path = "path/to/my_module"

  [tool.taskipy.tasks]
  lint = { cmd = "pylint {path}", use_vars = true }
  black = { cmd = "pylint {path}", use_vars = true }
  ```

  We have made the following changes to our configuration:

  1. We declared variables under `tool.taskipy.variables`
  2. We flagged the relevant task using `use_vars` to note that they should use the variables
  3. We replaced the repeating path with a `{path}` variable



  The formatting of the task commands uses python's own `string.format` method, and therefore supports everything that python's [formatted string literals](https://docs.python.org/3/tutorial/inputoutput.html#formatted-string-literals) let you do.



  Using variables is opt-in, which means that by default commands do **not** use them, and you will have to turn them on a task to task basis.

  If you want to turn on `use_vars` globally, all you need to do is to declare that under taskipy's **settings** table:

  ```toml
  [tool.taskipy.settings]
  use_vars = true

  [tool.taskipy.variables]
  path = "path/to/my_module"

  [tool.taskipy.tasks]
  lint = "pylint {path}"
  black = "black {path}"
  ```



  If we want to use variables within other variables, we can utilize recursive variables. By default, variables are not recursive, but we can specify a variable to be recursive by setting the `recursive` key to `true`.

  ```toml
  [tool.taskipy.settings]
  use_vars = true

  [tool.taskipy.variables]
  src_dir = "src"
  package_dir = { var = "{src_dir}/package", recursive = true }

  [tool.taskipy.tasks]
  echo = "echo {package_dir}"
  ```

  In this example, we could run `task echo` and we would then see `src/package`.



  Taskipy was created with poetry projects in mind, but actually only requires a valid `pyproject.toml` file in your project's directory. As a result, you can use it even eithout poetry:



  Install taskipy on your machine or in your virtualenv using:

  ```bash
  pip install taskipy
  ```



  Head into your project's directory (don't forget to activate virtualenv if you're using one), and run the following command:

  ```bash
  task TASK
  ```

  Where `TASK` is the name of your task.



  If you have a more specific use case, you might not be the first to run into it! Head over to the [ADVANCED_FEATURES](./docs/ADVANCED_FEATURES.md) doc, and look it up.



  <table>
    <tr>
      <td align="center"><a href="https://github.com/illBeRoy"><img src="https://avatars2.githubusercontent.com/u/6681893?v=4" width="100px;" alt=""/><br /><sub><b>Roy Sommer</b></sub></a></td>
    </tr>
  </table>



  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="http://triguba.com"><img src="https://avatars3.githubusercontent.com/u/15860938?v=4" width="100px;" alt=""/><br /><sub><b>Eugene Triguba</b></sub></a><br /><a href="https://github.com/illBeRoy/taskipy/commits?author=eugenetriguba" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/RobinFrcd"><img src="https://avatars0.githubusercontent.com/u/29704178?v=4" width="100px;" alt=""/><br /><sub><b>RobinFrcd</b></sub></a><br /><a href="https://github.com/illBeRoy/taskipy/commits?author=RobinFrcd" title="Code">💻</a></td>
      <td align="center"><a href="http://granitosaurus.rocks"><img src="https://avatars0.githubusercontent.com/u/5476164?v=4" width="100px;" alt=""/><br /><sub><b>Bernardas Ališauskas</b></sub></a><br /><a href="https://github.com/illBeRoy/taskipy/commits?author=Granitosaurus" title="Code">💻</a></td>
    </tr>
  </table>

  <!-- markdownlint-enable -->
  <!-- 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: f4936f8cc3892297dac999edd8ca0995d9a69c7b490e8f0b1a182fb22f5ead57
name: python-tasklib
arch: src
version: 2.5.1
epoch: 0
release: 1
summary: Official Taskwarrior library for Python
url: https://github.com/GothenburgBitFactory/tasklib
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a42dd2e7-28db-48d3-ae09-6958ea6755a3
location_href: 00005266-python-tasklib/python-tasklib-2.5.1-1.src.rpm
checksum_type: sha256
description:
  tasklib is a Python library for interacting with taskwarrior_ databases, using
  a queryset API similar to that of Django's ORM.


pkgId: a7d6c38b53f4bed4249046fe26b9fdb0d180025891cebf94a751156aee20b962
name: python-tasks
arch: src
version: 2.8.0
epoch: 0
release: 1
summary: A simple personal task queue to track todo items
url: https://github.com/pb-/tasks
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c96f0b01-3d4d-45db-85b3-8ca10d32ff00
location_href: 00011541-python-tasks/python-tasks-2.8.0-1.src.rpm
checksum_type: sha256
description:
  Proof of concept for a simple task queue, with a focus on UX and clean internal design.

  ![Screenshot of a tasks session](images/demo.png)

  Tasks can be installed through pip: `pip3 install tasks`, run with `tasks`.




  Follow these steps to add the output of `status` to your i3 status bar.

  1. Set up a cron job (`crontab -e`) that saves the status every minute.

     ```
     * * * * * /path/to/tasks status > $HOME/.tasks.status
     ```

  2. Configure i3 to use the provided status wrapper (installed alongside the `tasks` command.)

     ```
     ...
         status_command tasks-i3status
     ...
     ```




  It is very useful to have a quick and low-friction way to add new items from anywhere. This can be achieved by combining tasks with a generic dialog tool and your window manager keybindings.

  Example using zenity and i3:

  ```
  bindsym $mod+t exec --no-startup-id bash -c "zenity --title 'Add TODO item' --text 'What needs to be done?' --entry --width 450 | xargs tasks addt"
  ```

  Note that you will want to use tasks >= 2.7.0 for this since it detects external modification of the state file.




  The `standup` command shows (among other things) recently completed items. One use case is to send this list to your phone to have it ready for a daily standup. The repo contains a script (under `scripts`) to send stdin as an email with Mailgun which you can then combine with a cron job as follows.

  ```
  API_KEY=...
  DOMAIN=...
  EMAIL=...
  30 9 * * tue,wed,thu,fri /path/to/tasks standup 1 | /path/to/mailgun.sh
  30 9 * * mon /path/to/tasks standup 3 | /path/to/mailgun.sh
  ```




  To get started, have a look at the todo items for this project.

  ```
  make dev_install  # one-time setup
  make todo
  ```



  Pull requests are welcome. Please do keep in mind that the code is heavily inspired by the [Elm architecture](https://guide.elm-lang.org/architecture/) and consider the following guidelines.

   * Avoid mutation whenever possible, take advantage of [PEP 448](https://www.python.org/dev/peps/pep-0448/) to create updated versions of collections instead.
   * Side effects (and only side effects) should be in `main.py`; all other modules should be limited to pure code.
   * Avoid classes unless you have a really good reason for them (the code does not have any classes at the moment.)


pkgId: ff4d35ab47a4e30a82fb29744f71164ed7a9aa8458ea4de9ec193f4ae3468099
name: python-tasmotadevicecontroller
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: Control Tasmota devices via their web api
url: https://github.com/chaptergy/tasmota-device-controller
rpm_license: GNU General Public License v3 (GPLv3)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-db41438f-7bf3-484d-9a83-de78b318783b
location_href: 00005267-python-tasmotadevicecontroller/python-tasmotadevicecontroller-0.0.8-1.src.rpm
checksum_type: sha256
description:
  This packag provides async wrappers for Tasmota's web request API.

  Only very few requests are implemented so far! If you need other requests, please have a look at the section [Contributing](#contributing), or create an issue.

  `get` methods return the value of the fetched item, `set` methods return the new set value (so what the `get` method would return after the set). However there are some exceptions like `BLINK` for `setPower()` which always returns `True`, but that should be mentioned in the methods description.

  Since this package was created for a Home Assistant integration, you can check out [that integration](https://github.com/chaptergy/homeassistant-tasmota-switch) for other sample usage.

  Example usage:

  ```py
  import asyncio
  from tasmotadevicecontroller import TasmotaDevice
  from tasmotadevicecontroller import tasmota_types as t

  async def main():
      device = await TasmotaDevice.connect('192.168.10.21')

      
      nameResult = await device.getFriendlyName()
      print(nameResult)  # Returns 'My Tasmota Plug'

      
      getResult = await device.getPower()
      print(getResult)  # Returns True (on)

      
      setResult = await device.setPower(t.PowerType.TOGGLE)
      print(setResult)  # Returns True or False (depending if the device was switched on or off)

  loop = asyncio.get_event_loop()
  loop.run_until_complete(main())

  ```


  If you want to add new requests, can implement these commands and create a merge request on [GitHub](https://github.com/chaptergy/tasmota-device-controller).

  Almost every command is implemented as one getter method and one setter method. Add your command if possible in the same way inside the `TasmotaDevice` class. Remember to add descriptions to each method. This description can usually be taken from the Tasmota wiki.
  Also, remember to always use `async` `await`!

  If the command takes values from a specific set of values, create an `Enum` inside `tasmota_types.py` for it.


pkgId: 64666226c178403ca39d00ad68435435f52d136dbfaed56fac1e6c0152101119
name: python-tbats
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: BATS and TBATS for time series forecasting
url: https://github.com/intive-DataScience/tbats
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-21cfb780-67fa-47f5-955e-969f427b375a
location_href: 00012678-python-tbats/python-tbats-1.1.2-1.src.rpm
checksum_type: sha256
description:
  Package provides BATS and TBATS time series forecasting methods described in:

  > De Livera, A.M., Hyndman, R.J., & Snyder, R. D. (2011), Forecasting time series with complex seasonal patterns using exponential smoothing, Journal of the American Statistical Association, 106(496), 1513-1527.




  From pypi:

  ```bash
  pip install tbats
  ```

  Import via:

  ```python
  from tbats import BATS, TBATS
  ```



  ```python
  from tbats import TBATS
  import numpy as np



  if __name__ == '__main__':
      np.random.seed(2342)
      t = np.array(range(0, 160))
      y = 5 * np.sin(t * 2 * np.pi / 7) + 2 * np.cos(t * 2 * np.pi / 30.5) + \
          ((t / 20) ** 1.5 + np.random.normal(size=160) * t / 50) + 10

      
      estimator = TBATS(seasonal_periods=[14, 30.5])

      
      fitted_model = estimator.fit(y)

      
      y_forecasted = fitted_model.forecast(steps=14)

      
      print(fitted_model.summary())
  ```

  Reading model details

  ```python

  print(fitted_model.y_hat) # in sample prediction
  print(fitted_model.resid) # in sample residuals
  print(fitted_model.aic)


  print(fitted_model.params.alpha)
  print(fitted_model.params.beta)
  print(fitted_model.params.x0)
  print(fitted_model.params.components.use_box_cox)
  print(fitted_model.params.components.seasonal_harmonics)
  ```

  See **examples** directory for more details.



  BATS and TBATS tries multitude of models under the hood and **may appear slow when fitting** to long time series. In order to speed it up you can start with constrained model search space. It is recommended to run it without Box-Cox transformation and ARMA errors modelling that are the slowest model elements:

  ```python

  estimator = TBATS(
      seasonal_periods=[14, 30.5],
      use_arma_errors=False,  # shall try only models without ARMA
      use_box_cox=False  # will not use Box-Cox
  )
  fitted_model = estimator.fit(y)
  ```

  In some environment configurations parallel computation of models freezes. Reason for this is unclear yet. If **the process appears to be stuck** you can try running it on a single core:

  ```python
  estimator = TBATS(
      seasonal_periods=[14, 30.5],
      n_jobs=1
  )
  fitted_model = estimator.fit(y)
  ```



  Building package:

  ```bash
  pip install -e .[dev]
  ```

  Unit and integration tests:

  ```bash
  pytest test/
  ```

  R forecast package comparison tests. Those DO NOT RUN with default test command, you need R and forecast package installed:
  ```bash
  pytest test_R/
  ```



  Python implementation is meant to be as much as possible equivalent to R implementation in forecast package.

  - BATS in R https://www.rdocumentation.org/packages/forecast/versions/8.4/topics/bats
  - TBATS in R: https://www.rdocumentation.org/packages/forecast/versions/8.4/topics/tbats


pkgId: 83135be5a0eb84c5197f656e0d358042a0dea1045d4ca49f52f0e16ac2970f7b
name: python-tbtrim
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: A utility to trim Python traceback information.
url: https://github.com/gousaiyang/tbtrim
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-46b2011d-01d1-492b-bbe2-b14823374c4a
location_href: 00005269-python-tbtrim/python-tbtrim-0.3.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Downloads](https://pepy.tech/badge/tbtrim)](https://pepy.tech/count/tbtrim)
  [![PyPI - Version](https://img.shields.io/pypi/v/tbtrim.svg)](https://pypi.org/project/tbtrim)
  [![PyPI - Format](https://img.shields.io/pypi/format/tbtrim.svg)](https://pypi.org/project/tbtrim)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/tbtrim.svg)](https://pypi.org/project/tbtrim)
  [![PyPI - Status](https://img.shields.io/pypi/status/tbtrim.svg)](https://pypi.org/project/tbtrim)
  [![Travis CI - Status](https://img.shields.io/travis/gousaiyang/tbtrim.svg)](https://travis-ci.org/gousaiyang/tbtrim)
  ![License](https://img.shields.io/github/license/gousaiyang/tbtrim.svg)

  `tbtrim` is a utility to trim Python traceback information. By assigning user-refined [`sys.excepthook`](https://docs.python.org/3/library/sys.html#sys.excepthook), one can easily customize the behavior after an exception is raise and uncaught, and just before the interpreter prints out the given traceback and exception to `sys.stderr`.

  In a more human-readable way, `tbtrim` is to let you handle the last words of a program when it exits because of an exception.



  Simply run the following to install the current version from PyPI:

  ```shell
  $ pip install tbtrim
  ```

  Or install the latest version from the git repository:

  ```shell
  git clone https://github.com/gousaiyang/tbtrim.git
  cd tbtrim
  pip install -e .

  git pull
  ```



  > **set_trim_rule**(*predicate*, *target*=BaseException, *exclude*=None, *strict*=False, *exception*=None)

  Set the rule for trimming traceback (will set `sys.excepthook` and `threading.excepthook` if available).

  You can determine whether to start trimming traceback items based on the filename (using `predicate`), and can choose to trim traceback only for some certain exceptions (using `target` and `exclude`).

  **Args:**

  - **predicate** (*function*): a function which takes one `str` parameter (the filename of a traceback item) and returns `bool` (returning `True` indicates that this traceback item and the following items should be trimmed)
  - **target** (*class_or_tuple*): an exception or a tuple of exceptions may be given to trim traceback only for those exceptions
  - **exclude** (*class_or_tuple*): an exception or a tuple of exceptions may be given to exclude them from traceback trimming
  - **strict** (*bool*): indicate whether to check an exception against `target` and `exclude` in a strict mode (setting `True` uses `is` to check, `False` uses `issubclass` to check)
  - **exception** (*class_or_tuple*): this is a deprecated alias of `exclude`, retained for backward compatibility

  > **clear_trim_rule**()

  Clear the rule for trimming traceback (restore the excepthooks).


pkgId: 95609255a9fab154642147070ab13a1150ae767d910e5e0c10f993789d453e6f
name: python-tdigest
arch: src
version: 0.5.2.2
epoch: 0
release: 1
summary: T-Digest data structure
url: https://github.com/CamDavidsonPilon/tdigest
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0b04368e-3928-4c0c-8afd-210dd792e75c
location_href: 00010987-python-tdigest/python-tdigest-0.5.2.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/tdigest.svg)](https://badge.fury.io/py/tdigest)
  [![Build Status](https://travis-ci.org/CamDavidsonPilon/tdigest.svg?branch=master)](https://travis-ci.org/CamDavidsonPilon/tdigest)


  This is a Python implementation of Ted Dunning's [t-digest](https://github.com/tdunning/t-digest) data structure. The t-digest data structure is designed around computing accurate estimates from either streaming data, or distributed data. These estimates are percentiles, quantiles, trimmed means, etc. Two t-digests can be added, making the data structure ideal for map-reduce settings, and can be serialized into much less than 10kB (instead of storing the entire list of data).

  See a blog post about it here: [Percentile and Quantile Estimation of Big Data: The t-Digest](http://dataorigami.net/blogs/napkin-folding/19055451-percentile-and-quantile-estimation-of-big-data-the-t-digest)



  *tdigest* is compatible with both Python 2 and Python 3.

  ```
  pip install tdigest
  ```





  ```
  from tdigest import TDigest
  from numpy.random import random

  digest = TDigest()
  for x in range(5000):
      digest.update(random())

  print(digest.percentile(15))  # about 0.15, as 0.15 is the 15th percentile of the Uniform(0,1) distribution
  ```



  ```
  another_digest = TDigest()
  another_digest.batch_update(random(5000))
  print(another_digest.percentile(15))
  ```



  ```
  sum_digest = digest + another_digest
  sum_digest.percentile(30)  # about 0.3
  ```



  You can use the to_dict() method to turn a TDigest object into a standard Python dictionary.
  ```
  digest = TDigest()
  digest.update(1)
  digest.update(2)
  digest.update(3)
  print(digest.to_dict())
  ```
  Or you can get only a list of Centroids with `centroids_to_list()`.
  ```
  digest.centroids_to_list()
  ```

  Similarly, you can restore a Python dict of digest values with `update_from_dict()`. Centroids are merged with any existing ones in the digest.
  For example, make a fresh digest and restore values from a python dictionary.
  ```
  digest = TDigest()
  digest.update_from_dict({'K': 25, 'delta': 0.01, 'centroids': [{'c': 1.0, 'm': 1.0}, {'c': 1.0, 'm': 2.0}, {'c': 1.0, 'm': 3.0}]})
  ```

  K and delta values are optional, or you can provide only a list of centroids with `update_centroids_from_list()`.
  ```
  digest = TDigest()
  digest.update_centroids([{'c': 1.0, 'm': 1.0}, {'c': 1.0, 'm': 2.0}, {'c': 1.0, 'm': 3.0}])
  ```

  If you want to serialize with other tools like JSON, you can first convert to_dict().
  ```
  json.dumps(digest.to_dict())
  ```

  Alternatively, make a custom encoder function to provide as default to the standard json module.
  ```
  def encoder(digest_obj):
      return digest_obj.to_dict()
  ```
  Then pass the encoder function as the default parameter.
  ```
  json.dumps(digest, default=encoder)
  ```




  `TDigest.`

   - `update(x, w=1)`: update the tdigest with value `x` and weight `w`.
   - `batch_update(x, w=1)`: update the tdigest with values in array `x` and weight `w`.
   - `compress()`: perform a compression on the underlying data structure that will shrink the memory footprint of it, without hurting accuracy. Good to perform after adding many values.
   - `percentile(p)`: return the `p`th percentile. Example: `p=50` is the median.
   - `cdf(x)`: return the CDF the value `x` is at.
   - `trimmed_mean(p1, p2)`: return the mean of data set without the values below and above the `p1` and `p2` percentile respectively.
   - `to_dict()`: return a Python dictionary of the TDigest and internal Centroid values.
   - `update_from_dict(dict_values)`: update from serialized dictionary values into the TDigest object.
   - `centroids_to_list()`: return a Python list of the TDigest object's internal Centroid values.
   - `update_centroids_from_list(list_values)`: update Centroids from a python list.


pkgId: 8880423f80df08d794392b730457193c9e8982c798288ed66c33c5e63ea4948a
name: python-teamcity-messages
arch: src
version: 1.32
epoch: 0
release: 1
url: https://github.com/JetBrains/teamcity-messages
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-78825b5c-11cf-4d83-9475-6883d345ae45
location_href: 00011312-python-teamcity-messages/python-teamcity-messages-1.32-1.src.rpm
checksum_type: sha256
summary:
  Send test results to TeamCity continuous integration server from unittest, nose, py.test, twisted trial, behave (Python 2.6+)

description:
  |  |jb_project| |license| |pypi_version|
  |  |versions| |teamcity_ci|
  This package integrates Python with the
  `TeamCity <http://www.jetbrains.com/teamcity/>`__ Continuous Integration
  (CI) server. It allows sending `"service
  messages" <https://confluence.jetbrains.com/display/TCDL/Build+Script+Interaction+with+TeamCity>`__
  from Python code. Additionally, it provides integration with the
  following testing frameworks and tools:
  -  `py.test <http://pytest.org/>`__
  -  `nose <https://nose.readthedocs.org/>`__
  -  `Django <https://docs.djangoproject.com/en/1.8/topics/testing/advanced/#other-testing-frameworks>`__
  -  `unittest (Python standard
     library) <https://docs.python.org/2/library/unittest.html>`__
  -  `Trial (Twisted) <http://twistedmatrix.com/trac/wiki/TwistedTrial>`__
  -  `Flake8 <https://flake8.readthedocs.org/>`__
  -  `Behave <https://behave.readthedocs.io/>`__
  -  `PyLint <https://www.pylint.org/>`__


pkgId: 8b49832afbc4de5919db88cf7c835d46ca645d487c1f929817292d88f275a381
name: python-telebot
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: A Telegram bot library, with simple route decorators.
url: https://github.com/KyleJamesWalker/telebot
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-73bfd319-5c87-4bb9-b0c1-f922e72bdc60
location_href: 00011263-python-telebot/python-telebot-0.0.5-1.src.rpm
checksum_type: sha256
description:
  Note: This is not `pyTelegramBotAPI <https://github.com/eternnoir/pyTelegramBotAPI>`_, but do to often confusion I have included
  it within this package.  So if you accidentally install this instead of `pyTelegramBotAPI <https://github.com/eternnoir/pyTelegramBotAPI>`_
  the examples, etc will still work.
  This originally was telegram bot library, with simple route decorators, and will now
  be imported as telebot_router, to separate `pyTelegramBotAPI <https://github.com/eternnoir/pyTelegramBotAPI>`_ and this package from
  collision.
  Currently a work in progress, doesn't do much now, but will register and send messages.
  Example Setup
  ^^^^^^^^^^^^^
   from telebot_router import TeleBot
   app = TeleBot(__name__)
   @app.route('/command ?(.*)')
   def example_command(message, cmd):
       chat_dest = message['chat']['id']
       msg = "Command Recieved: {}".format(cmd)
       app.send_message(chat_dest, msg)
   @app.route('(?!/).+')
   def parrot(message):
      chat_dest = message['chat']['id']
      user_msg = message['text']
      msg = "Parrot Says: {}".format(user_msg)
      app.send_message(chat_dest, msg)
   if __name__ == '__main__':
       app.config['api_key'] = 'xxxxxxxx:enterYourBotKeyHereToTest'
       app.poll(debug=True)


pkgId: 413db400d5aa0064e48806a510230f64048171c69b92e5bc2ba4bbb7b8a5156d
name: python-telegraph
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Telegraph API wrapper
url: https://github.com/python273/telegraph
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-47d3b14d-594d-4033-9998-a99abb62d3da
location_href: 00010698-python-telegraph/python-telegraph-2.2.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/telegraph.svg)](https://pypi.python.org/pypi/telegraph)
  ![Python Versions](https://img.shields.io/pypi/pyversions/telegraph.svg)
  ![License](https://img.shields.io/github/license/python273/telegraph.svg)

  Python Telegraph API wrapper

  - [Documentation](https://python-telegraph.readthedocs.io/en/latest/)

  ```bash
  $ python3 -m pip install telegraph

  $ python3 -m pip install 'telegraph[aio]'
  ```


  ```python
  from telegraph import Telegraph

  telegraph = Telegraph()
  telegraph.create_account(short_name='1337')

  response = telegraph.create_page(
      'Hey',
      html_content='<p>Hello, world!</p>'
  )
  print(response['url'])
  ```


  ```python
  import asyncio
  from telegraph.aio import Telegraph

  async def main():
      telegraph = Telegraph()
      print(await telegraph.create_account(short_name='1337'))

      response = await telegraph.create_page(
          'Hey',
          html_content='<p>Hello, world!</p>',
      )
      print(response['url'])


  asyncio.run(main())
  ```


pkgId: 2f3ccda5b8f58d4787d72cd8256a8fedceb029422e8f82c7c620aa6bff1a3b7d
name: python-telepath
arch: src
version: 0.3
epoch: 0
release: 1
summary: A library for exchanging data between Python and JavaScript
url: https://github.com/wagtail/telepath
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8091d0b8-ec85-4d5a-928a-5adb51dc89e4
location_href: 00012549-python-telepath/python-telepath-0.3-1.src.rpm
checksum_type: sha256
description:
  *telepath* is a Django library for exchanging data between Python and JavaScript, allowing you to build apps with rich client-side interfaces while keeping the business logic in server-side code.



  It provides a mechanism for packing structured data, including Python objects, into a JSON-serializable format. This mechanism can be extended to support any Python class, by registering the class with a corresponding JavaScript implementation. The packed data can then be included in an HTTP response, and unpacked in JavaScript to obtain an equivalent data structure to the original. Think of it as [`pickle`](https://docs.python.org/3/library/pickle.html), but with the unpickling happening in the browser.

  Full documentation: https://wagtail.github.io/telepath/


pkgId: 9c534c4df07a3894ab91e26ba3f0096a3d79fb4f1e278bc814c96a7711102638
name: python-telethon-tgcrypto
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: telethon bindings for the tgcrypto module
url: https://github.com/kittyandrew/telethon-tgcrypto
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-88de2166-9192-4879-a2db-ef4158d3f979
location_href: 00010256-python-telethon-tgcrypto/python-telethon-tgcrypto-0.0.3-1.src.rpm
checksum_type: sha256
description:
  Module ``telethon-tgcrypto`` brings better performance to
  `Telethon <https://github.com/LonamiWebs/Telethon>`__ lib.
  Installation
  ~~~~~~~~~~~~
  **N.B.** you must not have ``cryptg`` installed, because it interferes with
  this module.
  To install this module and patch your Telethon installation just run:
      pip install telethon-tgcrypto
  Credits
  ~~~~~~~
  -  `@painor <https://github.com/painor>`__ for making this module
  -  `@andrew <https://github.com/kittyandrew>`__ for writing this readme
  -  `@tulir <https://github.com/tulir>`__ for the basic implementation
  -  `@lonami <https://github.com/lonami>`__ &
     `contributors <https://github.com/LonamiWebs/Telethon/graphs/contributors>`__
     for making `telethon <https://github.com/LonamiWebs/Telethon>`__
  -  `unknown <https://github.com/explore>`__ `d <https://github.com/delivrance>`__\ `eveloper <https://github.com/explore>`__
     for the fast crypto module


pkgId: 9f1e506ed9fc3e8056ad4748cc067c53da112f9a8077ad3129dea7df56f870ac
name: python-tempdir
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: Tempdirs are temporary directories, based on tempfile.mkdtemp
url: https://bitbucket.org/another_thomas/tempdir
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0d96631b-ca6b-4084-bfc6-426215c79474
location_href: 00005274-python-tempdir/python-tempdir-0.7.1-1.src.rpm
checksum_type: sha256
description:
  Having to manually manage temporary directories is annoying.
  So this class encapsulates temporary directories which just disappear after use,
  including contained directories and files.
  Temporary directories are created with tempfile.mkdtemp and thus save from race conditions.
  Cleanup might not work on windows if files are still opened.


pkgId: 565c0144b67920ec12d39fce66f939ada9874e06ea920318ea157a411f4d943c
name: python-tenacity
arch: src
version: 8.2.2
epoch: 0
release: 1
summary: Retry code until it succeeds
url: https://github.com/jd/tenacity
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-32b96a36-ae3e-443e-a2d3-70b31da49b70
location_href: 00005275-python-tenacity/python-tenacity-8.2.2-1.src.rpm
checksum_type: sha256
description:
  Tenacity is a general-purpose retrying library to simplify the task of adding retry behavior to just about anything.


pkgId: 31cc3897ce1b21c120e87d71b4005978015b9784f61b91a2926c13342a8c5578
name: python-tensor2tensor
arch: src
version: 1.15.7
epoch: 0
release: 1
summary: Tensor2Tensor
url: http://github.com/tensorflow/tensor2tensor
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d348dc52-7ef1-4950-8782-d9346dc00d74
location_href: 00010318-python-tensor2tensor/python-tensor2tensor-1.15.7-1.src.rpm
checksum_type: sha256
description:
  Tensor2Tensor, or T2T for short, is a library of deep learning models and datasets designed to make deep learning more accessible and accelerate ML research. T2T was developed by researchers and engineers in the Google Brain team and a community of users. It is now in maintenance mode -- we keep it running and welcome bug-fixes, but encourage users to use the successor library Trax.


pkgId: 3482c619df4965ca6515973c07916d54003a84cb5cb257946e49ce9dcce9ced2
name: python-tensorflow-datasets
arch: src
version: 4.9.0
epoch: 0
release: 1
summary: tensorflow/datasets is a library of datasets ready to use with TensorFlow.
url: https://github.com/tensorflow/datasets
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ad2f55ec-98d2-4609-b95d-d55b0836494c
location_href: 00009447-python-tensorflow-datasets/python-tensorflow-datasets-4.9.0-1.src.rpm
checksum_type: sha256
description:
  tensorflow/datasets is a library of public datasets ready to use with
  TensorFlow. Each dataset definition contains the logic necessary to download and
  prepare the dataset, as well as to read it into a model using the
  `tf.data.Dataset` API.

  Usage outside of TensorFlow is also supported.

  See the README on GitHub for further documentation.


pkgId: 1c0b814f06b9e7e6943db8a01d32184daa95e097abbea8a05e45d297aa90fde9
name: python-tensorflowonspark
arch: src
version: 2.2.5
epoch: 0
release: 1
summary: Deep learning with TensorFlow on Apache Spark clusters
url: https://github.com/yahoo/TensorFlowOnSpark
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6fc6b95d-e258-42bf-a14e-414cd1ee438c
location_href: 00010586-python-tensorflowonspark/python-tensorflowonspark-2.2.5-1.src.rpm
checksum_type: sha256
description:
  <!--
  Copyright 2019 Yahoo Inc.
  Licensed under the terms of the Apache 2.0 license.
  Please see LICENSE file in the project root for terms.
  -->

  > _TensorFlowOnSpark brings scalable deep learning to Apache Hadoop and Apache Spark
  clusters._

  [![Build Status](https://cd.screwdriver.cd/pipelines/6384/badge)](https://cd.screwdriver.cd/pipelines/6384)
  [![Package](https://img.shields.io/badge/package-pypi-blue.svg)](https://pypi.org/project/tensorflowonspark/)
  [![Downloads](https://img.shields.io/pypi/dm/tensorflowonspark.svg)](https://img.shields.io/pypi/dm/tensorflowonspark.svg)
  [![Documentation](https://img.shields.io/badge/Documentation-latest-blue.svg)](https://yahoo.github.io/TensorFlowOnSpark/)

  By combining salient features from the [TensorFlow](https://www.tensorflow.org) deep learning framework with [Apache Spark](http://spark.apache.org) and [Apache Hadoop](http://hadoop.apache.org), TensorFlowOnSpark enables distributed
  deep learning on a cluster of GPU and CPU servers.

  It enables both distributed TensorFlow training and
  inferencing on Spark clusters, with a goal to minimize the amount
  of code changes required to run existing TensorFlow programs on a
  shared grid.  Its Spark-compatible API helps manage the TensorFlow
  cluster with the following steps:

  1. **Startup** - launches the Tensorflow main function on the executors, along with listeners for data/control messages.
  1. **Data ingestion**
     - **InputMode.TENSORFLOW** - leverages TensorFlow's built-in APIs to read data files directly from HDFS.
     - **InputMode.SPARK** - sends Spark RDD data to the TensorFlow nodes via a `TFNode.DataFeed` class.  Note that we leverage the [Hadoop Input/Output Format](https://github.com/tensorflow/ecosystem/tree/master/hadoop) to access TFRecords on HDFS.
  1. **Shutdown** - shuts down the Tensorflow workers and PS nodes on the executors.



  - [Background](#background)
  - [Install](#install)
  - [Usage](#usage)
  - [API](#api)
  - [Contribute](#contribute)
  - [License](#license)



  TensorFlowOnSpark was developed by Yahoo for large-scale distributed
  deep learning on our Hadoop clusters in Yahoo's private cloud.

  TensorFlowOnSpark provides some important benefits (see [our
  blog](https://developer.yahoo.com/blogs/157196317141/))
  over alternative deep learning solutions.
     * Easily migrate existing TensorFlow programs with <10 lines of code change.
     * Support all TensorFlow functionalities: synchronous/asynchronous training, model/data parallelism, inferencing and TensorBoard.
     * Server-to-server direct communication achieves faster learning when available.
     * Allow datasets on HDFS and other sources pushed by Spark or pulled by TensorFlow.
     * Easily integrate with your existing Spark data processing pipelines.
     * Easily deployed on cloud or on-premise and on CPUs or GPUs.



  TensorFlowOnSpark is provided as a pip package, which can be installed on single machines via:
  ```

  pip install tensorflowonspark


  pip install tensorflowonspark==1.4.4
  ```

  For distributed clusters, please see our [wiki site](../../wiki) for detailed documentation for specific environments, such as our getting started guides for [single-node Spark Standalone](https://github.com/yahoo/TensorFlowOnSpark/wiki/GetStarted_Standalone), [YARN clusters](../../wiki/GetStarted_YARN) and [AWS EC2](../../wiki/GetStarted_EC2).  Note: the Windows operating system is not currently supported due to [this issue](https://github.com/yahoo/TensorFlowOnSpark/issues/36).



  To use TensorFlowOnSpark with an existing TensorFlow application, you can follow our [Conversion Guide](../../wiki/Conversion-Guide) to describe the required changes.  Additionally, our [wiki site](../../wiki) has pointers to some presentations which provide an overview of the platform.

  **Note: since TensorFlow 2.x breaks API compatibility with TensorFlow 1.x, the examples have been updated accordingly.  If you are using TensorFlow 1.x, you will need to checkout the `v1.4.4` tag for compatible examples and instructions.**



  [API Documentation](https://yahoo.github.io/TensorFlowOnSpark/) is automatically generated from the code.



  Please join the [TensorFlowOnSpark user group](https://groups.google.com/forum/#!forum/TensorFlowOnSpark-users) for discussions and questions.  If you have a question, please review our [FAQ](../../wiki/Frequently-Asked-Questions) before posting.

  Contributions are always welcome.  For more information, please see our [guide for getting involved](Contributing.md).



  The use and distribution terms for this software are covered by the Apache 2.0 license.
  See [LICENSE](LICENSE) file for terms.


pkgId: 48db2bc970dd04202b16db8853ea0d52a788edcedf7a763e7674cee542687847
name: python-tentaclio
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Unification of data connectors for distributed data tasks
url: https://github.com/octoenergy/tentaclio
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fef50d1c-0b48-444b-a6a4-bd8613137535
location_href: 00010815-python-tentaclio/python-tentaclio-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI status](https://circleci.com/gh/octoenergy/tentaclio/tree/master.png?circle-token=df7aad11367f1ace5bce253b18efb6b21eaa65bc)](https://circleci.com/gh/octoenergy/tentaclio/tree/master)
  [![Documentation Status](https://readthedocs.org/projects/tentaclio/badge/?version=latest)](https://tentaclio.readthedocs.io/en/latest/?badge=latest)

  Python library that simplifies:
  * Handling streams from different protocols such as `file:`, `ftp:`, `sftp:`, `s3:`, ...
  * Opening database connections.
  * Managing the credentials in distributed systems.

  Main considerations in the design:
  * Easy to use: all streams are open via `tentaclio.open`, all database connections through `tentaclio.db`.
  * URLs are the basic resource locator and db connection string.
  * Automagic authentication for protected resources.
  * Extensible: you can add your own handlers for other schemes.
  * Pandas interaction.




  ```python
  import tentaclio
  contents = "👋 🐙"

  with tentaclio.open("ftp://localhost:2021/upload/file.txt", mode="w") as writer:
      writer.write(contents)


  bucket = "s3://my-bucket/octopus/hello.txt"
  with tentaclio.open(bucket) as reader:
      print(reader.read())
  ```


  ```python
  import tentaclio

  tentaclio.copy("/home/constantine/data.csv", "sftp://constantine:tentacl3@sftp.octoenergy.com/uploads/data.csv")
  ```

  ```python
  import tentaclio

  tentaclio.remove("s3://my-bucket/octopus/the-9th-tentacle.txt")
  ```

  ```python
  import tentaclio

  for entry in tentaclio.listdir("s3:://mybucket/path/to/dir"):
      print("Entry", entry)
  ```


  ```python
  import os

  import tentaclio

  print("env ftp credentials", os.getenv("OCTOIO__CONN__OCTOENERGY_FTP"))




  with tentaclio.open("sftp://sftp.octoenergy.com/uploads/data.csv") as reader:
      print(reader.read())
  ```


  ```python
  import os

  import tentaclio

  print("env TENTACLIO__CONN__DB", os.getenv("TENTACLIO__CONN__DB"))




  with tentaclio.db("postgresql://hostname/example") as pg:
      results = pg.query("select * from my_table")
  ```


  ```python
  import pandas as pd  # 🐼🐼
  import tentaclio  # 🐙

  df = pd.DataFrame([[1, 2, 3], [10, 20, 30]], columns=["col_1", "col_2", "col_3"])

  bucket = "s3://my-bucket/data/pandas.csv"

  with tentaclio.open(bucket, mode="w") as writer:  # supports more pandas readers
      df.to_csv(writer, index=False)

  with tentaclio.open(bucket) as reader:
      new_df = pd.read_csv(reader)


  with tentaclio.db(
          connection_info,
          connect_args={'options': '-csearch_path=schema_name'}
      ) as client:
      df.to_sql(
          name='observations', # table name
          con=client.conn,
      )
  ```



  You can get tentaclio using pip

  ```sh
  pip install tentaclio
  ```
  or pipenv
  ```sh
  pipenv install tentaclio
  ```



  Clone this repo and install [pipenv](https://pipenv.readthedocs.io/en/latest/):

  In the `Makefile` you'll find some useful targets for linting, testing, etc. i.e.:
  ```sh
  make test
  ```



  This is how to use `tentaclio` for your daily data ingestion and storing needs.


  In order to open streams to load or store data the universal function is:

  ```python
  import tentaclio

  with tentaclio.open("/path/to/my/file") as reader:
      contents = reader.read()

  with tentaclio.open("s3://bucket/file", mode='w') as writer:
      writer.write(contents)

  ```
  Allowed modes are `r`, `w`, `rb`, and `wb`. You can use `t` instead of `b` to indicate text streams, but that's the default.

  In order to keep tentaclio as light as possible, it only includes `file`, `ftp`, `sftp`, `http` and `https` schemes by default.
  However, many more are easily available by installing extra packages:

  Default:
  * `/local/file`
  * `file:///local/file`
  * `ftp://path/to/file`
  * `sftp://path/to/file`
  * `http://host.com/path/to/resource`
  * `https://host.com/path/to/resource`

  [tentaclio-s3](https://github.com/octoenergy/tentaclio-s3)
  * `s3://bucket/file`

  [tentaclio-gs](https://github.com/octoenergy/tentaclio-gs)
  * `gs://bucket/file`
  * `gsc://bucket/file`

  [tentaclio-gdrive](https://github.com/octoenergy/tentaclio-gdrive)
  * `gdrive:/My Drive/file`
  * `googledrive:/My Drive/file`

  [tentaclio-postgres](https://github.com/octoenergy/tentaclio-postgres)
  * `postgresql://host/database::table` will allow you to write from a csv format into a database with the same column names (note that the table goes after `::` :warning:).


  You can add the credentials for any of the urls in order to access protected resources.


  You can use these readers and writers with pandas functions like:

  ```python
  import pandas as pd
  import tentaclio

  with tentaclio.open("/path/to/my/file") as reader:
      df = pd.read_csv(reader)

  [...]

  with tentaclio.open("s3::/path/to/my/file", mode='w') as writer:
      df.to_parquet(writer)
  ```
  `Readers`, `Writers` and their closeable versions can be used anywhere expecting a file-like object; pandas or pickle are examples of such functions.



  The default behaviour for the `open` context manager in python is to create an empty file when opening
  it in writable mode. This can be annoying if the process that creates the data within the `with` clause
  yields empty dataframes and nothing gets written. This will make Spark and Presto panic.

  To avoid this we can make the stream _empty safe_ so the empty buffer won't be flushed if no writes have been performed so no empty file will be created.


  ```
  with tio.make_empty_safe(tio.open("s3://bucket/file.parquet", mode="wb")) as writer:
      if not df.empty:
          df.to_parquet(writer)
  ```



  Some URL schemes allow listing resources in a pythonnic way:
  ```python
  import tentaclio

  for entry in tentaclio.listdir("s3:://mybucket/path/to/dir"):
      print("Entry", entry)
  ```

  Whereas `listdir` might be convinient we also offer `scandir`, which returns a list of [DirEntry](https://github.com/octoenergy/tentaclio/blob/ddbc28615de4b99106b956556db74a20e4761afe/src/tentaclio/fs/scanner.py#L13)s, and, `walk`. All functions follow as closely as possible their standard library definitions.




  In order to open db connections you can use `tentaclio.db` and have instant access to postgres, sqlite, athena and mssql.

  ```python
  import tentaclio

  [...]

  query = "select 1";
  with tentaclio.db(POSTGRES_TEST_URL) as client:
      result =client.query(query)
  [...]
  ```

  The supported db schemes are:

  Default:
  * `sqlite://`
  * `mssql://`
  * + Any other scheme supported by sqlalchemy.

  [tentaclio-postgres](https://github.com/octoenergy/tentaclio-postgres)
  * `postgresql://`

  [tentaclio-athena](https://github.com/octoenergy/tentaclio-athena)
  * `awsathena+rest://`

  [tentaclio-databricks](https://github.com/octoenergy/tentaclio-databricks)
  * `databricks+thrift://`

  [tentaclio-snowflake](https://github.com/octoenergy/tentaclio-snowflake)
  * `snowflake://`



  For postgres you can set the variable `TENTACLIO__PG_APPLICATION_NAME` and the value will be injected
  when connecting to the database.



  1. Configure credentials by using environmental variables prefixed with `TENTACLIO__CONN__`  (i.e.  `TENTACLIO__CONN__DATA_FTP=sfpt://real_user:132ldsf@ftp.octoenergy.com`).

  2. Open a stream:
  ```python
  with tentaclio.open("sftp://ftp.octoenergy.com/file.csv") as reader:
      reader.read()
  ```
  The credentials get injected into the url.

  3. Open a db client:
  ```python
  import tentaclio

  with tentaclio.db("postgresql://hostname/my_data_base") as client:
      client.query("select 1")
  ```
  Note that `hostname` in the url to be authenticated is a wildcard that will match any hostname. So `authenticate("http://hostname/file.txt")` will be injected to `http://user:pass@octo.co/file.txt` if the credential for `http://user:pass@octo.co/` exists.

  Different components of the URL are set differently:
  - Scheme and path will be set from the URL, and null if missing.
  - Username, password and hostname will be set from the stored credentials.
  - Port will be set from the stored credentials if it exists, otherwise from the URL.
  - Query will be set from the URL if it exists, otherwise from the stored credentials (so it can be
    overriden)



  You can also set a credentials file that looks like:
  ```
  secrets:
      db_1: postgresql://user1:pass1@myhost.com/database_1
      db_2: mssql://user2:pass2@otherhost.com/database_2?driver=ODBC+Driver+17+for+SQL+Server
      ftp_server: ftp://fuser:fpass@ftp.myhost.com
  ```
  And make it accessible to tentaclio by setting the environmental variable `TENTACLIO__SECRETS_FILE`. The actual name of each url is for traceability and has no effect in the functionality.

  (Note that you may need to add `?driver={driver from /usr/local/etc/odbcinst.ini}` for mssql database connection strings; see above example)

  Alternatively you can run `curl https://raw.githubusercontent.com/octoenergy/tentaclio/master/extras/init_tentaclio.sh` to create a secrets file in `~/.tentaclio.yml` and
  automatically configure your environment.



  In order to abstract concrete dependencies from the implementation of data related functions (or in any part of the system really) we use typed [protocols](https://mypy.readthedocs.io/en/latest/protocols.html#simple-user-defined-protocols). This allows a more flexible dependency injection than using subclassing or [more complex approches](http://code.activestate.com/recipes/413268/). This idea is heavily inspired by how this exact thing is done in [go](https://www.youtube.com/watch?v=ifBUfIb7kdo). Learn more about this principle in our [tech blog](https://tech.octopus.energy/news/2019/03/21/python-interfaces-a-la-go.html).


pkgId: fd2a5877393e5dafaa274b58802931e24ce5eef13f54bc64014f4ef96eeb429f
name: python-terminaltables
arch: src
version: 3.1.10
epoch: 0
release: 1
summary: Generate simple tables in terminals from a nested list of strings.
url: https://github.com/matthewdeanmartin/terminaltables
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8dad3f5f-33c3-4e87-a4a7-7fe5f5cfd061
location_href: 00005277-python-terminaltables/python-terminaltables-3.1.10-1.src.rpm
checksum_type: sha256
description:
  Install:
  ```bash
  pip install terminaltables
  ```
  Usage:
  ```python
  from terminaltables import AsciiTable
  table_data = [
      ['Heading1', 'Heading2'],
      ['row1 column1', 'row1 column2'],
      ['row2 column1', 'row2 column2'],
      ['row3 column1', 'row3 column2']
  ]
  table = AsciiTable(table_data)
  print
  table.table
  ```
  ```bash
  +--------------+--------------+
  | Heading1     | Heading2     |
  +--------------+--------------+
  | row1 column1 | row1 column2 |
  | row2 column1 | row2 column2 |
  | row3 column1 | row3 column2 |
  +--------------+--------------+
  ```


pkgId: 045070f023ea0ee757ec52213a6d8d272bb8416a17cad1eefe7b4796d480585a
name: python-terrawrap
arch: src
version: 0.9.23
epoch: 0
release: 1
summary: Set of Python-based CLI tools for working with Terraform configurations
url: https://github.com/amplify-education/terrawrap
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-381ec1a6-0c18-4bfb-b849-c8c89f67b039
location_href: 00011064-python-terrawrap/python-terrawrap-0.9.23-1.src.rpm
checksum_type: sha256
description:
  [![Codacy Badge](https://api.codacy.com/project/badge/Grade/e8bf52c80edf4070a18d8725b1f5f166)](https://app.codacy.com/app/amplify-education/terrawrap?utm_source=github.com&utm_medium=referral&utm_content=amplify-education/terrawrap&utm_campaign=Badge_Grade_Settings)
  [![Codacy Badge](https://api.codacy.com/project/badge/Coverage/ceeb459250dd429f9ca5a497c0e45051)](https://www.codacy.com/app/amplify-education/terrawrap?utm_source=github.com&utm_medium=referral&utm_content=amplify-education/terrawrap&utm_campaign=Badge_Coverage)
  [![Build Status](https://travis-ci.org/amplify-education/terrawrap.svg?branch=master)](https://travis-ci.org/amplify-education/terrawrap)
  [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/amplify-education/terrawrap/master/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/terrawrap.svg)](https://pypi.org/project/terrawrap/)
  [![Python Versions](https://img.shields.io/pypi/pyversions/terrawrap.svg)](https://pypi.python.org/pypi/terrawrap)
  [![Downloads](https://img.shields.io/badge/dynamic/json.svg?label=downloads&url=https%3A%2F%2Fpypistats.org%2Fapi%2Fpackages%2Fterrawrap%2Frecent&query=data.last_month&colorB=brightgreen&suffix=%2FMonth)](https://pypistats.org/packages/terrawrap)



  Set of Python-based CLI tools for working with Terraform configurations in bulk



  Amplify builds innovative and compelling digital educational products that empower teachers and students across the
  country. We have a long history as the leading innovator in K-12 education - and have been described as the best tech
  company in education and the best education company in tech. While others try to shrink the learning experience into
  the technology, we use technology to expand what is possible in real classrooms with real students and teachers.

  Learn more at <https://www.amplify.com>



  -   [Features](#features)

  -   [Goals](#goals)

  -   [Getting Started](#getting-started)
      -   [Prerequisites](#prerequisites)
      -   [Installing](#installing)
      -   [Building From Source](#building-from-source)
      -   [Running Tests](#running-tests)

  -   [Configuration](#configuration)
      -   [.tf_wrapper](#tf_wrapper)
      -   [Plugins](#plugins)
      -   [Autovars](#autovars)
      -   [Backend Configuration](#backend-configuration)

  -   [Commands](#commands)
      -   [tf](#tf)
      -   [plan_check](#plan_check)
      -   [graph_apply](https://github.com/amplify-education/terrawrap/wiki/graph_apply)



  1.  `auto.tfvars` inheritance. Terrawrap makes it easier to share variables between Terraform directories through
      inheritance of `auto.tfvars` files.

  2.  Remote backend generation. Terrawrap makes it easier to work with remote state backends by
      generating configuration for them.

  3.  Repository level plan/apply. Terrawrap provides commands for running plan/apply recursively on a entire
      repository at once.

  4.  Repository level dependency visualization. Terrawrap provides commands for displaying the order of applies in
      human readable output.

  5.  Automatically download third-party Terraform plugins



  1.  Make Terraform DRY for large organizations. A Terraform best practices is to break up Terraform configs
      into many small state files. This leads to an explosion in boilerplate code when using Terraform in large
      organizations with 100s of state files. Terrawrap reduces some boilerplate code by providing `auto.tfvars`
      inheritance and generating backend configurations.

  2.  Make Terraform code easier to manage. Terraform only runs commands on a single directory at a time. This makes
      working with hundreds of terraform directories/state files hard. Terrawrap provides utilities for running
      commands against an entire repository at once instead of one directory at a time.

  3.  All Terraform code should be valid Terraform. Any Terraform code used with Terrawrap should be runnable with
      Terraform by itself without the wrapper. Terrawrap does not provide any new syntax.

  4.  Terrawrap is not a code generator. Generated code is harder to
      read and understand. Code generators tend to lead to leaky abstractions that can be more trouble than they are
      worth. However, Terrawrap does generate remote backend configs as a workaround to Terraform's lack of support for
      variables in backend configs (See <https://github.com/hashicorp/terraform/issues/13022>). We expect this to be
      the only instance of code generation in Terrawrap.





  Terrawrap requires Python 3.7.0 or higher to run.



  This package can be installed using `pip`

  ```sh
  pip3 install terrawrap
  ```

  You should now be able to use the `tf` command.



  For development, `tox>=2.9.1` is recommended.



  Terrawrap uses `tox`. You will need to install tox with `pip install tox`.
  Running `tox` will automatically execute linters as well as the unit tests.

  You can also run them individually with the `-e` argument.

  For example, `tox -e py37-unit` will run the unit tests for python 3.7

  To see all the available options, run `tox -l`.





  Terrawrap can be configured via a `.tf_wrapper` file. The wrapper will walk the provided configuration
  path and look for `.tf_wrapper` files. The files are merged in the order that they are discovered. Consider
  the below example:

  ```text
  foo
  ├── bar
  │   └── .tf_wrapper
  └── .tf_wrapper
  ```

  If there are conflicting configurations between those two `.tf_wrapper` files, the `.tf_wrapper` file in
  `foo/bar` will win.

  The following options are supported in `.tf_wrapper`:

  ```yaml
  configure_backend: True # If true, automatically configure Terraform backends.
  backend_check: True # If true, require this directory to have a terraform backend configured

  envvars:
    <NAME_OF_ENVVAR>:
      source: # The source of the envvar. One of `['ssm', 'text', 'unset']`.
      path: # If the source of the envvar is `ssm`, the SSM Parameter Store path to lookup the value of the environment variable from.
      value: # if the source of the envvar is `text`, the string value to set as the environment variable.
      

  plugins:
      <NAME_OF_PLUGIN>: <plugin url>
  ```



  Terrawrap supports automatically downloading provider plugins by configuring the `.tf_wrapper` file as specified above.
  This is a temporary workaround until Terraform 0.13 is released with built-in support for automatically
  downloading plugins and plugin registries are available for hosting private plugins.

  Terrawrap will first try to download platform specific versions of plugins by downloading them from
  `<plugin url>/<system type>/<architecture type>`. If Terrawrap is unable to download from the platform specific URL
  then it will try to download directly from the given plugin url directly instead.

  For example, the following config on a Mac

  ```yaml
  plugins:
      foo: http://example.com/foo
  ```

  Terrawap will first try to download from `http://example.com/foo/Darwin/x86_64`.
  If that request fails then Terrawrap will try `http://example.com/foo` instead.



  Terrawrap automatically adds `-var-file` arguments to any terraform command by scanning for `*.auto.tfvars`
  files in the directory structure.

  For example, the following command `tf config/foo/bar apply` with the following directory structure:

  ```text
  config
  ├── foo
  |   └── bar
  |   │  ├── baz.tf
  |   │  └── bar.auto.tfvars
  |   └── foo.auto.tfvars
  └── config.auto.tfvars
  ```

  will generate the following command:

  ```bash
  terraform apply -var-file config/config.auto.tfvars \
      -var-file config/foo/foo.auto.tfvars \
      -var-file config/foo/bar/bar.auto.tfvars
  ```



  Terrawrap supports automatically configuring backends by injecting the appropriate `-backend-config`
  args when running `init`

  For example, the Terrawrap command `tf config/foo/bar init` will generate a Terraform command like below if using
  an AWS S3 remote state backend

  ```bash
  terraform init -reconfigure \
      -backend-config=dynamodb_table=<lock table name> \
      -backend-config=encrypt=true \
      -backend-config=key=config/foo/bar.tfstate \
      -backend-config=region=<region name> \
      -backend-config=bucket=<state bucket name> \
      -backend-config=skip_region_validation=true \
      -backend-config=skip_credentials_validation=true
  ```

  Terrawrap configures the backend by looking for `.tf_wrapper` files in the directory structure.
  Either `s3` or `gcs` are supported. See the relevant Terraform documentation for the options available
  for each type of backend:
  <https://www.terraform.io/docs/backends/types/s3.html#configuration-variables>
  <https://www.terraform.io/docs/backends/types/gcs.html#configuration-variables>


  ```yml
  backends:
      s3:
          region:
          role_arn:
          bucket:
          dynamodb_table:
  ```

  | Option Name    | Required | Purpose                                                                              |
  | -------------- | -------- | ------------------------------------------------------------------------------------ |
  | bucket         | Yes      | Name of S3 Bucket                                                                    |
  | region         | Yes      | AWS Region that S3 state bucket and DynamoDB lock table are located in               |
  | dynamodb_table | No       | DynamoDB table to use for state locking. Locking is disable if lock_table is not set |
  | role_arn       | No       | AWS role to assume when reading/writing to S3 bucket and lock table                  |

  The S3 state file key name is generated from the directory name being used to run the terraform command.
  For example, `tf config/foo/bar init` uses a state file with the key `config/foo/bar.tfstate` in S3


  ```yml
  backends:
      gcs:
          bucket:
  ```
  | Option Name    | Required | Purpose                                                                              |
  | -------------- | -------- | ------------------------------------------------------------------------------------ |
  | bucket         | Yes      | Name of GCS Bucket                                                                   |





  `tf <directory> <terraform command>` runs a terraform command for a given directory that contains `*.tf` files.
  Terrawrap automatically includes autovars as described above when running the given command. Any Terraform
  command is supported



  `plan_check <directory>` runs `terraform plan` recursively for all child directories starting at the given directory.
  `plan_check` uses `git` to identify which files have changed compared with the `master` branch. It will then run `plan`
  on any directory that contains `tf` files with the following criteria

  1.  A directory that has files that changed
  2.  A directory that is symlinked to a directory that has files changed
  3.  A directory with symlinked files that are linked to files that changed
  4.  A directory that that uses a Terraform module whose source changed
  5.  A directory with Terraform files that refer to an autovar file that changed



  `backend_check [directory]` verifies that all directories under the given directory that contain `.tf` files
  also have Terraform Backends defined.


pkgId: 419a85779c505686e73c583b2e70da25150a8bc77da0b2b4a9c18b701cb9fda3
name: python-teslajsonpy
arch: src
version: 3.7.4
epoch: 0
release: 1
summary: A library to work with Tesla API.
url: https://github.com/zabuldon/teslajsonpy
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b64af734-374c-4714-b044-6ac4da7af264
location_href: 00005278-python-teslajsonpy/python-teslajsonpy-3.7.4-1.src.rpm
checksum_type: sha256
description:
  [![Version status](https://img.shields.io/pypi/status/teslajsonpy)](https://pypi.org/project/teslajsonpy)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![Python version compatibility](https://img.shields.io/pypi/pyversions/teslajsonpy)](https://pypi.org/project/teslajsonpy)
  [![Version on Github](https://img.shields.io/github/v/release/zabuldon/teslajsonpy?include_prereleases&label=GitHub)](https://github.com/zabuldon/teslajsonpy/releases)
  [![Version on PyPi](https://img.shields.io/pypi/v/teslajsonpy)](https://pypi.org/project/teslajsonpy)
  ![PyPI - Downloads](https://img.shields.io/pypi/dd/teslajsonpy)
  ![PyPI - Downloads](https://img.shields.io/pypi/dw/teslajsonpy)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/teslajsonpy)

  Async python module for Tesla API primarily for enabling Home-Assistant.

  **NOTE:** Tesla has no official API; therefore, this library may stop
  working at any time without warning.



  Originally inspired by [this code.](https://github.com/gglockner/teslajson)
  Also thanks to [Tim Dorr](https://tesla-api.timdorr.com/) for documenting the API. Additional repo scaffolding from [simplisafe-python.](https://github.com/bachya/simplisafe-python)



  1.  [Check for open features/bugs](https://github.com/zabuldon/teslajsonpy/issues)
      or [initiate a discussion on one](https://github.com/zabuldon/teslajsonpy/issues/new).
  2.  [Fork the repository](https://github.com/zabuldon/teslajsonpy/fork/new).
  3.  Install the dev environment: `make init`.
  4.  Enter the virtual environment: `poetry shell`
  5.  Code your new feature or bug fix. [Developers Reference](DEVELOPERS.md)
  6.  Write a test that covers your new functionality.
  7.  Update `README.md` with any new documentation.
  8.  Run tests and ensure 100% code coverage for your contribution: `make coverage`
  9.  Ensure you have no linting errors: `make lint`
  10. Ensure you have typed your code correctly: `make typing`
  11. Add yourself to `AUTHORS.md`.
  12. Submit a [pull request](https://github.com/zabuldon/teslajsonpy/pulls)!



  [API docs](https://teslajsonpy.readthedocs.io/en/latest/).



  [Apache-2.0](LICENSE). By providing a contribution, you agree the contribution is licensed under Apache-2.0.
  This code is provided as-is with no warranty. Use at your own risk.


pkgId: 8bfd7293577868f533ef8cdcb8859978982750267de07f8f14a8e3705c7b8591
name: python-test-server
arch: src
version: 0.0.42
epoch: 0
release: 1
summary: Server for testing HTTP clients
url: https://pypi.org/project/test-server/
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-284e06d1-1bab-4ba5-880e-6f4f7b417a13
location_href: 00005281-python-test_server/python-test-server-0.0.42-1.src.rpm
checksum_type: sha256
description:
  [![Test Status](https://github.com/lorien/test_server/actions/workflows/test.yml/badge.svg)](https://github.com/lorien/test_server/actions/workflows/test.yml)
  [![Code Quality](https://github.com/lorien/test_server/actions/workflows/check.yml/badge.svg)](https://github.com/lorien/test_server/actions/workflows/test.yml)
  [![Type Check](https://github.com/lorien/test_server/actions/workflows/mypy.yml/badge.svg)](https://github.com/lorien/test_server/actions/workflows/mypy.yml)
  [![Test Coverage Status](https://coveralls.io/repos/github/lorien/test_server/badge.svg)](https://coveralls.io/github/lorien/test_server)
  [![Documentation Status](https://readthedocs.org/projects/test_server/badge/?version=latest)](http://user-agent.readthedocs.org)

  Simple HTTP Server for testing HTTP clients.




  Run `pip install -U test_server`




  ```python
  from unittest import TestCase
  import unittest
  from urllib.request import urlopen

  from test_server import TestServer, Response, HttpHeaderStorage


  class UrllibTestCase(TestCase):
     @classmethod
     def setUpClass(cls):
         cls.server = TestServer()
         cls.server.start()

     @classmethod
     def tearDownClass(cls):
         cls.server.stop()

     def setUp(self):
         self.server.reset()

     def test_get(self):
         self.server.add_response(
             Response(
                 data=b"hello",
                 headers={"foo": "bar"},
             )
         )
         self.server.add_response(Response(data=b"zzz"))
         url = self.server.get_url()
         info = urlopen(url)
         self.assertEqual(b"hello", info.read())
         self.assertEqual("bar", info.headers["foo"])
         info = urlopen(url)
         self.assertEqual(b"zzz", info.read())
         self.assertTrue("bar" not in info.headers)


     unittest.main()
  ```

rpm_license:
  The MIT License (MIT)  Copyright (c) 2015-2023, Gregory Petukhov  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: 5ea319944d7abe5b7b1a1bce3a6f7e4fac61091619b295355378d4c8492fbd12
name: python-testcloud
arch: src
version: 0.8.2
epoch: 0
release: 1
summary: A tool to download and boot cloud images locally, with an easy to use API.
url: https://pagure.io/testcloud
rpm_license: GPLv2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-574188ed-2165-4dbe-9830-a864bb2372a4
location_href: 00005282-python-testcloud/python-testcloud-0.8.2-1.src.rpm
checksum_type: sha256
description:
  **testcloud** is a small helper script to download and boot cloud/coreos images
  locally. Testcloud supports wide range of distributions, namely Fedora, Fedora CoreOS,
  CentOS, CentOS Stream, Red Hat Enterprise Linux, Debian and Ubuntu.

  **testcloud** can run either in system mode or in constrained user session mode,
  which is usefull for running it eg. in unprivileged containers.



  The following procedure should only be used to install **testcloud** on
  a production system. For developing purposes, you need a different kind
  of installation which is described in the **Testcloud Development**
  section below.

  To use **testcloud** on a production system:

  1. Install the **testcloud**.

         ```
         $ sudo dnf install testcloud
         ```

  2. Add yourself to the `testcloud group`.

        ```
        $ sudo usermod -a -G testcloud $USER
        ```

  3. Restart your user session to update the group privileges, or use
     `su -` to get a login shell for that particular user where the group
     settings will be updated.

        ```
        $ su -i $USER
        ```

  4. Now, you are ready to use **testcloud**.





  To create a new instance, you will need to provide distribution and version you wish to use or the url of some cloud
  image in the *qcow2* format. If you do not have an image location of
  your own, you can use the image from the **Fedora Cloud** download pages
  (<https://alt.fedoraproject.org/cloud/>).

  To create a new instance with the cloud image, run:

  ```
  $ testcloud instance create <url for qcow2 image> or <distro:version>
  ```

  Some examples how to create an instance with distribution:version shortcut:

  ```

  $ testcloud instance create fedora:latest
  ```

  or, you can skip latest, which is the default value for version:
  ```

  $ testcloud instance create fedora
  ```

  ```

  $ testcloud instance create fedora:rawhide
  ```

  ```

  $ testcloud instance create centos-stream:8
  ```

  ```

  $ testcloud instance create ubuntu:hirsute
  ```

  ```

  $ testcloud instance create debian:11
  ```

  Supported distributions with shortcuts are: Fedora, CentOS, CentOS Stream, Ubuntu and Debian. For other distributions, you can provide link to basically any qcow2 image which has the cloud-init package included.

  Testcloud supports also Vagrant .box files, in a limited manner and currently only for CentOS.

  **testcloud** will download the *qcow2* image and save it in the
  `/var/lib/testcloud/backingstores/<qcow2-filename>`. It will use this
  image a backing store for the newly created instance in
  `/var/tmp/instances/<instance-name>`. When the image has been already
  downloaded, **testcloud** will use the previously download image to
  create the instance.

  To create a new instance with the coreos image, run:

  ```
  $ testcloud instance create fedora-coreos:<stream> or <url for qcow2 image>

  ```

  You will be able to see the instance using the `list` command.

  ```
  $ testcloud instance list
  ```

  Alternatively, the instances can also be viewed and manipulated using
  the **virt-manager** tool.



  Instances can be started and stopped using the `instance` interface of
  the **testcloud**, too:

  1. List all instances to see the correct name of the instance:

         ```
         $ testcloud instance list
         ```

  2. Start the instance:

         ```
         $ testcloud instance start <instance-name>
         ```

  3. Stop the instance:

         ```
         $ testcloud instance stop <instance-name>
         ```

  4. Remove the instance:

         ```
         $ testcloud instance remove <instance-name>
         ```

  Removing the instance only succeeds when the appropriate instance has
  been **stopped** before. However, you can use the `-f` option to force
  removing the instance.



  1. Reboot the instance:

         ```
         $ testcloud instance reboot <instance-name>
         ```

  2. Remove non-existing libvirt VMs from testcloud:

         ```
         $ testcloud instance clean
         ```



  When the cloud/coreos instance is created, **testcloud** will return its IP address
  that you can use to access the running instance via `ssh`. The default *login
  name* is `cloud-user` and the *password* is `passw0rd`. Testcloud will output info how you can connect to any of the Supported Distributions.

  ```
  ssh cloud-user@<instance-IP>
  ```

  The IP address of an instance is also shown when you list the instance
  using the `testcloud instance list` command. You can also control the
  instance using the **virt-manager** , **GNOME Boxes** or any other tool to manage libvirt VMs.



  There are several options (all optional) that can be used to create a
  new instance using **testcloud**.

  -c, \--connection QEMU_URI

  : You can specify uri to qemu you wish to use. For limited environments, you might wish to use *qemu:///session*. Remote connections other than *qemu:///session* and *qemu:///system* (like qemu+ssh,...) are known to be problematic.

  \--ram RAM

  : To set the amount of RAM that will be available to the virtual
      machine (in MiB).

  \--vcpus VCPUS

  : To set the amount of VCPUS that will be available to the virtual
      machine.

  \--no-graphic

  : This turns off the graphical display of the virtual machine.

  \--vnc

  : To open a VNC connection at the `:1` display of the instance.

  -n, \--name NAME

  : To specify a custom name for you instance.

  \--timeout TIMEOUT

  : A time (in seconds) to wait for boot to complete. Setting to 0
      (default) will disable this functionality.

  \--disksize DISKSIZE

  : To set the disk size of the virtual machine (in GiB)

  There are several additional options that can be used to create a
  new Coreos instance using **testcloud**.

  \--bu_file BU_FILE

  : To provide a bu_file you want to use

  \--ign_file IGN_FILE

  : To provide an ign_file you want to use

  \--ssh_path

  : To provide ssh pubkey path



  The default configuration should work for many people but those defaults
  can be overridden through the use of a `settings.py` file containing the
  values to use when overriding default settings. The example file in
  `conf/settings-example.py` shows the possible configuration values which
  can be changed.

  Note that in order for those new values to be picked up, the filename
  must be `settings.py` and that file must live in one of the following
  locations:

  * `conf/settings.py` in the git checkout
  * `~/.config/testcloud/settings.py`
  * `/etc/testcloud/settings.py`

  For example, if you wanted to set up an ssh accessible root account that
  uses an ssh key as the authentification method, you could provide the
  following to the `~/.config/testcloud/settings.py`:

  ```yaml
  USER_DATA = """#cloud-config
  users:
      - default
      - name: root
        password: %s
        chpasswd: { expire: False }
        ssh-authorized-keys:
        - <my ssh pub key>
  """
  ```



  To develop **testcloud**, you need to perform a more complicated process
  to install all its dependencies, download the source code and perform a
  set-up.

  To install **testcloud** for development purposes:



  1. Install the dependencies for **testcloud**.

         ```
         $ sudo dnf install libvirt python3-libvirt libguestfs libguestfs-tools python3-requests python3-jinja2
         ```

  2. Start **libvirtd**.

         ```
         $ sudo systemctl start libvirtd
         ```

  3. Add the `testcloud` group to the system.

         ```
         $ sudo groupadd testcloud
         ```

  4. Add a user into the `testcloud` group.

         ```
         $ sudo usermod -a -G testcloud $USER
         ```

  5. Log out of the system and log in again to update the group
     information on your user or use a login shell on a different
     terminal.

         ```
         $ su - $USER
         ```



  1. Clone the **testcloud** repository.

         ```
         $ git clone https://pagure.io/testcloud.git
         ```

  2. Create the application directories.

         ```
         $ sudo mkdir -p -m 775 /var/lib/testcloud
         ```

         ```
         $ sudo mkdir -p -m 775 /var/lib/testcloud/instances
         ```

         ```
         $ sudo mkdir -p -m 775 /var/lib/testcloud/backingstores
         ```

  3. Change ownership on these directories to enable their use with
     **testcloud**.

         ```
         $ sudo chown qemu:testcloud /var/lib/testcloud
         ```

         ```
         $ sudo chown qemu:testcloud /var/lib/testcloud/instances
         ```

         ```
         $ sudo chown qemu:testcloud /var/lib/testcloud/backingstores
         ```

  4. Copy the `.rules` file to the **polkit** rules.

         ```
         $ sudo cp conf/99-testcloud-nonroot-libvirt-access.rules /etc/polkit-1/rules.d/
         ```



  1. Navigate to your **testcloud** git repository.

         ```
         $ cd testcloud
         ```

  2. Execute the `run_testcloud.py` script to run the **testcloud**. You
     can use any options as with the regular installation, for example:

         ```
             $ ./run_testcloud.py instance create ...
         ```

  3. Alternatively, you can use **pip** to install **testcloud** onto the
     system and then use it like it has been installed normally.

         ```
         $ pip3 install -e . --user
         ```



  There is a small testsuite you can run with:

  ```
  tox
  ```

  This is a good place to contribute if you\'re looking to help out.



  Our project tracker is on the Fedora QA-devel
  [Pagure](https://pagure.io/testcloud//) instance.



  Thanks to [Oddshocks](https://github.com/oddshocks) for the koji
  downloader code :)



  This code is licensed GPLv2+. See the LICENSE file for details.


pkgId: 5cbb73fd1c3fd7a1af9f40cf6a2738f9203e84fab26db9b95d7613761aa9740f
name: python-testcloud
arch: src
version: 0.9.2
epoch: 0
release: 1
summary: A tool to download and boot cloud images locally, with an easy to use API.
url: https://pagure.io/testcloud
rpm_license: GPLv2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ec98dc43-367a-493c-a48c-106fe40f4f6f
location_href: 00008607-python-testcloud/python-testcloud-0.9.2-1.src.rpm
checksum_type: sha256
description:
  **testcloud** is a small helper script to download and boot cloud/coreos images
  locally. Testcloud supports wide range of distributions, namely Fedora, Fedora CoreOS,
  CentOS, CentOS Stream, Red Hat Enterprise Linux, Debian and Ubuntu.

  **testcloud** can run either in system mode or in constrained user session mode,
  which is usefull for running it eg. in unprivileged containers.



  The following procedure should only be used to install **testcloud** on
  a production system. For developing purposes, you need a different kind
  of installation which is described in the **Testcloud Development**
  section below.

  To use **testcloud** on a production system:

  1. Install the **testcloud**.

         ```
         $ sudo dnf install testcloud
         ```

  2. Add yourself to the `testcloud group`.

        ```
        $ sudo usermod -a -G testcloud $USER
        ```

  3. Restart your user session to update the group privileges, or use
     `su -` to get a login shell for that particular user where the group
     settings will be updated.

        ```
        $ su -i $USER
        ```

  4. Now, you are ready to use **testcloud**.





  To create a new instance, you will need to provide distribution and version you wish to use or the url of some cloud
  image in the *qcow2* format. If you do not have an image location of
  your own, you can use the image from the **Fedora Cloud** download pages
  (<https://alt.fedoraproject.org/cloud/>).

  To create a new instance with the cloud image, run:

  ```
  $ testcloud create <url for qcow2 image> or <distro:version>
  ```

  Some examples how to create an instance with distribution:version shortcut:

  ```

  $ testcloud create fedora
  ```

  ```

  $ testcloud create fedora:rawhide
  ```

  ```

  $ testcloud create centos-stream:8
  ```

  ```

  $ testcloud create ubuntu:hirsute
  ```

  ```

  $ testcloud create debian:11
  ```

  Supported distributions with shortcuts are: Fedora, CentOS, CentOS Stream, Ubuntu, Debian, Alma, Rocky, and Oracle.
  For other distributions, you can provide link to basically any qcow2 image which has the cloud-init package included.

  Testcloud supports also Vagrant .box files, in a limited manner and currently only for Fedora and CentOS.

  **testcloud** will download the *qcow2* image and save it in the
  `/var/lib/testcloud/backingstores/<qcow2-filename>`. It will use this
  image a backing store for the newly created instance in
  `/var/tmp/instances/<instance-name>`. When the image has been already
  downloaded, **testcloud** will use the previously download image to
  create the instance.

  To create a new instance with the coreos image, run:

  ```
  $ testcloud create fedora-coreos:<stream> or <url for qcow2 image>

  ```

  You will be able to see the instance using the `list` command.

  ```
  $ testcloud list
  ```

  Alternatively, the instances can also be viewed and manipulated using
  the **virt-manager** tool.



  Instances can be created with a different architecture than the host architecture. You'll need to have a proper
  qemu binary installed for this to work (eg. qemu-system-aarch64-core for aarch64 on x86_64 on Fedora). Supported
  architectures in testcloud are: x86_64, aarch64, ppc64le, and s390x. Any combinations of these are supported.

  Some examples:

  ```

  $ testcloud create fedora --arch aarch64
  ```

  ```

  $ testcloud create centos-stream --arch x86_64
  ```

  ```

  $ testcloud create fedora:rawhide --arch ppc64le
  ```



  Instances can be started and stopped using the `instance` interface of
  the **testcloud**, too:

  1. List all instances to see the correct name of the instance:

         ```
         $ testcloud list
         ```

  2. Start the instance:

         ```
         $ testcloud start <instance-name>
         ```

  3. Stop the instance:

         ```
         $ testcloud stop <instance-name>
         ```

  4. Remove the instance:

         ```
         $ testcloud remove <instance-name>
         ```

  Removing the instance only succeeds when the appropriate instance has
  been **stopped** before. However, you can use the `-f` option to force
  removing the instance.



  1. Reboot the instance:

         ```
         $ testcloud reboot <instance-name>
         ```

  2. Remove non-existing libvirt VMs from testcloud:

         ```
         $ testcloud clean
         ```



  When the cloud/coreos instance is created, **testcloud** will return its IP address
  that you can use to access the running instance via `ssh`. The default *login
  name* is `cloud-user` and the *password* is `passw0rd`. Testcloud will output info how you can connect to any of the Supported Distributions.

  ```
  ssh cloud-user@<instance-IP>
  ```

  The IP address of an instance is also shown when you list the instance
  using the `testcloud list` command. You can also control the
  instance using the **virt-manager** , **GNOME Boxes** or any other tool to manage libvirt VMs.



  There are several options (all optional) that can be used to create a
  new instance using **testcloud**.

  -c, \--connection QEMU_URI

  : You can specify uri to qemu you wish to use. For limited environments, you might wish to use *qemu:///session*. Remote connections other than *qemu:///session* and *qemu:///system* (like qemu+ssh,...) are known to be problematic.

  \--arch ARCH

  : To request a speciffic architecture for the guest. The default
  |    is the architecture of the host system.

  \--ram RAM

  : To set the amount of RAM that will be available to the virtual
      machine (in MiB).

  \--vcpus VCPUS

  : To set the amount of VCPUS that will be available to the virtual
      machine.

  \--no-graphic

  : This turns off the graphical display of the virtual machine.

  \--vnc

  : To open a VNC connection at the `:1` display of the instance.

  -n, \--name NAME

  : To specify a custom name for you instance.

  \--timeout TIMEOUT

  : A time (in seconds) to wait for boot to complete. Setting to 0
      (default) will disable this functionality.

  \--disksize DISKSIZE

  : To set the disk size of the virtual machine (in GiB)

  \--disk_number

  : To provide disk number you want

  There are several additional options that can be used to create a
  new Coreos instance using **testcloud**.

  \--bu_file BU_FILE

  : To provide a bu_file you want to use

  \--ign_file IGN_FILE

  : To provide an ign_file you want to use

  \--ssh_path

  : To provide ssh pubkey path



  The default configuration should work for many people but those defaults
  can be overridden through the use of a `settings.py` file containing the
  values to use when overriding default settings. The example file in
  `conf/settings-example.py` shows the possible configuration values which
  can be changed.

  Note that in order for those new values to be picked up, the filename
  must be `settings.py` and that file must live in one of the following
  locations:

  * `conf/settings.py` in the git checkout
  * `~/.config/testcloud/settings.py`
  * `/etc/testcloud/settings.py`

  For example, if you wanted to set up an ssh accessible root account that
  uses an ssh key as the authentification method, you could provide the
  following to the `~/.config/testcloud/settings.py`:

  ```yaml
  USER_DATA = """#cloud-config
  users:
      - default
      - name: root
        password: %s
        chpasswd: { expire: False }
        ssh-authorized-keys:
        - <my ssh pub key>
  """
  ```



  To develop **testcloud**, you need to perform a more complicated process
  to install all its dependencies, download the source code and perform a
  set-up.

  To install **testcloud** for development purposes:



  1. Install the dependencies for **testcloud**.

         ```
         $ sudo dnf install libvirt python3-libvirt libguestfs libguestfs-tools python3-requests python3-jinja2
         ```

  2. Start **libvirtd**.

         ```
         $ sudo systemctl start libvirtd
         ```

  3. Add the `testcloud` group to the system.

         ```
         $ sudo groupadd testcloud
         ```

  4. Add a user into the `testcloud` group.

         ```
         $ sudo usermod -a -G testcloud $USER
         ```

  5. Log out of the system and log in again to update the group
     information on your user or use a login shell on a different
     terminal.

         ```
         $ su - $USER
         ```



  1. Clone the **testcloud** repository.

         ```
         $ git clone https://pagure.io/testcloud.git
         ```

  2. Create the application directories.

         ```
         $ sudo mkdir -p -m 775 /var/lib/testcloud
         ```

         ```
         $ sudo mkdir -p -m 775 /var/lib/testcloud/instances
         ```

         ```
         $ sudo mkdir -p -m 775 /var/lib/testcloud/backingstores
         ```

  3. Change ownership on these directories to enable their use with
     **testcloud**.

         ```
         $ sudo chown qemu:testcloud /var/lib/testcloud
         ```

         ```
         $ sudo chown qemu:testcloud /var/lib/testcloud/instances
         ```

         ```
         $ sudo chown qemu:testcloud /var/lib/testcloud/backingstores
         ```

  4. Copy the `.rules` file to the **polkit** rules.

         ```
         $ sudo cp conf/99-testcloud-nonroot-libvirt-access.rules /etc/polkit-1/rules.d/
         ```



  1. Navigate to your **testcloud** git repository.

         ```
         $ cd testcloud
         ```

  2. Execute the `run_testcloud.py` script to run the **testcloud**. You
     can use any options as with the regular installation, for example:

         ```
             $ ./run_testcloud.py instance create ...
         ```

  3. Alternatively, you can use **pip** to install **testcloud** onto the
     system and then use it like it has been installed normally.

         ```
         $ pip3 install -e . --user
         ```



  There is a small testsuite you can run with:

  ```
  tox
  ```

  This is a good place to contribute if you\'re looking to help out.



  Our project tracker is on the Fedora QA-devel
  [Pagure](https://pagure.io/testcloud//) instance.



  Thanks to [Oddshocks](https://github.com/oddshocks) for the koji
  downloader code :)



  This code is licensed GPLv2+. See the LICENSE file for details.


pkgId: 1192b656829bac7498191bd1dfbac2a1428102c4d5bc8087bc39eaac034f3934
name: python-testinfra
arch: src
version: 6.0.0
epoch: 0
release: 1
summary: Test infrastructures
url: https://github.com/philpep/testinfra
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8ace20e8-1866-4e80-bfd0-440ac4f07272
location_href: 00005284-python-testinfra/python-testinfra-6.0.0-1.src.rpm
checksum_type: sha256
description:
  Testinfra test your infrastructure


  This package is just a transitional package for https://github.com/pytest-dev/philpep you should install pytest-testinfra instead.


pkgId: d72c448ded41fa498c31475c4b3264b629eaa6b237c880ed64949debb0a5299b
name: python-testing.postgresql
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: automatically setups a postgresql instance in a temporary directory, and destroys it after testing
url: https://github.com/tk0miya/testing.postgresql
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b1942f83-a969-4d52-b206-81d2a0440247
location_href: 00010896-python-testing-postgresql/python-testing.postgresql-1.3.0-1.src.rpm
checksum_type: sha256
description:
  ``testing.postgresql`` automatically setups a postgresql instance in a temporary directory, and destroys it after testing.
  Documentation
    https://github.com/tk0miya/testing.postgresql
  Issues
    https://github.com/tk0miya/testing.postgresql/issues
  Download
    https://pypi.python.org/pypi/testing.postgresql


pkgId: 8fe8f25e8903571b5fb3ccdb2f28125a2eaf110245fbe31ba8e69b79c0a15e8b
name: python-testpath
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Test utilities for code working with files and commands
url: https://pypi.org/project/testpath/
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a554b1a3-0242-4523-92ca-f23206f13000
location_href: 00005286-python-testpath/python-testpath-0.6.0-1.src.rpm
checksum_type: sha256
description:
  Testpath is a collection of utilities for Python code working with files and commands.

  It contains functions to check things on the filesystem, and tools for mocking
  system commands and recording calls to those.

  `Documentation on ReadTheDocs <https://testpath.readthedocs.io/en/latest/>`_

  e.g.::

      import testpath
      testpath.assert_isfile(path)

      with testpath.assert_calls('git', ['add', path]):
          function_under_test()


pkgId: 72e88b857550f126f408e3d43e10d6d2e6fc6cef10276c9118752bd9466ce881
name: python-testrepository
arch: src
version: 0.0.20
epoch: 0
release: 1
summary: A repository of test results.
url: https://launchpad.net/testrepository
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ff7113a9-7c9d-4a6c-aa7d-d5dcd80b8f3b
location_href: 00005287-python-testrepository/python-testrepository-0.0.20-1.src.rpm
checksum_type: sha256
description:
  Test Repository
  +++++++++++++++

  Overview
  ~~~~~~~~

  This project provides a database of test results which can be used as part of
  developer workflow to ensure/check things like:

  * No commits without having had a test failure, test fixed cycle.
  * No commits without new tests being added.
  * What tests have failed since the last commit (to run just a subset).
  * What tests are currently failing and need work.

  Test results are inserted using subunit (and thus anything that can output
  subunit or be converted into a subunit stream can be accepted).

  A mailing list for discussion, usage and development is at
  https://launchpad.net/~testrepository-dev - all are welcome to join. Some folk
  hang out on #testrepository on irc.freenode.net.

  CI for the project is at http://build.robertcollins.net/job/testrepository-default/.

  Licensing
  ~~~~~~~~~

  Test Repository is under BSD / Apache 2.0 licences. See the file COPYING in the source for details.

  Quick Start
  ~~~~~~~~~~~

  Create a config file::
    $ touch .testr.conf

  Create a repository::
    $ testr init

  Load a test run into the repository::
    $ testr load < testrun

  Query the repository::
    $ testr stats
    $ testr last
    $ testr failing

  Delete a repository::
    $ rm -rf .testrepository

  Documentation
  ~~~~~~~~~~~~~

  More detailed documentation including design and implementation details, a
  user manual, and guidelines for development of Test Repository itself can be
  found at https://testrepository.readthedocs.org/en/latest, or in the source
  tree at doc/ (run make -C doc html).


pkgId: 5776296b678a149139adfa8c6cae2a4a802598a17b994ae6957e9a72cc4b6978
name: python-testresources
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Testresources, a pyunit extension for managing expensive test resources
url: https://launchpad.net/testresources
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f5c5eaec-1f35-4aba-acc8-94092c23a305
location_href: 00005288-python-testresources/python-testresources-2.0.1-1.src.rpm
checksum_type: sha256
description:
  * Python 2.6+ (or 3.3+)
  * docutils
  * testtools (http://pypi.python.org/pypi/testtools/)
  * fixtures (http://pypi.python.org/pypi/fixtures)


pkgId: 588996819cca7091fd200e215b5dab34dc06499570ba00958c247e5d5847966d
name: python-text-unidecode
arch: src
version: 1.3
epoch: 0
release: 1
summary: The most basic Text::Unidecode port
url: https://github.com/kmike/text-unidecode/
rpm_license: Artistic License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1d484944-80ed-4616-b6e7-05e1bd58d286
location_href: 00005290-python-text-unidecode/python-text-unidecode-1.3-1.src.rpm
checksum_type: sha256
description:
  text-unidecode is the most basic port of the
  `Text::Unidecode <http://search.cpan.org/~sburke/Text-Unidecode-0.04/lib/Text/Unidecode.pm>`_
  Perl library.
  There are other Python ports of Text::Unidecode (unidecode_
  and isounidecode_). unidecode_ is GPL; isounidecode_ uses too much memory,
  and it didn't support Python 3 when this package was created.
  You can redistribute it and/or modify this port under the terms of either:
  * `Artistic License`_, or
  * GPL or GPLv2+
  If you're OK with GPL-only, use unidecode_ (it has better memory usage and
  better transliteration quality).
  ``text-unidecode`` supports Python 2.7 and 3.4+.


pkgId: fb1255350ab4f9314188c3668dab73ef2e34796e557fb296770a9d770c30a156
name: python-textblob
arch: src
version: 0.17.1
epoch: 0
release: 1
url: https://github.com/sloria/TextBlob
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5712381d-5c16-4850-9a4d-0a294f956828
location_href: 00009706-python-textblob/python-textblob-0.17.1-1.src.rpm
checksum_type: sha256
summary:
  Simple, Pythonic text processing. Sentiment analysis, part-of-speech tagging, noun phrase parsing, and more.

description:
  Homepage: `https://textblob.readthedocs.io/ <https://textblob.readthedocs.io/>`_
  `TextBlob` is a Python (2 and 3) library for processing textual data. It provides a simple API for diving into common natural language processing (NLP) tasks such as part-of-speech tagging, noun phrase extraction, sentiment analysis, classification, translation, and more.
      from textblob import TextBlob
      text = '''
      The titular threat of The Blob has always struck me as the ultimate movie
      monster: an insatiably hungry, amoeba-like mass able to penetrate
      virtually any safeguard, capable of--as a doomed doctor chillingly
      describes it--"assimilating flesh on contact.
      Snide comparisons to gelatin be damned, it's a concept with the most
      devastating of potential consequences, not unlike the grey goo scenario
      proposed by technological theorists fearful of
      artificial intelligence run rampant.
      '''
      blob = TextBlob(text)
      blob.tags           # [('The', 'DT'), ('titular', 'JJ'),
                          
      blob.noun_phrases   # WordList(['titular threat', 'blob',
                          
                          
      for sentence in blob.sentences:
          print(sentence.sentiment.polarity)
      
      
  TextBlob stands on the giant shoulders of `NLTK`_ and `pattern`_, and plays nicely with both.


pkgId: 7e02d643ba0c9a98376d24f4664bf682be36fb3114be5f12f4adb6174286839f
name: python-textdistance
arch: src
version: 4.5.0
epoch: 0
release: 1
summary: Compute distance between the two texts.
url: https://github.com/orsinium/textdistance
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4d5207f0-8fe5-416b-8c0c-e1467f9c5220
location_href: 00010502-python-textdistance/python-textdistance-4.5.0-1.src.rpm
checksum_type: sha256
description:
  ![TextDistance logo](logo.png)

  [![Build Status](https://travis-ci.org/life4/textdistance.svg?branch=master)](https://travis-ci.org/life4/textdistance) [![PyPI version](https://img.shields.io/pypi/v/textdistance.svg)](https://pypi.python.org/pypi/textdistance) [![Status](https://img.shields.io/pypi/status/textdistance.svg)](https://pypi.python.org/pypi/textdistance) [![License](https://img.shields.io/pypi/l/textdistance.svg)](LICENSE)

  **TextDistance** -- python library for comparing distance between two or more sequences by many algorithms.

  Features:

  - 30+ algorithms
  - Pure python implementation
  - Simple usage
  - More than two sequences comparing
  - Some algorithms have more than one implementation in one class.
  - Optional numpy usage for maximum speed.





  | Algorithm                                                                                 | Class                | Functions              |
  |-------------------------------------------------------------------------------------------|----------------------|------------------------|
  | [Hamming](https://en.wikipedia.org/wiki/Hamming_distance)                                 | `Hamming`            | `hamming`              |
  | [MLIPNS](http://www.sial.iias.spb.su/files/386-386-1-PB.pdf)                              | `Mlipns`             | `mlipns`               |
  | [Levenshtein](https://en.wikipedia.org/wiki/Levenshtein_distance)                         | `Levenshtein`        | `levenshtein`          |
  | [Damerau-Levenshtein](https://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance) | `DamerauLevenshtein` | `damerau_levenshtein`  |
  | [Jaro-Winkler](https://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance)               | `JaroWinkler`        | `jaro_winkler`, `jaro` |
  | [Strcmp95](http://cpansearch.perl.org/src/SCW/Text-JaroWinkler-0.1/strcmp95.c)            | `StrCmp95`           | `strcmp95`             |
  | [Needleman-Wunsch](https://en.wikipedia.org/wiki/Needleman%E2%80%93Wunsch_algorithm)      | `NeedlemanWunsch`    | `needleman_wunsch`     |
  | [Gotoh](http://bioinfo.ict.ac.cn/~dbu/AlgorithmCourses/Lectures/LOA/Lec6-Sequence-Alignment-Affine-Gaps-Gotoh1982.pdf) | `Gotoh`              | `gotoh`                |
  | [Smith-Waterman](https://en.wikipedia.org/wiki/Smith%E2%80%93Waterman_algorithm)          | `SmithWaterman`      | `smith_waterman`       |



  | Algorithm                                                                                 | Class                | Functions     |
  |-------------------------------------------------------------------------------------------|----------------------|---------------|
  | [Jaccard index](https://en.wikipedia.org/wiki/Jaccard_index)                              | `Jaccard`            | `jaccard`     |
  | [Sørensen–Dice coefficient](https://en.wikipedia.org/wiki/S%C3%B8rensen%E2%80%93Dice_coefficient) | `Sorensen`   | `sorensen`, `sorensen_dice`, `dice` |
  | [Tversky index](https://en.wikipedia.org/wiki/Tversky_index)                              | `Tversky`            | `tversky`    |
  | [Overlap coefficient](https://en.wikipedia.org/wiki/Overlap_coefficient)                  | `Overlap`            | `overlap`    |
  | [Tanimoto distance](https://en.wikipedia.org/wiki/Jaccard_index#Tanimoto_similarity_and_distance) | `Tanimoto`   | `tanimoto`   |
  | [Cosine similarity](https://en.wikipedia.org/wiki/Cosine_similarity)                      | `Cosine`             | `cosine`     |
  | [Monge-Elkan](https://www.academia.edu/200314/Generalized_Monge-Elkan_Method_for_Approximate_Text_String_Comparison) | `MongeElkan` | `monge_elkan` |
  | [Bag distance](https://github.com/Yomguithereal/talisman/blob/master/src/metrics/bag.js) | `Bag`        | `bag`        |



  | Algorithm | Class | Functions |
  |-----------|-------|-----------|
  | [longest common subsequence similarity](https://en.wikipedia.org/wiki/Longest_common_subsequence_problem)          | `LCSSeq` | `lcsseq` |
  | [longest common substring similarity](https://docs.python.org/2/library/difflib.html#difflib.SequenceMatcher)      | `LCSStr` | `lcsstr` |
  | [Ratcliff-Obershelp similarity](https://en.wikipedia.org/wiki/Gestalt_Pattern_Matching) | `RatcliffObershelp` | `ratcliff_obershelp` |



  [Normalized compression distance](https://en.wikipedia.org/wiki/Normalized_compression_distance#Normalized_compression_distance) with different compression algorithms.

  Classic compression algorithms:

  | Algorithm                                                                  | Class       | Function     |
  |----------------------------------------------------------------------------|-------------|--------------|
  | [Arithmetic coding](https://en.wikipedia.org/wiki/Arithmetic_coding)       | `ArithNCD`  | `arith_ncd`  |
  | [RLE](https://en.wikipedia.org/wiki/Run-length_encoding)                   | `RLENCD`    | `rle_ncd`    |
  | [BWT RLE](https://en.wikipedia.org/wiki/Burrows%E2%80%93Wheeler_transform) | `BWTRLENCD` | `bwtrle_ncd` |

  Normal compression algorithms:

  | Algorithm                                                                  | Class        | Function      |
  |----------------------------------------------------------------------------|--------------|---------------|
  | Square Root                                                                | `SqrtNCD`    | `sqrt_ncd`    |
  | [Entropy](https://en.wikipedia.org/wiki/Entropy_(information_theory))      | `EntropyNCD` | `entropy_ncd` |

  Work in progress algorithms that compare two strings as array of bits:

  | Algorithm                                  | Class     | Function   |
  |--------------------------------------------|-----------|------------|
  | [BZ2](https://en.wikipedia.org/wiki/Bzip2) | `BZ2NCD`  | `bz2_ncd`  |
  | [LZMA](https://en.wikipedia.org/wiki/LZMA) | `LZMANCD` | `lzma_ncd` |
  | [ZLib](https://en.wikipedia.org/wiki/Zlib) | `ZLIBNCD` | `zlib_ncd` |

  See [blog post](https://articles.life4web.ru/other/ncd/) for more details about NCD.



  | Algorithm                                                                    | Class    | Functions |
  |------------------------------------------------------------------------------|----------|-----------|
  | [MRA](https://en.wikipedia.org/wiki/Match_rating_approach)                   | `MRA`    | `mra`     |
  | [Editex](https://anhaidgroup.github.io/py_stringmatching/v0.3.x/Editex.html) | `Editex` | `editex`  |



  | Algorithm           | Class      | Functions  |
  |---------------------|------------|------------|
  | Prefix similarity   | `Prefix`   | `prefix`   |
  | Postfix similarity  | `Postfix`  | `postfix`  |
  | Length distance     | `Length`   | `length`   |
  | Identity similarity | `Identity` | `identity` |
  | Matrix similarity   | `Matrix`   | `matrix`   |





  Only pure python implementation:

  ```bash
  pip install textdistance
  ```

  With extra libraries for maximum speed:

  ```bash
  pip install "textdistance[extras]"
  ```

  With all libraries (required for [benchmarking](#benchmarks) and [testing](#running-tests)):

  ```bash
  pip install "textdistance[benchmark]"
  ```

  With algorithm specific extras:

  ```bash
  pip install "textdistance[Hamming]"
  ```

  Algorithms with available extras: `DamerauLevenshtein`, `Hamming`, `Jaro`, `JaroWinkler`, `Levenshtein`.



  Via pip:

  ```bash
  pip install -e git+https://github.com/life4/textdistance.git#egg=textdistance
  ```

  Or clone repo and install with some extras:

  ```bash
  git clone https://github.com/life4/textdistance.git
  pip install -e ".[benchmark]"
  ```



  All algorithms have 2 interfaces:

  1. Class with algorithm-specific params for customizing.
  2. Class instance with default params for quick and simple usage.

  All algorithms have some common methods:

  1. `.distance(*sequences)` -- calculate distance between sequences.
  2. `.similarity(*sequences)` -- calculate similarity for sequences.
  3. `.maximum(*sequences)` -- maximum possible value for distance and similarity. For any sequence: `distance + similarity == maximum`.
  4. `.normalized_distance(*sequences)` -- normalized distance between sequences. The return value is a float between 0 and 1, where 0 means equal, and 1 totally different.
  5. `.normalized_similarity(*sequences)` -- normalized similarity for sequences. The return value is a float between 0 and 1, where 0 means totally different, and 1 equal.

  Most common init arguments:

  1. `qval` -- q-value for split sequences into q-grams. Possible values:
      - 1 (default) -- compare sequences by chars.
      - 2 or more -- transform sequences to q-grams.
      - None -- split sequences by words.
  2. `as_set` -- for token-based algorithms:
      - True -- `t` and `ttt` is equal.
      - False (default) -- `t` and `ttt` is different.



  For example, [Hamming distance](https://en.wikipedia.org/wiki/Hamming_distance):

  ```python
  import textdistance

  textdistance.hamming('test', 'text')


  textdistance.hamming.distance('test', 'text')


  textdistance.hamming.similarity('test', 'text')


  textdistance.hamming.normalized_distance('test', 'text')


  textdistance.hamming.normalized_similarity('test', 'text')


  textdistance.Hamming(qval=2).distance('test', 'text')


  ```

  Any other algorithms have same interface.



  A few articles with examples how to use textdistance in the real world:

  - [Guide to Fuzzy Matching with Python](http://theautomatic.net/2019/11/13/guide-to-fuzzy-matching-with-python/)
  - [String similarity — the basic know your algorithms guide!](https://itnext.io/string-similarity-the-basic-know-your-algorithms-guide-3de3d7346227)
  - [Normalized compression distance](https://articles.life4web.ru/other/ncd/)



  For main algorithms textdistance try to call known external libraries (fastest first) if available (installed in your system) and possible (this implementation can compare this type of sequences). [Install](#installation) textdistance with extras for this feature.

  You can disable this by passing `external=False` argument on init:

  ```python3
  import textdistance
  hamming = textdistance.Hamming(external=False)
  hamming('text', 'testit')

  ```

  Supported libraries:

  1. [abydos](https://github.com/chrislit/abydos)
  1. [Distance](https://github.com/doukremt/distance)
  1. [jellyfish](https://github.com/jamesturk/jellyfish)
  1. [py_stringmatching](https://github.com/anhaidgroup/py_stringmatching)
  1. [pylev](https://github.com/toastdriven/pylev)
  1. [python-Levenshtein](https://github.com/ztane/python-Levenshtein)
  1. [pyxDamerauLevenshtein](https://github.com/gfairchild/pyxDamerauLevenshtein)

  Algorithms:

  1. DamerauLevenshtein
  1. Hamming
  1. Jaro
  1. JaroWinkler
  1. Levenshtein



  Without extras installation:

  | algorithm          | library               |    time |
  |--------------------|-----------------------|---------|
  | DamerauLevenshtein | rapidfuzz             | 0.00312 |
  | DamerauLevenshtein | jellyfish             | 0.00591 |
  | DamerauLevenshtein | pyxdameraulevenshtein | 0.03335 |
  | DamerauLevenshtein | abydos                | 0.63278 |
  | DamerauLevenshtein | **textdistance**      | 0.83524 |
  | Hamming            | Levenshtein           | 0.00038 |
  | Hamming            | rapidfuzz             | 0.00044 |
  | Hamming            | jellyfish             | 0.00091 |
  | Hamming            | distance              | 0.00812 |
  | Hamming            | abydos                | 0.00902 |
  | Hamming            | **textdistance**      | 0.03531 |
  | Jaro               | rapidfuzz             | 0.00092 |
  | Jaro               | jellyfish             | 0.00191 |
  | Jaro               | **textdistance**      | 0.07365 |
  | JaroWinkler        | rapidfuzz             | 0.00094 |
  | JaroWinkler        | jellyfish             | 0.00195 |
  | JaroWinkler        | **textdistance**      | 0.07501 |
  | Levenshtein        | rapidfuzz             | 0.00099 |
  | Levenshtein        | Levenshtein           | 0.00122 |
  | Levenshtein        | jellyfish             | 0.00254 |
  | Levenshtein        | pylev                 | 0.15688 |
  | Levenshtein        | distance              | 0.28669 |
  | Levenshtein        | **textdistance**      | 0.53902 |
  | Levenshtein        | abydos                | 1.25783 |

  Total: 24 libs.

  Yeah, so slow. Use TextDistance on production only with extras.

  Textdistance use benchmark's results for algorithm's optimization and try to call fastest external lib first (if possible).

  You can run benchmark manually on your system:

  ```bash
  pip install textdistance[benchmark]
  python3 -m textdistance.benchmark
  ```

  TextDistance show benchmarks results table for your system and save libraries priorities into `libraries.json` file in TextDistance's folder. This file will be used by textdistance for calling fastest algorithm implementation. Default [libraries.json](textdistance/libraries.json) already included in package.



  All you need is [task](https://taskfile.dev/). See [Taskfile.yml](./Taskfile.yml) for the list of available commands. For example, to run tests including third-party libraries usage, execute `task pytest-external:run`.



  PRs are welcome!

  - Found a bug? Fix it!
  - Want to add more algorithms? Sure! Just make it with the same interface as other algorithms in the lib and add some tests.
  - Can make something faster? Great! Just avoid external dependencies and remember that everything should work not only with strings.
  - Something else that do you think is good? Do it! Just make sure that CI passes and everything from the README is still applicable (interface, features, and so on).
  - Have no time to code? Tell your friends and subscribers about `textdistance`. More users, more contributions, more amazing features.

  Thank you :heart:


pkgId: 4ed79184c15c2da2f28d4c5fd63364d3fb076faf07d3c24e89e2ac1f7fa72ada
name: python-textfsm
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: Python module for parsing semi-structured text into python tables.
url: https://github.com/google/textfsm
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ae3fe219-fc84-437a-9f7f-2116f3bf592d
location_href: 00005291-python-textfsm/python-textfsm-1.1.3-1.src.rpm
checksum_type: sha256
description:
  Python module which implements a template based state machine for parsing
  semi-formatted text. Originally developed to allow programmatic access to
  information returned from the command line interface (CLI) of networking
  devices.
  The engine takes two inputs - a template file, and text input (such as command
  responses from the CLI of a device) and returns a list of records that contains
  the data parsed from the text.
  A template file is needed for each uniquely structured text input. Some examples
  are provided with the code and users are encouraged to develop their own.
  By developing a pool of template files, scripts can call TextFSM to parse useful
  information from a variety of sources. It is also possible to use different
  templates on the same data in order to create different tables (or views).
  TextFSM was developed internally at Google and released under the Apache 2.0
  licence for the benefit of the wider community.
  [**See documentation for more details.**](https://github.com/google/textfsm/wiki/TextFSM)


pkgId: 794a53b3040b38ce8f86b82d7e660fc919ce0ecd64c1d3767fd53ba1e1309415
name: python-textparser
arch: src
version: 0.24.0
epoch: 0
release: 1
summary: Text parser.
url: https://github.com/eerimoq/textparser
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8b30e821-0ada-466f-9977-3ef0e02013ee
location_href: 00005293-python-textparser/python-textparser-0.24.0-1.src.rpm
checksum_type: sha256
description:
  A text parser written in the Python language.
  The project has one goal, speed! See the benchmark below more details.
  Project homepage: https://github.com/eerimoq/textparser
  Documentation: http://textparser.readthedocs.org/en/latest


pkgId: 7c27aeb1216fea604d3a12e048fab92a0d86a28a9e951754ceae894b52b035bc
name: python-textstat
arch: src
version: 0.7.3
epoch: 0
release: 1
summary: Calculate statistical features from text
url: https://github.com/shivam5992/textstat
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e5108e30-1d46-466a-aae9-e3f3aa715a7c
location_href: 00012883-python-textstat/python-textstat-0.7.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/textstat.svg)](https://pypi.org/project/textstat/)
  [![Build Status](https://github.com/shivam5992/textstat/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/shivam5992/textstat/actions/workflows/test.yml)
  [![Downloads](https://img.shields.io/badge/dynamic/json.svg?url=https://pypistats.org/api/packages/textstat/recent?mirrors=false&label=downloads&query=$.data.last_month&suffix=/month)](https://pypistats.org/packages/textstat)

  **Textstat is an easy to use library to calculate statistics from text. It helps determine readability, complexity, and grade level.**

  <p align="center">
    <img width="100%" src="https://images.unsplash.com/photo-1457369804613-52c61a468e7d?ixlib=rb-1.2.1&auto=format&fit=crop&w=1350&h=400&q=80">
  </p>
  <p align="right">
    <sup>Photo by <a href="https://unsplash.com/@impatrickt">Patrick Tomasso</a>
    on <a href="https://unsplash.com/images/things/book">Unsplash</a></sup>
  </p>



  ```python
  >>> import textstat

  >>> test_data = (
      "Playing games has always been thought to be important to "
      "the development of well-balanced and creative children; "
      "however, what part, if any, they should play in the lives "
      "of adults has never been researched that deeply. I believe "
      "that playing games is every bit as important for adults "
      "as for children. Not only is taking time out to play games "
      "with our children and other adults valuable to building "
      "interpersonal relationships but is also a wonderful way "
      "to release built up tension."
  )

  >>> textstat.flesch_reading_ease(test_data)
  >>> textstat.flesch_kincaid_grade(test_data)
  >>> textstat.smog_index(test_data)
  >>> textstat.coleman_liau_index(test_data)
  >>> textstat.automated_readability_index(test_data)
  >>> textstat.dale_chall_readability_score(test_data)
  >>> textstat.difficult_words(test_data)
  >>> textstat.linsear_write_formula(test_data)
  >>> textstat.gunning_fog(test_data)
  >>> textstat.text_standard(test_data)
  >>> textstat.fernandez_huerta(test_data)
  >>> textstat.szigriszt_pazos(test_data)
  >>> textstat.gutierrez_polini(test_data)
  >>> textstat.crawford(test_data)
  >>> textstat.gulpease_index(test_data)
  >>> textstat.osman(test_data)
  ```

  The argument (text) for all the defined functions remains the same -
  i.e the text for which statistics need to be calculated.



  You can install textstat either via the Python Package Index (PyPI) or from source.



  ```shell
  pip install textstat
  ```



  ```shell
  easy_install textstat
  ```



  ```shell
  git clone https://github.com/shivam5992/textstat.git
  cd textstat
  pip install .
  ```



  Download the latest version of textstat from http://pypi.python.org/pypi/textstat/

  You can install it by doing the following:

  ```shell
  tar xfz textstat-*.tar.gz
  cd textstat-*/
  python setup.py build
  python setup.py install # as root
  ```


  By default functions implement algorithms for english language.
  To change language, use:

  ```python
  textstat.set_lang(lang)
  ```

  The language will be used for syllable calculation and to choose
  variant of the formula.


  All functions implement `en_US` language. Some of them has also variants
  for other languages listed below.

  |  Function                   | en | de | es | fr | it | nl | pl | ru |
  |-----------------------------|----|----|----|----|----|----|----|----|
  | flesch_reading_ease         | ✔  | ✔  | ✔  | ✔  | ✔  | ✔  |    | ✔  |
  | gunning_fog                 | ✔  |    |    |    |    |    | ✔  |    |


  The following functions are specifically designed for spanish language.
  They can be used on non-spanish texts, even though that use case is not recommended.

  ```python
  >>> textstat.fernandez_huerta(test_data)
  >>> textstat.szigriszt_pazos(test_data)
  >>> textstat.gutierrez_polini(test_data)
  >>> textstat.crawford(test_data)
  ```

  Additional information on the formula they implement can be found in their respective docstrings.







  ```python
  textstat.flesch_reading_ease(text)
  ```

  Returns the Flesch Reading Ease Score.

  The following table can be helpful to assess the ease of
  readability in a document.

  The table is an _example_ of values. While the
  maximum score is 121.22, there is no limit on how low
  the score can be. A negative score is valid.

  | Score |    Difficulty     |
  |-------|-------------------|
  |90-100 | Very Easy         |
  | 80-89 | Easy              |
  | 70-79 | Fairly Easy       |
  | 60-69 | Standard          |
  | 50-59 | Fairly Difficult  |
  | 30-49 | Difficult         |
  | 0-29  | Very Confusing    |

  > Further reading on
  [Wikipedia](https://en.wikipedia.org/wiki/Flesch%E2%80%93Kincaid_readability_tests#Flesch_reading_ease)



  ```python
  textstat.flesch_kincaid_grade(text)
  ```

  Returns the Flesch-Kincaid Grade of the given text. This is a grade
  formula in that a score of 9.3 means that a ninth grader would be able to
  read the document.

  > Further reading on
  [Wikipedia](https://en.wikipedia.org/wiki/Flesch%E2%80%93Kincaid_readability_tests#Flesch%E2%80%93Kincaid_grade_level)



  ```python
  textstat.gunning_fog(text)
  ```

  Returns the FOG index of the given text. This is a grade formula in that
  a score of 9.3 means that a ninth grader would be able to read the document.

  > Further reading on
  [Wikipedia](https://en.wikipedia.org/wiki/Gunning_fog_index)



  ```python
  textstat.smog_index(text)
  ```

  Returns the SMOG index of the given text. This is a grade formula in that
  a score of 9.3 means that a ninth grader would be able to read the document.

  Texts of fewer than 30 sentences are statistically invalid, because
  the SMOG formula was normed on 30-sentence samples. textstat requires at
  least 3 sentences for a result.

  > Further reading on
  [Wikipedia](https://en.wikipedia.org/wiki/SMOG)



  ```python
  textstat.automated_readability_index(text)
  ```

  Returns the ARI (Automated Readability Index) which outputs
  a number that approximates the grade level needed to
  comprehend the text.

  For example if the ARI is 6.5, then the grade level to comprehend
  the text is 6th to 7th grade.

  > Further reading on
  [Wikipedia](https://en.wikipedia.org/wiki/Automated_readability_index)



  ```python
  textstat.coleman_liau_index(text)
  ```

  Returns the grade level of the text using the Coleman-Liau Formula. This is
  a grade formula in that a score of 9.3 means that a ninth grader would be
  able to read the document.

  > Further reading on
  [Wikipedia](https://en.wikipedia.org/wiki/Coleman%E2%80%93Liau_index)



  ```python
  textstat.linsear_write_formula(text)
  ```

  Returns the grade level using the Linsear Write Formula. This is
  a grade formula in that a score of 9.3 means that a ninth grader would be
  able to read the document.

  > Further reading on
  [Wikipedia](https://en.wikipedia.org/wiki/Linsear_Write)



  ```python
  textstat.dale_chall_readability_score(text)
  ```

  Different from other tests, since it uses a lookup table
  of the most commonly used 3000 English words. Thus it returns
  the grade level using the New Dale-Chall Formula.

  | Score       |  Understood by                                |
  |-------------|-----------------------------------------------|
  |4.9 or lower | average 4th-grade student or lower            |
  |  5.0–5.9    | average 5th or 6th-grade student              |
  |  6.0–6.9    | average 7th or 8th-grade student              |
  |  7.0–7.9    | average 9th or 10th-grade student             |
  |  8.0–8.9    | average 11th or 12th-grade student            |
  |  9.0–9.9    | average 13th to 15th-grade (college) student  |

  > Further reading on
  [Wikipedia](https://en.wikipedia.org/wiki/Dale%E2%80%93Chall_readability_formula)



  ```python
  textstat.text_standard(text, float_output=False)
  ```

  Based upon all the above tests, returns the estimated school
  grade level required to understand the text.

  Optional `float_output` allows the score to be returned as a
  `float`. Defaults to `False`.



  ```python
  textstat.spache_readability(text)
  ```

  Returns grade level of english text.

  Intended for text written for children up to grade four.

  > Further reading on
  [Wikipedia](https://en.wikipedia.org/wiki/Spache_readability_formula)



  ```python
  textstat.mcalpine_eflaw(text)
  ```

  Returns a score for the readability of an english text for a foreign learner or
  English, focusing on the number of miniwords and length of sentences.

  It is recommended to aim for a score equal to or lower than 25.

  > Further reading on
  [This blog post](https://strainindex.wordpress.com/2009/04/30/mcalpine-eflaw-readability-score/)



  ```python
  textstat.reading_time(text, ms_per_char=14.69)
  ```

  Returns the reading time of the given text.

  Assumes 14.69ms per character.

  > Further reading in
  [This academic paper](https://homepages.inf.ed.ac.uk/keller/papers/cognition08a.pdf)




  ```python
  textstat.fernandez_huerta(text)
  ```

  Reformulation of the Flesch Reading Ease Formula specifically for spanish.
  The results can be interpreted similarly

  > Further reading on
  [This blog post](https://legible.es/blog/lecturabilidad-fernandez-huerta/)



  ```python
  textstat.szigriszt_pazos(text)
  ```
  Adaptation of Flesch Reading Ease formula for spanish-based texts.

  Attempts to quantify how understandable a text is.

  > Further reading on
  [This blog post](https://legible.es/blog/perspicuidad-szigriszt-pazos/)



  ```python
  textstat.gutierrez_polini(text)
  ```

  Returns the Guttiérrez de Polini understandability index.

  Specifically designed for the texts in spanish, not an adaptation.
  Conceived for grade-school level texts.

  Scores for more complex text are not reliable.

  > Further reading on
  [This blog post](https://legible.es/blog/comprensibilidad-gutierrez-de-polini/)



  ```python
  textstat.crawford(text)
  ```

  Returns the Crawford score for the text.

  Returns an estimate of the years of schooling required to understand the text.

  The text is only valid for elementary school level texts.

  > Further reading on
  [This blog post](https://legible.es/blog/formula-de-crawford/)



  ```python
  textstat.osman(text)
  ```

  Returns OSMAN score for text.

  Designed for Arabic, an adaption of Flesch and Fog Formula.
  Introduces a new factor called "Faseeh".

  > Further reading in
  [This academic paper](https://www.aclweb.org/anthology/L16-1038.pdf)



  ```python
  textstat.gulpease_index(text)
  ```

  Returns the Gulpease index of Italian text, which translates to
  level of education completed.

  Lower scores require higher level of education to read with ease.

  > Further reading on
  [Wikipedia](https://it.wikipedia.org/wiki/Indice_Gulpease)



  ```python
  textstat.wiener_sachtextformel(text, variant)
  ```

  Returns a grade level score for the given text.

  A value of 4 means very easy text, whereas 15 means very difficult text.

  > Further reading on
  [Wikipedia](https://de.wikipedia.org/wiki/Lesbarkeitsindex#Wiener_Sachtextformel)





  ```python
  textstat.syllable_count(text)
  ```

  Returns the number of syllables present in the given text.

  Uses the Python module [Pyphen](https://github.com/Kozea/Pyphen)
  for syllable calculation.



  ```python
  textstat.lexicon_count(text, removepunct=True)
  ```

  Calculates the number of words present in the text.
  Optional `removepunct` specifies whether we need to take
  punctuation symbols into account while counting lexicons.
  Default value is `True`, which removes the punctuation
  before counting lexicon items.



  ```python
  textstat.sentence_count(text)
  ```

  Returns the number of sentences present in the given text.



  ```python
  textstat.char_count(text, ignore_spaces=True)
  ```

  Returns the number of characters present in the given text.



  ```python
  textstat.letter_count(text, ignore_spaces=True)
  ```

  Returns the number of characters present in the given text without punctuation.



  ```python
  textstat.polysyllabcount(text)
  ```

  Returns the number of words with a syllable count greater than or equal to 3.



  ```python
  textstat.monosyllabcount(text)
  ```

  Returns the number of words with a syllable count equal to one.



  If you find any problems, you should open an
  [issue](https://github.com/shivam5992/textstat/issues).

  If you can fix an issue you've found, or another issue, you should open
  a [pull request](https://github.com/shivam5992/textstat/pulls).

  1. Fork this repository on GitHub to start making your changes to the master
  branch (or branch off of it).
  2. Write a test which shows that the bug was fixed or that the feature works as expected.
  3. Send a pull request!



  > It is recommended you use a [virtual environment](
  https://docs.python.org/3/tutorial/venv.html), or [Pipenv](
  https://docs.pipenv.org/) to keep your development work isolated from your
  systems Python installation.

  ```bash
  $ git clone https://github.com/<yourname>/textstat.git  # Clone the repo from your fork
  $ cd textstat
  $ pip install -r requirements.txt  # Install all dependencies

  $ # Make changes

  $ python -m pytest test.py  # Run tests
  ```


pkgId: fa7f550996c535d708c9f89318d33124f9e50602592d7b4cd2246f8389d37e76
name: python-texttable
arch: src
version: 1.6.7
epoch: 0
release: 1
summary: module to create simple ASCII tables
url: https://github.com/foutaise/texttable/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-918de79b-b11b-4904-b5ea-0991341ab910
location_href: 00009252-python-texttable/python-texttable-1.6.7-1.src.rpm
checksum_type: sha256
description:
          abcd      67.000   6.540e+02    89   128.001
          efghijk   67.543   6.540e-01    90   1.280e+22
          lmn        0.000   5.000e-78    89   0.000
          opqrstu    0.023   5.000e+78    92   1.280e+22
  CLASSES
      class Texttable
       |  Methods defined here:
       |
       |  __init__(self, max_width=80)
       |      Constructor
       |
       |      - max_width is an integer, specifying the maximum width of the table
       |      - if set to 0, size is unlimited, therefore cells won't be wrapped
       |
       |  add_row(self, array)
       |      Add a row in the rows stack
       |
       |      - cells can contain newlines and tabs
       |
       |  add_rows(self, rows, header=True)
       |      Add several rows in the rows stack
       |
       |      - The 'rows' argument can be either an iterator returning arrays,
       |        or a by-dimensional array
       |      - 'header' specifies if the first row should be used as the header
       |        of the table
       |
       |  draw(self)
       |      Draw the table
       |
       |      - the table is returned as a whole string
       |
       |  header(self, array)
       |      Specify the header of the table
       |
       |  reset(self)
       |      Reset the instance
       |
       |      - reset rows and header
       |
       |  set_chars(self, array)
       |      Set the characters used to draw lines between rows and columns
       |
       |      - the array should contain 4 fields:
       |
       |          [horizontal, vertical, corner, header]
       |
       |      - default is set to:
       |
       |          ['-', '|', '+', '=']
       |
       |  set_cols_align(self, array)
       |      Set the desired columns alignment
       |
       |      - the elements of the array should be either "l", "c" or "r":
       |
       |          * "l": column flushed left
       |          * "c": column centered
       |          * "r": column flushed right
       |
       |  set_cols_dtype(self, array)
       |      Set the desired columns datatype for the cols.
       |
       |      - the elements of the array should be either a callable or any of
       |        "a", "t", "f", "e" or "i":
       |
       |          * "a": automatic (try to use the most appropriate datatype)
       |          * "t": treat as text
       |          * "f": treat as float in decimal format
       |          * "e": treat as float in exponential format
       |          * "i": treat as int
       |          * a callable: should return formatted string for any value given
       |
       |      - by default, automatic datatyping is used for each column
       |
       |  set_cols_valign(self, array)
       |      Set the desired columns vertical alignment
       |
       |      - the elements of the array should be either "t", "m" or "b":
       |
       |          * "t": column aligned on the top of the cell
       |          * "m": column aligned on the middle of the cell
       |          * "b": column aligned on the bottom of the cell
       |
       |  set_cols_width(self, array)
       |      Set the desired columns width
       |
       |      - the elements of the array should be integers, specifying the
       |        width of each column. For example:
       |
       |              [10, 20, 5]
       |
       |  set_deco(self, deco)
       |      Set the table decoration
       |
       |      - 'deco' can be a combination of:
       |
       |          Texttable.BORDER: Border around the table
       |          Texttable.HEADER: Horizontal line below the header
       |          Texttable.HLINES: Horizontal lines between rows
       |          Texttable.VLINES: Vertical lines between columns
       |
       |         All of them are enabled by default
       |
       |      - example:
       |
       |          Texttable.BORDER | Texttable.HEADER
       |
       |  set_header_align(self, array)
       |      Set the desired header alignment
       |
       |      - the elements of the array should be either "l", "c" or "r":
       |
       |          * "l": column flushed left
       |          * "c": column centered
       |          * "r": column flushed right
       |
       |  set_max_width(self, max_width)
       |      Set the maximum width of the table
       |
       |      - max_width is an integer, specifying the maximum width of the table
       |      - if set to 0, size is unlimited, therefore cells won't be wrapped
       |
       |  set_precision(self, width)
       |      Set the desired precision for float/exponential formats
       |
       |      - width must be an integer >= 0
       |
       |      - default value is set to 3
       |
       |  ----------------------------------------------------------------------
       |  Data and other attributes defined here:
       |
       |  BORDER = 1
       |
       |  HEADER = 2
       |
       |  HLINES = 4
       |
       |  VLINES = 8
  DATA
      __all__ = ['Texttable', 'ArraySizeError']
      __author__ = 'Gerome Fournier <jef(at)foutaise.org>'
      __credits__ = 'Jeff Kowalczyk:\n    - textwrap improved import\n ...at...
      __license__ = 'MIT'
      __version__ = '1.6.7'
  VERSION
      1.6.7
  AUTHOR
      Gerome Fournier <jef(at)foutaise.org>
  CREDITS
      Jeff Kowalczyk:
          - textwrap improved import
          - comment concerning header output
      Anonymous:
          - add_rows method, for adding rows in one go
      Sergey Simonenko:
          - redefined len() function to deal with non-ASCII characters
      Roger Lew:
          - columns datatype specifications
      Brian Peterson:
          - better handling of unicode errors
      Frank Sachsenheim:
          - add Python 2/3-compatibility
      Maximilian Hils:
          - fix minor bug for Python 3 compatibility
      frinkelpi:
          - preserve empty lines
  ```

  * [latextable](https://github.com/JAEarly/latextable) is a fork of texttable that provide a LaTeX backend.


pkgId: 79474495ee1fe49406f315dccf94007e1a2360cf9a209e9b6b89c54261b071a6
name: python-textwrap3
arch: src
version: 0.9.2
epoch: 0
release: 1
summary: textwrap from Python 3.6 backport (plus a few tweaks)
url: https://github.com/jonathaneunice/textwrap3
rpm_license: Python Software Foundation License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9c1f21ae-5055-49c2-9368-eeb75ac7bf1c
location_href: 00005294-python-textwrap3/python-textwrap3-0.9.2-1.src.rpm
checksum_type: sha256
description:
  By design, Python 3 sensibilities and expectations rule. Especially when
  processing text that includes Unicode characters, ``textwrap3``'s results may
  differ a bit from those of the ``textwrap`` of the underlying Python version
  (esp. 2.x). In particular, ``textwrap3`` uses the ``re.UNICODE`` flag so that
  non-ASCII characters such as accented letters are considered legitimate word
  characters.
  It also adds one tweak, considering the Unicode em-dash
  (``'\N{EM DASH}'`` or ``u'\u2014'``) identical to the simulated ASCII em-dash
  ``'--'``.


pkgId: acee53a3009f8743d8a1f2fafe1a318af2ec8b68f1ab762ed655fb4bf635302d
name: python-thingserver
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: HTTP Web Thing implementation
url: https://pypi.org/project/thingserver/
rpm_license: MPL-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a1647e90-1ac1-4501-94c6-4f0e67d7de3d
location_href: 00005297-python-thingserver/python-thingserver-0.2.1-1.src.rpm
checksum_type: sha256
description:
  [![LabThings](https://img.shields.io/badge/-LabThings-8E00FF?style=flat&logo=data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4NCjwhRE9DVFlQRSBzdmcgIFBVQkxJQyAnLS8vVzNDLy9EVEQgU1ZHIDEuMS8vRU4nICAnaHR0cDovL3d3dy53My5vcmcvR3JhcGhpY3MvU1ZHLzEuMS9EVEQvc3ZnMTEuZHRkJz4NCjxzdmcgY2xpcC1ydWxlPSJldmVub2RkIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIHN0cm9rZS1taXRlcmxpbWl0PSIyIiB2ZXJzaW9uPSIxLjEiIHZpZXdCb3g9IjAgMCAxNjMgMTYzIiB4bWw6c3BhY2U9InByZXNlcnZlIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPjxwYXRoIGQ9Im0xMjIuMjQgMTYyLjk5aDQwLjc0OHYtMTYyLjk5aC0xMDEuODd2NDAuNzQ4aDYxLjEyMnYxMjIuMjR6IiBmaWxsPSIjZmZmIi8+PHBhdGggZD0ibTAgMTIuMjI0di0xMi4yMjRoNDAuNzQ4djEyMi4yNGg2MS4xMjJ2NDAuNzQ4aC0xMDEuODd2LTEyLjIyNGgyMC4zNzR2LTguMTVoLTIwLjM3NHYtOC4xNDloOC4wMTl2LTguMTVoLTguMDE5di04LjE1aDIwLjM3NHYtOC4xNDloLTIwLjM3NHYtOC4xNWg4LjAxOXYtOC4xNWgtOC4wMTl2LTguMTQ5aDIwLjM3NHYtOC4xNWgtMjAuMzc0di04LjE0OWg4LjAxOXYtOC4xNWgtOC4wMTl2LTguMTVoMjAuMzc0di04LjE0OWgtMjAuMzc0di04LjE1aDguMDE5di04LjE0OWgtOC4wMTl2LTguMTVoMjAuMzc0di04LjE1aC0yMC4zNzR6IiBmaWxsPSIjZmZmIi8+PC9zdmc+DQo=)](https://github.com/labthings/)
  [![PyPI](https://img.shields.io/pypi/v/thingserver)](https://pypi.org/project/thingserver/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Riot.im](https://img.shields.io/badge/chat-on%20riot.im-368BD6)](https://riot.im/app/#/room/#labthings:matrix.org)


  Implementation of an HTTP [Web Thing](https://iot.mozilla.org/wot/).
  This library is compatible with Python 3.5+.



  `thingserver` can be installed via `pip`, as such:

  ``` {.sourceCode .shell}
  $ pip install thingserver
  ```



  In this code-walkthrough we will set up a dimmable light and a humidity
  sensor (both using fake data, of course).



  Imagine you have a dimmable light that you want to expose via the web of
  things API. The light can be turned on/off and the brightness can be set
  from 0% to 100%. Besides the name, description, and type, a `Light`\_ is
  required to expose two properties:

  -   `on`: the state of the light, whether it is turned on or off
      -   Setting this property via a `PUT {"on": true/false}` call to the
          REST API toggles the light.
  -   `brightness`: the brightness level of the light from 0-100%
      -   Setting this property via a PUT call to the REST API sets the
          brightness level of this light.

  First we create a new Thing:

  ``` {.sourceCode .python}
  light = Thing(
      'urn:dev:ops:my-lamp-1234',
      'My Lamp',
      ['OnOffSwitch', 'Light'],
      'A web connected lamp'
  )
  ```

  Now we can add the required properties.

  The on property reports and sets the on/off state of the light. For
  this, we need to have a Value object which holds the actual state and
  also a method to turn the light on/off. For our purposes, we just want
  to log the new state if the light is switched on/off.

  ``` {.sourceCode .python}
  light.add_property(
      Property(
          light,
          'on',
          Value(True, None, lambda x: print(x)),
          metadata={
              '@type': 'OnOffProperty',
              'title': 'On/Off',
              'type': 'boolean',
              'description': 'Whether the lamp is turned on',
          }))
  ```

  The `brightness` property reports the brightness level of the light and
  sets the level. Like before, instead of actually setting the level of a
  light, we just log the level.

  ``` {.sourceCode .python}
  light.add_property(
      Property(
          light,
          'brightness',
          Value(50, None, lambda x: print(x)),
          metadata={
              '@type': 'BrightnessProperty',
              'title': 'Brightness',
              'type': 'number',
              'description': 'The level of light from 0-100',
              'minimum': 0,
              'maximum': 100,
              'unit': 'percent',
          }))
  ```

  Now we can add our newly created thing to the server and start it:

  ``` {.sourceCode .python}
  server = WebThingServer(light, port=8888)

  try:
      server.start()
  except KeyboardInterrupt:
      server.stop()
  ```

  This will start the server, making the light available via the WoT REST
  API and announcing it as a discoverable resource on your local network
  via mDNS.



  Let's now also connect a humidity sensor to the server we set up for our
  light.

  A `MultiLevelSensor`\_ (a sensor that returns a level instead of just
  on/off) has one required property (besides the name, type, and optional
  description): `level`. We want to monitor this property and get notified
  if the value changes.

  First we create a new Thing:

  ``` {.sourceCode .python}
  sensor = Thing(
      'urn:dev:ops:my-humidity-sensor-1234',
      'My Humidity Sensor',
       ['MultiLevelSensor'],
       'A web connected humidity sensor'
  )
  ```

  Then we create and add the appropriate property.

  Contrary to the light, the value cannot be set via an API call, as it
  wouldn't make much sense, to SET what a sensor is reading. Therefore, we
  are creating a **readOnly** property.

  ``` {.sourceCode .python}
  sensor.add_property(
      Property(
          sensor,
          'level',
          Value(None, self.read_from_gpio, None),
          metadata={
              '@type': 'LevelProperty',
              'title': 'Humidity',
              'type': 'number',
              'description': 'The current humidity in %',
              'minimum': 0,
              'maximum': 100,
              'unit': 'percent',
              'readOnly': True,
          }))
  ```

  In this example, we pass a readproperty method that will read and return
  the sensor value every time it is requested.

  Alternatively, we can create a thread that queries the physical sensor
  every few seconds. We first remove the readproperty argument from our
  Property.

  ``` {.sourceCode .python}
  sensor.add_property(
      Property(
          sensor,
          'level',
          Value(0.0),
          metadata={
              '@type': 'LevelProperty',
              'title': 'Humidity',
              'type': 'number',
              'description': 'The current humidity in %',
              'minimum': 0,
              'maximum': 100,
              'unit': 'percent',
              'readOnly': True,
          }))
  ```

  We then create our looping function to periodically query the sensor and
  set the property value.

  ``` {.sourceCode .python}
  self.sensor_update_task = \
      get_event_loop().create_task(self.update_level())

  async def update_level(self):
      try:
          while True:
              await sleep(3)
              sensor.properties["level"].value.set(self.read_from_gpio())
              logging.debug('setting new humidity level: %s', new_level)
      except CancelledError:
          pass
  ```

  This will update our `Value` object with the sensor readings via the
  `sensor.properties["level"].value.set(self.read_from_gpio())` call. The
  `Value` object now notifies the property and the thing that the value
  has changed, which in turn notifies all websocket listeners.



  To add your web thing to the WebThings Gateway, install the "Web Thing"
  add-on and follow the instructions
  [here](https://github.com/mozilla-iot/thing-url-adapter#readme).


pkgId: ca97ab2ee29ce2a7f52a2ba765baf3a1a4a4552f72819aac583b461904b146fa
name: python-threadloop
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: Tornado IOLoop Backed Concurrent Futures
url: https://github.com/breerly/threadloop
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-31517c16-99ef-402d-9eb1-7c95d3dc5d02
location_href: 00010263-python-threadloop/python-threadloop-1.0.2-1.src.rpm
checksum_type: sha256
description:
  |build-status| |coverage| |pypi|
      Run Tornado Coroutines from Synchronous Python.
      from threadloop import ThreadLoop
      from tornado import gen
      @gen.coroutine
      def coroutine(greeting="Goodbye"):
          yield gen.sleep(1)
          raise gen.Return("%s World" % greeting)
      with ThreadLoop() as threadloop:
          future = threadloop.submit(coroutine, "Hello")
          print future.result() # Hello World


pkgId: df8d8affad6e55f056508b0eec0b68d7ffe8ccab259116eaad374d545ca38b06
name: python-three-merge
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Simple library for merging two strings with respect to a base one
url: https://github.com/spyder-ide/three-merge
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a027aa89-accc-4359-931e-5659c6f36481
location_href: 00005298-python-three_merge/python-three-merge-0.1.1-1.src.rpm
checksum_type: sha256
description:
  [![Project License - MIT](https://img.shields.io/pypi/l/three-merge.svg)](https://raw.githubusercontent.com/spyder-ide/three-merge/master/LICENSE)
  [![pypi version](https://img.shields.io/pypi/v/three-merge.svg)](https://pypi.org/project/three-merge/)
  [![conda version](https://img.shields.io/conda/vn/conda-forge/three-merge.svg)](https://www.anaconda.com/download/)
  [![download count](https://img.shields.io/conda/dn/conda-forge/three-merge.svg)](https://www.anaconda.com/download/)
  [![Downloads](https://pepy.tech/badge/three-merge)](https://pepy.tech/project/three-merge)
  [![PyPI status](https://img.shields.io/pypi/status/three-merge.svg)](https://github.com/spyder-ide/three-merge)
  ![Linux tests](https://github.com/spyder-ide/three-merge/workflows/Linux%20tests/badge.svg)
  ![MacOS tests](https://github.com/spyder-ide/three-merge/workflows/MacOS%20tests/badge.svg)
  ![Windows tests](https://github.com/spyder-ide/three-merge/workflows/Windows%20tests/badge.svg)

  *Copyright © 2020– Spyder Project Contributors*


  Simple Python library to perform a 3-way merge between strings, based on [diff-match-patch](https://github.com/google/diff-match-patch). This library performs merges at a character level, as opposed to most VCS systems, which opt for a line-based approach.



  To install three-merge, you can use both conda or pip package managers:

  ```bash

  conda install three-merge -c spyder-ide


  pip install three-merge
  ```


  This package depends on [diff-match-patch](https://github.com/google/diff-match-patch) to compute and track the differences across the source and target strings with respect to the base one.


  To install and develop three-merge locally, you will need to install diff-match-patch:

  ```bash

  conda install diff-match-patch


  pip install diff-match-patch
  ```

  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 three_merge/tests
  ```


  Three-merge provides a ``merge`` function to merge changes from two strings (source, target) with respect a original string (base). This library is able to handle additions, deletions and preserved sections across both strings, while detecting and highlighting possible merge conflicts (like Git).

  ```python

  from three_merge import merge


  base = '123456789101112'
  source = '0123456789101112'
  target = '12345678910111213'


  merged = merge(source, target, base)


  base = '123456789101112'
  source = '123a456789101112'
  target = '123b456789101112'


  merged = merge(source, target, base)


  base = '123456789101112'
  source = '123456789ab101112'
  target = '123789101112'


  merged = merge(source, target, base)
  ```

  For more examples, please take a look at our [tests](https://github.com/spyder-ide/three-merge/blob/master/three_merge/tests/test_merge.py).



  Please see our [CHANGELOG](https://github.com/spyder-ide/three-merge/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: d991db91aeaef1a2992d3936555df65fffeb73684714dff390669a9e3b295ce6
name: python-tifffile
arch: src
version: 2023.2.28
epoch: 0
release: 1
summary: Read and write TIFF files
url: https://www.cgohlke.com
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e3a808b2-ab3e-4ca3-b4f8-e6ff70e21beb
location_href: 00005300-python-tifffile/python-tifffile-2023.2.28-1.src.rpm
checksum_type: sha256
description:
  Tifffile is a Python library to
  (1) store NumPy arrays in TIFF (Tagged Image File Format) files, and
  (2) read image and metadata from TIFF-like files used in bioimaging.
  Image and metadata can be read from TIFF, BigTIFF, OME-TIFF, DNG, STK, LSM,
  SGI, NIHImage, ImageJ, Micro-Manager NDTiff, FluoView, ScanImage, SEQ, GEL,
  SVS, SCN, SIS, BIF, ZIF (Zoomable Image File Format), QPTIFF (QPI, PKI), NDPI,
  and GeoTIFF files.
  Image data can be read as NumPy arrays or Zarr arrays/groups from strips,
  tiles, pages (IFDs), SubIFDs, higher order series, and pyramidal levels.
  Image data can be written to TIFF, BigTIFF, OME-TIFF, and ImageJ hyperstack
  compatible files in multi-page, volumetric, pyramidal, memory-mappable,
  tiled, predicted, or compressed form.
  Many compression and predictor schemes are supported via the imagecodecs
  library, including LZW, PackBits, Deflate, PIXTIFF, LZMA, LERC, Zstd,
  JPEG (8 and 12-bit, lossless), JPEG 2000, JPEG XR, JPEG XL, WebP, PNG, Jetraw,
  24-bit floating-point, and horizontal differencing.
  Tifffile can also be used to inspect TIFF structures, read image data from
  multi-dimensional file sequences, write fsspec ReferenceFileSystem for
  TIFF files and image file sequences, patch TIFF tag values, and parse
  many proprietary metadata formats.


pkgId: d26b7aef55fe33168cd1323b40a1f94f55f923ca3fc303726c086a21a744693e
name: python-tifffile
arch: src
version: 2023.3.21
epoch: 0
release: 1
summary: Read and write TIFF files
url: https://www.cgohlke.com
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-37dd2b5c-b019-4543-acb2-f7b062053140
location_href: 00008625-python-tifffile/python-tifffile-2023.3.21-1.src.rpm
checksum_type: sha256
description:
  Tifffile is a Python library to
  (1) store NumPy arrays in TIFF (Tagged Image File Format) files, and
  (2) read image and metadata from TIFF-like files used in bioimaging.
  Image and metadata can be read from TIFF, BigTIFF, OME-TIFF, DNG, STK, LSM,
  SGI, NIHImage, ImageJ, MMStack, NDTiff, FluoView, ScanImage, SEQ, GEL,
  SVS, SCN, SIS, BIF, ZIF (Zoomable Image File Format), QPTIFF (QPI, PKI), NDPI,
  and GeoTIFF formatted files.
  Image data can be read as NumPy arrays or Zarr arrays/groups from strips,
  tiles, pages (IFDs), SubIFDs, higher order series, and pyramidal levels.
  Image data can be written to TIFF, BigTIFF, OME-TIFF, and ImageJ hyperstack
  compatible files in multi-page, volumetric, pyramidal, memory-mappable,
  tiled, predicted, or compressed form.
  Many compression and predictor schemes are supported via the imagecodecs
  library, including LZW, PackBits, Deflate, PIXTIFF, LZMA, LERC, Zstd,
  JPEG (8 and 12-bit, lossless), JPEG 2000, JPEG XR, JPEG XL, WebP, PNG, Jetraw,
  24-bit floating-point, and horizontal differencing.
  Tifffile can also be used to inspect TIFF structures, read image data from
  multi-dimensional file sequences, write fsspec ReferenceFileSystem for
  TIFF files and image file sequences, patch TIFF tag values, and parse
  many proprietary metadata formats.


pkgId: 427d6af48012a57b935ff367e3ae40221b76638117985b5c901a0d584dadc7a0
name: python-tika
arch: src
version: 2.6.0
epoch: 0
release: 1
summary: Apache Tika Python library
url: http://github.com/chrismattmann/tika-python
rpm_license: Apache License version 2 ("ALv2")
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fae7158b-d4b3-4d49-9dc9-b94c83083401
location_href: 00011769-python-tika/python-tika-2.6.0-1.src.rpm
checksum_type: sha256
description:
  A Python port of the [Apache Tika](http://tika.apache.org/)
  library that makes Tika available using the
  [Tika REST Server](https://cwiki.apache.org/confluence/display/TIKA/TikaServer).
  This makes Apache Tika available as a Python library,
  installable via Setuptools, Pip and Easy Install.
  To use this library, you need to have Java 7+ installed on your
  system as tika-python starts up the Tika REST server in the
  background.
  Inspired by [Aptivate Tika](https://github.com/aptivate/python-tika).


pkgId: 1ff4a257053ddb9a065c7dd9938d8d2ad0930442fc15ce9e32d283dfdb467367
name: python-tilemapbase
arch: src
version: 0.4.7
epoch: 0
release: 1
summary: Use OpenStreetMap tiles as basemaps in python / matplotlib
url: https://github.com/MatthewDaws/TileMapBase
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-585956c7-05b8-4cc3-8958-42a2d663fbc9
location_href: 00013497-python-tilemapbase/python-tilemapbase-0.4.7-1.src.rpm
checksum_type: sha256
description:
  Uses OpenStreetMap tiles, or other tile servers, to produce “basemaps”
  for use with matplotlib. Uses a SQLite database to cache the tiles, so
  you can experiment with map production without re-downloading the same
  tiles. Supports Open Data tiles from the UK Ordnance Survey.


pkgId: bec3fe4d33932daa861a3fdead320132f75e2648169df4411a40e22389b339a0
name: python-timedelta
arch: src
version: 2020.12.3
epoch: 0
release: 1
summary: datetime.timedelta replacement
url: https://github.com/andrewp-as-is/timedelta.py
rpm_license: Unlicense
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0b4dc024-f35c-41aa-a8f0-b853c58acb4f
location_href: 00012057-python-timedelta/python-timedelta-2020.12.3-1.src.rpm
checksum_type: sha256
description:
  <!--
  https://readme42.com
  -->


  [![](https://img.shields.io/pypi/v/timedelta.svg?maxAge=3600)](https://pypi.org/project/timedelta/)
  [![](https://img.shields.io/badge/License-Unlicense-blue.svg?longCache=True)](https://unlicense.org/)


  ```bash
  $ [sudo] pip install timedelta
  ```


  ```python
  >>> import timedelta

  >>> td = timedelta.Timedelta(days=2, hours=2)


  >>> td = timedelta.Timedelta(datetime1 - datetime2)
  ```

  `total` seconds, minutes, hours, days
  ```python
  >>> td = timedelta.Timedelta(days=2, hours=2)
  >>> td.total.seconds
  180000
  >>> td.total.minutes
  3000
  >>> td.total.hours
  50
  >>> td.total.days
  2
  ```


  + [timedelta Objects](https://docs.python.org/3/library/datetime.html#timedelta-objects)

  <p align="center">
      <a href="https://readme42.com/">readme42.com</a>
  </p>


pkgId: 47b2a441c9d1004d54554dbcc2dce36c26800b720d2d83a4718de2d5ede42f8b
name: python-timeloop
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: An elegant way to run period tasks.
url: https://github.com/sankalpjonn/timeloop
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-80f0fb04-3ab9-4436-a2ec-63cd70e4d9cd
location_href: 00010724-python-timeloop/python-timeloop-1.0.2-1.src.rpm
checksum_type: sha256
description:
  Timeloop is a service that can be used to run periodic tasks after a certain interval.

  ![timeloop](http://66.42.57.109/timeloop.jpg)

  Each job runs on a separate thread and when the service is shut down, it waits till all tasks currently being executed are completed.

  Inspired by this blog [`here`](https://www.g-loaded.eu/2016/11/24/how-to-terminate-running-python-threads-using-signals/)


  ```sh
  pip install timeloop
  ```


  ```python
  import time

  from timeloop import Timeloop
  from datetime import timedelta

  tl = Timeloop()

  @tl.job(interval=timedelta(seconds=2))
  def sample_job_every_2s():
      print "2s job current time : {}".format(time.ctime())

  @tl.job(interval=timedelta(seconds=5))
  def sample_job_every_5s():
      print "5s job current time : {}".format(time.ctime())


  @tl.job(interval=timedelta(seconds=10))
  def sample_job_every_10s():
      print "10s job current time : {}".format(time.ctime())
  ```


  By default timeloop starts in a separate thread.

  Please do not forget to call ```tl.stop``` before exiting the program, Or else the jobs wont shut down gracefully.

  ```python
  tl.start()

  while True:
    try:
      time.sleep(1)
    except KeyboardInterrupt:
      tl.stop()
      break
  ```


  Doing this will automatically shut down the jobs gracefully when the program is killed, so no need to  call ```tl.stop```
  ```python
  tl.start(block=True)
  ```


  * **Sankalp Jonna**

  Email me with any queries: [sankalpjonna@gmail.com](sankalpjonna@gmail.com).


pkgId: c2e81e4481f1636bbea1f9802ad5d580b49fc5c8bbc88e3379e33d7ac6b50b11
name: python-times
arch: src
version: 0.7
epoch: 0
release: 1
url: https://github.com/nvie/times/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9a6746b7-0315-43c2-ac0a-6bc456bddb39
location_href: 00011638-python-times/python-times-0.7-1.src.rpm
checksum_type: sha256
summary:
  Times is a small, minimalistic, Python library for dealing with time conversions between universal time and arbitrary timezones.


pkgId: 4193e87c454759924eaba75aa4b821ec35d62b2cb20c442dd5ffeeee6833b8fe
name: python-timm
arch: src
version: 0.6.13
epoch: 0
release: 1
summary: (Unofficial) PyTorch Image Models
url: https://github.com/rwightman/pytorch-image-models
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-90e13fc5-31fa-4026-8b07-fc7961de912e
location_href: 00010609-python-timm/python-timm-0.6.13-1.src.rpm
checksum_type: sha256
description:
  - [Sponsors](#sponsors)
  - [What's New](#whats-new)
  - [Introduction](#introduction)
  - [Models](#models)
  - [Features](#features)
  - [Results](#results)
  - [Getting Started (Documentation)](#getting-started-documentation)
  - [Train, Validation, Inference Scripts](#train-validation-inference-scripts)
  - [Awesome PyTorch Resources](#awesome-pytorch-resources)
  - [Licenses](#licenses)
  - [Citing](#citing)



  Thanks to the following for hardware support:
  * TPU Research Cloud (TRC) (https://sites.research.google/trc/about/)
  * Nvidia (https://www.nvidia.com/en-us/)

  And a big thanks to all GitHub sponsors who helped with some of my costs before I joined Hugging Face.




  * 0.6.13 release to include Python 3.11 fix. Please try 0.8.x pre-releases (main branch or `pip install --pre timm`) for latest (transitioning to a 0.9 release soon).


  * More weights in `maxxvit` series, incl first ConvNeXt block based `coatnext` and `maxxvit` experiments:
    * `coatnext_nano_rw_224` - 82.0 @ 224 (G) -- (uses ConvNeXt conv block, no BatchNorm)
    * `maxxvit_rmlp_nano_rw_256` - 83.0 @ 256, 83.7 @ 320  (G) (uses ConvNeXt conv block, no BN)
    * `maxvit_rmlp_small_rw_224` - 84.5 @ 224, 85.1 @ 320 (G)
    * `maxxvit_rmlp_small_rw_256` - 84.6 @ 256, 84.9 @ 288 (G) -- could be trained better, hparams need tuning (uses ConvNeXt block, no BN)
    * `coatnet_rmlp_2_rw_224` - 84.6 @ 224, 85 @ 320  (T)
    * NOTE: official MaxVit weights (in1k) have been released at https://github.com/google-research/maxvit -- some extra work is needed to port and adapt since my impl was created independently of theirs and has a few small differences + the whole TF same padding fun.


  * LAION-2B CLIP image towers supported as pretrained backbones for fine-tune or features (no classifier)
    * vit_base_patch32_224_clip_laion2b
    * vit_large_patch14_224_clip_laion2b
    * vit_huge_patch14_224_clip_laion2b
    * vit_giant_patch14_224_clip_laion2b


  * Hugging Face [`timm` docs](https://huggingface.co/docs/hub/timm) home now exists, look for more here in the future
  * Add BEiT-v2 weights for base and large 224x224 models from https://github.com/microsoft/unilm/tree/master/beit2
  * Add more weights in `maxxvit` series incl a `pico` (7.5M params, 1.9 GMACs), two `tiny` variants:
    * `maxvit_rmlp_pico_rw_256` - 80.5 @ 256, 81.3 @ 320  (T)
    * `maxvit_tiny_rw_224` - 83.5 @ 224 (G)
    * `maxvit_rmlp_tiny_rw_256` - 84.2 @ 256, 84.8 @ 320 (T)


  * MaxVit window size scales with img_size by default. Add new RelPosMlp MaxViT weight that leverages this:
    * `maxvit_rmlp_nano_rw_256` - 83.0 @ 256, 83.6 @ 320  (T)


  * CoAtNet (https://arxiv.org/abs/2106.04803) and MaxVit (https://arxiv.org/abs/2204.01697) `timm` original models
    * both found in [`maxxvit.py`](https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/maxxvit.py) model def, contains numerous experiments outside scope of original papers
    * an unfinished Tensorflow version from MaxVit authors can be found https://github.com/google-research/maxvit
  * Initial CoAtNet and MaxVit timm pretrained weights (working on more):
    * `coatnet_nano_rw_224` - 81.7 @ 224  (T)
    * `coatnet_rmlp_nano_rw_224` - 82.0 @ 224, 82.8 @ 320 (T)
    * `coatnet_0_rw_224` - 82.4  (T)  -- NOTE timm '0' coatnets have 2 more 3rd stage blocks
    * `coatnet_bn_0_rw_224` - 82.4  (T)
    * `maxvit_nano_rw_256` - 82.9 @ 256  (T)
    * `coatnet_rmlp_1_rw_224` - 83.4 @ 224, 84 @ 320  (T)
    * `coatnet_1_rw_224` - 83.6 @ 224 (G)
    * (T) = TPU trained with `bits_and_tpu` branch training code, (G) = GPU trained
  * GCVit (weights adapted from https://github.com/NVlabs/GCVit, code 100% `timm` re-write for license purposes)
  * MViT-V2 (multi-scale vit, adapted from https://github.com/facebookresearch/mvit)
  * EfficientFormer (adapted from https://github.com/snap-research/EfficientFormer)
  * PyramidVisionTransformer-V2 (adapted from https://github.com/whai362/PVT)
  * 'Fast Norm' support for LayerNorm and GroupNorm that avoids float32 upcast w/ AMP (uses APEX LN if available for further boost)



  * ConvNeXt atto weights added
    * `convnext_atto` - 75.7 @ 224, 77.0 @ 288
    * `convnext_atto_ols` - 75.9  @ 224, 77.2 @ 288


  * More custom ConvNeXt smaller model defs with weights
    * `convnext_femto` - 77.5 @ 224, 78.7 @ 288
    * `convnext_femto_ols` - 77.9  @ 224, 78.9 @ 288
    * `convnext_pico` - 79.5 @ 224, 80.4 @ 288
    * `convnext_pico_ols` - 79.5 @ 224, 80.5 @ 288
    * `convnext_nano_ols` - 80.9 @ 224, 81.6 @ 288
  * Updated EdgeNeXt to improve ONNX export, add new base variant and weights from original (https://github.com/mmaaz60/EdgeNeXt)


  * Add freshly minted DeiT-III Medium (width=512, depth=12, num_heads=8) model weights. Thanks [Hugo Touvron](https://github.com/TouvronHugo)!


  * All runtime benchmark and validation result csv files are finally up-to-date!
  * A few more weights & model defs added:
    * `darknetaa53` -  79.8 @ 256, 80.5 @ 288
    * `convnext_nano` - 80.8 @ 224, 81.5 @ 288
    * `cs3sedarknet_l` - 81.2 @ 256, 81.8 @ 288
    * `cs3darknet_x` - 81.8 @ 256, 82.2 @ 288
    * `cs3sedarknet_x` - 82.2 @ 256, 82.7 @ 288
    * `cs3edgenet_x` - 82.2 @ 256, 82.7 @ 288
    * `cs3se_edgenet_x` - 82.8 @ 256, 83.5 @ 320
  * `cs3*` weights above all trained on TPU w/ `bits_and_tpu` branch. Thanks to TRC program!
  * Add output_stride=8 and 16 support to ConvNeXt (dilation)
  * deit3 models not being able to resize pos_emb fixed
  * Version 0.6.7 PyPi release (/w above bug fixes and new weighs since 0.6.5)


  More models, more fixes
  * Official research models (w/ weights) added:
    * EdgeNeXt from (https://github.com/mmaaz60/EdgeNeXt)
    * MobileViT-V2 from (https://github.com/apple/ml-cvnets)
    * DeiT III (Revenge of the ViT) from (https://github.com/facebookresearch/deit)
  * My own models:
    * Small `ResNet` defs added by request with 1 block repeats for both basic and bottleneck (resnet10 and resnet14)
    * `CspNet` refactored with dataclass config, simplified CrossStage3 (`cs3`) option. These are closer to YOLO-v5+ backbone defs.
    * More relative position vit fiddling. Two `srelpos` (shared relative position) models trained, and a medium w/ class token.
    * Add an alternate downsample mode to EdgeNeXt and train a `small` model. Better than original small, but not their new USI trained weights.
  * My own model weight results (all ImageNet-1k training)
    * `resnet10t` - 66.5 @ 176, 68.3 @ 224
    * `resnet14t` - 71.3 @ 176, 72.3 @ 224
    * `resnetaa50` - 80.6 @ 224 , 81.6 @ 288
    * `darknet53` -  80.0 @ 256, 80.5 @ 288
    * `cs3darknet_m` - 77.0 @ 256, 77.6 @ 288
    * `cs3darknet_focus_m` - 76.7 @ 256, 77.3 @ 288
    * `cs3darknet_l` - 80.4 @ 256, 80.9 @ 288
    * `cs3darknet_focus_l` - 80.3 @ 256, 80.9 @ 288
    * `vit_srelpos_small_patch16_224` - 81.1 @ 224, 82.1 @ 320
    * `vit_srelpos_medium_patch16_224` - 82.3 @ 224, 83.1 @ 320
    * `vit_relpos_small_patch16_cls_224` - 82.6 @ 224, 83.6 @ 320
    * `edgnext_small_rw` - 79.6 @ 224, 80.4 @ 320
  * `cs3`, `darknet`, and `vit_*relpos` weights above all trained on TPU thanks to TRC program! Rest trained on overheating GPUs.
  * Hugging Face Hub support fixes verified, demo notebook TBA
  * Pretrained weights / configs can be loaded externally (ie from local disk) w/ support for head adaptation.
  * Add support to change image extensions scanned by `timm` datasets/parsers. See (https://github.com/rwightman/pytorch-image-models/pull/1274#issuecomment-1178303103)
  * Default ConvNeXt LayerNorm impl to use `F.layer_norm(x.permute(0, 2, 3, 1), ...).permute(0, 3, 1, 2)` via `LayerNorm2d` in all cases.
    * a bit slower than previous custom impl on some hardware (ie Ampere w/ CL), but overall fewer regressions across wider HW / PyTorch version ranges.
    * previous impl exists as `LayerNormExp2d` in `models/layers/norm.py`
  * Numerous bug fixes
  * Currently testing for imminent PyPi 0.6.x release
  * LeViT pretraining of larger models still a WIP, they don't train well / easily without distillation. Time to add distill support (finally)?
  * ImageNet-22k weight training + finetune ongoing, work on multi-weight support (slowly) chugging along (there are a LOT of weights, sigh) ...


  * Official Swin-V2 models and weights added from (https://github.com/microsoft/Swin-Transformer). Cleaned up to support torchscript.
  * Some refactoring for existing `timm` Swin-V2-CR impl, will likely do a bit more to bring parts closer to official and decide whether to merge some aspects.
  * More Vision Transformer relative position / residual post-norm experiments (all trained on TPU thanks to TRC program)
    * `vit_relpos_small_patch16_224` - 81.5 @ 224, 82.5 @ 320 -- rel pos, layer scale, no class token, avg pool
    * `vit_relpos_medium_patch16_rpn_224` - 82.3 @ 224, 83.1 @ 320 -- rel pos + res-post-norm, no class token, avg pool
    * `vit_relpos_medium_patch16_224` - 82.5 @ 224, 83.3 @ 320 -- rel pos, layer scale, no class token, avg pool
    * `vit_relpos_base_patch16_gapcls_224` - 82.8 @ 224, 83.9 @ 320 -- rel pos, layer scale, class token, avg pool (by mistake)
  * Bring 512 dim, 8-head 'medium' ViT model variant back to life (after using in a pre DeiT 'small' model for first ViT impl back in 2020)
  * Add ViT relative position support for switching btw existing impl and some additions in official Swin-V2 impl for future trials
  * Sequencer2D impl (https://arxiv.org/abs/2205.01972), added via PR from author (https://github.com/okojoalg)


  * Vision Transformer experiments adding Relative Position (Swin-V2 log-coord) (`vision_transformer_relpos.py`) and Residual Post-Norm branches (from Swin-V2) (`vision_transformer*.py`)
    * `vit_relpos_base_patch32_plus_rpn_256` - 79.5 @ 256, 80.6 @ 320 -- rel pos + extended width + res-post-norm, no class token, avg pool
    * `vit_relpos_base_patch16_224` - 82.5 @ 224, 83.6 @ 320 -- rel pos, layer scale, no class token, avg pool
    * `vit_base_patch16_rpn_224` - 82.3 @ 224 -- rel pos + res-post-norm, no class token, avg pool
  * Vision Transformer refactor to remove representation layer that was only used in initial vit and rarely used since with newer pretrain (ie `How to Train Your ViT`)
  * `vit_*` models support removal of class token, use of global average pool, use of fc_norm (ala beit, mae).


  * `timm` models are now officially supported in [fast.ai](https://www.fast.ai/)! Just in time for the new Practical Deep Learning course. `timmdocs` documentation link updated to [timm.fast.ai](http://timm.fast.ai/).
  * Two more model weights added in the TPU trained [series](https://github.com/rwightman/pytorch-image-models/releases/tag/v0.1-tpu-weights). Some In22k pretrain still in progress.
    * `seresnext101d_32x8d` - 83.69 @ 224, 84.35 @ 288
    * `seresnextaa101d_32x8d` (anti-aliased w/ AvgPool2d) - 83.85 @ 224, 84.57 @ 288


  * Add `ParallelBlock` and `LayerScale` option to base vit models to support model configs in [Three things everyone should know about ViT](https://arxiv.org/abs/2203.09795)
  * `convnext_tiny_hnf` (head norm first) weights trained with (close to) A2 recipe, 82.2% top-1, could do better with more epochs.


  * Merge `norm_norm_norm`. **IMPORTANT** this update for a coming 0.6.x release will likely de-stabilize the master branch for a while. Branch [`0.5.x`](https://github.com/rwightman/pytorch-image-models/tree/0.5.x) or a previous 0.5.x release can be used if stability is required.
  * Significant weights update (all TPU trained) as described in this [release](https://github.com/rwightman/pytorch-image-models/releases/tag/v0.1-tpu-weights)
    * `regnety_040` - 82.3 @ 224, 82.96 @ 288
    * `regnety_064` - 83.0 @ 224, 83.65 @ 288
    * `regnety_080` - 83.17 @ 224, 83.86 @ 288
    * `regnetv_040` - 82.44 @ 224, 83.18 @ 288   (timm pre-act)
    * `regnetv_064` - 83.1 @ 224, 83.71 @ 288   (timm pre-act)
    * `regnetz_040` - 83.67 @ 256, 84.25 @ 320
    * `regnetz_040h` - 83.77 @ 256, 84.5 @ 320 (w/ extra fc in head)
    * `resnetv2_50d_gn` - 80.8 @ 224, 81.96 @ 288 (pre-act GroupNorm)
    * `resnetv2_50d_evos` 80.77 @ 224, 82.04 @ 288 (pre-act EvoNormS)
    * `regnetz_c16_evos`  - 81.9 @ 256, 82.64 @ 320 (EvoNormS)
    * `regnetz_d8_evos`  - 83.42 @ 256, 84.04 @ 320 (EvoNormS)
    * `xception41p` - 82 @ 299   (timm pre-act)
    * `xception65` -  83.17 @ 299
    * `xception65p` -  83.14 @ 299   (timm pre-act)
    * `resnext101_64x4d` - 82.46 @ 224, 83.16 @ 288
    * `seresnext101_32x8d` - 83.57 @ 224, 84.270 @ 288
    * `resnetrs200` - 83.85 @ 256, 84.44 @ 320
  * HuggingFace hub support fixed w/ initial groundwork for allowing alternative 'config sources' for pretrained model definitions and weights (generic local file / remote url support soon)
  * SwinTransformer-V2 implementation added. Submitted by [Christoph Reich](https://github.com/ChristophReich1996). Training experiments and model changes by myself are ongoing so expect compat breaks.
  * Swin-S3 (AutoFormerV2) models / weights added from https://github.com/microsoft/Cream/tree/main/AutoFormerV2
  * MobileViT models w/ weights adapted from https://github.com/apple/ml-cvnets
  * PoolFormer models w/ weights adapted from https://github.com/sail-sg/poolformer
  * VOLO models w/ weights adapted from https://github.com/sail-sg/volo
  * Significant work experimenting with non-BatchNorm norm layers such as EvoNorm, FilterResponseNorm, GroupNorm, etc
  * Enhance support for alternate norm + act ('NormAct') layers added to a number of models, esp EfficientNet/MobileNetV3, RegNet, and aligned Xception
  * Grouped conv support added to EfficientNet family
  * Add 'group matching' API to all models to allow grouping model parameters for application of 'layer-wise' LR decay, lr scale added to LR scheduler
  * Gradient checkpointing support added to many models
  * `forward_head(x, pre_logits=False)` fn added to all models to allow separate calls of `forward_features` + `forward_head`
  * All vision transformer and vision MLP models update to return non-pooled / non-token selected features from `foward_features`, for consistency with CNN models, token selection or pooling now applied in `forward_head`


  * [Chris Hughes](https://github.com/Chris-hughes10) posted an exhaustive run through of `timm` on his blog yesterday. Well worth a read. [Getting Started with PyTorch Image Models (timm): A Practitioner’s Guide](https://towardsdatascience.com/getting-started-with-pytorch-image-models-timm-a-practitioners-guide-4e77b4bf9055)
  * I'm currently prepping to merge the `norm_norm_norm` branch back to master (ver 0.6.x) in next week or so.
    * The changes are more extensive than usual and may destabilize and break some model API use (aiming for full backwards compat). So, beware `pip install git+https://github.com/rwightman/pytorch-image-models` installs!
    * `0.5.x` releases and a `0.5.x` branch will remain stable with a cherry pick or two until dust clears. Recommend sticking to pypi install for a bit if you want stable.


  * Version 0.5.4 w/ release to be pushed to pypi. It's been a while since last pypi update and riskier changes will be merged to main branch soon....
  * Add ConvNeXT models /w weights from official impl (https://github.com/facebookresearch/ConvNeXt), a few perf tweaks, compatible with timm features
  * Tried training a few small (~1.8-3M param) / mobile optimized models, a few are good so far, more on the way...
    * `mnasnet_small` - 65.6 top-1
    * `mobilenetv2_050` - 65.9
    * `lcnet_100/075/050` - 72.1 / 68.8 / 63.1
    * `semnasnet_075` - 73
    * `fbnetv3_b/d/g` - 79.1 / 79.7 / 82.0
  * TinyNet models added by [rsomani95](https://github.com/rsomani95)
  * LCNet added via MobileNetV3 architecture


  * A number of updated weights anew new model defs
    * `eca_halonext26ts` - 79.5 @ 256
    * `resnet50_gn` (new) - 80.1 @ 224, 81.3 @ 288
    * `resnet50` - 80.7 @ 224, 80.9 @ 288 (trained at 176, not replacing current a1 weights as default since these don't scale as well to higher res, [weights](https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-rsb-weights/resnet50_a1h2_176-001a1197.pth))
    * `resnext50_32x4d` - 81.1 @ 224, 82.0 @ 288
    * `sebotnet33ts_256` (new) - 81.2 @ 224
    * `lamhalobotnet50ts_256` - 81.5 @ 256
    * `halonet50ts` - 81.7 @ 256
    * `halo2botnet50ts_256` - 82.0 @ 256
    * `resnet101` - 82.0 @ 224, 82.8 @ 288
    * `resnetv2_101` (new) - 82.1 @ 224, 83.0 @ 288
    * `resnet152` - 82.8 @ 224, 83.5 @ 288
    * `regnetz_d8` (new) - 83.5 @ 256, 84.0 @ 320
    * `regnetz_e8` (new) - 84.5 @ 256, 85.0 @ 320
  * `vit_base_patch8_224` (85.8 top-1) & `in21k` variant weights added thanks [Martins Bruveris](https://github.com/martinsbruveris)
  * Groundwork in for FX feature extraction thanks to [Alexander Soare](https://github.com/alexander-soare)
    * models updated for tracing compatibility (almost full support with some distlled transformer exceptions)


  * ResNet strikes back (https://arxiv.org/abs/2110.00476) weights added, plus any extra training components used. Model weights and some more details here (https://github.com/rwightman/pytorch-image-models/releases/tag/v0.1-rsb-weights)
  * BCE loss and Repeated Augmentation support for RSB paper
  * 4 series of ResNet based attention model experiments being added (implemented across byobnet.py/byoanet.py). These include all sorts of attention, from channel attn like SE, ECA to 2D QKV self-attention layers such as Halo, Bottlneck, Lambda. Details here (https://github.com/rwightman/pytorch-image-models/releases/tag/v0.1-attn-weights)
  * Working implementations of the following 2D self-attention modules (likely to be differences from paper or eventual official impl):
    * Halo (https://arxiv.org/abs/2103.12731)
    * Bottleneck Transformer (https://arxiv.org/abs/2101.11605)
    * LambdaNetworks (https://arxiv.org/abs/2102.08602)
  * A RegNetZ series of models with some attention experiments (being added to). These do not follow the paper (https://arxiv.org/abs/2103.06877) in any way other than block architecture, details of official models are not available. See more here (https://github.com/rwightman/pytorch-image-models/releases/tag/v0.1-attn-weights)
  * ConvMixer (https://openreview.net/forum?id=TVHS5Y4dNvM), CrossVit (https://arxiv.org/abs/2103.14899), and BeiT (https://arxiv.org/abs/2106.08254) architectures + weights added
  * freeze/unfreeze helpers by [Alexander Soare](https://github.com/alexander-soare)


  * Optimizer bonanza!
    * Add LAMB and LARS optimizers, incl trust ratio clipping options. Tweaked to work properly in PyTorch XLA (tested on TPUs w/ `timm bits` [branch](https://github.com/rwightman/pytorch-image-models/tree/bits_and_tpu/timm/bits))
    * Add MADGRAD from FB research w/ a few tweaks (decoupled decay option, step handling that works with PyTorch XLA)
    * Some cleanup on all optimizers and factory. No more `.data`, a bit more consistency, unit tests for all!
    * SGDP and AdamP still won't work with PyTorch XLA but others should (have yet to test Adabelief, Adafactor, Adahessian myself).
  * EfficientNet-V2 XL TF ported weights added, but they don't validate well in PyTorch (L is better). The pre-processing for the V2 TF training is a bit diff and the fine-tuned 21k -> 1k weights are very sensitive and less robust than the 1k weights.
  * Added PyTorch trained EfficientNet-V2 'Tiny' w/ GlobalContext attn weights. Only .1-.2 top-1 better than the SE so more of a curiosity for those interested.



  Py**T**orch **Im**age **M**odels (`timm`) is a collection of image models, layers, utilities, optimizers, schedulers, data-loaders / augmentations, and reference training / validation scripts that aim to pull together a wide variety of SOTA models with ability to reproduce ImageNet training results.

  The work of many others is present here. I've tried to make sure all source material is acknowledged via links to github, arxiv papers, etc in the README, documentation, and code docstrings. Please let me know if I missed anything.



  All model architecture families include variants with pretrained weights. There are specific model variants without any weights, it is NOT a bug. Help training new or better weights is always appreciated. Here are some example [training hparams](https://rwightman.github.io/pytorch-image-models/training_hparam_examples) to get you started.

  A full version of the list below with source links can be found in the [documentation](https://rwightman.github.io/pytorch-image-models/models/).

  * Aggregating Nested Transformers - https://arxiv.org/abs/2105.12723
  * BEiT - https://arxiv.org/abs/2106.08254
  * Big Transfer ResNetV2 (BiT) - https://arxiv.org/abs/1912.11370
  * Bottleneck Transformers - https://arxiv.org/abs/2101.11605
  * CaiT (Class-Attention in Image Transformers) - https://arxiv.org/abs/2103.17239
  * CoaT (Co-Scale Conv-Attentional Image Transformers) - https://arxiv.org/abs/2104.06399
  * CoAtNet (Convolution and Attention) - https://arxiv.org/abs/2106.04803
  * ConvNeXt - https://arxiv.org/abs/2201.03545
  * ConViT (Soft Convolutional Inductive Biases Vision Transformers)- https://arxiv.org/abs/2103.10697
  * CspNet (Cross-Stage Partial Networks) - https://arxiv.org/abs/1911.11929
  * DeiT - https://arxiv.org/abs/2012.12877
  * DeiT-III - https://arxiv.org/pdf/2204.07118.pdf
  * DenseNet - https://arxiv.org/abs/1608.06993
  * DLA - https://arxiv.org/abs/1707.06484
  * DPN (Dual-Path Network) - https://arxiv.org/abs/1707.01629
  * EdgeNeXt - https://arxiv.org/abs/2206.10589
  * EfficientFormer - https://arxiv.org/abs/2206.01191
  * EfficientNet (MBConvNet Family)
      * EfficientNet NoisyStudent (B0-B7, L2) - https://arxiv.org/abs/1911.04252
      * EfficientNet AdvProp (B0-B8) - https://arxiv.org/abs/1911.09665
      * EfficientNet (B0-B7) - https://arxiv.org/abs/1905.11946
      * EfficientNet-EdgeTPU (S, M, L) - https://ai.googleblog.com/2019/08/efficientnet-edgetpu-creating.html
      * EfficientNet V2 - https://arxiv.org/abs/2104.00298
      * FBNet-C - https://arxiv.org/abs/1812.03443
      * MixNet - https://arxiv.org/abs/1907.09595
      * MNASNet B1, A1 (Squeeze-Excite), and Small - https://arxiv.org/abs/1807.11626
      * MobileNet-V2 - https://arxiv.org/abs/1801.04381
      * Single-Path NAS - https://arxiv.org/abs/1904.02877
      * TinyNet - https://arxiv.org/abs/2010.14819
  * GCViT (Global Context Vision Transformer) - https://arxiv.org/abs/2206.09959
  * GhostNet - https://arxiv.org/abs/1911.11907
  * gMLP - https://arxiv.org/abs/2105.08050
  * GPU-Efficient Networks - https://arxiv.org/abs/2006.14090
  * Halo Nets - https://arxiv.org/abs/2103.12731
  * HRNet - https://arxiv.org/abs/1908.07919
  * Inception-V3 - https://arxiv.org/abs/1512.00567
  * Inception-ResNet-V2 and Inception-V4 - https://arxiv.org/abs/1602.07261
  * Lambda Networks - https://arxiv.org/abs/2102.08602
  * LeViT (Vision Transformer in ConvNet's Clothing) - https://arxiv.org/abs/2104.01136
  * MaxViT (Multi-Axis Vision Transformer) - https://arxiv.org/abs/2204.01697
  * MLP-Mixer - https://arxiv.org/abs/2105.01601
  * MobileNet-V3 (MBConvNet w/ Efficient Head) - https://arxiv.org/abs/1905.02244
    * FBNet-V3 - https://arxiv.org/abs/2006.02049
    * HardCoRe-NAS - https://arxiv.org/abs/2102.11646
    * LCNet - https://arxiv.org/abs/2109.15099
  * MobileViT - https://arxiv.org/abs/2110.02178
  * MobileViT-V2 - https://arxiv.org/abs/2206.02680
  * MViT-V2 (Improved Multiscale Vision Transformer) - https://arxiv.org/abs/2112.01526
  * NASNet-A - https://arxiv.org/abs/1707.07012
  * NesT - https://arxiv.org/abs/2105.12723
  * NFNet-F - https://arxiv.org/abs/2102.06171
  * NF-RegNet / NF-ResNet - https://arxiv.org/abs/2101.08692
  * PNasNet - https://arxiv.org/abs/1712.00559
  * PoolFormer (MetaFormer) - https://arxiv.org/abs/2111.11418
  * Pooling-based Vision Transformer (PiT) - https://arxiv.org/abs/2103.16302
  * PVT-V2 (Improved Pyramid Vision Transformer) - https://arxiv.org/abs/2106.13797
  * RegNet - https://arxiv.org/abs/2003.13678
  * RegNetZ - https://arxiv.org/abs/2103.06877
  * RepVGG - https://arxiv.org/abs/2101.03697
  * ResMLP - https://arxiv.org/abs/2105.03404
  * ResNet/ResNeXt
      * ResNet (v1b/v1.5) - https://arxiv.org/abs/1512.03385
      * ResNeXt - https://arxiv.org/abs/1611.05431
      * 'Bag of Tricks' / Gluon C, D, E, S variations - https://arxiv.org/abs/1812.01187
      * Weakly-supervised (WSL) Instagram pretrained / ImageNet tuned ResNeXt101 - https://arxiv.org/abs/1805.00932
      * Semi-supervised (SSL) / Semi-weakly Supervised (SWSL) ResNet/ResNeXts - https://arxiv.org/abs/1905.00546
      * ECA-Net (ECAResNet) - https://arxiv.org/abs/1910.03151v4
      * Squeeze-and-Excitation Networks (SEResNet) - https://arxiv.org/abs/1709.01507
      * ResNet-RS - https://arxiv.org/abs/2103.07579
  * Res2Net - https://arxiv.org/abs/1904.01169
  * ResNeSt - https://arxiv.org/abs/2004.08955
  * ReXNet - https://arxiv.org/abs/2007.00992
  * SelecSLS - https://arxiv.org/abs/1907.00837
  * Selective Kernel Networks - https://arxiv.org/abs/1903.06586
  * Sequencer2D - https://arxiv.org/abs/2205.01972
  * Swin S3 (AutoFormerV2) - https://arxiv.org/abs/2111.14725
  * Swin Transformer - https://arxiv.org/abs/2103.14030
  * Swin Transformer V2 - https://arxiv.org/abs/2111.09883
  * Transformer-iN-Transformer (TNT) - https://arxiv.org/abs/2103.00112
  * TResNet - https://arxiv.org/abs/2003.13630
  * Twins (Spatial Attention in Vision Transformers) - https://arxiv.org/pdf/2104.13840.pdf
  * Visformer - https://arxiv.org/abs/2104.12533
  * Vision Transformer - https://arxiv.org/abs/2010.11929
  * VOLO (Vision Outlooker) - https://arxiv.org/abs/2106.13112
  * VovNet V2 and V1 - https://arxiv.org/abs/1911.06667
  * Xception - https://arxiv.org/abs/1610.02357
  * Xception (Modified Aligned, Gluon) - https://arxiv.org/abs/1802.02611
  * Xception (Modified Aligned, TF) - https://arxiv.org/abs/1802.02611
  * XCiT (Cross-Covariance Image Transformers) - https://arxiv.org/abs/2106.09681



  Several (less common) features that I often utilize in my projects are included. Many of their additions are the reason why I maintain my own set of models, instead of using others' via PIP:

  * All models have a common default configuration interface and API for
      * accessing/changing the classifier - `get_classifier` and `reset_classifier`
      * doing a forward pass on just the features - `forward_features` (see [documentation](https://rwightman.github.io/pytorch-image-models/feature_extraction/))
      * these makes it easy to write consistent network wrappers that work with any of the models
  * All models support multi-scale feature map extraction (feature pyramids) via create_model (see [documentation](https://rwightman.github.io/pytorch-image-models/feature_extraction/))
      * `create_model(name, features_only=True, out_indices=..., output_stride=...)`
      * `out_indices` creation arg specifies which feature maps to return, these indices are 0 based and generally correspond to the `C(i + 1)` feature level.
      * `output_stride` creation arg controls output stride of the network by using dilated convolutions. Most networks are stride 32 by default. Not all networks support this.
      * feature map channel counts, reduction level (stride) can be queried AFTER model creation via the `.feature_info` member
  * All models have a consistent pretrained weight loader that adapts last linear if necessary, and from 3 to 1 channel input if desired
  * High performance [reference training, validation, and inference scripts](https://rwightman.github.io/pytorch-image-models/scripts/) that work in several process/GPU modes:
      * NVIDIA DDP w/ a single GPU per process, multiple processes with APEX present (AMP mixed-precision optional)
      * PyTorch DistributedDataParallel w/ multi-gpu, single process (AMP disabled as it crashes when enabled)
      * PyTorch w/ single GPU single process (AMP optional)
  * A dynamic global pool implementation that allows selecting from average pooling, max pooling, average + max, or concat([average, max]) at model creation. All global pooling is adaptive average by default and compatible with pretrained weights.
  * A 'Test Time Pool' wrapper that can wrap any of the included models and usually provides improved performance doing inference with input images larger than the training size. Idea adapted from original DPN implementation when I ported (https://github.com/cypw/DPNs)
  * Learning rate schedulers
    * Ideas adopted from
       * [AllenNLP schedulers](https://github.com/allenai/allennlp/tree/master/allennlp/training/learning_rate_schedulers)
       * [FAIRseq lr_scheduler](https://github.com/pytorch/fairseq/tree/master/fairseq/optim/lr_scheduler)
       * SGDR: Stochastic Gradient Descent with Warm Restarts (https://arxiv.org/abs/1608.03983)
    * Schedulers include `step`, `cosine` w/ restarts, `tanh` w/ restarts, `plateau`
  * Optimizers:
      * `rmsprop_tf` adapted from PyTorch RMSProp by myself. Reproduces much improved Tensorflow RMSProp behaviour.
      * `radam` by [Liyuan Liu](https://github.com/LiyuanLucasLiu/RAdam) (https://arxiv.org/abs/1908.03265)
      * `novograd` by [Masashi Kimura](https://github.com/convergence-lab/novograd) (https://arxiv.org/abs/1905.11286)
      * `lookahead` adapted from impl by [Liam](https://github.com/alphadl/lookahead.pytorch) (https://arxiv.org/abs/1907.08610)
      * `fused<name>` optimizers by name with [NVIDIA Apex](https://github.com/NVIDIA/apex/tree/master/apex/optimizers) installed
      * `adamp` and `sgdp` by [Naver ClovAI](https://github.com/clovaai) (https://arxiv.org/abs/2006.08217)
      * `adafactor` adapted from [FAIRSeq impl](https://github.com/pytorch/fairseq/blob/master/fairseq/optim/adafactor.py) (https://arxiv.org/abs/1804.04235)
      * `adahessian` by [David Samuel](https://github.com/davda54/ada-hessian) (https://arxiv.org/abs/2006.00719)
  * Random Erasing from [Zhun Zhong](https://github.com/zhunzhong07/Random-Erasing/blob/master/transforms.py)  (https://arxiv.org/abs/1708.04896)
  * Mixup (https://arxiv.org/abs/1710.09412)
  * CutMix (https://arxiv.org/abs/1905.04899)
  * AutoAugment (https://arxiv.org/abs/1805.09501) and RandAugment (https://arxiv.org/abs/1909.13719) ImageNet configurations modeled after impl for EfficientNet training (https://github.com/tensorflow/tpu/blob/master/models/official/efficientnet/autoaugment.py)
  * AugMix w/ JSD loss (https://arxiv.org/abs/1912.02781), JSD w/ clean + augmented mixing support works with AutoAugment and RandAugment as well
  * SplitBachNorm - allows splitting batch norm layers between clean and augmented (auxiliary batch norm) data
  * DropPath aka "Stochastic Depth" (https://arxiv.org/abs/1603.09382)
  * DropBlock (https://arxiv.org/abs/1810.12890)
  * Blur Pooling (https://arxiv.org/abs/1904.11486)
  * Space-to-Depth by [mrT23](https://github.com/mrT23/TResNet/blob/master/src/models/tresnet/layers/space_to_depth.py) (https://arxiv.org/abs/1801.04590) -- original paper?
  * Adaptive Gradient Clipping (https://arxiv.org/abs/2102.06171, https://github.com/deepmind/deepmind-research/tree/master/nfnets)
  * An extensive selection of channel and/or spatial attention modules:
      * Bottleneck Transformer - https://arxiv.org/abs/2101.11605
      * CBAM - https://arxiv.org/abs/1807.06521
      * Effective Squeeze-Excitation (ESE) - https://arxiv.org/abs/1911.06667
      * Efficient Channel Attention (ECA) - https://arxiv.org/abs/1910.03151
      * Gather-Excite (GE) - https://arxiv.org/abs/1810.12348
      * Global Context (GC) - https://arxiv.org/abs/1904.11492
      * Halo - https://arxiv.org/abs/2103.12731
      * Involution - https://arxiv.org/abs/2103.06255
      * Lambda Layer - https://arxiv.org/abs/2102.08602
      * Non-Local (NL) -  https://arxiv.org/abs/1711.07971
      * Squeeze-and-Excitation (SE) - https://arxiv.org/abs/1709.01507
      * Selective Kernel (SK) - (https://arxiv.org/abs/1903.06586
      * Split (SPLAT) - https://arxiv.org/abs/2004.08955
      * Shifted Window (SWIN) - https://arxiv.org/abs/2103.14030



  Model validation results can be found in the [documentation](https://rwightman.github.io/pytorch-image-models/results/) and in the [results tables](results/README.md)



  My current [documentation](https://rwightman.github.io/pytorch-image-models/) for `timm` covers the basics.

  Hugging Face [`timm` docs](https://huggingface.co/docs/hub/timm) will be the documentation focus going forward and will eventually replace the `github.io` docs above.

  [Getting Started with PyTorch Image Models (timm): A Practitioner’s Guide](https://towardsdatascience.com/getting-started-with-pytorch-image-models-timm-a-practitioners-guide-4e77b4bf9055) by [Chris Hughes](https://github.com/Chris-hughes10) is an extensive blog post covering many aspects of `timm` in detail.

  [timmdocs](http://timm.fast.ai/) is quickly becoming a much more comprehensive set of documentation for `timm`. A big thanks to [Aman Arora](https://github.com/amaarora) for his efforts creating timmdocs.

  [paperswithcode](https://paperswithcode.com/lib/timm) is a good resource for browsing the models within `timm`.



  The root folder of the repository contains reference train, validation, and inference scripts that work with the included models and other features of this repository. They are adaptable for other datasets and use cases with a little hacking. See [documentation](https://rwightman.github.io/pytorch-image-models/scripts/) for some basics and [training hparams](https://rwightman.github.io/pytorch-image-models/training_hparam_examples) for some train examples that produce SOTA ImageNet results.



  One of the greatest assets of PyTorch is the community and their contributions. A few of my favourite resources that pair well with the models and components here are listed below.


  * Detectron2 - https://github.com/facebookresearch/detectron2
  * Segmentation Models (Semantic) - https://github.com/qubvel/segmentation_models.pytorch
  * EfficientDet (Obj Det, Semantic soon) - https://github.com/rwightman/efficientdet-pytorch


  * Albumentations - https://github.com/albumentations-team/albumentations
  * Kornia - https://github.com/kornia/kornia


  * RepDistiller - https://github.com/HobbitLong/RepDistiller
  * torchdistill - https://github.com/yoshitomo-matsubara/torchdistill


  * PyTorch Metric Learning - https://github.com/KevinMusgrave/pytorch-metric-learning


  * fastai - https://github.com/fastai/fastai




  The code here is licensed Apache 2.0. I've taken care to make sure any third party code included or adapted has compatible (permissive) licenses such as MIT, BSD, etc. I've made an effort to avoid any GPL / LGPL conflicts. That said, it is your responsibility to ensure you comply with licenses here and conditions of any dependent licenses. Where applicable, I've linked the sources/references for various components in docstrings. If you think I've missed anything please create an issue.


  So far all of the pretrained weights available here are pretrained on ImageNet with a select few that have some additional pretraining (see extra note below). ImageNet was released for non-commercial research purposes only (https://image-net.org/download). It's not clear what the implications of that are for the use of pretrained weights from that dataset. Any models I have trained with ImageNet are done for research purposes and one should assume that the original dataset license applies to the weights. It's best to seek legal advice if you intend to use the pretrained weights in a commercial product.


  Several weights included or references here were pretrained with proprietary datasets that I do not have access to. These include the Facebook WSL, SSL, SWSL ResNe(Xt) and the Google Noisy Student EfficientNet models. The Facebook models have an explicit non-commercial license (CC-BY-NC 4.0, https://github.com/facebookresearch/semi-supervised-ImageNet1K-models, https://github.com/facebookresearch/WSL-Images). The Google models do not appear to have any restriction beyond the Apache 2.0 license (and ImageNet concerns). In either case, you should contact Facebook or Google with any questions.





  ```bibtex
  @misc{rw2019timm,
    author = {Ross Wightman},
    title = {PyTorch Image Models},
    year = {2019},
    publisher = {GitHub},
    journal = {GitHub repository},
    doi = {10.5281/zenodo.4414861},
    howpublished = {\url{https://github.com/rwightman/pytorch-image-models}}
  }
  ```



  [![DOI](https://zenodo.org/badge/168799526.svg)](https://zenodo.org/badge/latestdoi/168799526)


pkgId: f9751554d071bf7e4c4e22c4a966df1f140ef72acc19818df8df925c5afdb8bc
name: python-timm-clean
arch: src
version: 0.4.12
epoch: 0
release: 1
summary: (Unofficial) PyTorch Image Models, with torch dependency removed in setup.py
url: https://github.com/rwightman/pytorch-image-models
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7b3b33f8-3143-4973-a5f5-9d8796f304d8
location_href: 00010539-python-timm-clean/python-timm-clean-0.4.12-1.src.rpm
checksum_type: sha256
description:
  - [Sponsors](#sponsors)
  - [What's New](#whats-new)
  - [Introduction](#introduction)
  - [Models](#models)
  - [Features](#features)
  - [Results](#results)
  - [Getting Started (Documentation)](#getting-started-documentation)
  - [Train, Validation, Inference Scripts](#train-validation-inference-scripts)
  - [Awesome PyTorch Resources](#awesome-pytorch-resources)
  - [Licenses](#licenses)
  - [Citing](#citing)



  A big thank you to my [GitHub Sponsors](https://github.com/sponsors/rwightman) for their support!

  In addition to the sponsors at the link above, I've received hardware and/or cloud resources from
  * Nvidia (https://www.nvidia.com/en-us/)
  * TFRC (https://www.tensorflow.org/tfrc)

  I'm fortunate to be able to dedicate significant time and money of my own supporting this and other open source projects. However, as the projects increase in scope, outside support is needed to continue with the current trajectory of hardware, infrastructure, and electricty costs.




  * Reproduce gMLP model training, `gmlp_s16_224` trained to 79.6 top-1, matching [paper](https://arxiv.org/abs/2105.08050). Hparams for this and other recent MLP training [here](https://gist.github.com/rwightman/d6c264a9001f9167e06c209f630b2cc6)


  * Release Vision Transformer 'AugReg' weights from [How to train your ViT? Data, Augmentation, and Regularization in Vision Transformers](https://arxiv.org/abs/2106.10270)
    * .npz weight loading support added, can load any of the 50K+ weights from the [AugReg series](https://console.cloud.google.com/storage/browser/vit_models/augreg)
    * See [example notebook](https://colab.research.google.com/github/google-research/vision_transformer/blob/master/vit_jax_augreg.ipynb) from [official impl](https://github.com/google-research/vision_transformer/) for navigating the augreg weights
    * Replaced all default weights w/ best AugReg variant (if possible). All AugReg 21k classifiers work.
      * Highlights: `vit_large_patch16_384` (87.1 top-1), `vit_large_r50_s32_384` (86.2 top-1), `vit_base_patch16_384` (86.0 top-1)
    * `vit_deit_*` renamed to just `deit_*`
    * Remove my old small model, replace with DeiT compatible small w/ AugReg weights
  * Add 1st training of my `gmixer_24_224` MLP /w GLU, 78.1 top-1 w/ 25M params.
  * Add weights from official ResMLP release (https://github.com/facebookresearch/deit)
  * Add `eca_nfnet_l2` weights from my 'lightweight' series. 84.7 top-1 at 384x384.
  * Add distilled BiT 50x1 student and 152x2 Teacher weights from  [Knowledge distillation: A good teacher is patient and consistent](https://arxiv.org/abs/2106.05237)
  * NFNets and ResNetV2-BiT models work w/ Pytorch XLA now
    * weight standardization uses F.batch_norm instead of std_mean (std_mean wasn't lowered)
    * eps values adjusted, will be slight differences but should be quite close
  * Improve test coverage and classifier interface of non-conv (vision transformer and mlp) models
  * Cleanup a few classifier / flatten details for models w/ conv classifiers or early global pool
  * Please report any regressions, this PR touched quite a few models.


  * Add first ResMLP weights, trained in PyTorch XLA on TPU-VM w/ my XLA branch. 24 block variant, 79.2 top-1.
  * Add ResNet51-Q model w/ pretrained weights at 82.36 top-1.
    * NFNet inspired block layout with quad layer stem and no maxpool
    * Same param count (35.7M) and throughput as ResNetRS-50 but +1.5 top-1 @ 224x224 and +2.5 top-1 at 288x288


  * Add LeViT, Visformer, ConViT (PR by Aman Arora), Twins (PR by paper authors) transformer models
  * Add ResMLP and gMLP MLP vision models to the existing MLP Mixer impl
  * Fix a number of torchscript issues with various vision transformer models
  * Cleanup input_size/img_size override handling and improve testing / test coverage for all vision transformer and MLP models
  * More flexible pos embedding resize (non-square) for ViT and TnT. Thanks [Alexander Soare](https://github.com/alexander-soare)
  * Add `efficientnetv2_rw_m` model and weights (started training before official code). 84.8 top-1, 53M params.


  * Add EfficientNet-V2 official model defs w/ ported weights from official [Tensorflow/Keras](https://github.com/google/automl/tree/master/efficientnetv2) impl.
    * 1k trained variants: `tf_efficientnetv2_s/m/l`
    * 21k trained variants: `tf_efficientnetv2_s/m/l_in21k`
    * 21k pretrained -> 1k fine-tuned: `tf_efficientnetv2_s/m/l_in21ft1k`
    * v2 models w/ v1 scaling: `tf_efficientnetv2_b0` through `b3`
    * Rename my prev V2 guess `efficientnet_v2s` -> `efficientnetv2_rw_s`
    * Some blank `efficientnetv2_*` models in-place for future native PyTorch training


  * Add MLP-Mixer models and port pretrained weights from [Google JAX impl](https://github.com/google-research/vision_transformer/tree/linen)
  * Add CaiT models and pretrained weights from [FB](https://github.com/facebookresearch/deit)
  * Add ResNet-RS models and weights from [TF](https://github.com/tensorflow/tpu/tree/master/models/official/resnet/resnet_rs). Thanks [Aman Arora](https://github.com/amaarora)
  * Add CoaT models and weights. Thanks [Mohammed Rizin](https://github.com/morizin)
  * Add new ImageNet-21k weights & finetuned weights for TResNet, MobileNet-V3, ViT models. Thanks [mrT](https://github.com/mrT23)
  * Add GhostNet models and weights. Thanks [Kai Han](https://github.com/iamhankai)
  * Update ByoaNet attention modules
     * Improve SA module inits
     * Hack together experimental stand-alone Swin based attn module and `swinnet`
     * Consistent '26t' model defs for experiments.
  * Add improved Efficientnet-V2S (prelim model def) weights. 83.8 top-1.
  * WandB logging support


  * Add Swin Transformer models and weights from https://github.com/microsoft/Swin-Transformer


  * Add ECA-NFNet-L1 (slimmed down F1 w/ SiLU, 41M params) trained with this code. 84% top-1 @ 320x320. Trained at 256x256.
  * Add EfficientNet-V2S model (unverified model definition) weights. 83.3 top-1 @ 288x288. Only trained single res 224. Working on progressive training.
  * Add ByoaNet model definition (Bring-your-own-attention) w/ SelfAttention block and corresponding SA/SA-like modules and model defs
    * Lambda Networks - https://arxiv.org/abs/2102.08602
    * Bottleneck Transformers - https://arxiv.org/abs/2101.11605
    * Halo Nets - https://arxiv.org/abs/2103.12731
  * Adabelief optimizer contributed by Juntang Zhuang


  * Add snazzy `benchmark.py` script for bulk `timm` model benchmarking of train and/or inference
  * Add Pooling-based Vision Transformer (PiT) models (from https://github.com/naver-ai/pit)
    * Merged distilled variant into main for torchscript compatibility
    * Some `timm` cleanup/style tweaks and weights have hub download support
  * Cleanup Vision Transformer (ViT) models
    * Merge distilled (DeiT) model into main so that torchscript can work
    * Support updated weight init (defaults to old still) that closer matches original JAX impl (possibly better training from scratch)
    * Separate hybrid model defs into different file and add several new model defs to fiddle with, support patch_size != 1 for hybrids
    * Fix fine-tuning num_class changes (PiT and ViT) and pos_embed resizing (Vit) with distilled variants
    * nn.Sequential for block stack (does not break downstream compat)
  * TnT (Transformer-in-Transformer) models contributed by author (from https://gitee.com/mindspore/mindspore/tree/master/model_zoo/research/cv/TNT)
  * Add RegNetY-160 weights from DeiT teacher model
  * Add new NFNet-L0 w/ SE attn (rename `nfnet_l0b`->`nfnet_l0`) weights 82.75 top-1 @ 288x288
  * Some fixes/improvements for TFDS dataset wrapper


  * Add new ECA-NFNet-L0 (rename `nfnet_l0c`->`eca_nfnet_l0`) weights trained by myself.
    * 82.6 top-1 @ 288x288, 82.8 @ 320x320, trained at 224x224
    * Uses SiLU activation, approx 2x faster than `dm_nfnet_f0` and 50% faster than `nfnet_f0s` w/ 1/3 param count
  * Integrate [Hugging Face model hub](https://huggingface.co/models) into timm create_model and default_cfg handling for pretrained weight and config sharing (more on this soon!)
  * Merge HardCoRe NAS models contributed by https://github.com/yoniaflalo
  * Merge PyTorch trained EfficientNet-EL and pruned ES/EL variants contributed by [DeGirum](https://github.com/DeGirum)



  * First 0.4.x PyPi release w/ NFNets (& related), ByoB (GPU-Efficient, RepVGG, etc).
  * Change feature extraction for pre-activation nets (NFNets, ResNetV2) to return features before activation.
  * Tested with PyTorch 1.8 release. Updated CI to use 1.8.
  * Benchmarked several arch on RTX 3090, Titan RTX, and V100 across 1.7.1, 1.8, NGC 20.12, and 21.02. Some interesting performance variations to take note of https://gist.github.com/rwightman/bb59f9e245162cee0e38bd66bd8cd77f


  * Add pretrained weights and model variants for NFNet-F* models from [DeepMind Haiku impl](https://github.com/deepmind/deepmind-research/tree/master/nfnets).
    * Models are prefixed with `dm_`. They require SAME padding conv, skipinit enabled, and activation gains applied in act fn.
    * These models are big, expect to run out of GPU memory. With the GELU activiation + other options, they are roughly 1/2 the inference speed of my SiLU PyTorch optimized `s` variants.
    * Original model results are based on pre-processing that is not the same as all other models so you'll see different results in the results csv (once updated).
    * Matching the original pre-processing as closely as possible I get these results:
      * `dm_nfnet_f6` - 86.352
      * `dm_nfnet_f5` - 86.100
      * `dm_nfnet_f4` - 85.834
      * `dm_nfnet_f3` - 85.676
      * `dm_nfnet_f2` - 85.178
      * `dm_nfnet_f1` - 84.696
      * `dm_nfnet_f0` - 83.464


  * Add Adaptive Gradient Clipping (AGC) as per https://arxiv.org/abs/2102.06171. Integrated w/ PyTorch gradient clipping via mode arg that defaults to prev 'norm' mode. For backward arg compat, clip-grad arg must be specified to enable when using train.py.
    * AGC w/ default clipping factor `--clip-grad .01 --clip-mode agc`
    * PyTorch global norm of 1.0 (old behaviour, always norm), `--clip-grad 1.0`
    * PyTorch value clipping of 10, `--clip-grad 10. --clip-mode value`
    * AGC performance is definitely sensitive to the clipping factor. More experimentation needed to determine good values for smaller batch sizes and optimizers besides those in paper. So far I've found .001-.005 is necessary for stable RMSProp training w/ NFNet/NF-ResNet.


  * Update Normalization-Free nets to include new NFNet-F (https://arxiv.org/abs/2102.06171) model defs


  * First Normalization-Free model training experiments done,
    * nf_resnet50 - 80.68 top-1 @ 288x288, 80.31 @ 256x256
    * nf_regnet_b1 - 79.30 @ 288x288, 78.75 @ 256x256
  * More model archs, incl a flexible ByobNet backbone ('Bring-your-own-blocks')
    * GPU-Efficient-Networks (https://github.com/idstcv/GPU-Efficient-Networks), impl in `byobnet.py`
    * RepVGG (https://github.com/DingXiaoH/RepVGG), impl in `byobnet.py`
    * classic VGG (from torchvision, impl in `vgg.py`)
  * Refinements to normalizer layer arg handling and normalizer+act layer handling in some models
  * Default AMP mode changed to native PyTorch AMP instead of APEX. Issues not being fixed with APEX. Native works with `--channels-last` and `--torchscript` model training, APEX does not.
  * Fix a few bugs introduced since last pypi release


  * Add several ResNet weights with ECA attention. 26t & 50t trained @ 256, test @ 320. 269d train @ 256, fine-tune @320, test @ 352.
    * `ecaresnet26t` - 79.88 top-1 @ 320x320, 79.08 @ 256x256
    * `ecaresnet50t` - 82.35 top-1 @ 320x320, 81.52 @ 256x256
    * `ecaresnet269d` - 84.93 top-1 @ 352x352, 84.87 @ 320x320
  * Remove separate tiered (`t`) vs tiered_narrow (`tn`) ResNet model defs, all `tn` changed to `t` and `t` models removed (`seresnext26t_32x4d` only model w/ weights that was removed).
  * Support model default_cfgs with separate train vs test resolution `test_input_size` and remove extra `_320` suffix ResNet model defs that were just for test.


  * Add initial "Normalization Free" NF-RegNet-B* and NF-ResNet model definitions based on [paper](https://arxiv.org/abs/2101.08692)


  * Add ResNetV2 Big Transfer (BiT) models w/ ImageNet-1k and 21k weights from https://github.com/google-research/big_transfer
  * Add official R50+ViT-B/16 hybrid models + weights from https://github.com/google-research/vision_transformer
  * ImageNet-21k ViT weights are added w/ model defs and representation layer (pre logits) support
    * NOTE: ImageNet-21k classifier heads were zero'd in original weights, they are only useful for transfer learning
  * Add model defs and weights for DeiT Vision Transformer models from https://github.com/facebookresearch/deit
  * Refactor dataset classes into ImageDataset/IterableImageDataset + dataset specific parser classes
  * Add Tensorflow-Datasets (TFDS) wrapper to allow use of TFDS image classification sets with train script
    * Ex: `train.py /data/tfds --dataset tfds/oxford_iiit_pet --val-split test --model resnet50 -b 256 --amp --num-classes 37 --opt adamw --lr 3e-4 --weight-decay .001 --pretrained -j 2`
  * Add improved .tar dataset parser that reads images from .tar, folder of .tar files, or .tar within .tar
    * Run validation on full ImageNet-21k directly from tar w/ BiT model: `validate.py /data/fall11_whole.tar --model resnetv2_50x1_bitm_in21k --amp`
  * Models in this update should be stable w/ possible exception of ViT/BiT, possibility of some regressions with train/val scripts and dataset handling


  * Add SE-ResNet-152D weights
    * 256x256 val, 0.94 crop top-1 - 83.75
    * 320x320 val, 1.0 crop - 84.36
  * Update [results files](results/)




  Py**T**orch **Im**age **M**odels (`timm`) is a collection of image models, layers, utilities, optimizers, schedulers, data-loaders / augmentations, and reference training / validation scripts that aim to pull together a wide variety of SOTA models with ability to reproduce ImageNet training results.

  The work of many others is present here. I've tried to make sure all source material is acknowledged via links to github, arxiv papers, etc in the README, documentation, and code docstrings. Please let me know if I missed anything.



  All model architecture families include variants with pretrained weights. There are specific model variants without any weights, it is NOT a bug. Help training new or better weights is always appreciated. Here are some example [training hparams](https://rwightman.github.io/pytorch-image-models/training_hparam_examples) to get you started.

  A full version of the list below with source links can be found in the [documentation](https://rwightman.github.io/pytorch-image-models/models/).

  * Big Transfer ResNetV2 (BiT) - https://arxiv.org/abs/1912.11370
  * Bottleneck Transformers - https://arxiv.org/abs/2101.11605
  * CaiT (Class-Attention in Image Transformers) - https://arxiv.org/abs/2103.17239
  * CoaT (Co-Scale Conv-Attentional Image Transformers) - https://arxiv.org/abs/2104.06399
  * ConViT (Soft Convolutional Inductive Biases Vision Transformers)- https://arxiv.org/abs/2103.10697
  * CspNet (Cross-Stage Partial Networks) - https://arxiv.org/abs/1911.11929
  * DeiT (Vision Transformer) - https://arxiv.org/abs/2012.12877
  * DenseNet - https://arxiv.org/abs/1608.06993
  * DLA - https://arxiv.org/abs/1707.06484
  * DPN (Dual-Path Network) - https://arxiv.org/abs/1707.01629
  * EfficientNet (MBConvNet Family)
      * EfficientNet NoisyStudent (B0-B7, L2) - https://arxiv.org/abs/1911.04252
      * EfficientNet AdvProp (B0-B8) - https://arxiv.org/abs/1911.09665
      * EfficientNet (B0-B7) - https://arxiv.org/abs/1905.11946
      * EfficientNet-EdgeTPU (S, M, L) - https://ai.googleblog.com/2019/08/efficientnet-edgetpu-creating.html
      * EfficientNet V2 - https://arxiv.org/abs/2104.00298
      * FBNet-C - https://arxiv.org/abs/1812.03443
      * MixNet - https://arxiv.org/abs/1907.09595
      * MNASNet B1, A1 (Squeeze-Excite), and Small - https://arxiv.org/abs/1807.11626
      * MobileNet-V2 - https://arxiv.org/abs/1801.04381
      * Single-Path NAS - https://arxiv.org/abs/1904.02877
  * GhostNet - https://arxiv.org/abs/1911.11907
  * gMLP - https://arxiv.org/abs/2105.08050
  * GPU-Efficient Networks - https://arxiv.org/abs/2006.14090
  * Halo Nets - https://arxiv.org/abs/2103.12731
  * HardCoRe-NAS - https://arxiv.org/abs/2102.11646
  * HRNet - https://arxiv.org/abs/1908.07919
  * Inception-V3 - https://arxiv.org/abs/1512.00567
  * Inception-ResNet-V2 and Inception-V4 - https://arxiv.org/abs/1602.07261
  * Lambda Networks - https://arxiv.org/abs/2102.08602
  * LeViT (Vision Transformer in ConvNet's Clothing) - https://arxiv.org/abs/2104.01136
  * MLP-Mixer - https://arxiv.org/abs/2105.01601
  * MobileNet-V3 (MBConvNet w/ Efficient Head) - https://arxiv.org/abs/1905.02244
  * NASNet-A - https://arxiv.org/abs/1707.07012
  * NFNet-F - https://arxiv.org/abs/2102.06171
  * NF-RegNet / NF-ResNet - https://arxiv.org/abs/2101.08692
  * PNasNet - https://arxiv.org/abs/1712.00559
  * Pooling-based Vision Transformer (PiT) - https://arxiv.org/abs/2103.16302
  * RegNet - https://arxiv.org/abs/2003.13678
  * RepVGG - https://arxiv.org/abs/2101.03697
  * ResMLP - https://arxiv.org/abs/2105.03404
  * ResNet/ResNeXt
      * ResNet (v1b/v1.5) - https://arxiv.org/abs/1512.03385
      * ResNeXt - https://arxiv.org/abs/1611.05431
      * 'Bag of Tricks' / Gluon C, D, E, S variations - https://arxiv.org/abs/1812.01187
      * Weakly-supervised (WSL) Instagram pretrained / ImageNet tuned ResNeXt101 - https://arxiv.org/abs/1805.00932
      * Semi-supervised (SSL) / Semi-weakly Supervised (SWSL) ResNet/ResNeXts - https://arxiv.org/abs/1905.00546
      * ECA-Net (ECAResNet) - https://arxiv.org/abs/1910.03151v4
      * Squeeze-and-Excitation Networks (SEResNet) - https://arxiv.org/abs/1709.01507
      * ResNet-RS - https://arxiv.org/abs/2103.07579
  * Res2Net - https://arxiv.org/abs/1904.01169
  * ResNeSt - https://arxiv.org/abs/2004.08955
  * ReXNet - https://arxiv.org/abs/2007.00992
  * SelecSLS - https://arxiv.org/abs/1907.00837
  * Selective Kernel Networks - https://arxiv.org/abs/1903.06586
  * Swin Transformer - https://arxiv.org/abs/2103.14030
  * Transformer-iN-Transformer (TNT) - https://arxiv.org/abs/2103.00112
  * TResNet - https://arxiv.org/abs/2003.13630
  * Twins (Spatial Attention in Vision Transformers) - https://arxiv.org/pdf/2104.13840.pdf
  * Vision Transformer - https://arxiv.org/abs/2010.11929
  * VovNet V2 and V1 - https://arxiv.org/abs/1911.06667
  * Xception - https://arxiv.org/abs/1610.02357
  * Xception (Modified Aligned, Gluon) - https://arxiv.org/abs/1802.02611
  * Xception (Modified Aligned, TF) - https://arxiv.org/abs/1802.02611



  Several (less common) features that I often utilize in my projects are included. Many of their additions are the reason why I maintain my own set of models, instead of using others' via PIP:

  * All models have a common default configuration interface and API for
      * accessing/changing the classifier - `get_classifier` and `reset_classifier`
      * doing a forward pass on just the features - `forward_features` (see [documentation](https://rwightman.github.io/pytorch-image-models/feature_extraction/))
      * these makes it easy to write consistent network wrappers that work with any of the models
  * All models support multi-scale feature map extraction (feature pyramids) via create_model (see [documentation](https://rwightman.github.io/pytorch-image-models/feature_extraction/))
      * `create_model(name, features_only=True, out_indices=..., output_stride=...)`
      * `out_indices` creation arg specifies which feature maps to return, these indices are 0 based and generally correspond to the `C(i + 1)` feature level.
      * `output_stride` creation arg controls output stride of the network by using dilated convolutions. Most networks are stride 32 by default. Not all networks support this.
      * feature map channel counts, reduction level (stride) can be queried AFTER model creation via the `.feature_info` member
  * All models have a consistent pretrained weight loader that adapts last linear if necessary, and from 3 to 1 channel input if desired
  * High performance [reference training, validation, and inference scripts](https://rwightman.github.io/pytorch-image-models/scripts/) that work in several process/GPU modes:
      * NVIDIA DDP w/ a single GPU per process, multiple processes with APEX present (AMP mixed-precision optional)
      * PyTorch DistributedDataParallel w/ multi-gpu, single process (AMP disabled as it crashes when enabled)
      * PyTorch w/ single GPU single process (AMP optional)
  * A dynamic global pool implementation that allows selecting from average pooling, max pooling, average + max, or concat([average, max]) at model creation. All global pooling is adaptive average by default and compatible with pretrained weights.
  * A 'Test Time Pool' wrapper that can wrap any of the included models and usually provides improved performance doing inference with input images larger than the training size. Idea adapted from original DPN implementation when I ported (https://github.com/cypw/DPNs)
  * Learning rate schedulers
    * Ideas adopted from
       * [AllenNLP schedulers](https://github.com/allenai/allennlp/tree/master/allennlp/training/learning_rate_schedulers)
       * [FAIRseq lr_scheduler](https://github.com/pytorch/fairseq/tree/master/fairseq/optim/lr_scheduler)
       * SGDR: Stochastic Gradient Descent with Warm Restarts (https://arxiv.org/abs/1608.03983)
    * Schedulers include `step`, `cosine` w/ restarts, `tanh` w/ restarts, `plateau`
  * Optimizers:
      * `rmsprop_tf` adapted from PyTorch RMSProp by myself. Reproduces much improved Tensorflow RMSProp behaviour.
      * `radam` by [Liyuan Liu](https://github.com/LiyuanLucasLiu/RAdam) (https://arxiv.org/abs/1908.03265)
      * `novograd` by [Masashi Kimura](https://github.com/convergence-lab/novograd) (https://arxiv.org/abs/1905.11286)
      * `lookahead` adapted from impl by [Liam](https://github.com/alphadl/lookahead.pytorch) (https://arxiv.org/abs/1907.08610)
      * `fused<name>` optimizers by name with [NVIDIA Apex](https://github.com/NVIDIA/apex/tree/master/apex/optimizers) installed
      * `adamp` and `sgdp` by [Naver ClovAI](https://github.com/clovaai) (https://arxiv.org/abs/2006.08217)
      * `adafactor` adapted from [FAIRSeq impl](https://github.com/pytorch/fairseq/blob/master/fairseq/optim/adafactor.py) (https://arxiv.org/abs/1804.04235)
      * `adahessian` by [David Samuel](https://github.com/davda54/ada-hessian) (https://arxiv.org/abs/2006.00719)
  * Random Erasing from [Zhun Zhong](https://github.com/zhunzhong07/Random-Erasing/blob/master/transforms.py)  (https://arxiv.org/abs/1708.04896)
  * Mixup (https://arxiv.org/abs/1710.09412)
  * CutMix (https://arxiv.org/abs/1905.04899)
  * AutoAugment (https://arxiv.org/abs/1805.09501) and RandAugment (https://arxiv.org/abs/1909.13719) ImageNet configurations modeled after impl for EfficientNet training (https://github.com/tensorflow/tpu/blob/master/models/official/efficientnet/autoaugment.py)
  * AugMix w/ JSD loss (https://arxiv.org/abs/1912.02781), JSD w/ clean + augmented mixing support works with AutoAugment and RandAugment as well
  * SplitBachNorm - allows splitting batch norm layers between clean and augmented (auxiliary batch norm) data
  * DropPath aka "Stochastic Depth" (https://arxiv.org/abs/1603.09382)
  * DropBlock (https://arxiv.org/abs/1810.12890)
  * Blur Pooling (https://arxiv.org/abs/1904.11486)
  * Space-to-Depth by [mrT23](https://github.com/mrT23/TResNet/blob/master/src/models/tresnet/layers/space_to_depth.py) (https://arxiv.org/abs/1801.04590) -- original paper?
  * Adaptive Gradient Clipping (https://arxiv.org/abs/2102.06171, https://github.com/deepmind/deepmind-research/tree/master/nfnets)
  * An extensive selection of channel and/or spatial attention modules:
      * Bottleneck Transformer - https://arxiv.org/abs/2101.11605
      * CBAM - https://arxiv.org/abs/1807.06521
      * Effective Squeeze-Excitation (ESE) - https://arxiv.org/abs/1911.06667
      * Efficient Channel Attention (ECA) - https://arxiv.org/abs/1910.03151
      * Gather-Excite (GE) - https://arxiv.org/abs/1810.12348
      * Global Context (GC) - https://arxiv.org/abs/1904.11492
      * Halo - https://arxiv.org/abs/2103.12731
      * Involution - https://arxiv.org/abs/2103.06255
      * Lambda Layer - https://arxiv.org/abs/2102.08602
      * Non-Local (NL) -  https://arxiv.org/abs/1711.07971
      * Squeeze-and-Excitation (SE) - https://arxiv.org/abs/1709.01507
      * Selective Kernel (SK) - (https://arxiv.org/abs/1903.06586
      * Split (SPLAT) - https://arxiv.org/abs/2004.08955
      * Shifted Window (SWIN) - https://arxiv.org/abs/2103.14030



  Model validation results can be found in the [documentation](https://rwightman.github.io/pytorch-image-models/results/) and in the [results tables](results/README.md)



  My current [documentation](https://rwightman.github.io/pytorch-image-models/) for `timm` covers the basics.

  [timmdocs](https://fastai.github.io/timmdocs/) is quickly becoming a much more comprehensive set of documentation for `timm`. A big thanks to [Aman Arora](https://github.com/amaarora) for his efforts creating timmdocs.

  [paperswithcode](https://paperswithcode.com/lib/timm) is a good resource for browsing the models within `timm`.



  The root folder of the repository contains reference train, validation, and inference scripts that work with the included models and other features of this repository. They are adaptable for other datasets and use cases with a little hacking. See [documentation](https://rwightman.github.io/pytorch-image-models/scripts/) for some basics and [training hparams](https://rwightman.github.io/pytorch-image-models/training_hparam_examples) for some train examples that produce SOTA ImageNet results.



  One of the greatest assets of PyTorch is the community and their contributions. A few of my favourite resources that pair well with the models and components here are listed below.


  * Detectron2 - https://github.com/facebookresearch/detectron2
  * Segmentation Models (Semantic) - https://github.com/qubvel/segmentation_models.pytorch
  * EfficientDet (Obj Det, Semantic soon) - https://github.com/rwightman/efficientdet-pytorch


  * Albumentations - https://github.com/albumentations-team/albumentations
  * Kornia - https://github.com/kornia/kornia


  * RepDistiller - https://github.com/HobbitLong/RepDistiller
  * torchdistill - https://github.com/yoshitomo-matsubara/torchdistill


  * PyTorch Metric Learning - https://github.com/KevinMusgrave/pytorch-metric-learning


  * fastai - https://github.com/fastai/fastai




  The code here is licensed Apache 2.0. I've taken care to make sure any third party code included or adapted has compatible (permissive) licenses such as MIT, BSD, etc. I've made an effort to avoid any GPL / LGPL conflicts. That said, it is your responsibility to ensure you comply with licenses here and conditions of any dependent licenses. Where applicable, I've linked the sources/references for various components in docstrings. If you think I've missed anything please create an issue.


  So far all of the pretrained weights available here are pretrained on ImageNet with a select few that have some additional pretraining (see extra note below). ImageNet was released for non-commercial research purposes only (http://www.image-net.org/download-faq). It's not clear what the implications of that are for the use of pretrained weights from that dataset. Any models I have trained with ImageNet are done for research purposes and one should assume that the original dataset license applies to the weights. It's best to seek legal advice if you intend to use the pretrained weights in a commercial product.


  Several weights included or references here were pretrained with proprietary datasets that I do not have access to. These include the Facebook WSL, SSL, SWSL ResNe(Xt) and the Google Noisy Student EfficientNet models. The Facebook models have an explicit non-commercial license (CC-BY-NC 4.0, https://github.com/facebookresearch/semi-supervised-ImageNet1K-models, https://github.com/facebookresearch/WSL-Images). The Google models do not appear to have any restriction beyond the Apache 2.0 license (and ImageNet concerns). In either case, you should contact Facebook or Google with any questions.





  ```
  @misc{rw2019timm,
    author = {Ross Wightman},
    title = {PyTorch Image Models},
    year = {2019},
    publisher = {GitHub},
    journal = {GitHub repository},
    doi = {10.5281/zenodo.4414861},
    howpublished = {\url{https://github.com/rwightman/pytorch-image-models}}
  }
  ```



  [![DOI](https://zenodo.org/badge/168799526.svg)](https://zenodo.org/badge/latestdoi/168799526)


pkgId: 95c3476652eb1b8c123456ce70f33b8581ec52619563ecacac4f13a1ee1fb1f9
name: python-tinycss
arch: src
version: 0.4
epoch: 0
release: 1
summary: tinycss is a complete yet simple CSS parser for Python.
url: http://tinycss.readthedocs.io/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-27431ad3-41e7-4781-829e-3e9d016ad134
location_href: 00005304-python-tinycss/python-tinycss-0.4-1.src.rpm
checksum_type: sha256
description:
  *tinycss* is a complete yet simple CSS parser for Python. It supports the full
  syntax and error handling for CSS 2.1 as well as some CSS 3 modules:
  * CSS Color 3
  * CSS Fonts 3
  * CSS Paged Media 3
  It is designed to be easy to extend for new CSS modules and syntax,
  and integrates well with cssselect_ for Selectors 3 support.
  Quick facts:
  * Free software: BSD licensed
  * Compatible with Python 2.7 and 3.x
  * Latest documentation `on python.org`_
  * Source, issues and pull requests `on Github`_
  * Releases `on PyPI`_
  * Install with ``pip install tinycss``


pkgId: 01ad5edbd219577241d9c59c7221549d6a29d9900ffa0b1f30c7df5a4b4041b3
name: python-tinydb
arch: src
version: 4.7.1
epoch: 0
release: 1
summary: TinyDB is a tiny, document oriented database optimized for your happiness :)
url: https://github.com/msiemens/tinydb
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a46aefb6-ff92-40c2-a35c-b85eaad3e738
location_href: 00005306-python-tinydb/python-tinydb-4.7.1-1.src.rpm
checksum_type: sha256
description:
      >>> User = Query()
      >>> # Search for a field value
      >>> db.search(User.name == 'John')
      [{'name': 'John', 'age': 22}, {'name': 'John', 'age': 37}]
      >>> # Combine two queries with logical and
      >>> db.search((User.name == 'John') & (User.age <= 30))
      [{'name': 'John', 'age': 22}]
      >>> # Combine two queries with logical or
      >>> db.search((User.name == 'John') | (User.name == 'Bob'))
      [{'name': 'John', 'age': 22}, {'name': 'John', 'age': 37}, {'name': 'Bob', 'age': 42}]
      >>> # Apply transformation to field with `map`
      >>> db.search((User.age.map(lambda x: x + x) == 44))
      >>> [{'name': 'John', 'age': 22}]
      >>> # More possible comparisons:  !=  <  >  <=  >=
      >>> # More possible checks: where(...).matches(regex), where(...).test(your_test_func)


pkgId: a5b63a1009b90244d07db04c8bb8dbd72fe8476d7877141275f4a44eca265597
name: python-tinyrpc
arch: src
version: 1.1.6
epoch: 0
release: 1
url: http://github.com/mbr/tinyrpc
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-09b7cd21-cfa8-4918-bff8-3bd61516f704
location_href: 00005307-python-tinyrpc/python-tinyrpc-1.1.6-1.src.rpm
checksum_type: sha256
summary:
  A small, modular, transport and protocol neutral RPC library that, among other things, supports JSON-RPC and zmq.


pkgId: 04f9cbf1f4ca02fdffde1118205a9a31b3affdd7e3876eb47b7fc72183791ee6
name: python-tinysegmenter
arch: src
version: 0.4
epoch: 0
release: 1
summary: Very compact Japanese tokenizer
url: http://tinysegmenter.tuxfamily.org/
rpm_license: New BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eee27dd3-5e14-4ff4-a4af-eb8e8850ba6b
location_href: 00010960-python-tinysegmenter/python-tinysegmenter-0.4-1.src.rpm
checksum_type: sha256
description:
  “TinySegmenter in Python” is a Python port_ by Masato Hagiwara of TinySegmenter_, which is an extremely compact Japanese tokenizer originally written in JavaScript by Mr. Taku Kudo.
  The library has been finally packaged by Jehan. It resulted into this fork because Masako Hagiwara did not answer emails, and packaging patches
  could therefore not be committed upstream. But this is a friendly fork, and Masako Hagiwara is welcome to take back maintainance over his
  project.
  For the time being, I (Jehan) took up the maintenance, so please refer to this new website_ as being official, and
  direct any new patch_ there. I will follow up on patchs and bug reports, but probably won't maintain an active development. Anyone wishing to
  improve the library is welcome to participate and will be gladly given committer rights.
  It works on Python 2.6 or above (works on Python 3 too).


pkgId: cef6b57993a62ad2428e3b73252e55f5719faa56913729c1adfc11b28b801816
name: python-titlecase
arch: src
version: 2.4
epoch: 0
release: 1
summary: Python Port of John Gruber's titlecase.pl
url: https://github.com/ppannuto/python-titlecase
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8e710674-3cb5-478b-8bb1-4f5a2a1c7ebe
location_href: 00010935-python-titlecase/python-titlecase-2.4-1.src.rpm
checksum_type: sha256
description:
  This filter changes a given text to Title Caps, and attempts to be clever
  about SMALL words like a/an/the in the input.
  The list of "SMALL words" which are not capped comes from the New York
  Times Manual of Style, plus some others like 'vs' and 'v'.
  The filter employs some heuristics to guess abbreviations that don't need conversion.
  +------------------+----------------+
  | Original         | Conversion     |
  +==================+================+
  | this is a test   | This Is a Test |
  +------------------+----------------+
  | THIS IS A TEST   | This Is a Test |
  +------------------+----------------+
  | this is a TEST   | This Is a TEST |
  +------------------+----------------+
  More examples and expected behavior for corner cases are available in the
  `package test suite <https://github.com/ppannuto/python-titlecase/blob/main/titlecase/tests.py>`__.
  This library is a resurrection of `Stuart Colville's
  titlecase.py <https://muffinresearch.co.uk/titlecasepy-titlecase-in-python/>`__,
  which was in turn a port of `John Gruber's
  titlecase.pl <http://daringfireball.net/2008/05/title_case>`__.
  Issues, updates, pull requests, etc should be directed
  `to github <https://github.com/ppannuto/python-titlecase>`__.


pkgId: 4c7ff4a73c162847e0ba3dff21eef551a8db2e11982d98f9c29966c317bc905b
name: python-tldextract
arch: src
version: 3.4.0
epoch: 0
release: 1
url: https://github.com/john-kurkowski/tldextract
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fc8fcff8-45ec-4865-a607-ea083ccc3dad
location_href: 00005312-python-tldextract/python-tldextract-3.4.0-1.src.rpm
checksum_type: sha256
summary:
  Accurately separates a URL's subdomain, domain, and public suffix, using the Public Suffix List (PSL). By default, this includes the public ICANN TLDs and their exceptions. You can optionally support the Public Suffix List's private domains as well.

description:
   `tldextract` accurately separates a URL's subdomain, domain, and public suffix,
  using the Public Suffix List (PSL).

      >>> import tldextract
      >>> tldextract.extract('http://forums.news.cnn.com/')
      ExtractResult(subdomain='forums.news', domain='cnn', suffix='com')
      >>> tldextract.extract('http://forums.bbc.co.uk/') # United Kingdom
      ExtractResult(subdomain='forums', domain='bbc', suffix='co.uk')
      >>> tldextract.extract('http://www.worldbank.org.kg/') # Kyrgyzstan
      ExtractResult(subdomain='www', domain='worldbank', suffix='org.kg')

  `ExtractResult` is a namedtuple, so it's simple to access the parts you want.

      >>> ext = tldextract.extract('http://forums.bbc.co.uk')
      >>> (ext.subdomain, ext.domain, ext.suffix)
      ('forums', 'bbc', 'co.uk')
      >>> # rejoin subdomain and domain
      >>> '.'.join(ext[:2])
      'forums.bbc'
      >>> # a common alias
      >>> ext.registered_domain
      'bbc.co.uk'

  By default, this package supports the public ICANN TLDs and their exceptions.
  You can optionally support the Public Suffix List's private domains as well.


pkgId: cf2aa86544da4a3590f1e3a8925ec85beaed783b9b138f6e0848632e8b2d1c47
name: python-tmuxp
arch: src
version: 1.27.0
epoch: 0
release: 1
summary: tmux session manager
url: http://github.com/tmux-python/tmuxp/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0ed38adc-f669-43d0-866a-fd555ad9f7ba
location_href: 00005315-python-tmuxp/python-tmuxp-1.27.0-1.src.rpm
checksum_type: sha256
description:
  environment:
      system: Linux
      arch: x86_64

  ```

  See the [Quickstart](http://tmuxp.git-pull.com/quickstart.html).
  [Documentation](http://tmuxp.git-pull.com) homepage (also in
  [中文](http://tmuxp-zh.rtfd.org/))
  Want to learn more about tmux itself? [Read The Tao of Tmux
  online](http://tmuxp.git-pull.com/about_tmux.html).

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

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


pkgId: 983305befb5651967d8aeb97df26ffafbc9950beaad62e1de1278fb7906a45a0
name: python-tnefparse
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: a TNEF decoding library written in Python, without external dependencies
url: https://github.com/koodaamo/tnefparse
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9e319988-d257-414a-becf-e33b8bbe28e5
location_href: 00013901-python-tnefparse/python-tnefparse-1.4.0-1.src.rpm
checksum_type: sha256
description:
  This is a pure-python library for decoding Microsoft's Transport Neutral Encapsulation Format (TNEF), for Python
  versions 3.6+ and PyPy3. The last version to support Python2 was 1.3.1. For more information on TNEF, see for example
  `wikipedia <http://en.wikipedia.org/wiki/Transport_Neutral_Encapsulation_Format>`_. The full TNEF specification
  is also available as a `PDF download <https://interoperability.blob.core.windows.net/files/MS-OXTNEF/[MS-OXTNEF].pdf>`_.
  A :code:`tnefparse` command-line utility is provided for listing contents of TNEF files, extracting attachments
  found inside them and so on::
   usage: tnefparse [-h] [-o] [-a] [-p PATH] [-b] [-hb]
                    [-l LEVEL] [-c]
                    file [file ...]
   Extract TNEF file contents. Show this help message if no arguments are given.
   positional arguments:
     file                  space-separated list of paths to the TNEF files
   optional arguments:
     -h, --help             show this help message and exit
     -o, --overview         show (possibly long) overview of TNEF file contents
     -a, --attachments      extract attachments, by default to current dir
     -z, --zip              extract attachments into a single zip file, by default to current dir
     -p PATH, --path PATH   optional explicit path to extract attachments to
     -b, --body             extract the body to stdout
     -hb, --htmlbody        extract the HTML body to stdout
     -rb, --rtfbody         extract the RTF body to stdout
     -l LEVEL, --log LEVEL  set log level to DEBUG, INFO, WARN or ERROR
     -c, --checksum         calculate checksums (off by default)
     -d, --dump             extract a json dump of the tnef contents
  The library can also be used as a basis for applications that need to parse TNEF. To parse a TNEF attachment, run eg. :
  >>> from tnefparse import TNEF
  >>> with open("tests/examples/one-file.tnef", "rb") as tneffile:
  The parsed attachment contents are then available as TNEF object attributes:
  * signature - TNEF file signature
  * key - generated by TNEF enabled transports before using the TNEF implementation to generate a TNEF stream
  * codepage - a Windows code page string
  * objects - a collection of `TNEFObject` instances
  * attachments - a collection of `TNEFAttachment` instances
  * mapiprops - a collection of MAPI properties represented by `TNEFMAPI_Attribute` instances
  * body - message body (may contain both HTML and RTF)
  * htmlbody - a string containing just the HTML message body
  * rtfbody - just the RTF body
  Some of the above properties may be empty, depending on what's contained in the attachment that was parsed.


pkgId: 597c239047ca4a90b2230d0f633ab559d63f8815d8419c3817c82833446f9ae9
name: python-toml
arch: src
version: 0.10.2
epoch: 0
release: 1
summary: Python Library for Tom's Obvious, Minimal Language
url: https://github.com/uiri/toml
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-66424e74-35b6-40a2-ae13-35111d156174
location_href: 00008923-python-toml/python-toml-0.10.2-1.src.rpm
checksum_type: sha256
description:
  To install the latest release on `PyPI <https://pypi.org/project/toml/>`_,
  simply run:
    pip install toml
  Or to install the latest development version, run:
    git clone https://github.com/uiri/toml.git
    cd toml
    python setup.py install


pkgId: 4bd8b09fd80671c6740fc719db0d20bfe4f892cf1e6a443e0d479571903b1017
name: python-tomlkit
arch: src
version: 0.11.6
epoch: 0
release: 1
summary: Style preserving TOML library
url: https://github.com/sdispater/tomlkit
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-90f0550c-e152-440b-a7d5-637da69a027d
location_href: 00005316-python-tomlkit/python-tomlkit-0.11.6-1.src.rpm
checksum_type: sha256
description:
  [github_release]: https://img.shields.io/github/release/sdispater/tomlkit.svg?logo=github&logoColor=white
  [pypi_version]: https://img.shields.io/pypi/v/tomlkit.svg?logo=python&logoColor=white
  [python_versions]: https://img.shields.io/pypi/pyversions/tomlkit.svg?logo=python&logoColor=white
  [github_license]: https://img.shields.io/github/license/sdispater/tomlkit.svg?logo=github&logoColor=white
  [github_action]: https://github.com/sdispater/tomlkit/actions/workflows/tests.yml/badge.svg

  [![GitHub Release][github_release]](https://github.com/sdispater/tomlkit/releases/)
  [![PyPI Version][pypi_version]](https://pypi.org/project/tomlkit/)
  [![Python Versions][python_versions]](https://pypi.org/project/tomlkit/)
  [![License][github_license]](https://github.com/sdispater/tomlkit/blob/master/LICENSE)
  <br>
  [![Tests][github_action]](https://github.com/sdispater/tomlkit/actions/workflows/tests.yml)



  TOML Kit is a **1.0.0-compliant** [TOML](https://toml.io/) library.

  It includes a parser that preserves all comments, indentations, whitespace and internal element ordering,
  and makes them accessible and editable via an intuitive API.

  You can also create new TOML documents from scratch using the provided helpers.

  Part of the implementation has been adapted, improved and fixed from [Molten](https://github.com/LeopoldArkham/Molten).



  See the [documentation](https://github.com/sdispater/tomlkit/blob/master/docs/quickstart.rst) for more information.



  If you are using [Poetry](https://poetry.eustace.io),
  add `tomlkit` to your `pyproject.toml` file by using:

  ```bash
  poetry add tomlkit
  ```

  If not, you can use `pip`:

  ```bash
  pip install tomlkit
  ```



  Please clone the repo with submodules with the following command
  `git clone --recurse-submodules https://github.com/sdispater/tomlkit.git`.
  We need the submodule - `toml-test` for running the tests.

  You can run the tests with `poetry run pytest -q tests`


pkgId: a98943e26b05f5982ad009872c57b03e2eac81543c50f98ab2507c79dbfba3be
name: python-toolz
arch: src
version: 0.12.0
epoch: 0
release: 1
summary: List processing tools and functional utilities
url: https://github.com/pytoolz/toolz/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-58f437ae-8861-4552-8c7a-6a75901a2473
location_href: 00005317-python-toolz/python-toolz-0.12.0-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Coverage Status| |Version Status|
  A set of utility functions for iterators, functions, and dictionaries.
  See the PyToolz documentation at https://toolz.readthedocs.io


pkgId: 239b4b8e02c71d8e7c5ce1a524d7bc1ef92d81092ccd368076b7356eaea57b47
name: python-torch-lr-finder
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Pytorch implementation of the learning rate range test
url: https://github.com/davidtvs/pytorch-lr-finder
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-543ae75f-1b8d-4748-b934-74613703f7d3
location_href: 00013240-python-torch-lr-finder/python-torch-lr-finder-0.2.1-1.src.rpm
checksum_type: sha256
description:
  ![](https://github.com/davidtvs/pytorch-lr-finder/workflows/ci-build/badge.svg?branch=master)
  [![codecov](https://codecov.io/gh/davidtvs/pytorch-lr-finder/branch/master/graph/badge.svg)](https://codecov.io/gh/davidtvs/pytorch-lr-finder)
  [![](https://img.shields.io/pypi/v/torch-lr-finder)](https://pypi.org/project/torch-lr-finder/)

  A PyTorch implementation of the learning rate range test detailed in [Cyclical Learning Rates for Training Neural Networks](https://arxiv.org/abs/1506.01186) by Leslie N. Smith and the tweaked version used by [fastai](https://github.com/fastai/fastai).

  The learning rate range test is a test that provides valuable information about the optimal learning rate. During a pre-training run, the learning rate is increased linearly or exponentially between two boundaries. The low initial learning rate allows the network to start converging and as the learning rate is increased it will eventually be too large and the network will diverge.

  Typically, a good static learning rate can be found half-way on the descending loss curve. In the plot below that would be `lr = 0.002`.

  For cyclical learning rates (also detailed in Leslie Smith's paper) where the learning rate is cycled between two boundaries `(start_lr, end_lr)`, the author advises the point at which the loss starts descending and the point at which the loss stops descending or becomes ragged for `start_lr` and `end_lr` respectively.  In the plot below, `start_lr = 0.0002` and `end_lr=0.2`.

  ![Learning rate range test](images/lr_finder_cifar10.png)



  Python 3.5 and above:

  ```bash
  pip install torch-lr-finder
  ```

  Install with the support of mixed precision training (see also [this section](#Mixed-precision-training)):

  ```bash
  pip install torch-lr-finder -v --global-option="apex"
  ```





  Increases the learning rate in an exponential manner and computes the training loss for each learning rate. `lr_finder.plot()` plots the training loss versus logarithmic learning rate.

  ```python
  from torch_lr_finder import LRFinder

  model = ...
  criterion = nn.CrossEntropyLoss()
  optimizer = optim.Adam(model.parameters(), lr=1e-7, weight_decay=1e-2)
  lr_finder = LRFinder(model, optimizer, criterion, device="cuda")
  lr_finder.range_test(trainloader, end_lr=100, num_iter=100)
  lr_finder.plot() # to inspect the loss-learning rate graph
  lr_finder.reset() # to reset the model and optimizer to their initial state
  ```



  Increases the learning rate linearly and computes the evaluation loss for each learning rate. `lr_finder.plot()` plots the evaluation loss versus learning rate.
  This approach typically produces more precise curves because the evaluation loss is more susceptible to divergence but it takes significantly longer to perform the test, especially if the evaluation dataset is large.

  ```python
  from torch_lr_finder import LRFinder

  model = ...
  criterion = nn.CrossEntropyLoss()
  optimizer = optim.Adam(model.parameters(), lr=0.1, weight_decay=1e-2)
  lr_finder = LRFinder(model, optimizer, criterion, device="cuda")
  lr_finder.range_test(trainloader, val_loader=val_loader, end_lr=1, num_iter=100, step_mode="linear")
  lr_finder.plot(log_lr=False)
  lr_finder.reset()
  ```



  - Examples for CIFAR10 and MNIST can be found in the examples folder.
  - The optimizer passed to `LRFinder` should not have an `LRScheduler` attached to it.
  - `LRFinder.range_test()` will change the model weights and the optimizer parameters. Both can be restored to their initial state with `LRFinder.reset()`.
  - The learning rate and loss history can be accessed through `lr_finder.history`. This will return a dictionary with `lr` and `loss` keys.
  - When using `step_mode="linear"` the learning rate range should be within the same order of magnitude.
  - `LRFinder.range_test()` expects a pair of `input, label` to be returned from the `DataLoader` objects passed to it. The `input` must be ready to be passed to the model and the `label` must be ready to be passed to the `criterion` without any further data processing/handling/conversion. If you find yourself needing a workaround you can make use of the classes `TrainDataLoaderIter` and `ValDataLoaderIter` to perform any data processing/handling/conversion inbetween the `DataLoader` and the training/evaluation loop. You can find an example of how to use these classes in [examples/lrfinder_cifar10_dataloader_iter](examples/lrfinder_cifar10_dataloader_iter.ipynb).





  You can set the `accumulation_steps` parameter in `LRFinder.range_test()` with a proper value to perform gradient accumulation:

  ```python
  from torch.utils.data import DataLoader
  from torch_lr_finder import LRFinder

  desired_batch_size, real_batch_size = 32, 4
  accumulation_steps = desired_batch_size // real_batch_size

  dataset = ...


  trainloader = DataLoader(dataset, batch_size=real_batch_size, shuffle=True)

  model = ...
  criterion = ...
  optimizer = ...




  lr_finder = LRFinder(model, optimizer, criterion, device="cuda")
  lr_finder.range_test(trainloader, end_lr=10, num_iter=100, step_mode="exp", accumulation_steps=accumulation_steps)
  lr_finder.plot()
  lr_finder.reset()
  ```



  Currently, we use [`apex`](https://github.com/NVIDIA/apex) as the dependency for mixed precision training.
  To enable mixed precision training, you just need to call `amp.initialize()` before running `LRFinder`. e.g.

  ```python
  from torch_lr_finder import LRFinder
  from apex import amp


  model, optimizer = amp.initialize(model, optimizer, opt_level='O1')

  lr_finder = LRFinder(model, optimizer, criterion, device='cuda')
  lr_finder.range_test(trainloader, end_lr=10, num_iter=100, step_mode='exp')
  lr_finder.plot()
  lr_finder.reset()
  ```

  Note that the benefit of mixed precision training requires a nvidia GPU with tensor cores (see also: [NVIDIA/apex #297](https://github.com/NVIDIA/apex/issues/297))

  Besides, you can try to set `torch.backends.cudnn.benchmark = True` to improve the training speed. (but it won't work for some cases, you should use it at your own risk)



  All contributions are welcome but first, have a look at [CONTRIBUTING.md](CONTRIBUTING.md).


pkgId: f77fb73dd9d633fee76da6f50b5e6809762e40763d05ddc2bac418b84c9f190e
name: python-torchlayers-nightly
arch: src
version: 1681171628
epoch: 0
release: 1
summary: Input shape inference and SOTA custom layers for PyTorch.
url: https://github.com/pypa/torchlayers
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f9993780-5b39-42bf-b6f2-3dfc70889050
location_href: 00014179-python-torchlayers-nightly/python-torchlayers-nightly-1681171628-1.src.rpm
checksum_type: sha256
description:
  | Version | Docs | Tests | Coverage | Style | PyPI | Python | PyTorch | Docker |
  |---------|------|-------|----------|-------|------|--------|---------|--------|
  | [![Version](https://img.shields.io/static/v1?label=&message=0.1.1&color=377EF0&style=for-the-badge)](https://github.com/szymonmaszke/torchlayers/releases) | [![Documentation](https://img.shields.io/static/v1?label=&message=docs&color=EE4C2C&style=for-the-badge)](https://szymonmaszke.github.io/torchlayers/)  | ![Tests](https://img.shields.io/github/workflow/status/szymonmaszke/torchlayers/test?label=%20&style=for-the-badge) | [![codecov](https://codecov.io/gh/szymonmaszke/torchlayers/branch/master/graph/badge.svg?token=GbZmdqbTWM)](https://codecov.io/gh/szymonmaszke/torchlayers) | [![codebeat badge](https://codebeat.co/badges/0e3d33b0-95a4-429c-8692-881a4ffeac6b)](https://codebeat.co/projects/github-com-szymonmaszke-torchlayers-master) | [![PyPI](https://img.shields.io/static/v1?label=&message=PyPI&color=377EF0&style=for-the-badge)](https://pypi.org/project/torchlayers/) | [![Python](https://img.shields.io/static/v1?label=&message=>=3.7&color=377EF0&style=for-the-badge&logo=python&logoColor=F8C63D)](https://www.python.org/) | [![PyTorch](https://img.shields.io/static/v1?label=&message=>=1.3.0&color=EE4C2C&style=for-the-badge)](https://pytorch.org/) | [![Docker](https://img.shields.io/static/v1?label=&message=docker&color=309cef&style=for-the-badge)](https://hub.docker.com/r/szymonmaszke/torchlayers) |
  [__torchlayers__](https://szymonmaszke.github.io/torchlayers/) is a library based on [__PyTorch__](https://pytorch.org/)
  providing __automatic shape and dimensionality inference of `torch.nn` layers__ + additional
  building blocks featured in current SOTA architectures (e.g. [Efficient-Net](https://arxiv.org/abs/1905.11946)).
  Above requires no user intervention (except single call to `torchlayers.build`)
  similarly to the one seen in [__Keras__](https://www.tensorflow.org/guide/keras).

  * __Shape inference__ for most of `torch.nn` module (__convolutional, recurrent, transformer, attention and linear layers__)
  * __Dimensionality inference__ (e.g. `torchlayers.Conv` working as `torch.nn.Conv1d/2d/3d` based on `input shape`)
  * __Shape inference of custom modules__ (see examples section)
  * __Additional [Keras-like](https://www.tensorflow.org/guide/keras) layers__ (e.g. `torchlayers.Reshape` or `torchlayers.StandardNormalNoise`)
  * __Additional SOTA layers__ mostly from ImageNet competitions
  (e.g. [PolyNet](https://arxiv.org/abs/1608.06993),
  [Squeeze-And-Excitation](https://arxiv.org/abs/1709.01507),
  [StochasticDepth](www.arxiv.org/abs/1512.03385>))
  * __Useful defaults__ (`"same"` padding and default `kernel_size=3` for `Conv`, dropout rates etc.)
  * __Zero overhead and [torchscript](https://pytorch.org/docs/stable/jit.html) support__
  __Keep in mind this library works almost exactly like PyTorch originally__.
  What that means is you can use `Sequential`, __define your own networks of any complexity using
  `torch.nn.Module`__, create new layers with shape inference etc.
  _See below to get some intuition about library_.

  For full functionality please check [__torchlayers documentation__](https://szymonmaszke.github.io/torchlayers/).
  Below examples should introduce all necessary concepts you should know.

  __All__ `torch.nn` modules can be used through `torchlayers` and __each module with input shape__
  will be appropriately modified with it's input inferable counterpart.
  ```python
  import torchlayers as tl
  class Classifier(tl.Module):
      def __init__(self):
          super().__init__()
          self.conv1 = tl.Conv2d(64, kernel_size=6)
          self.conv2 = tl.Conv2d(128, kernel_size=3)
          self.conv3 = tl.Conv2d(256, kernel_size=3, padding=1)
          
          self.pooling = tl.GlobalMaxPool()
          self.dense = tl.Linear(10)
      def forward(self, x):
          x = torch.relu(self.conv1(x))
          x = torch.relu(self.conv2(x))
          x = torch.relu(self.conv3(x))
          return self.dense(self.pooling(x))

  clf = tl.build(Classifier(), torch.randn(1, 3, 32, 32))
  ```
  Above `torchlayers.Linear(out_features=10)` is used. It is "equivalent" to
  original PyTorch's `torch.nn.Linear(in_features=?, out_features=10)` where `in_features`
  will be inferred from example input input during `torchlayers.build` call.
  Same thing happens with `torch.nn.Conv2d(in_channels, out_channels, kernel_size, ...)`
  which can be replaced directly by `tl.Conv2d(out_channels, kernel_size, ...)`.
  __Just remember to pass example input through the network!__

  * We will use single "model" for both tasks.
  Firstly let's define it using `torch.nn` and `torchlayers`:
  ```python
  import torch
  import torchlayers as tl

  model = torch.nn.Sequential(
      tl.Conv(64),  # specify ONLY out_channels
      torch.nn.ReLU(),  # use torch.nn wherever you wish
      tl.BatchNorm(),  # BatchNormNd inferred from input
      tl.Conv(128),  # Default kernel_size equal to 3
      tl.ReLU(),
      tl.Conv(256, kernel_size=11),  # "same" padding as default
      tl.GlobalMaxPool(),  # Known from Keras
      tl.Linear(10),  # Output for 10 classes
  )
  print(model)
  ```
  Above would give you model's summary like this (__notice question marks for not yet inferred values__):
  ```python
  Sequential(
    (0): Conv(in_channels=?, out_channels=64, kernel_size=3, stride=1, padding=same, dilation=1, groups=1, bias=True, padding_mode=zeros)
    (1): ReLU()
    (2): BatchNorm(num_features=?, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (3): Conv(in_channels=?, out_channels=128, kernel_size=3, stride=1, padding=same, dilation=1, groups=1, bias=True, padding_mode=zeros)
    (4): ReLU()
    (5): Conv(in_channels=?, out_channels=256, kernel_size=11, stride=1, padding=same, dilation=1, groups=1, bias=True, padding_mode=zeros)
    (6): GlobalMaxPool()
    (7): Linear(in_features=?, out_features=10, bias=True)
  )
  ```
  * Now you can __build__/instantiate your model with example input (in this case MNIST-like):
  ```python
  mnist_model = tl.build(model, torch.randn(1, 3, 28, 28))
  ```
  * Or if it's text classification you are after, same model could be built with different
  `input shape` (e.g. for text classification using `300` dimensional pretrained embedding):
  ```python

  text_model = tl.build(model, torch.randn(2, 300, 1))
  ```
  * Finally, you can `print` both models after instantiation, provided below side
  by-side for readability (__notice different dimenstionality, e.g. `Conv2d` vs `Conv1d` after `torchlayers.build`__):
  ```python
                  
                  Sequential(                       Sequential(
                    (0): Conv1d(300, 64)              (0): Conv2d(3, 64)
                    (1): ReLU()                       (1): ReLU()
                    (2): BatchNorm1d(64)              (2): BatchNorm2d(64)
                    (3): Conv1d(64, 128)              (3): Conv2d(64, 128)
                    (4): ReLU()                       (4): ReLU()
                    (5): Conv1d(128, 256)             (5): Conv2d(128, 256)
                    (6): GlobalMaxPool()              (6): GlobalMaxPool()
                    (7): Linear(256, 10)              (7): Linear(256, 10)
                  )                                 )
  ```
  As you can see both modules "compiled" into original `pytorch` layers.

  User can define any module and make it shape inferable with `torchlayers.infer`
  function:
  ```python
   
   
   
  class _MyLinearImpl(torch.nn.Module):
      def __init__(self, in_features: int, out_features: int):
          super().__init__()
          self.weight = torch.nn.Parameter(torch.randn(out_features, in_features))
          self.bias = torch.nn.Parameter(torch.randn(out_features))
      def forward(self, inputs):
          return torch.nn.functional.linear(inputs, self.weight, self.bias)
  MyLinear = tl.infer(_MyLinearImpl)

  layer =tl.build(MyLinear(out_features=32), torch.randn(1, 64))
  layer(torch.randn(1, 64))
  ```
  By default `inputs.shape[1]` will be used as `in_features` value
  during initial `forward` pass. If you wish to use different `index` (e.g. to infer using
  `inputs.shape[3]`) use `MyLayer = tl.infer(_MyLayerImpl, index=3)` as a decorator.

  Please check code comments and [__documentation__](https://szymonmaszke.github.io/torchlayers/)
  if needed. If you are unsure what autoencoder is you could see
  [__this example blog post__](https://towardsdatascience.com/auto-encoder-what-is-it-and-what-is-it-used-for-part-1-3e5c6f017726).
  Below is a convolutional denoising autoencoder example for `ImageNet`-like images.
  Think of it like a demonstration of capabilities of different layers
  and building blocks provided by `torchlayers`.
  ```python

  class AutoEncoder(torch.nn.Module):
      def __init__(self):
          super().__init__()
          self.encoder = tl.Sequential(
              tl.StandardNormalNoise(),  # Apply noise to input images
              tl.Conv(64, kernel_size=7),
              tl.activations.Swish(),  # Direct access to module .activations
              tl.InvertedResidualBottleneck(squeeze_excitation=False),
              tl.AvgPool(),  # shape 64 x 128 x 128, kernel_size=2 by default
              tl.HardSwish(),  # Access simply through tl
              tl.SeparableConv(128),  # Up number of channels to 128
              tl.InvertedResidualBottleneck(),  # Default with squeeze excitation
              torch.nn.ReLU(),
              tl.AvgPool(),  # shape 128 x 64 x 64, kernel_size=2 by default
              tl.DepthwiseConv(256),  # DepthwiseConv easier to use
              
              tl.Poly(tl.InvertedResidualBottleneck(), order=3),
              tl.ReLU(),  # all torch.nn can be accessed via tl
              tl.MaxPool(),  # shape 256 x 32 x 32
              tl.Fire(out_channels=512),  # shape 512 x 32 x 32
              tl.SqueezeExcitation(hidden=64),
              tl.InvertedResidualBottleneck(),
              tl.MaxPool(),  # shape 512 x 16 x 16
              tl.InvertedResidualBottleneck(squeeze_excitation=False),
              
              tl.StochasticDepth(
                  torch.nn.Sequential(
                      tl.InvertedResidualBottleneck(squeeze_excitation=False),
                      tl.InvertedResidualBottleneck(squeeze_excitation=False),
                  ),
                  p=0.5,
              ),
              tl.AvgPool(),  # shape 512 x 8 x 8
          )
          
          self.decoder = tl.Sequential(
              tl.Poly(tl.InvertedResidualBottleneck(), order=2),
              
              tl.ConvPixelShuffle(out_channels=512, upscale_factor=2),
              
              tl.Poly(tl.InvertedResidualBottleneck(), order=3),
              tl.ConvPixelShuffle(out_channels=256, upscale_factor=2),
              
              tl.Poly(tl.InvertedResidualBottleneck(), order=3),
              tl.ConvPixelShuffle(out_channels=128, upscale_factor=2),
              
              tl.Poly(tl.InvertedResidualBottleneck(), order=4),
              tl.ConvPixelShuffle(out_channels=64, upscale_factor=2),
              
              tl.InvertedResidualBottleneck(),
              tl.Conv(256),
              tl.Dropout(),  # Defaults to 0.5 and Dropout2d for images
              tl.Swish(),
              tl.InstanceNorm(),
              tl.ConvPixelShuffle(out_channels=32, upscale_factor=2),
              
              tl.Conv(16),
              tl.Swish(),
              tl.Conv(3),
              
          )
      def forward(self, inputs):
          return self.decoder(self.encoder(inputs))
  ```
  Now one can instantiate the module and use it with `torch.nn.MSELoss` as per usual.
  ```python
  autoencoder = tl.build(AutoEncoder(), torch.randn(1, 3, 256, 256))
  ```



  ```shell
  pip install --user torchlayers
  ```

  ```shell
  pip install --user torchlayers-nightly
  ```

  __CPU standalone__ and various versions of __GPU enabled__ images are available
  at [dockerhub](https://hub.docker.com/r/szymonmaszke/torchlayers/tags).
  For CPU quickstart, issue:
  ```shell
  docker pull szymonmaszke/torchlayers:18.04
  ```
  Nightly builds are also available, just prefix tag with `nightly_`. If you are going for `GPU` image make sure you have
  [nvidia/docker](https://github.com/NVIDIA/nvidia-docker) installed and it's runtime set.

  If you find issue or would like to see some functionality (or implement one), please [open new Issue](https://help.github.com/en/articles/creating-an-issue) or [create Pull Request](https://help.github.com/en/articles/creating-a-pull-request-from-a-fork).


pkgId: c0276d9e479cc5e4741c3bce1069d1e0a637a76dfc52a9ccd73008149e542d13
name: python-torchmetrics
arch: src
version: 0.11.4
epoch: 0
release: 1
summary: PyTorch native Metrics
url: https://github.com/Lightning-AI/metrics
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5c63ee16-4b4b-406a-a933-3d5df85e1550
location_href: 00009783-python-torchmetrics/python-torchmetrics-0.11.4-1.src.rpm
checksum_type: sha256
description:
  <div align="center">

  <img src="https://github.com/Lightning-AI/metrics/raw/v0.11.4/docs/source/_static/images/logo.png" width="400px">

  **Machine learning metrics for distributed, scalable PyTorch applications.**

  ______________________________________________________________________

  <p align="center">
    <a href="#what-is-torchmetrics">What is Torchmetrics</a> •
    <a href="#implementing-your-own-module-metric">Implementing a metric</a> •
    <a href="#build-in-metrics">Built-in metrics</a> •
    <a href="https://torchmetrics.readthedocs.io/en/v0.11.4">Docs</a> •
    <a href="#community">Community</a> •
    <a href="#license">License</a>
  </p>

  ______________________________________________________________________

  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/torchmetrics)](https://pypi.org/project/torchmetrics/)
  [![PyPI Status](https://badge.fury.io/py/torchmetrics.svg)](https://badge.fury.io/py/torchmetrics)
  [![PyPI Status](https://pepy.tech/badge/torchmetrics)](https://pepy.tech/project/torchmetrics)
  [![Conda](https://img.shields.io/conda/v/conda-forge/torchmetrics?label=conda&color=success)](https://anaconda.org/conda-forge/torchmetrics)
  ![Conda](https://img.shields.io/conda/dn/conda-forge/torchmetrics)
  [![license](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/Lightning-AI/metrics/blob/master/LICENSE)

  [![CI testing - complete](https://github.com/Lightning-AI/metrics/actions/workflows/ci-tests-full.yml/badge.svg?event=push)](https://github.com/Lightning-AI/metrics/actions/workflows/ci-tests-full.yml)
  [![Build Status](https://dev.azure.com/Lightning-AI/Metrics/_apis/build/status/Lightning-AI.metrics?branchName=refs%2Ftags%2Fv0.11.4)](https://dev.azure.com/Lightning-AI/Metrics/_build/latest?definitionId=2&branchName=refs%2Ftags%2Fv0.11.4)
  [![codecov](https://codecov.io/gh/Lightning-AI/metrics/release/v0.11.4/graph/badge.svg?token=NER6LPI3HS)](https://codecov.io/gh/Lightning-AI/metrics)

  [![Slack](https://img.shields.io/badge/slack-chat-green.svg?logo=slack)](https://www.pytorchlightning.ai/community)
  [![Documentation Status](https://readthedocs.org/projects/torchmetrics/badge/?version=latest)](https://torchmetrics.readthedocs.io/en/latest/?badge=latest)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.5844769.svg)](https://doi.org/10.5281/zenodo.5844769)
  [![JOSS status](https://joss.theoj.org/papers/561d9bb59b400158bc8204e2639dca43/status.svg)](https://joss.theoj.org/papers/561d9bb59b400158bc8204e2639dca43)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/Lightning-AI/metrics/master.svg)](https://results.pre-commit.ci/latest/github/Lightning-AI/metrics/master)

  ______________________________________________________________________

  </div>



  Simple installation from PyPI

  ```bash
  pip install torchmetrics
  ```

  <details>
    <summary>Other installations</summary>

  Install using conda

  ```bash
  conda install -c conda-forge torchmetrics
  ```

  Pip from source

  ```bash

  pip install git+https://github.com/Lightning-AI/metrics.git@release/stable
  ```

  Pip from archive

  ```bash
  pip install https://github.com/Lightning-AI/metrics/archive/refs/heads/release/stable.zip
  ```

  Extra dependencies for specialized metrics:

  ```bash
  pip install torchmetrics[audio]
  pip install torchmetrics[image]
  pip install torchmetrics[text]
  pip install torchmetrics[all]  # install all of the above
  ```

  Install latest developer version

  ```bash
  pip install https://github.com/Lightning-AI/metrics/archive/master.zip
  ```

  </details>

  ______________________________________________________________________



  TorchMetrics is a collection of 90+ PyTorch metrics implementations and an easy-to-use API to create custom metrics. It offers:

  - A standardized interface to increase reproducibility
  - Reduces boilerplate
  - Automatic accumulation over batches
  - Metrics optimized for distributed-training
  - Automatic synchronization between multiple devices

  You can use TorchMetrics with any PyTorch model or with [PyTorch Lightning](https://pytorch-lightning.readthedocs.io/en/stable/) to enjoy additional features such as:

  - Module metrics are automatically placed on the correct device.
  - Native support for logging metrics in Lightning to reduce even more boilerplate.





  The [module-based metrics](https://pytorchlightning.github.io/metrics/references/modules.html) contain internal metric states (similar to the parameters of the PyTorch module) that automate accumulation and synchronization across devices!

  - Automatic accumulation over multiple batches
  - Automatic synchronization between multiple devices
  - Metric arithmetic

  **This can be run on CPU, single GPU or multi-GPUs!**

  For the single GPU/CPU case:

  ```python
  import torch


  import torchmetrics


  metric = torchmetrics.Accuracy(task="multiclass", num_classes=5)


  device = "cuda" if torch.cuda.is_available() else "cpu"
  metric.to(device)

  n_batches = 10
  for i in range(n_batches):
      
      preds = torch.randn(10, 5).softmax(dim=-1).to(device)
      target = torch.randint(5, (10,)).to(device)

      
      acc = metric(preds, target)
      print(f"Accuracy on batch {i}: {acc}")


  acc = metric.compute()
  print(f"Accuracy on all data: {acc}")
  ```

  Module metric usage remains the same when using multiple GPUs or multiple nodes.

  <details>
    <summary>Example using DDP</summary>

  <!--phmdoctest-mark.skip-->

  ```python
  import os
  import torch
  import torch.distributed as dist
  import torch.multiprocessing as mp
  from torch import nn
  from torch.nn.parallel import DistributedDataParallel as DDP
  import torchmetrics


  def metric_ddp(rank, world_size):
      os.environ["MASTER_ADDR"] = "localhost"
      os.environ["MASTER_PORT"] = "12355"

      
      dist.init_process_group("gloo", rank=rank, world_size=world_size)

      
      metric = torchmetrics.Accuracy(task="multiclass", num_classes=5)

      
      
      
      model = nn.Linear(10, 10)
      model.metric = metric
      model = model.to(rank)

      
      model = DDP(model, device_ids=[rank])

      n_epochs = 5
      
      for n in range(n_epochs):
          
          n_batches = 10
          for i in range(n_batches):
              
              preds = torch.randn(10, 5).softmax(dim=-1)
              target = torch.randint(5, (10,))

              
              acc = metric(preds, target)
              if rank == 0:  # print only for rank 0
                  print(f"Accuracy on batch {i}: {acc}")

          
          
          acc = metric.compute()
          print(f"Accuracy on all data: {acc}, accelerator rank: {rank}")

          
          metric.reset()

      
      dist.destroy_process_group()


  if __name__ == "__main__":
      world_size = 2  # number of gpus to parallelize over
      mp.spawn(metric_ddp, args=(world_size,), nprocs=world_size, join=True)
  ```

  </details>



  Implementing your own metric is as easy as subclassing an [`torch.nn.Module`](https://pytorch.org/docs/stable/generated/torch.nn.Module.html). Simply, subclass `torchmetrics.Metric`
  and implement the following methods:

  ```python
  import torch
  from torchmetrics import Metric


  class MyAccuracy(Metric):
      def __init__(self):
          super().__init__()
          
          
          
          self.add_state("correct", default=torch.tensor(0), dist_reduce_fx="sum")
          self.add_state("total", default=torch.tensor(0), dist_reduce_fx="sum")

      def update(self, preds: torch.Tensor, target: torch.Tensor):
          
          preds, target = self._input_format(preds, target)
          assert preds.shape == target.shape

          self.correct += torch.sum(preds == target)
          self.total += target.numel()

      def compute(self):
          
          return self.correct.float() / self.total
  ```



  Similar to [`torch.nn`](https://pytorch.org/docs/stable/nn.html), most metrics have both a [module-based](https://torchmetrics.readthedocs.io/en/latest/references/modules.html) and a [functional](https://torchmetrics.readthedocs.io/en/latest/references/functional.html) version.
  The functional versions are simple python functions that as input take [torch.tensors](https://pytorch.org/docs/stable/tensors.html) and return the corresponding metric as a [torch.tensor](https://pytorch.org/docs/stable/tensors.html).

  ```python
  import torch


  import torchmetrics


  preds = torch.randn(10, 5).softmax(dim=-1)
  target = torch.randint(5, (10,))

  acc = torchmetrics.functional.classification.multiclass_accuracy(
      preds, target, num_classes=5
  )
  ```



  We currently have implemented metrics within the following domains:

  - Audio
  - Classification
  - Detection
  - Information Retrieval
  - Image
  - Multimodal (Image-Text)
  - Nominal
  - Regression
  - Text

  In total TorchMetrics contains [90+ metrics](https://torchmetrics.readthedocs.io/en/v0.11.4all-metrics.html)!



  The lightning + TorchMetrics team is hard at work adding even more metrics.
  But we're looking for incredible contributors like you to submit new metrics
  and improve existing ones!

  Join our [Slack](https://www.pytorchlightning.ai/community) to get help with becoming a contributor!



  For help or questions, join our huge community on [Slack](https://www.pytorchlightning.ai/community)!



  We’re excited to continue the strong legacy of open source software and have been inspired
  over the years by Caffe, Theano, Keras, PyTorch, torchbearer, ignite, sklearn and fast.ai.

  If you want to cite this framework feel free to use GitHub's built-in citation option to generate a bibtex or APA-Style citation based on [this file](https://github.com/Lightning-AI/metrics/blob/master/CITATION.cff) (but only if you loved it 😊).



  Please observe the Apache 2.0 license that is listed in this repository.
  In addition, the Lightning framework is Patent Pending.


pkgId: 316e84f46895075b12b8c39b88dfb2b46ed164c12a0ac91cb696816858b1e2ea
name: python-tornado
arch: src
version: 6.2
epoch: 0
release: 1
url: http://www.tornadoweb.org/
rpm_license: http://www.apache.org/licenses/LICENSE-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f86eb4f9-7007-4c05-ba98-a5d475722044
location_href: 00008994-python-tornado/python-tornado-6.2-1.src.rpm
checksum_type: sha256
summary:
  Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed.

description:
  `Tornado <http://www.tornadoweb.org>`_ is a Python web framework and
  asynchronous networking library, originally developed at `FriendFeed
  <http://friendfeed.com>`_.  By using non-blocking network I/O, Tornado
  can scale to tens of thousands of open connections, making it ideal for
  `long polling <http://en.wikipedia.org/wiki/Push_technology#Long_Polling>`_,
  `WebSockets <http://en.wikipedia.org/wiki/WebSocket>`_, and other
  applications that require a long-lived connection to each user.


pkgId: 7e5417851f563a4cf39317723c3eb80c046952bde265f15778a4111ce624ced3
name: python-tornado-debuginfo
arch: x86_64
version: 6.2
epoch: 0
release: 1
summary: Debug information for package python-tornado
url: http://www.tornadoweb.org/
rpm_license: http://www.apache.org/licenses/LICENSE-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-f86eb4f9-7007-4c05-ba98-a5d475722044
rpm_sourcerpm: python-tornado-6.2-1.src.rpm
location_href: 00008994-python-tornado/python-tornado-debuginfo-6.2-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-tornado.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 178e738b843c34e1556c463b7d8e7c52eaf53f6f0910f7c9c831d027761c3690
name: python-tornado-debugsource
arch: x86_64
version: 6.2
epoch: 0
release: 1
summary: Debug sources for package python-tornado
url: http://www.tornadoweb.org/
rpm_license: http://www.apache.org/licenses/LICENSE-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-f86eb4f9-7007-4c05-ba98-a5d475722044
rpm_sourcerpm: python-tornado-6.2-1.src.rpm
location_href: 00008994-python-tornado/python-tornado-debugsource-6.2-1.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-tornado.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 88ef8f7e3d8852ffd786ad169e4488453bc8be6c1bfb92de5536f027ca22b1a8
name: python-towncrier
arch: src
version: 22.12.0
epoch: 0
release: 1
summary: Building newsfiles for your project.
url: https://github.com/twisted/towncrier
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f46b4a57-c812-444f-9a3f-2df6909fb130
location_href: 00005322-python-towncrier/python-towncrier-22.12.0-1.src.rpm
checksum_type: sha256
description:
  ``towncrier`` is a utility to produce useful, summarized news files (also known as changelogs) for your project.
  Rather than reading the Git history, or having one single file which developers all write to and produce merge conflicts, ``towncrier`` reads "news fragments" which contain information useful to **end users**.
  Used by `Twisted <https://github.com/twisted/twisted>`_, `pytest <https://github.com/pytest-dev/pytest/>`_, `pip <https://github.com/pypa/pip/>`_, `BuildBot <https://github.com/buildbot/buildbot>`_, and `attrs <https://github.com/python-attrs/attrs>`_, among others.
  While the command line tool ``towncrier`` works on Python 3.7+ only, as long as you don't use any Python-specific affordances (like auto-detection of the project version), it is usable with **any project type** on **any platform**.


