# packages

pkgId: 720d1a6367eaae72542bcbd20ca5c525ba98133b2875d2552a293a752b044967
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-43dc4778-a516-4116-86fb-041033055a4b
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: 986d44cf4c24ad0ca2af204f6129e8a1dd281f12b8871b9e32a8a109d2ed8813
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-a9ec0219-a451-4ab4-91b4-3b613dca5db4
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: 80b9b1bc920870477a7fcd9852881d92d615f0ac84382bb706dcdb7d8dc78e33
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-8e8da80f-21ad-48d2-bf96-bb0c640c9248
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: b61fd6d67390623de61aee88469d2e42feadb7a014bd9c363d8cb52f497ed0ec
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-f0cc5c3d-dd55-489d-9957-d4e9bdc9c178
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: 52ede1f88bae11bea62572889ac217fb11c5459aa688489e2297203eef020de9
name: python-threadpool
arch: src
version: 1.3.2
epoch: 0
release: 1
summary: Easy to use object-oriented thread pool framework.
url: http://chrisarndt.de/projects/threadpool/
rpm_license: MIT license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1a584c38-4678-4734-9edc-586a6b9efa7b
location_href: 00011926-python-threadpool/python-threadpool-1.3.2-1.src.rpm
checksum_type: sha256
description:
  .. warning::    This module is **OBSOLETE** and is only provided on PyPI to support old    projects that still use it. Please **DO NOT USE IT FOR NEW PROJECTS!**    Use modern alternatives like the `multiprocessing <https://docs.python.org/3/library/multiprocessing.html>`_    module in the standard library or even an asynchroneous approach with    `asyncio <_asyncio: https://docs.python.org/3/library/asyncio.html>`_.A thread pool is an object that maintains a pool of worker threads to performtime consuming operations in parallel. It assigns jobs to the threadsby putting them in a work request queue, where they are picked up by thenext available thread. This then performs the requested operation in thebackground and puts the results in another queue.The thread pool object can then collect the results from all threads fromthis queue as soon as they become available or after all threads havefinished their work. It's also possible, to define callbacks to handleeach result as it comes in... note::    This module is regarded as an extended example, not as a finished product.    Feel free to adapt it too your needs.


pkgId: 05f44300f231b01913a49592389bb819163d3dba7a2f1b7aba9ef934d048db55
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-608604c5-e44d-465e-942d-64153ac190ee
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: 01fe99f7f3fb77e26ad901a92548f8bf1adeffba4acd737eeee0dc8d25ae4af3
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-c0013297-4bdb-4c14-909e-3a33df482b03
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: c66b9052122c05cf2694c6487afe5d3189e8175fc55d19ec7bdb082cdda453bc
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-4226bbc0-5171-4d36-a9c2-20e6c864944e
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: 7dc05a2cf8d67ae850d44a1d03acc84e520f9fcc75d09268a9a373e51b626983
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-8931db5b-7200-4ce5-b0fe-023fa2f96f0d
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: 5b1845f53ea37c8ef1da0a2f33b9707cd6aac78b87e4e59039b2299b7640319e
name: python-time-machine-debuginfo
arch: aarch64
version: 2.9.0
epoch: 0
release: 1
summary: Debug information for package python-time-machine
url: https://github.com/adamchainz/time-machine
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-2cff327a-b129-4cf0-9c14-5a04dfd4ddb0
rpm_sourcerpm: python-time-machine-2.9.0-1.src.rpm
location_href: 00011987-python-time-machine/python-time-machine-debuginfo-2.9.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-time-machine.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 2fba87a2b568ac53eb919dd9a7a5dab7aadeaeb2a5b335f1966ae115e2a051d3
name: python-time-machine-debugsource
arch: aarch64
version: 2.9.0
epoch: 0
release: 1
summary: Debug sources for package python-time-machine
url: https://github.com/adamchainz/time-machine
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-2cff327a-b129-4cf0-9c14-5a04dfd4ddb0
rpm_sourcerpm: python-time-machine-2.9.0-1.src.rpm
location_href: 00011987-python-time-machine/python-time-machine-debugsource-2.9.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-time-machine.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 589dbf40283d4a1c8e5225c36a21e3f2a71fa7ddf03aa3595c1cd515434dedc8
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-6cc94580-c7f7-4bf1-a930-f6af9616732a
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: 8518f7dcaad44e71246a7de34412abcbdc3c8a922a6d6ed2168e478e8bc6f0a8
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-66292ff9-3db3-4438-8eea-064e4815b70a
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: 68f48eaa9755ef9d722c34c71104c8228282e196cc1cf69e06b8f8ca3a1cab92
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-a3f781f5-edf6-4a13-9883-356d5312eebd
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: 53b3271f40480bd0bef89b4142f076767150b9e001d506431362edea4d581d88
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-eb71f352-b381-4b06-b429-6a61b936af0b
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: 08acf2d1f30ab05f23c2ed876b2e554a008ef5dea94cdfd0e6b0d46aa921d39d
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-3ea9345f-9b37-415e-8bf9-b96614ac26f9
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: 90547c597a26f6c48dbdd087e51a048dc0486880910fafc03c01c84c93d8efad
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-a8353994-e370-41a5-a30c-9fd57faee077
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: 6cb0cf0c946e51af9164d7f8d557a5262770653ccf2c3875a62460396050f2c9
name: python-tinys3
arch: src
version: 0.1.12
epoch: 0
release: 1
description: UNKNOWN
url: https://www.smore.com/labs/tinys3/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-be6fc4d0-f590-4b62-b7fd-ea74fb4389e5
location_href: 00012539-python-tinys3/python-tinys3-0.1.12-1.src.rpm
checksum_type: sha256
summary:
  A small library for uploading files to S3,With support of async uploads, worker pools, cache headers etc


pkgId: 75bcef38ceae2d6e55005d6a169bf94123a29427b49626f1e6792f9e08cd64f7
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-594d7671-88bf-4876-b693-c021eb05ae59
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: b8d6c06c04ccc377ce90bf7a5d8b618a63f572afaa436e8c0b707412eb8aae23
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-8e5567d3-c4ba-48ba-b662-f647df7b6d9a
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: 45701b65b67b3b1e4c17d74258deb7c9c745a95c2565dfaab02cd6ce2277a9d2
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-1d5942d1-e6a7-4ae9-a6bf-d1ea0a8b8ea6
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: 6a112a1f9d7c1a42824519fa907af1eedaf34ec037edac9361c9255a69887f81
name: python-tlds
arch: src
version: 2022070701
epoch: 0
release: 1
summary: Automatically updated list of valid TLDs taken directly from IANA
url: https://github.com/kichik/tlds
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f6e1b349-f4e3-4887-add9-0de53f798fcd
location_href: 00012283-python-tlds/python-tlds-2022070701-1.src.rpm
checksum_type: sha256
description:
    >>> from tlds import tld_set
    >>> 'com' in tld_set
    True
    >>> 'foobar' in tld_set
    False
    >>> 'pizza' in tld_set
    True
    >>>


pkgId: 86d11964d7b6257001376eeb03e96ee98062db4a93c352390f9c208abc649aa5
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-0db5d05f-832a-462b-8272-6a829a08bdbc
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: 15822e946cae150457574db430c839d73c27a00cf1bc9bb689d9d9651ef83c3b
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-ae04a433-8d31-4626-a347-8d7f282db3f1
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: 4a2234b6eab797ae202c32ab366e18d20b41a003ebb57fb1683ddc01d448fd84
name: python-toastedmarshmallow
arch: src
version: 2.15.2.post1
epoch: 0
release: 1
summary: A JIT implementation for Marshmallow to speed up dumping and loading objects.
url: https://github.com/lyft/toastedmarshmallow
rpm_license: apache2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7c1d8cfa-cb26-4158-8a7d-a52eb1a958ce
location_href: 00011895-python-toastedmarshmallow/python-toastedmarshmallow-2.15.2.post1-1.src.rpm
checksum_type: sha256
description:
    pip install toastedmarshmallow
  This will *also* install a slightly-forked ``marshmallow`` that includes some
  hooks Toastedmarshmallow needs enable the JIT to run before falling back
  to the original marshmallow code.  These changes are minimal making it easier
  to track upstream.  You can find the changes
  `Here <https://github.com/marshmallow-code/marshmallow/pull/629/files>`_.
  This means you should **remove** ``marshmallow`` from your requirements and
  replace it with ``toastedmarshmallow``.  By default there is no
  difference unless you explicitly enable Toasted Marshmallow.


pkgId: 7e03a4d5eea41225b1ba6d798b4dee339297c69431ec77a603ef81ab14babd26
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-270772e4-e1d8-4f10-9243-61b8c751ff62
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: bc3164fbe09213b5edd00232874e6d48f0dd79b397a2585ad5695188e7753dd8
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-79766b96-4495-4a5b-a9db-f408e74d11a4
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: 5b0f96c99c51825779bd7a8e7df0357cb142d80646877d195d40c2c5df83ab92
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-1a56bd06-481f-45f5-a772-7b75a4319643
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: f8a5cbc311c1439e81499d93d24aa29b6697445cae8377a328c2b15be959ed96
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-9156fbfc-2ad8-4b59-be82-1ccf8f53b35f
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: 65628b6346d62ddda21bd0459ab5713f2b5ad5e5d6aa62b61f9bb3080dca9b48
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-defe0900-d78b-49e5-93a5-3493b2eb0ecb
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: 700c68e121b993d8f16278331a221e2b81f156e843e3c46e497cf2a6e54eb69e
name: python-tornado-debuginfo
arch: aarch64
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-defe0900-d78b-49e5-93a5-3493b2eb0ecb
rpm_sourcerpm: python-tornado-6.2-1.src.rpm
location_href: 00008994-python-tornado/python-tornado-debuginfo-6.2-1.aarch64.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: 6b6b91ee5e9605669fd61508c4ddf621f880845824a195a32304611d88ad5691
name: python-tornado-debugsource
arch: aarch64
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-defe0900-d78b-49e5-93a5-3493b2eb0ecb
rpm_sourcerpm: python-tornado-6.2-1.src.rpm
location_href: 00008994-python-tornado/python-tornado-debugsource-6.2-1.aarch64.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: 4fb389819c865d9c897fca785547665aa01e12771d28d647953404e3ed4c4e39
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-1ef0341f-2f6f-4a5d-b966-4e8f01233b9a
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**.


pkgId: a9868020d5605f3eec8f7d862ecba0ce1d0c8a7397680e86d0456886c0bf2998
name: python-tox-factor
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Run tox testenvs that match a given factor
url: https://github.com/rpkilby/tox-factor
rpm_license: BSD 3-Clause License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-588c0910-01fb-4c3d-b146-99bc60a3afc0
location_href: 00012892-python-tox-factor/python-tox-factor-0.1.2-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/rpkilby/tox-factor.svg?style=shield)](https://circleci.com/gh/rpkilby/tox-factor)
  [![Appveyor](https://ci.appveyor.com/api/projects/status/8yqgrr22dct9rxxg?svg=true)](https://ci.appveyor.com/project/rpkilby/tox-factor)
  [![codecov](https://codecov.io/gh/rpkilby/tox-factor/branch/master/graph/badge.svg)](https://codecov.io/gh/rpkilby/tox-factor)
  [![version](https://img.shields.io/pypi/v/tox-factor.svg)](https://pypi.python.org/pypi/tox-factor)
  [![python](https://img.shields.io/pypi/pyversions/tox-factor.svg)](https://pypi.org/project/tox-factor/)
  [![license](https://img.shields.io/pypi/l/tox-factor.svg)](https://pypi.python.org/pypi/tox-factor)



  tox-factor enables running a subset of tox test envs, based on factor matching.




  Take the following tox config:

  ```ini
  [tox]
  envlist =
      py{35,36,37}-django{20,21,22}-{redis,memcached}
  ```

  The above defines 18 test envs, based on three factor groups - the python
  version, the django version, and a caching backend. While the above is powerful,
  tox does not provide a way to run builds based on a subset of those factors.
  For example, the call to run all Python 3.7 builds would be:

  ```shell
  $ tox -e py37-django20-redis,py37-django20-memcached,py37-django21-redis,py37-django21-memcached,py37-django22-redis,py37-django22-memcached
  ```

  tox-factor functions similarly to the `-e <env name>` argument, except it runs
  all envs that match the given factor. The six `py37` builds could be ran with:

  ```shell
  $ tox -f py37
  ```

  In addition to ease of use when running tox locally, this is useful for some CI
  setups. For example, two common tox CI patterns are to either:

  - Define a CI job for each tox test env. e.g.,

      `tox -e py37-django20-redis`

  - Define a CI job for a common environment that runs multiple test envs. e.g.,

      `tox -e py37-django20-redis,py37-django20-memcached,...`

  For the latter case, this plugin eases maintenance of CI, as it could be
  shortened to `tox -f py37`. Additionally, take the following update to the above
  tox config:

  ```ini
  [tox]
  envlist =
      py{35,36,37}-django{20,21,22}-{redis,memcached}
      py{36,37,38}-django{30}-{redis,memcached}
  ```

  By using tox-factor, it wouldn't be necessary to update the Python 3.7 build, as
  the new `py37-django30-*` env would be matched automatically.





  If you want to verify which test envs are actually ran, combine the factor
  matching with the `-l` flag. This will display all test envs that match. e.g.,

  ```shell
  $ tox -f py37 -l
  py37-django20-redis
  py37-django20-memcached
  py37-django21-redis
  py37-django21-memcached
  py37-django22-redis
  py37-django22-memcached
  ```




  The factor option accepts a comma-separated list (similar to the `-e` option).
  ```shell
  $ tox -f py27,py37 -l
  py27-django111
  py37-django21
  ```

  Alternatively, factors can be provided via the `TOXFACTOR` environment variable:
  ```shell
  $ TOXFACTOR=py27,py37 tox -l
  py27-django111
  py37-django21
  ```

  Factors can also match non-generative env names. For example, given the
  following tox config:

  ```ini
  [tox]
  envlist =
      py{35,36,37}-django20

  [testenv:list]
  ```

  Then the following would match:

  ```shell
  $ tox -f py37,lint -l
  py37-django20
  lint
  ```

  Factors are always superseded by a given `toxenv`. For example, tox-factor would
  noop in the following cases:

  ```shell
  $ tox -f py37 -e py35-django21 -l
  py35-django21

  $ TOXENV=py35-django21 tox -f py37 -l
  py35-django21
  ```

  Factors do not support partial matching. `tox -f py3` would not match `py37`.
  However, factors may match disparate dash-separated parts. Given the following:
  ```ini
  [tox]
  envlist =
      py{35,36,37}-django{20,21,22}-{redis,memcached}
  ```

  Then `tox -f py37-redis` would match:
  ```
  py37-django20-redis
  py37-django21-redis
  py37-django22-redis
  ```




  - Update changelog
  - Update package version in setup.py
  - Create git tag for version
  - Upload release to PyPI test server
  - Upload release to official PyPI server

  ```shell
  $ pip install -U pip setuptools wheel twine
  $ rm -rf dist/ build/
  $ python setup.py sdist bdist_wheel
  $ twine upload -r test dist/*
  $ twine upload dist/*
  ```




  This code is largely based off the work done by @ryanhiebert in [tox-travis][1].
  Without his efforts, it would have taken significantly more time to write and
  test this package.



  See: [LICENSE][2]

  [1]: https://github.com/tox-dev/tox-travis
  [2]: https://github.com/rpkilby/tox-factor/blob/master/LICENSE

  BSD 3-Clause License

  Copyright (c) 2019, Ryan P Kilby
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this
    list of conditions and the following disclaimer.

  * Redistributions in binary form must reproduce the above copyright notice,
    this list of conditions and the following disclaimer in the documentation
    and/or other materials provided with the distribution.

  * Neither the name of the copyright holder nor the names of its
    contributors may be used to endorse or promote products derived from
    this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 5d05e828e1e2bdd6a0e464a4d4d99865d7ee87be996c32edab4e187d39875747
name: python-tox-gh-actions
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: Seamless integration of tox into GitHub Actions
url: https://github.com/ymyzk/tox-gh-actions
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-03f11513-eed5-492e-9a7d-66751c1d5631
location_href: 00010921-python-tox-gh-actions/python-tox-gh-actions-3.1.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/tox-gh-actions.svg)](https://badge.fury.io/py/tox-gh-actions)
  [![PyPI Supported Python Versions](https://img.shields.io/pypi/pyversions/tox-gh-actions.svg)](https://pypi.python.org/pypi/tox-gh-actions/)
  [![GitHub Actions (Tests)](https://github.com/ymyzk/tox-gh-actions/actions/workflows/tests.yml/badge.svg)](https://github.com/ymyzk/tox-gh-actions/actions/workflows/tests.yml)
  [![codecov](https://codecov.io/gh/ymyzk/tox-gh-actions/branch/master/graph/badge.svg?token=7RWjRk2LkX)](https://codecov.io/gh/ymyzk/tox-gh-actions)

  **tox-gh-actions** is a tox plugin which helps running tox on GitHub Actions
  with multiple different Python versions on multiple workers in parallel.
  This project is inspired by [tox-travis](https://github.com/tox-dev/tox-travis).


  Currently, tox-gh-actions supports both tox 3 and 4, but users need to install the appropriate version by following the table below.

  | tox | tox-gh-actions | Supported by tox-gh-actions | Branch                                                    |
  |-----|----------------|-----------------------------|-----------------------------------------------------------|
  | 4.x | 3.x            | Yes (stable)                | [master](https://github.com/ymyzk/tox-gh-actions)         |
  | 3.x | 2.x            | Yes (stable)                | [tox3](https://github.com/ymyzk/tox-gh-actions/tree/tox3) |

  - [Features](#features)
  - [Usage](#usage)
  - [Examples](#examples)
    - [Basic Example](#basic-example)
      - [tox-gh-actions Configuration](#tox-gh-actions-configuration)
      - [Workflow Configuration](#workflow-configuration)
    - [Advanced Examples](#advanced-examples)
      - [Factor-Conditional Settings: Python Version](#factor-conditional-settings-python-version)
      - [Factor-Conditional Settings: Environment Variable](#factor-conditional-settings-environment-variable)
    - [Overriding Environments to Run](#overriding-environments-to-run)
  - [Versioning](#versioning)
  - [Understanding Behavior of tox-gh-actions](#understanding-behavior-of-tox-gh-actions)
    - [How tox-gh-actions Works](#how-tox-gh-actions-works)
    - [Logging](#logging)


  When running tox on GitHub Actions, tox-gh-actions
  * detects which environment to run based on configurations and
  * provides utilities such as [grouping log lines](https://github.com/actions/toolkit/blob/main/docs/commands.md#group-and-ungroup-log-lines).


  1. Add configurations under `[gh-actions]` section along with tox's configuration.
     - It will be `pyproject.toml`, `tox.ini`, or `setup.cfg`. See [tox's documentation](https://tox.wiki/en/latest/config.html) for more details.

  2. Install `tox-gh-actions` package in the GitHub Actions workflow before running `tox` command.



  The following configuration will create 4 jobs when running the workflow on GitHub Actions.
  - On Python 3.7 job, tox runs `py37` environment
  - On Python 3.8 job, tox runs `py38` environment
  - On Python 3.9 job, tox runs `py39` environment
  - On Python 3.10 job, tox runs `py310` and `mypy` environments


  Add `[gh-actions]` section to the same file as tox's configuration.

  If you're using `tox.ini`:
  ```ini
  [tox]
  envlist = py37, py38, py39, py310, mypy

  [gh-actions]
  python =
      3.7: py37
      3.8: py38
      3.9: py39
      3.10: py310, mypy

  [testenv]
  ...
  ```

  If you're using `setup.cfg`:
  ```ini
  [tox:tox]
  envlist = py37, py38, py39, py310, mypy

  [gh-actions]
  python =
      3.7: py37
      3.8: py38
      3.9: py39
      3.10: py310, mypy

  [testenv]
  ...
  ```

  If you're using `pyproject.toml`:
  ```toml
  [tool.tox]
  legacy_tox_ini = """
  [tox]
  envlist = py37, py38, py39, py310, mypy

  [gh-actions]
  python =
      3.7: py37
      3.8: py38
      3.9: py39
      3.10: py310, mypy

  [testenv]
  """
  ```


  `.github/workflows/<workflow>.yml`:
  ```yaml
  name: Python package

  on:
    - push
    - pull_request

  jobs:
    build:
      runs-on: ubuntu-latest
      strategy:
        matrix:
          python-version: ['3.7', '3.8', '3.9', '3.10']

      steps:
      - uses: actions/checkout@v3
      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v4
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          python -m pip install tox tox-gh-actions
      - name: Test with tox
        run: tox
  ```



  The following configuration will create 2 jobs when running the workflow on GitHub Actions.
  - On Python 3.7 job, tox runs `py37-django22` and `py37-django32` environments
  - On Python 3.8 job, tox runs `py38-django32` environment

  `tox.ini`:
  ```ini
  [tox]
  envlist = py37-django{22,32}, py38-django32

  [gh-actions]
  python =
      3.7: py37
      3.8: py38

  [testenv]
  ...
  ```

  When using pre-release versions of Python, please do not specify `-beta` or `-dev` in `tox.ini`.

  `.github/workflows/<workflow>.yml`:
  ```yaml
  ...
  jobs:
    build:
      strategy:
        matrix:
          python-version: [3.9, 3.10.0-beta.3]
  ...
  ```

  `tox.ini`:
  ```ini
  [tox]
  envlist = py39, py310

  [gh-actions]
  python =
      3.9: py39
      3.10: py310
      
      
      

  [testenv]
  ...
  ```

  PyPy is also supported in the `python` configuration key.
  Support of Pyston is experimental and not tested by our CI.

   `tox.ini`:
  ```ini
  [tox]
  envlist = py37, py38, pypy3, pyston38

  [gh-actions]
  python =
      3.7: py37
      3.8: py38, mypy
      pypy-3.7: pypy3
      pyston-3.8: pyston38

  [testenv]
  ...

  [testenv:pyston38]
  basepython = pyston38
  ```

  You can also specify without minor versions in the `python` configuration key.

  `tox.ini`:
  ```ini
  [tox]
  envlist = py3, pypy3

  [gh-actions]
  python =
      3: py3, mypy
      pypy-3: pypy3

  [testenv]
  ...
  ```

  If there are multiple matching Python versions in the configuration, only the most precise one is used.
  For example, if you are running CPython 3.8 and `gh-actions.python` has both `3` and `3.8`,
  tox-gh-actions gets factors only from the key `3.8`.

  _Changed in 3.0_: `pypy3` is not supported in the configuration anymore. Please use `pypy-3` instead.


  You can also use environment variable to decide which environment to run.
  The following is an example to install different dependency based on platform.
  It will create 9 jobs when running the workflow on GitHub Actions.
  - On Python 3.8/ubuntu-latest job, tox runs `py38-linux` environment
  - On Python 3.9/ubuntu-latest job, tox runs `py39-linux` environment
  - and so on.

  `.github/workflows/<workflow>.yml`:
  ```yaml
  name: Python package

  on:
    - push
    - pull_request

  jobs:
    build:
      runs-on: ${{ matrix.platform }}
      strategy:
        matrix:
          platform: [ubuntu-latest, macos-latest, windows-latest]
          python-version: ['3.8', '3.9', '3.10']

      steps:
      - uses: actions/checkout@v3
      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v4
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          python -m pip install tox tox-gh-actions
      - name: Test with tox
        run: tox
        env:
          PLATFORM: ${{ matrix.platform }}
  ```

  `tox.ini`:
  ```ini
  [tox]
  envlist = py{38,39,310}-{linux,macos,windows}

  [gh-actions]
  python =
      3.8: py38
      3.9: py39
      3.10: py310

  [gh-actions:env]
  PLATFORM =
      ubuntu-latest: linux
      macos-latest: macos
      windows-latest: windows

  [testenv]
  deps =
    <common dependency>
    linux: <Linux specific deps>
    macos: <macOS specific deps>
    windows: <Windows specific deps>
  ...
  ```

  _Changed in 3.0_: Environment variables should not use lowercase letters.
  Because of the limitation in tox's configuration loading API,
  tox-gh-actions always convert keys in `[gh-actions:env]` to uppercase.


  _Changed in 2.0_: When a list of environments to run is specified explicitly via `-e` option or `TOXENV` environment variable ([tox's help](https://tox.wiki/en/latest/cli_interface.html#tox-run--e)),
  tox-gh-actions respects the given environments and simply runs the given environments without enforcing its configuration.

  Before 2.0, tox-gh-actions was always enforcing its configuration even when a list of environments is given explicitly.


  This project follows [PEP 440](https://www.python.org/dev/peps/pep-0440/) and uses a format of major.minor.patch (X.Y.Z).
  The major version (X) will be incremented when we make backward incompatible changes to a public API.
  The public API of this project is the configuration of tox-gh-actions.
  The major version can be also incremented when we require a new version of tox.

  This project tries not to introduce backward incompatibles changes as much as possible so that users don't need to
  update their project's configuration too frequently.

  tox-gh-actions 3.x may drop support of unsupported Python 3.y versions in the future without bumping its major version.



  See [ARCHITECTURE.md](./ARCHITECTURE.md) for more details.


  tox-gh-actions writes log messages using the standard `logging` module.
  This is handy for understanding behavior of tox-gh-actions and for debugging tox-gh-actions.
  To see the log messages, please run `tox -vv`.


pkgId: bfd193fa2738f43e542dc0f35b04e9f1fa889fe43298bafbcf858d7af5da3399
name: python-tox-pip-version
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: Select PIP version to use with tox
url: https://github.com/pglass/tox-pip-version
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-989f2e70-01e6-466c-a379-6a7108bce0f3
location_href: 00011845-python-tox-pip-version/python-tox-pip-version-0.0.7-1.src.rpm
checksum_type: sha256
description:
  This is a tox plugin that preinstalls a specific version of pip in each tox
  environment.
  ```bash
  pip install tox-pip-version
  ```
  This works around the default behavior of tox/virtualenv that always installs
  the latest version pip. It is an improvment over the `VIRTUALENV_NO_DOWNLOAD=1`
  option that does not install the latest version, but could result in usage of
  an outdated version of pip.
  *Recommendation*: Do not pin the pip version long term. You get more stable
  repeatable builds, but at the cost of using an outdated (possibly vulnerable)
  package. This should be used as a temporary fix for breakages in upstream pip,
  or in conjunction with a regular process to update the version pin.
  *Note*: This relies on an [unstable tox plugin interface](
  https://tox.readthedocs.io/en/latest/plugins.html#tox.hookspecs.tox_testenv_create).
  You may experience breakage with new tox versions. If you do, please feel
  free to [report the issue](https://github.com/pglass/tox-pip-version/issues/new)
  on Github.

  Install the package and include `pip_version` in your tox.ini
  ```tox
  [testenv]
  pip_version = pip==19.0.1
  ```
  Or, set the `TOX_PIP_VERSION` environment variable,
  ```bash
  export TOX_PIP_VERSION=18.1
  tox
  ```
  The plugin will install that version of pip into the tox-created virtualenv,
  just after tox creates the virtualenv, but before dependencies are installed.
  The `pip_version` within tox.ini, if present, is always used over the
  environment variable.
  If neither `pip_version` or `TOX_PIP_VERSION` is present, the plugin does
  nothing.

  Version sets/ranges are supported, enabling installation of a version of pip
  matching a set of specifiers. There are two basic formats: a plain version
  number, or the package name with optional [PEP440-compatible](
  https://www.python.org/dev/peps/pep-0440/#version-specifiers) version
  specifiers.
  | tox.ini                      | effective pip command        |
  | ---------------------------- | ---------------------------- |
  | `pip_version = 19.0`         | `pip install -U pip==19.0`   |
  | `pip_version = pip==19.0`    | `pip install -U pip==19.0`   |
  | `pip_version = pip>=19.0`    | `pip install -U pip>=19.0`   |
  | `pip_version = pip!=19,>18`  | `pip install -U pip!=19,>18` |
  | `pip_version = pip`          | `pip install -U pip`         |

  Use `make test` to run the tests, which includes linting and functional tests.
  Each of the `tests/*` directories is a "feature" that needs testing. Each
  feature sub-directory contains a tox.ini file that sets pip version in a
  particular way, and then uses a tox command to check the correct pip version
  was installed.


pkgId: e9dd176f1a1dfc3c2693608f3ef44efed18c78851dc2fc7aa5936e0f0e17d45c
name: python-tox-pyenv
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: tox plugin that makes tox use `pyenv which` to find python executables
url: https://github.com/samstav/tox-pyenv
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-249c2b7f-4e61-414f-9bbe-bd4e154280e4
location_href: 00013778-python-tox-pyenv/python-tox-pyenv-1.1.0-1.src.rpm
checksum_type: sha256
description:
  | |latest|  |Circle CI|
  Plugin that tells `tox <https://tox.readthedocs.org/en/latest/>`__ to
  use `pyenv which <https://github.com/yyuu/pyenv/blob/master/COMMANDS.md#pyenv-which>`__
  to `find python
  executables <https://testrun.org/tox/latest/plugins.html#tox.hookspecs.tox_get_python_executable>`__
  Your project's `circle.yml <https://circleci.com/docs/configuration>`__
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  In order for ``tox`` to have the versions of python you want available,
  set them using
  `pyenv local <https://github.com/yyuu/pyenv/blob/master/COMMANDS.md#pyenv-local>`__
      dependencies:
        override:
          - pip install tox tox-pyenv
          - pyenv local 2.7.9 3.4.3 3.5.0
  The versions passed to ``pyenv local`` must be
  `installed <https://github.com/yyuu/pyenv/blob/master/COMMANDS.md#pyenv-install>`__
  for this to work. See `CircleCI Preinstalled Python
  Versions <#circleci-preinstalled-python-versions>`__ for a list.
  Corresponding `tox.ini <https://tox.readthedocs.org/en/latest/config.html>`__
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      [tox]
      envlist = py27,py34,py35
  The result of the setup above means running ``tox`` will run tests
  against python 2.7.9, python 3.4.3 and python 3.5.0, assuming those
  versions of python have been
  `pyenv install <https://github.com/yyuu/pyenv/blob/master/COMMANDS.md#pyenv-install>`__\ed.
  notes
  ^^^^^
  If you want tox to *exclusively* use ``pyenv which`` to find
  executables, you will need use the ``--tox-pyenv-no-fallback`` command
  line option, or set ``tox_pyenv_fallback=False`` in your tox.ini. By
  default, if ``tox-pyenv`` fails to find a python executable it will
  fallback to tox's built-in strategy.
  CircleCI Preinstalled Python Versions
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  Here is the list of python versions that are *pre-installed* in the
  CircleCI build environment (as of 09/27/2017):
      $ pyenv versions
        system
        2.6.6
        2.6.8
        2.7
        2.7.10
        2.7.11
        2.7.3
        2.7.4
        2.7.5
        2.7.6
        2.7.7
        2.7.8
      * 2.7.9 (set by /home/ubuntu/.pyenv/version)
        3.1.5
        3.2
        3.2.5
        3.3.0
        3.3.2
        3.3.3
        3.4.0
        3.4.1
        3.4.2
        3.4.3
        3.5.0
        pypy-2.2.1
        pypy-2.3.1
        pypy-2.4.0
        pypy-2.5.0
  If the version you need isn't in the list, such as Python ``3.6-dev``
  include an ``install`` step:
      dependencies:
        override:
          - pip install tox tox-pyenv
          - pyenv install --skip-existing 3.6-dev
          - pyenv local 3.6-dev


pkgId: b22163ad445bc016023179a8ac75d73a2c45af9c504d7441181ac9a3e52d20af
name: python-tqdm
arch: src
version: 4.65.0
epoch: 0
release: 1
summary: Fast, Extensible Progress Meter
url: https://tqdm.github.io
rpm_license: MPLv2.0, MIT Licences
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fd3a4dc8-0f2f-4f01-9eb4-d03fbb8a4dee
location_href: 00005324-python-tqdm/python-tqdm-4.65.0-1.src.rpm
checksum_type: sha256
description:
  |Py-Versions| |Versions| |Conda-Forge-Status| |Docker| |Snapcraft|
  |Build-Status| |Coverage-Status| |Branch-Coverage-Status| |Codacy-Grade| |Libraries-Rank| |PyPI-Downloads|
  |LICENCE| |OpenHub-Status| |binder-demo| |awesome-python|
  ``tqdm`` derives from the Arabic word *taqaddum* (تقدّم) which can mean "progress,"
  and is an abbreviation for "I love you so much" in Spanish (*te quiero demasiado*).
  Instantly make your loops show a smart progress meter - just wrap any
  iterable with ``tqdm(iterable)``, and you're done!
      from tqdm import tqdm
      for i in tqdm(range(10000)):
  ``76%|████████████████████████        | 7568/10000 [00:33<00:10, 229.00it/s]``
  ``trange(N)`` can be also used as a convenient shortcut for
  ``tqdm(range(N))``.
  |Screenshot|
      |Video| |Slides| |Merch|
  It can also be executed as a module with pipes:
      $ seq 9999999 | tqdm --bytes | wc -l
      75.2MB [00:00, 217MB/s]
      9999999
      $ tar -zcf - docs/ | tqdm --bytes --total `du -sb docs/ | cut -f1` \
          > backup.tgz
       32%|██████████▍                      | 8.89G/27.9G [00:42<01:31, 223MB/s]
  Overhead is low -- about 60ns per iteration (80ns with ``tqdm.gui``), and is
  unit tested against performance regression.
  By comparison, the well-established
  `ProgressBar <https://github.com/niltonvolpato/python-progressbar>`__ has
  an 800ns/iter overhead.
  In addition to its low overhead, ``tqdm`` uses smart algorithms to predict
  the remaining time and to skip unnecessary iteration displays, which allows
  for a negligible overhead in most cases.
  ``tqdm`` works on any platform
  (Linux, Windows, Mac, FreeBSD, NetBSD, Solaris/SunOS),
  in any console or in a GUI, and is also friendly with IPython/Jupyter notebooks.
  ``tqdm`` does not require any dependencies (not even ``curses``!), just
  Python and an environment supporting ``carriage return \r`` and


pkgId: e85a33772b97f2f8bf4822411c2a78fdd07a0441b695e0e899024ffac971c06b
name: python-tracemoepy
arch: src
version: 4.1
epoch: 0
release: 1
summary: Trace.moe python wrapper
url: https://github.com/DragSama/tracemoepy
rpm_license: GNU Lesser General Public License v3 (LGPLv3)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2c83e048-ce20-4ba7-8429-90bee47cc60f
location_href: 00012819-python-tracemoepy/python-tracemoepy-4.1-1.src.rpm
checksum_type: sha256
description:
  [![Codacy Badge](https://api.codacy.com/project/badge/Grade/aaed48cb31674d86b9e1355d8b78f855)](https://app.codacy.com/gh/DragSama/tracemoepy?utm_source=github.com&utm_medium=referral&utm_content=DragSama/tracemoepy&utm_campaign=Badge_Grade)
  [![PyPI version](https://img.shields.io/pypi/v/tracemoepy?color=bright-green)](https://pypi.org/project/tracemoepy/)
  [![Downloads](https://img.shields.io/pypi/dd/tracemoepy)](https://pypi.org/project/tracemoepy/)
  [![Code style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)


  - Install using pip: `pip install tracemoepy`


  - All the examples below are after this piece of code:
  ```python
  import tracemoepy
  tracemoe = tracemoepy.tracemoe.TraceMoe()
  ```

  - Search image using url:
  ```python
  resp = tracemoe.search('https://trace.moe/img/flipped-good.jpg', is_url = True)
  print(resp.prettify())
  print(f"Match: {resp.result[0].anilist.title.romaji}\nSimilarity: {resp.result[0].similarity*100}")
  ```

  - Or just file path:
  ```python
  print(tracemoe.search('image.jpg', upload_file=True))
  ```
  - Save Video Preview:
  ```python
  output = tracemoe.search('https://trace.moe/img/flipped-good.jpg', is_url = True)
  output.result[0].save('preview.mp4', mute = False) # True for silent
  ```
  - Save Video preview (2)
  ```python
  output = tracemoe.search('https://trace.moe/img/flipped-good.jpg', is_url = True)
  video = tracemoe.natural_preview(output)
  with open('preview.mp4', 'wb') as f:
    f.write(video)
  ```
  - Save Image Preview
  ```python
  output = tracemoe.search('https://trace.moe/img/flipped-good.jpg', is_url = True)
  output.result[0].save(save_path = 'preview.png', preview_type="image")
  ```
  - Image Preview (Method 2)
  ```python
  output = tracemoe.search('https://trace.moe/img/flipped-good.jpg', is_url = True)
  tracemoe.image_preview(output) # Gives content
  ```
  - You can do help(method_name) to get more info about the given method
  ```python
  help(tracemoe.search)
  ```

  **All the examples below assume you are running this inside a async function**

  - Basic search (AioHttp session is not closed, You can access it as .aio_session)
  ```python
  import tracemoepy
  tracemoe = tracemoepy.AsyncTrace()
  resp = await tracemoe.search('https://trace.moe/img/flipped-good.jpg', is_url = True)
  print(f"Match: {resp.result[0].anilist.title.romaji}\nSimilarity: {resp.result[0].similarity*100}")
  ```

  - Auto close session
  ```python
  import tracemoepy
  async with tracemoepy.AsyncTrace() as tracemoe:
    resp = await tracemoe.search('https://trace.moe/img/flipped-good.jpg', is_url = True)
    print(f"Match: {resp.result[0].anilist.title.romaji}\nSimilarity: {resp.result[0].similarity*100}")

  ```


    - `TooManyRequests`: Raised when API Limit is reached or Too many requests in short period of time.
    - `EntityTooLarge`: Raised when image size is greater than max size of 10MB.
    - `ServerError`: Raised when Something wrong with the trace.moe server or Image provided was malformed.
    - `InvalidToken`: Raised when Invalid token was provided.
    - `EmptyImage`: Raised when Image provided was empty.
    - `InvalidPath`: Invalid path was given, This is only raised by `.save(...)` method
    - All these errors are located at tracemoepy.errors, Example of handling Exception:
  ```python
  from tracemoepy.errors import TooManyRequests

  try:
    
  except TooManyRequests as t:
    print(t)
    
  ```


pkgId: 372ccf788ea7abeaa49723927ecb5d72acd59abd063417623886ccfed8073447
name: python-tracer
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Centralized sys.settrace management
url: https://pypi.org/project/tracer/
rpm_license: None
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ed376bc6-207b-41ac-8f23-a11fb32e434d
location_href: 00005325-python-tracer/python-tracer-0.3.2-1.src.rpm
checksum_type: sha256
description:
  Centralized Trace management using sys.settrace.

  We allow several trace hooks to get registered and unregistered and
  allow tracing to be turned on and off temporarily without losing the
  trace hooks. You can also indicate filters on events for which trace
  hooks should fire and mark methods that should automatically be
  ignored.


pkgId: 406661fcf06a22624670a9a5608f6861bfdc7362849eb38e03c17320b0a99134
name: python-tracers
arch: src
version: 21.8.6876
epoch: 0
release: 1
url: https://github.com/fluidattacks/tracers
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-61fb9312-f80f-4639-8803-c577bab3acdd
location_href: 00010743-python-tracers/python-tracers-21.8.6876-1.src.rpm
checksum_type: sha256
summary:
  Open-Source APM (Application monitoring) project that offers you minimal overhead wrappers for profiling your code execution flow

description:
  +++ b/examples/with_tracers.py
  @@ -1,15 +1,18 @@
   import time
   from dateutil.parser import parse
  +from tracers.function import trace
  +@trace()
   def example():
       time.sleep(2.0)
       your_business_logic('Sat Oct 11')
  +@trace()
   def your_business_logic(date: str):
       parse(date)
       time.sleep(1.0)
   example()
  ```
  If you run it, all the functions you decorated will be traced
  and you'll have metrics of the execution flow:
  ```
  🛈  Finished transaction: 3.00 seconds
       
       1     0.00s     2.00s [ 66.7%]     3.00s [100.0%]    ✓ example
       2     2.00s     1.00s [ 33.3%]     1.00s [ 33.3%]    ¦   ✓ your_business_logic
             Count                Net              Total    Function
                 1     2.00s [ 66.7%]     3.00s [100.0%]    ✓ example
                 1     1.00s [ 33.3%]     1.00s [ 33.3%]    ✓ your_business_logic
  ```
  From the output you can conclude:
  - executing function *example* took a total of *3.0* seconds to complete
  - function *example* takes *66.7%* of the execution time
  - function *example encloses *100%* of your code time
  - function *example* called function: *your_business_logic*
  - function *your_business_logic* took *1.0* seconds out of the *3.0* seconds
    the function *example* needed to complete
  - function *your_business_logic* represents *33.3%* of your execution time
  Tracing code is not limited to your own code.
  You can trace any **callable object** including **third party packages**,
  **Python's standard library**, and almost anything
  The level of detail is up to you!


pkgId: fd92ee27dd6ed53a5e80946e49094cb1d92a9f684249f1031b743fa99b81c058
name: python-trademgen
arch: src
version: 1.0.6.post1
epoch: 0
release: 1
summary: Simple Python wrapper for AirInv
url: https://github.com/airsim/airinv
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f79b4718-03ac-4bb2-b823-e45fbed8560e
location_href: 00005326-python-trademgen/python-trademgen-1.0.6.post1-1.src.rpm
checksum_type: sha256
description:
  TraDemGen aims at providing a clean API, and the corresponding
  C++ implementation, able to generate demand for travel solutions
  (_e.g._, from JFK to PEK on 25-05-2019) according to characteristics
  (_e.g._, Willingness-To-Pay, preferred airline, etc).
  TraDemGen makes an extensive use of existing open-source libraries for
  increased functionality, speed and accuracy. In particular the
  Boost (C++ Standard Extensions: https://www.boost.org) library is used.
  TraDemGen is the one of the components of the Travel Market Simulator
  (https://travel-sim.org). However, it may be used in a
  stand-alone mode.


  Just use DNF (or Yum on older distributions):
  ```bash
  $ dnf -y install trademgen-devel trademgen-doc
  ```
  You can also get the RPM packages (which may work on Linux
  distributions like Suse and Mandriva) from the Fedora repository
  (_e.g._, for Fedora 32,
  https://fr2.rpmfind.net/linux/RPM/fedora/32/x86_64/)

  The Git repository may be cloned as following:
  ```bash
  $ git clone git@github.com:airsim/trademgen.git trademgengit # through SSH
  $ git clone https://github.com/airsim/trademgen.git # if the firewall filters SSH
  $ cd trademgengit
  ```
  Then, you need the following packages (Fedora/RedHat/CentOS names here,
  but names may vary according to distributions):
  * cmake
  * gcc-c++
  * boost-devel / libboost-dev
  * python-devel / python-dev
  * gettext-devel / gettext-dev
  * sqlite3-devel / libsqlite3-dev
  * readline-devel / readline-dev
  * ncurses-devel
  * soci-mysql-devel, soci-sqlite3-devel
  * stdair-devel / libstdair-dev
  * sevmgr-devel / libsevmgr-dev
  * doxygen, ghostscript, graphviz
  * tetex-latex (optional)
  * rpm-build (optional)

  The latest stable source tarball (`trademgen*.tar.gz` or `.bz2`) can be
  found on GitHub: https://github.com/airsim/trademgen/tags, _e.g._,
  https://github.com/airsim/trademgen/archive/trademgen-1.00.6.tar.gz
  As TraDemGen depends on other
  [Travel Market Simulator (TvlSim/AirSim)](https://github.com/airsim/)
  modules, more specifically [StdAir](https://github.com/airsim/stdair)
  and [SEvMgr](https://github.com/airsim/sevmgr), it may be
  convenient to use the
  [MetaSim project](https://github.com/airsim/metasim),
  which pulls at once all the components of TvlSim in the same place,
  and then orchestrates the dependencies for the builds, installations
  and use of components.
  If MetaSim is not used, in order to customise the following to your
  environment, you can alter the path to the installation directory:
  ```bash
  export INSTALL_BASEDIR="/home/user/dev/deliveries"
  export TDG_VER="1.00.6"
  if [ -d /usr/lib64 ]; then LIBSUFFIX="64"; fi
  export LIBSUFFIX_4_CMAKE="-DLIB_SUFFIX=${LIBSUFFIX}"
  ```
  Then, as usual:
  * To configure the project, type something like:
  ```bash
    mkdir build && cd build
    cmake -DCMAKE_INSTALL_PREFIX=${INSTALL_BASEDIR}/trademgen-$TDG_VER \
     -DWITH_SEVMGR_PREFIX=${INSTALL_BASEDIR}/sevmgr-stable \
     -DWITH_STDAIR_PREFIX=${INSTALL_BASEDIR}/stdair-stable \
     -DCMAKE_BUILD_TYPE:STRING=Debug -DENABLE_TEST:BOOL=ON \
     -DINSTALL_DOC:BOOL=ON -DRUN_GCOV:BOOL=OFF ${LIBSUFFIX_4_CMAKE} ..
  ```
  * To build the project, type:
  ```bash
    make
  ```
  * To test the project, type:
  ```bash
    make check
  ```
  * To install the library (`libtrademgen*.so*`) and the binary (trademgen),
    just type:
  ```bash
    make install
    cd ${INSTALL_BASEDIR}
    rm -f trademgen-stable && ln -s trademgen-${TDG_VER} trademgen-stable
    cd -
  ```
  * To package the source files, type:
  ```bash
    make dist
  ```
  * To package the binary and the (HTML and PDF) documentation:
  ```bash
    make package
  ```
  * To browse the (just installed, if enabled) HTML documentation:
  ```bash
    midori file://${INSTALL_BASEDIR}/trademgen-$TDG_VER/share/doc/trademgen/html/index.html
  ```
  * To browse the (just installed, if enabled) PDF documentation:
  ```bash
    evince ${INSTALL_BASEDIR}/trademgen-$TDG_VER/share/doc/trademgen/html/refman.pdf
  ```
  * To run the local binary version:
  ```bash
    ./trademgen/trademgen -b
  ```
  * To run the installed version:
  ```bash
    ${INSTALL_BASEDIR}/trademgen-${TDG_VER}/bin/trademgen -b
    ${INSTALL_BASEDIR}/trademgen-${TDG_VER}/bin/pytrademgen
    ${INSTALL_BASEDIR}/trademgen-${TDG_VER}/bin/trademgen_generateDemand
    ${INSTALL_BASEDIR}/trademgen-${TDG_VER}/bin/trademgen_extractBookingRequests
    ${INSTALL_BASEDIR}/trademgen-${TDG_VER}/bin/trademgen_drawBookingArrivals
    ${INSTALL_BASEDIR}/trademgen-${TDG_VER}/bin/trademgen_with_db
  ```

  The way to interact with a C++-based Python extension is extensively described
  in the [OpenTREP project](https://github.com/trep/opentrep).
  Only a quick start is given here.

  * Install Python dependencies:
  ```bash
  $ python3 -m pip install -U pip
  $ python3 -m pip install -U wheel
  $ python3 -m pip install -U build setuptools scikit-build tox pytest sphinx twine
  ```

  * Build the Python extension with SciKit-Build:
  ```bash
  $ rm -rf _skbuild/ dist/ MANIFEST_
  $ python3 setup.py --build-type=Debug build sdist bdist_wheel
  ```
  * The Python artifacts should be similar to:
  ```bash
  $ ls -lFh dist/
  total 5872
  -rw-r--r-- 1 user staff 2.0M Jun  1 15:49 rmol-1.0.5.post1-cp38-cp38-macosx_10_15_x86_64.whl
  -rw-r--r-- 1 user staff 834K Jun  1 15:49 rmol-1.0.5.post1.tar.gz
  ```
  * Updload the RMOL Python extension onto PyPi:
  ```bash
  $ twine upload -u __token__ --repository-url https://upload.pypi.org/legacy/ dist/*
  ```
  * The RMOL Python artifacts may then be browsed on PyyPI:
    https://pypi.org/project/rmol/

  * Launch the Python interpreter:
  ```bash
  $ export PYTHONPATH=${PWD}/_skbuild/macosx-10.15-x86_64-3.8/cmake-install/lib:${PWD}/_skbuild/macosx-10.15-x86_64-3.8/cmake-install/lib/python3.8/site-packages/pyrmol
  $ DYLD_INSERT_LIBRARIES=/Library/Developer/CommandLineTools/usr/lib/clang/11.0.0/lib/darwin/libclang_rt.asan_osx_dynamic.dylib ASAN_OPTIONS=detect_container_overflow=0 /usr/local/Cellar/python@3.8/3.8.3/Frameworks/Python.framework/Versions/3.8/Resources/Python.app/Contents/MacOS/Python
  ```
  * Within the Python interpreter, import, initialize
    and use the RMOL Python extension:
  ```python
  Python 3.8.3 (default, May 27 2020, 20:54:22)
  [Clang 11.0.3 (clang-1103.0.32.59)] on darwin
  Type "help", "copyright", "credits" or "license" for more information.
  >>> import pyrmol
  >>> rmolLibrary = pyrmol.RMOLer()
  >>> rmolLibrary.init('rmol.log', 40, 1, '')
  True
  >>> rmolLibrary.rmol(100, 10, 40.0)
  'RMOL has completed the generation of the booking requests. See the log file for more details.\n'
  >>> quit()
  ```
  * Back to the Shell session, look for the results in the RMOL log file:
  ```bash
  $ cat rmol.log
  Python wrapper initialisation
  [D]${STDAIR_PREFIX}/stdair/command/CmdBomManager.cpp:52: StdAir is building the BOM tree from built-in specifications.
  Python wrapper initialised
  Optimisation for 100 draws, capacity of 40, and with the following method: 10
  [D]${RMOL_PREFIX}/rmol/service/RMOL_Service.cpp:491: Optimisation by Monte-Carlo performed in 0.000321
  [D]${RMOL_PREFIX}/rmol/service/RMOL_Service.cpp:492: Result:
  Yield: 100.00, Protection: 70.48, Booking limit: 100.00
  Yield: 70.00, Protection: 156.19, Booking limit: 29.52
  Yield: 42.00, Protection: -0.00, Booking limit: -56.19
  [D]${RMOL_PREFIX}/rmol/service/RMOL_Service.cpp:505: Bid-Price Vector (BPV): 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 100.00, 99.00, 99.00, 99.00, 99.00, 99.00, 98.00, 98.00, 97.00, 96.00, 96.00, 96.00, 96.00, 96.00, 95.00, 94.00, 94.00, 90.00, 90.00, 89.00, 88.00, 86.00, 84.00, 82.00, 80.00, 80.00, 79.00, 77.00, 76.00, 75.00, 72.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00, 70.00
  End of the optimisation.
  RMOL output:
  ```
  * Of course, a few more features could be added to the Python extension API,
    in order not to have to leave the Python interpreter to interact with the
    results of invoking the optimizer. Do not hesitate to contribute
    through [Pull Requests](https://github.com/airsim/rmol/pulls), which are
    always welcome!


pkgId: 443a026da432a2d874027f869e4995a6830aaada46efb803888a15c44fefc4a6
name: python-trafaret
arch: src
version: 2.1.1
epoch: 0
release: 1
summary: Validation and parsing library
url: https://github.com/Deepwalker/trafaret/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e09c3456-aef2-4516-b6c6-b37486809e44
location_href: 00010597-python-trafaret/python-trafaret-2.1.1-1.src.rpm
checksum_type: sha256
description:
  |circleci_build| |gitter_chat| |pypi_version| |pypi_license|
  Ultimate transformation library that supports validation, contexts and ``aiohttp``.
  Trafaret is rigid and powerful lib to work with foreign data, configs etc.
  It provides simple way to check anything, and convert it accordingly to your needs.
  It has shortcut syntax and ability to express anything that you can code:
      >>> from trafaret.constructor import construct
      >>> validator = construct({'a': int, 'b': [str]})
      >>> validator({'a': 5, 'b': ['lorem', 'ipsum']})
      {'a': 5, 'b': ['lorem', 'ipsum']}
      >>> validator({'a': 5, 'b': ['gorky', 9]})
      Traceback (most recent call last):
        File "<console>", line 1, in <module>
        File "/Users/mkrivushin/w/trafaret/trafaret/__init__.py", line 204, in __call__
          return self.check(val)
        File "/Users/mkrivushin/w/trafaret/trafaret/__init__.py", line 144, in check
          return self._convert(self.check_and_return(value))
        File "/Users/mkrivushin/w/trafaret/trafaret/__init__.py", line 1105, in check_and_return
          raise DataError(error=errors, trafaret=self)
      trafaret.DataError: {'b': DataError({1: DataError(value is not a string)})}
  Read The Docs hosted documentation http://trafaret.readthedocs.org/en/latest/
  or look to the `docs/intro.rst`_ for start.
  Trafaret can even generate Trafarets instances to build transformators from json,
  like in json schema implementation `Trafaret Schema <https://github.com/Deepwalker/trafaret_schema>`_


pkgId: 10929a8aeb6535e7d3db68dec0ebfe91b5ca00fa848a5be725c2cf5c875e8cf1
name: python-traits-debuginfo
arch: aarch64
version: 6.4.1
epoch: 0
release: 1
summary: Debug information for package python-traits
url: http://docs.enthought.com/traits
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-3045a794-a644-4fb7-89a7-dcded7bb8305
rpm_sourcerpm: python-traits-6.4.1-1.src.rpm
location_href: 00002888-python-Traits/python-traits-debuginfo-6.4.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-traits.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 7e6557e1bb67e5463ab527bdcc0a7fad4cea37046c8f80ff5f5590a5a41eb0ba
name: python-traits-debugsource
arch: aarch64
version: 6.4.1
epoch: 0
release: 1
summary: Debug sources for package python-traits
url: http://docs.enthought.com/traits
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-3045a794-a644-4fb7-89a7-dcded7bb8305
rpm_sourcerpm: python-traits-6.4.1-1.src.rpm
location_href: 00002888-python-Traits/python-traits-debugsource-6.4.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-traits.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 9f76ffae3ffee57b874cd2317da1562f2b86a351b2e6f925fba3c50be002932d
name: python-transformers
arch: src
version: 4.27.4
epoch: 0
release: 1
summary: State-of-the-art Machine Learning for JAX, PyTorch and TensorFlow
url: https://github.com/huggingface/transformers
rpm_license: Apache 2.0 License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-88dd7b8e-78e0-4d02-b24c-81d06cfd5fac
location_href: 00009242-python-transformers/python-transformers-4.27.4-1.src.rpm
checksum_type: sha256
description:
  <!---
  Copyright 2020 The HuggingFace Team. All rights reserved.

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

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

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

  <p align="center">
    <picture>
      <source media="(prefers-color-scheme: dark)" srcset="https://huggingface.co/datasets/huggingface/documentation-images/raw/main/transformers-logo-dark.svg">
      <source media="(prefers-color-scheme: light)" srcset="https://huggingface.co/datasets/huggingface/documentation-images/raw/main/transformers-logo-light.svg">
      <img alt="Hugging Face Transformers Library" src="https://huggingface.co/datasets/huggingface/documentation-images/raw/main/transformers-logo-light.svg" width="352" height="59" style="max-width: 100%;">
    </picture>
    <br/>
    <br/>
  </p>

  <p align="center">
      <a href="https://circleci.com/gh/huggingface/transformers">
          <img alt="Build" src="https://img.shields.io/circleci/build/github/huggingface/transformers/main">
      </a>
      <a href="https://github.com/huggingface/transformers/blob/main/LICENSE">
          <img alt="GitHub" src="https://img.shields.io/github/license/huggingface/transformers.svg?color=blue">
      </a>
      <a href="https://huggingface.co/docs/transformers/index">
          <img alt="Documentation" src="https://img.shields.io/website/http/huggingface.co/docs/transformers/index.svg?down_color=red&down_message=offline&up_message=online">
      </a>
      <a href="https://github.com/huggingface/transformers/releases">
          <img alt="GitHub release" src="https://img.shields.io/github/release/huggingface/transformers.svg">
      </a>
      <a href="https://github.com/huggingface/transformers/blob/main/CODE_OF_CONDUCT.md">
          <img alt="Contributor Covenant" src="https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg">
      </a>
      <a href="https://zenodo.org/badge/latestdoi/155220641"><img src="https://zenodo.org/badge/155220641.svg" alt="DOI"></a>
  </p>

  <h4 align="center">
      <p>
          <b>English</b> |
          <a href="https://github.com/huggingface/transformers/blob/main/README_zh-hans.md">简体中文</a> |
          <a href="https://github.com/huggingface/transformers/blob/main/README_zh-hant.md">繁體中文</a> |
          <a href="https://github.com/huggingface/transformers/blob/main/README_ko.md">한국어</a> |
          <a href="https://github.com/huggingface/transformers/blob/main/README_es.md">Español</a> |
          <a href="https://github.com/huggingface/transformers/blob/main/README_ja.md">日本語</a> |
          <a href="https://github.com/huggingface/transformers/blob/main/README_hd.md">हिन्दी</a>
      <p>
  </h4>

  <h3 align="center">
      <p>State-of-the-art Machine Learning for JAX, PyTorch and TensorFlow</p>
  </h3>

  <h3 align="center">
      <a href="https://hf.co/course"><img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/course_banner.png"></a>
  </h3>

  🤗 Transformers provides thousands of pretrained models to perform tasks on different modalities such as text, vision, and audio.

  These models can be applied on:

  * 📝 Text, for tasks like text classification, information extraction, question answering, summarization, translation, text generation, in over 100 languages.
  * 🖼️ Images, for tasks like image classification, object detection, and segmentation.
  * 🗣️ Audio, for tasks like speech recognition and audio classification.

  Transformer models can also perform tasks on **several modalities combined**, such as table question answering, optical character recognition, information extraction from scanned documents, video classification, and visual question answering.

  🤗 Transformers provides APIs to quickly download and use those pretrained models on a given text, fine-tune them on your own datasets and then share them with the community on our [model hub](https://huggingface.co/models). At the same time, each python module defining an architecture is fully standalone and can be modified to enable quick research experiments.

  🤗 Transformers is backed by the three most popular deep learning libraries — [Jax](https://jax.readthedocs.io/en/latest/), [PyTorch](https://pytorch.org/) and [TensorFlow](https://www.tensorflow.org/) — with a seamless integration between them. It's straightforward to train your models with one before loading them for inference with the other.



  You can test most of our models directly on their pages from the [model hub](https://huggingface.co/models). We also offer [private model hosting, versioning, & an inference API](https://huggingface.co/pricing) for public and private models.

  Here are a few examples:

   In Natural Language Processing:
  - [Masked word completion with BERT](https://huggingface.co/bert-base-uncased?text=Paris+is+the+%5BMASK%5D+of+France)
  - [Name Entity Recognition with Electra](https://huggingface.co/dbmdz/electra-large-discriminator-finetuned-conll03-english?text=My+name+is+Sarah+and+I+live+in+London+city)
  - [Text generation with GPT-2](https://huggingface.co/gpt2?text=A+long+time+ago%2C+)
  - [Natural Language Inference with RoBERTa](https://huggingface.co/roberta-large-mnli?text=The+dog+was+lost.+Nobody+lost+any+animal)
  - [Summarization with BART](https://huggingface.co/facebook/bart-large-cnn?text=The+tower+is+324+metres+%281%2C063+ft%29+tall%2C+about+the+same+height+as+an+81-storey+building%2C+and+the+tallest+structure+in+Paris.+Its+base+is+square%2C+measuring+125+metres+%28410+ft%29+on+each+side.+During+its+construction%2C+the+Eiffel+Tower+surpassed+the+Washington+Monument+to+become+the+tallest+man-made+structure+in+the+world%2C+a+title+it+held+for+41+years+until+the+Chrysler+Building+in+New+York+City+was+finished+in+1930.+It+was+the+first+structure+to+reach+a+height+of+300+metres.+Due+to+the+addition+of+a+broadcasting+aerial+at+the+top+of+the+tower+in+1957%2C+it+is+now+taller+than+the+Chrysler+Building+by+5.2+metres+%2817+ft%29.+Excluding+transmitters%2C+the+Eiffel+Tower+is+the+second+tallest+free-standing+structure+in+France+after+the+Millau+Viaduct)
  - [Question answering with DistilBERT](https://huggingface.co/distilbert-base-uncased-distilled-squad?text=Which+name+is+also+used+to+describe+the+Amazon+rainforest+in+English%3F&context=The+Amazon+rainforest+%28Portuguese%3A+Floresta+Amaz%C3%B4nica+or+Amaz%C3%B4nia%3B+Spanish%3A+Selva+Amaz%C3%B3nica%2C+Amazon%C3%ADa+or+usually+Amazonia%3B+French%3A+For%C3%AAt+amazonienne%3B+Dutch%3A+Amazoneregenwoud%29%2C+also+known+in+English+as+Amazonia+or+the+Amazon+Jungle%2C+is+a+moist+broadleaf+forest+that+covers+most+of+the+Amazon+basin+of+South+America.+This+basin+encompasses+7%2C000%2C000+square+kilometres+%282%2C700%2C000+sq+mi%29%2C+of+which+5%2C500%2C000+square+kilometres+%282%2C100%2C000+sq+mi%29+are+covered+by+the+rainforest.+This+region+includes+territory+belonging+to+nine+nations.+The+majority+of+the+forest+is+contained+within+Brazil%2C+with+60%25+of+the+rainforest%2C+followed+by+Peru+with+13%25%2C+Colombia+with+10%25%2C+and+with+minor+amounts+in+Venezuela%2C+Ecuador%2C+Bolivia%2C+Guyana%2C+Suriname+and+French+Guiana.+States+or+departments+in+four+nations+contain+%22Amazonas%22+in+their+names.+The+Amazon+represents+over+half+of+the+planet%27s+remaining+rainforests%2C+and+comprises+the+largest+and+most+biodiverse+tract+of+tropical+rainforest+in+the+world%2C+with+an+estimated+390+billion+individual+trees+divided+into+16%2C000+species)
  - [Translation with T5](https://huggingface.co/t5-base?text=My+name+is+Wolfgang+and+I+live+in+Berlin)

  In Computer Vision:
  - [Image classification with ViT](https://huggingface.co/google/vit-base-patch16-224)
  - [Object Detection with DETR](https://huggingface.co/facebook/detr-resnet-50)
  - [Semantic Segmentation with SegFormer](https://huggingface.co/nvidia/segformer-b0-finetuned-ade-512-512)
  - [Panoptic Segmentation with MaskFormer](https://huggingface.co/facebook/maskformer-swin-small-coco)
  - [Depth Estimation with DPT](https://huggingface.co/docs/transformers/model_doc/dpt)
  - [Video Classification with VideoMAE](https://huggingface.co/docs/transformers/model_doc/videomae)
  - [Universal Segmentation with OneFormer](https://huggingface.co/shi-labs/oneformer_ade20k_dinat_large)

  In Audio:
  - [Automatic Speech Recognition with Wav2Vec2](https://huggingface.co/facebook/wav2vec2-base-960h)
  - [Keyword Spotting with Wav2Vec2](https://huggingface.co/superb/wav2vec2-base-superb-ks)
  - [Audio Classification with Audio Spectrogram Transformer](https://huggingface.co/MIT/ast-finetuned-audioset-10-10-0.4593)

  In Multimodal tasks:
  - [Table Question Answering with TAPAS](https://huggingface.co/google/tapas-base-finetuned-wtq)
  - [Visual Question Answering with ViLT](https://huggingface.co/dandelin/vilt-b32-finetuned-vqa)
  - [Zero-shot Image Classification with CLIP](https://huggingface.co/openai/clip-vit-large-patch14)
  - [Document Question Answering with LayoutLM](https://huggingface.co/impira/layoutlm-document-qa)
  - [Zero-shot Video Classification with X-CLIP](https://huggingface.co/docs/transformers/model_doc/xclip)

  **[Write With Transformer](https://transformer.huggingface.co)**, built by the Hugging Face team, is the official demo of this repo’s text generation capabilities.



  <a target="_blank" href="https://huggingface.co/support">
      <img alt="HuggingFace Expert Acceleration Program" src="https://cdn-media.huggingface.co/marketing/transformers/new-support-improved.png" style="max-width: 600px; border: 1px solid #eee; border-radius: 4px; box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.05);">
  </a><br>



  To immediately use a model on a given input (text, image, audio, ...), we provide the `pipeline` API. Pipelines group together a pretrained model with the preprocessing that was used during that model's training. Here is how to quickly use a pipeline to classify positive versus negative texts:

  ```python
  >>> from transformers import pipeline


  >>> classifier = pipeline('sentiment-analysis')
  >>> classifier('We are very happy to introduce pipeline to the transformers repository.')
  [{'label': 'POSITIVE', 'score': 0.9996980428695679}]
  ```

  The second line of code downloads and caches the pretrained model used by the pipeline, while the third evaluates it on the given text. Here the answer is "positive" with a confidence of 99.97%.

  Many tasks have a pre-trained `pipeline` ready to go, in NLP but also in computer vision and speech. For example, we can easily extract detected objects in an image:

  ``` python
  >>> import requests
  >>> from PIL import Image
  >>> from transformers import pipeline


  >>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/coco_sample.png"
  >>> image_data = requests.get(url, stream=True).raw
  >>> image = Image.open(image_data)


  >>> object_detector = pipeline('object-detection')
  >>> object_detector(image)
  [{'score': 0.9982201457023621,
    'label': 'remote',
    'box': {'xmin': 40, 'ymin': 70, 'xmax': 175, 'ymax': 117}},
   {'score': 0.9960021376609802,
    'label': 'remote',
    'box': {'xmin': 333, 'ymin': 72, 'xmax': 368, 'ymax': 187}},
   {'score': 0.9954745173454285,
    'label': 'couch',
    'box': {'xmin': 0, 'ymin': 1, 'xmax': 639, 'ymax': 473}},
   {'score': 0.9988006353378296,
    'label': 'cat',
    'box': {'xmin': 13, 'ymin': 52, 'xmax': 314, 'ymax': 470}},
   {'score': 0.9986783862113953,
    'label': 'cat',
    'box': {'xmin': 345, 'ymin': 23, 'xmax': 640, 'ymax': 368}}]
  ```

  Here we get a list of objects detected in the image, with a box surrounding the object and a confidence score. Here is the original image on the left, with the predictions displayed on the right:

  <h3 align="center">
      <a><img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/coco_sample.png" width="400"></a>
      <a><img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/coco_sample_post_processed.png" width="400"></a>
  </h3>

  You can learn more about the tasks supported by the `pipeline` API in [this tutorial](https://huggingface.co/docs/transformers/task_summary).

  In addition to `pipeline`, to download and use any of the pretrained models on your given task, all it takes is three lines of code. Here is the PyTorch version:
  ```python
  >>> from transformers import AutoTokenizer, AutoModel

  >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
  >>> model = AutoModel.from_pretrained("bert-base-uncased")

  >>> inputs = tokenizer("Hello world!", return_tensors="pt")
  >>> outputs = model(**inputs)
  ```

  And here is the equivalent code for TensorFlow:
  ```python
  >>> from transformers import AutoTokenizer, TFAutoModel

  >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
  >>> model = TFAutoModel.from_pretrained("bert-base-uncased")

  >>> inputs = tokenizer("Hello world!", return_tensors="tf")
  >>> outputs = model(**inputs)
  ```

  The tokenizer is responsible for all the preprocessing the pretrained model expects, and can be called directly on a single string (as in the above examples) or a list. It will output a dictionary that you can use in downstream code or simply directly pass to your model using the ** argument unpacking operator.

  The model itself is a regular [Pytorch `nn.Module`](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) or a [TensorFlow `tf.keras.Model`](https://www.tensorflow.org/api_docs/python/tf/keras/Model) (depending on your backend) which you can use as usual. [This tutorial](https://huggingface.co/docs/transformers/training) explains how to integrate such a model into a classic PyTorch or TensorFlow training loop, or how to use our `Trainer` API to quickly fine-tune on a new dataset.



  1. Easy-to-use state-of-the-art models:
      - High performance on natural language understanding & generation, computer vision, and audio tasks.
      - Low barrier to entry for educators and practitioners.
      - Few user-facing abstractions with just three classes to learn.
      - A unified API for using all our pretrained models.

  1. Lower compute costs, smaller carbon footprint:
      - Researchers can share trained models instead of always retraining.
      - Practitioners can reduce compute time and production costs.
      - Dozens of architectures with over 60,000 pretrained models across all modalities.

  1. Choose the right framework for every part of a model's lifetime:
      - Train state-of-the-art models in 3 lines of code.
      - Move a single model between TF2.0/PyTorch/JAX frameworks at will.
      - Seamlessly pick the right framework for training, evaluation and production.

  1. Easily customize a model or an example to your needs:
      - We provide examples for each architecture to reproduce the results published by its original authors.
      - Model internals are exposed as consistently as possible.
      - Model files can be used independently of the library for quick experiments.



  - This library is not a modular toolbox of building blocks for neural nets. The code in the model files is not refactored with additional abstractions on purpose, so that researchers can quickly iterate on each of the models without diving into additional abstractions/files.
  - The training API is not intended to work on any model but is optimized to work with the models provided by the library. For generic machine learning loops, you should use another library (possibly, [Accelerate](https://huggingface.co/docs/accelerate)).
  - While we strive to present as many use cases as possible, the scripts in our [examples folder](https://github.com/huggingface/transformers/tree/main/examples) are just that: examples. It is expected that they won't work out-of-the box on your specific problem and that you will be required to change a few lines of code to adapt them to your needs.





  This repository is tested on Python 3.6+, Flax 0.3.2+, PyTorch 1.3.1+ and TensorFlow 2.3+.

  You should install 🤗 Transformers in a [virtual environment](https://docs.python.org/3/library/venv.html). If you're unfamiliar with Python virtual environments, check out the [user guide](https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/).

  First, create a virtual environment with the version of Python you're going to use and activate it.

  Then, you will need to install at least one of Flax, PyTorch or TensorFlow.
  Please refer to [TensorFlow installation page](https://www.tensorflow.org/install/), [PyTorch installation page](https://pytorch.org/get-started/locally/#start-locally) and/or [Flax](https://github.com/google/flax#quick-install) and [Jax](https://github.com/google/jax#installation) installation pages regarding the specific installation command for your platform.

  When one of those backends has been installed, 🤗 Transformers can be installed using pip as follows:

  ```bash
  pip install transformers
  ```

  If you'd like to play with the examples or need the bleeding edge of the code and can't wait for a new release, you must [install the library from source](https://huggingface.co/docs/transformers/installation#installing-from-source).



  Since Transformers version v4.0.0, we now have a conda channel: `huggingface`.

  🤗 Transformers can be installed using conda as follows:

  ```shell script
  conda install -c huggingface transformers
  ```

  Follow the installation pages of Flax, PyTorch or TensorFlow to see how to install them with conda.

  > **_NOTE:_**  On Windows, you may be prompted to activate Developer Mode in order to benefit from caching. If this is not an option for you, please let us know in [this issue](https://github.com/huggingface/huggingface_hub/issues/1062).



  **[All the model checkpoints](https://huggingface.co/models)** provided by 🤗 Transformers are seamlessly integrated from the huggingface.co [model hub](https://huggingface.co/models) where they are uploaded directly by [users](https://huggingface.co/users) and [organizations](https://huggingface.co/organizations).

  Current number of checkpoints: ![](https://img.shields.io/endpoint?url=https://huggingface.co/api/shields/models&color=brightgreen)

  🤗 Transformers currently provides the following architectures (see [here](https://huggingface.co/docs/transformers/model_summary) for a high-level summary of each them):

  1. **[ALBERT](https://huggingface.co/docs/transformers/model_doc/albert)** (from Google Research and the Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut.
  1. **[ALIGN](https://huggingface.co/docs/transformers/model_doc/align)** (from Google Research) released with the paper [Scaling Up Visual and Vision-Language Representation Learning With Noisy Text Supervision](https://arxiv.org/abs/2102.05918) by Chao Jia, Yinfei Yang, Ye Xia, Yi-Ting Chen, Zarana Parekh, Hieu Pham, Quoc V. Le, Yunhsuan Sung, Zhen Li, Tom Duerig.
  1. **[AltCLIP](https://huggingface.co/docs/transformers/model_doc/altclip)** (from BAAI) released with the paper [AltCLIP: Altering the Language Encoder in CLIP for Extended Language Capabilities](https://arxiv.org/abs/2211.06679) by Chen, Zhongzhi and Liu, Guang and Zhang, Bo-Wen and Ye, Fulong and Yang, Qinghong and Wu, Ledell.
  1. **[Audio Spectrogram Transformer](https://huggingface.co/docs/transformers/model_doc/audio-spectrogram-transformer)** (from MIT) released with the paper [AST: Audio Spectrogram Transformer](https://arxiv.org/abs/2104.01778) by Yuan Gong, Yu-An Chung, James Glass.
  1. **[BART](https://huggingface.co/docs/transformers/model_doc/bart)** (from Facebook) released with the paper [BART: Denoising Sequence-to-Sequence Pre-training for Natural Language Generation, Translation, and Comprehension](https://arxiv.org/abs/1910.13461) by Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Ves Stoyanov and Luke Zettlemoyer.
  1. **[BARThez](https://huggingface.co/docs/transformers/model_doc/barthez)** (from École polytechnique) released with the paper [BARThez: a Skilled Pretrained French Sequence-to-Sequence Model](https://arxiv.org/abs/2010.12321) by Moussa Kamal Eddine, Antoine J.-P. Tixier, Michalis Vazirgiannis.
  1. **[BARTpho](https://huggingface.co/docs/transformers/model_doc/bartpho)** (from VinAI Research) released with the paper [BARTpho: Pre-trained Sequence-to-Sequence Models for Vietnamese](https://arxiv.org/abs/2109.09701) by Nguyen Luong Tran, Duong Minh Le and Dat Quoc Nguyen.
  1. **[BEiT](https://huggingface.co/docs/transformers/model_doc/beit)** (from Microsoft) released with the paper [BEiT: BERT Pre-Training of Image Transformers](https://arxiv.org/abs/2106.08254) by Hangbo Bao, Li Dong, Furu Wei.
  1. **[BERT](https://huggingface.co/docs/transformers/model_doc/bert)** (from Google) released with the paper [BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding](https://arxiv.org/abs/1810.04805) by Jacob Devlin, Ming-Wei Chang, Kenton Lee and Kristina Toutanova.
  1. **[BERT For Sequence Generation](https://huggingface.co/docs/transformers/model_doc/bert-generation)** (from Google) released with the paper [Leveraging Pre-trained Checkpoints for Sequence Generation Tasks](https://arxiv.org/abs/1907.12461) by Sascha Rothe, Shashi Narayan, Aliaksei Severyn.
  1. **[BERTweet](https://huggingface.co/docs/transformers/model_doc/bertweet)** (from VinAI Research) released with the paper [BERTweet: A pre-trained language model for English Tweets](https://aclanthology.org/2020.emnlp-demos.2/) by Dat Quoc Nguyen, Thanh Vu and Anh Tuan Nguyen.
  1. **[BigBird-Pegasus](https://huggingface.co/docs/transformers/model_doc/bigbird_pegasus)** (from Google Research) released with the paper [Big Bird: Transformers for Longer Sequences](https://arxiv.org/abs/2007.14062) by Manzil Zaheer, Guru Guruganesh, Avinava Dubey, Joshua Ainslie, Chris Alberti, Santiago Ontanon, Philip Pham, Anirudh Ravula, Qifan Wang, Li Yang, Amr Ahmed.
  1. **[BigBird-RoBERTa](https://huggingface.co/docs/transformers/model_doc/big_bird)** (from Google Research) released with the paper [Big Bird: Transformers for Longer Sequences](https://arxiv.org/abs/2007.14062) by Manzil Zaheer, Guru Guruganesh, Avinava Dubey, Joshua Ainslie, Chris Alberti, Santiago Ontanon, Philip Pham, Anirudh Ravula, Qifan Wang, Li Yang, Amr Ahmed.
  1. **[BioGpt](https://huggingface.co/docs/transformers/model_doc/biogpt)** (from Microsoft Research AI4Science) released with the paper [BioGPT: generative pre-trained transformer for biomedical text generation and mining](https://academic.oup.com/bib/advance-article/doi/10.1093/bib/bbac409/6713511?guestAccessKey=a66d9b5d-4f83-4017-bb52-405815c907b9) by Renqian Luo, Liai Sun, Yingce Xia, Tao Qin, Sheng Zhang, Hoifung Poon and Tie-Yan Liu.
  1. **[BiT](https://huggingface.co/docs/transformers/model_doc/bit)** (from Google AI) released with the paper [Big Transfer (BiT): General Visual Representation Learning](https://arxiv.org/abs/1912.11370) by Alexander Kolesnikov, Lucas Beyer, Xiaohua Zhai, Joan Puigcerver, Jessica Yung, Sylvain Gelly, Neil Houlsby.
  1. **[Blenderbot](https://huggingface.co/docs/transformers/model_doc/blenderbot)** (from Facebook) released with the paper [Recipes for building an open-domain chatbot](https://arxiv.org/abs/2004.13637) by Stephen Roller, Emily Dinan, Naman Goyal, Da Ju, Mary Williamson, Yinhan Liu, Jing Xu, Myle Ott, Kurt Shuster, Eric M. Smith, Y-Lan Boureau, Jason Weston.
  1. **[BlenderbotSmall](https://huggingface.co/docs/transformers/model_doc/blenderbot-small)** (from Facebook) released with the paper [Recipes for building an open-domain chatbot](https://arxiv.org/abs/2004.13637) by Stephen Roller, Emily Dinan, Naman Goyal, Da Ju, Mary Williamson, Yinhan Liu, Jing Xu, Myle Ott, Kurt Shuster, Eric M. Smith, Y-Lan Boureau, Jason Weston.
  1. **[BLIP](https://huggingface.co/docs/transformers/model_doc/blip)** (from Salesforce) released with the paper [BLIP: Bootstrapping Language-Image Pre-training for Unified Vision-Language Understanding and Generation](https://arxiv.org/abs/2201.12086) by Junnan Li, Dongxu Li, Caiming Xiong, Steven Hoi.
  1. **[BLIP-2](https://huggingface.co/docs/transformers/model_doc/blip-2)** (from Salesforce) released with the paper [BLIP-2: Bootstrapping Language-Image Pre-training with Frozen Image Encoders and Large Language Models](https://arxiv.org/abs/2301.12597) by Junnan Li, Dongxu Li, Silvio Savarese, Steven Hoi.
  1. **[BLOOM](https://huggingface.co/docs/transformers/model_doc/bloom)** (from BigScience workshop) released by the [BigScience Workshop](https://bigscience.huggingface.co/).
  1. **[BORT](https://huggingface.co/docs/transformers/model_doc/bort)** (from Alexa) released with the paper [Optimal Subarchitecture Extraction For BERT](https://arxiv.org/abs/2010.10499) by Adrian de Wynter and Daniel J. Perry.
  1. **[BridgeTower](https://huggingface.co/docs/transformers/model_doc/bridgetower)** (from Harbin Institute of Technology/Microsoft Research Asia/Intel Labs) released with the paper [BridgeTower: Building Bridges Between Encoders in Vision-Language Representation Learning](https://arxiv.org/abs/2206.08657) by Xiao Xu, Chenfei Wu, Shachar Rosenman, Vasudev Lal, Wanxiang Che, Nan Duan.
  1. **[ByT5](https://huggingface.co/docs/transformers/model_doc/byt5)** (from Google Research) released with the paper [ByT5: Towards a token-free future with pre-trained byte-to-byte models](https://arxiv.org/abs/2105.13626) by Linting Xue, Aditya Barua, Noah Constant, Rami Al-Rfou, Sharan Narang, Mihir Kale, Adam Roberts, Colin Raffel.
  1. **[CamemBERT](https://huggingface.co/docs/transformers/model_doc/camembert)** (from Inria/Facebook/Sorbonne) released with the paper [CamemBERT: a Tasty French Language Model](https://arxiv.org/abs/1911.03894) by Louis Martin*, Benjamin Muller*, Pedro Javier Ortiz Suárez*, Yoann Dupont, Laurent Romary, Éric Villemonte de la Clergerie, Djamé Seddah and Benoît Sagot.
  1. **[CANINE](https://huggingface.co/docs/transformers/model_doc/canine)** (from Google Research) released with the paper [CANINE: Pre-training an Efficient Tokenization-Free Encoder for Language Representation](https://arxiv.org/abs/2103.06874) by Jonathan H. Clark, Dan Garrette, Iulia Turc, John Wieting.
  1. **[Chinese-CLIP](https://huggingface.co/docs/transformers/model_doc/chinese_clip)** (from OFA-Sys) released with the paper [Chinese CLIP: Contrastive Vision-Language Pretraining in Chinese](https://arxiv.org/abs/2211.01335) by An Yang, Junshu Pan, Junyang Lin, Rui Men, Yichang Zhang, Jingren Zhou, Chang Zhou.
  1. **[CLAP](https://huggingface.co/docs/transformers/model_doc/clap)** (from LAION-AI) released with the paper [Large-scale Contrastive Language-Audio Pretraining with Feature Fusion and Keyword-to-Caption Augmentation]https://arxiv.org/abs/2211.06687) by Yusong Wu, Ke Chen, Tianyu Zhang, Yuchen Hui, Taylor Berg-Kirkpatrick, Shlomo Dubnov.
  1. **[CLIP](https://huggingface.co/docs/transformers/model_doc/clip)** (from OpenAI) released with the paper [Learning Transferable Visual Models From Natural Language Supervision](https://arxiv.org/abs/2103.00020) by Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, Gretchen Krueger, Ilya Sutskever.
  1. **[CLIPSeg](https://huggingface.co/docs/transformers/model_doc/clipseg)** (from University of Göttingen) released with the paper [Image Segmentation Using Text and Image Prompts](https://arxiv.org/abs/2112.10003) by Timo Lüddecke and Alexander Ecker.
  1. **[CodeGen](https://huggingface.co/docs/transformers/model_doc/codegen)** (from Salesforce) released with the paper [A Conversational Paradigm for Program Synthesis](https://arxiv.org/abs/2203.13474) by Erik Nijkamp, Bo Pang, Hiroaki Hayashi, Lifu Tu, Huan Wang, Yingbo Zhou, Silvio Savarese, Caiming Xiong.
  1. **[Conditional DETR](https://huggingface.co/docs/transformers/model_doc/conditional_detr)** (from Microsoft Research Asia) released with the paper [Conditional DETR for Fast Training Convergence](https://arxiv.org/abs/2108.06152) by Depu Meng, Xiaokang Chen, Zejia Fan, Gang Zeng, Houqiang Li, Yuhui Yuan, Lei Sun, Jingdong Wang.
  1. **[ConvBERT](https://huggingface.co/docs/transformers/model_doc/convbert)** (from YituTech) released with the paper [ConvBERT: Improving BERT with Span-based Dynamic Convolution](https://arxiv.org/abs/2008.02496) by Zihang Jiang, Weihao Yu, Daquan Zhou, Yunpeng Chen, Jiashi Feng, Shuicheng Yan.
  1. **[ConvNeXT](https://huggingface.co/docs/transformers/model_doc/convnext)** (from Facebook AI) released with the paper [A ConvNet for the 2020s](https://arxiv.org/abs/2201.03545) by Zhuang Liu, Hanzi Mao, Chao-Yuan Wu, Christoph Feichtenhofer, Trevor Darrell, Saining Xie.
  1. **[ConvNeXTV2](https://huggingface.co/docs/transformers/model_doc/convnextv2)** (from Facebook AI) released with the paper [ConvNeXt V2: Co-designing and Scaling ConvNets with Masked Autoencoders](https://arxiv.org/abs/2301.00808) by Sanghyun Woo, Shoubhik Debnath, Ronghang Hu, Xinlei Chen, Zhuang Liu, In So Kweon, Saining Xie.
  1. **[CPM](https://huggingface.co/docs/transformers/model_doc/cpm)** (from Tsinghua University) released with the paper [CPM: A Large-scale Generative Chinese Pre-trained Language Model](https://arxiv.org/abs/2012.00413) by Zhengyan Zhang, Xu Han, Hao Zhou, Pei Ke, Yuxian Gu, Deming Ye, Yujia Qin, Yusheng Su, Haozhe Ji, Jian Guan, Fanchao Qi, Xiaozhi Wang, Yanan Zheng, Guoyang Zeng, Huanqi Cao, Shengqi Chen, Daixuan Li, Zhenbo Sun, Zhiyuan Liu, Minlie Huang, Wentao Han, Jie Tang, Juanzi Li, Xiaoyan Zhu, Maosong Sun.
  1. **[CTRL](https://huggingface.co/docs/transformers/model_doc/ctrl)** (from Salesforce) released with the paper [CTRL: A Conditional Transformer Language Model for Controllable Generation](https://arxiv.org/abs/1909.05858) by Nitish Shirish Keskar*, Bryan McCann*, Lav R. Varshney, Caiming Xiong and Richard Socher.
  1. **[CvT](https://huggingface.co/docs/transformers/model_doc/cvt)** (from Microsoft) released with the paper [CvT: Introducing Convolutions to Vision Transformers](https://arxiv.org/abs/2103.15808) by Haiping Wu, Bin Xiao, Noel Codella, Mengchen Liu, Xiyang Dai, Lu Yuan, Lei Zhang.
  1. **[Data2Vec](https://huggingface.co/docs/transformers/model_doc/data2vec)** (from Facebook) released with the paper [Data2Vec:  A General Framework for Self-supervised Learning in Speech, Vision and Language](https://arxiv.org/abs/2202.03555) by Alexei Baevski, Wei-Ning Hsu, Qiantong Xu, Arun Babu, Jiatao Gu, Michael Auli.
  1. **[DeBERTa](https://huggingface.co/docs/transformers/model_doc/deberta)** (from Microsoft) released with the paper [DeBERTa: Decoding-enhanced BERT with Disentangled Attention](https://arxiv.org/abs/2006.03654) by Pengcheng He, Xiaodong Liu, Jianfeng Gao, Weizhu Chen.
  1. **[DeBERTa-v2](https://huggingface.co/docs/transformers/model_doc/deberta-v2)** (from Microsoft) released with the paper [DeBERTa: Decoding-enhanced BERT with Disentangled Attention](https://arxiv.org/abs/2006.03654) by Pengcheng He, Xiaodong Liu, Jianfeng Gao, Weizhu Chen.
  1. **[Decision Transformer](https://huggingface.co/docs/transformers/model_doc/decision_transformer)** (from Berkeley/Facebook/Google) released with the paper [Decision Transformer: Reinforcement Learning via Sequence Modeling](https://arxiv.org/abs/2106.01345) by Lili Chen, Kevin Lu, Aravind Rajeswaran, Kimin Lee, Aditya Grover, Michael Laskin, Pieter Abbeel, Aravind Srinivas, Igor Mordatch.
  1. **[Deformable DETR](https://huggingface.co/docs/transformers/model_doc/deformable_detr)** (from SenseTime Research) released with the paper [Deformable DETR: Deformable Transformers for End-to-End Object Detection](https://arxiv.org/abs/2010.04159) by Xizhou Zhu, Weijie Su, Lewei Lu, Bin Li, Xiaogang Wang, Jifeng Dai.
  1. **[DeiT](https://huggingface.co/docs/transformers/model_doc/deit)** (from Facebook) released with the paper [Training data-efficient image transformers & distillation through attention](https://arxiv.org/abs/2012.12877) by Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre Sablayrolles, Hervé Jégou.
  1. **[DETA](https://huggingface.co/docs/transformers/model_doc/deta)** (from The University of Texas at Austin) released with the paper [NMS Strikes Back](https://arxiv.org/abs/2212.06137) by Jeffrey Ouyang-Zhang, Jang Hyun Cho, Xingyi Zhou, Philipp Krähenbühl.
  1. **[DETR](https://huggingface.co/docs/transformers/model_doc/detr)** (from Facebook) released with the paper [End-to-End Object Detection with Transformers](https://arxiv.org/abs/2005.12872) by Nicolas Carion, Francisco Massa, Gabriel Synnaeve, Nicolas Usunier, Alexander Kirillov, Sergey Zagoruyko.
  1. **[DialoGPT](https://huggingface.co/docs/transformers/model_doc/dialogpt)** (from Microsoft Research) released with the paper [DialoGPT: Large-Scale Generative Pre-training for Conversational Response Generation](https://arxiv.org/abs/1911.00536) by Yizhe Zhang, Siqi Sun, Michel Galley, Yen-Chun Chen, Chris Brockett, Xiang Gao, Jianfeng Gao, Jingjing Liu, Bill Dolan.
  1. **[DiNAT](https://huggingface.co/docs/transformers/model_doc/dinat)** (from SHI Labs) released with the paper [Dilated Neighborhood Attention Transformer](https://arxiv.org/abs/2209.15001) by Ali Hassani and Humphrey Shi.
  1. **[DistilBERT](https://huggingface.co/docs/transformers/model_doc/distilbert)** (from HuggingFace), released together with the paper [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and lighter](https://arxiv.org/abs/1910.01108) by Victor Sanh, Lysandre Debut and Thomas Wolf. The same method has been applied to compress GPT2 into [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/research_projects/distillation), RoBERTa into [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/research_projects/distillation), Multilingual BERT into [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/research_projects/distillation) and a German version of DistilBERT.
  1. **[DiT](https://huggingface.co/docs/transformers/model_doc/dit)** (from Microsoft Research) released with the paper [DiT: Self-supervised Pre-training for Document Image Transformer](https://arxiv.org/abs/2203.02378) by Junlong Li, Yiheng Xu, Tengchao Lv, Lei Cui, Cha Zhang, Furu Wei.
  1. **[Donut](https://huggingface.co/docs/transformers/model_doc/donut)** (from NAVER), released together with the paper [OCR-free Document Understanding Transformer](https://arxiv.org/abs/2111.15664) by Geewook Kim, Teakgyu Hong, Moonbin Yim, Jeongyeon Nam, Jinyoung Park, Jinyeong Yim, Wonseok Hwang, Sangdoo Yun, Dongyoon Han, Seunghyun Park.
  1. **[DPR](https://huggingface.co/docs/transformers/model_doc/dpr)** (from Facebook) released with the paper [Dense Passage Retrieval for Open-Domain Question Answering](https://arxiv.org/abs/2004.04906) by Vladimir Karpukhin, Barlas Oğuz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, and Wen-tau Yih.
  1. **[DPT](https://huggingface.co/docs/transformers/master/model_doc/dpt)** (from Intel Labs) released with the paper [Vision Transformers for Dense Prediction](https://arxiv.org/abs/2103.13413) by René Ranftl, Alexey Bochkovskiy, Vladlen Koltun.
  1. **[EfficientFormer](https://huggingface.co/docs/transformers/model_doc/efficientformer)** (from Snap Research) released with the paper [EfficientFormer: Vision Transformers at MobileNetSpeed](https://arxiv.org/abs/2206.01191) by Yanyu Li, Geng Yuan, Yang Wen, Ju Hu, Georgios Evangelidis, Sergey Tulyakov, Yanzhi Wang, Jian Ren.
  1. **[EfficientNet](https://huggingface.co/docs/transformers/model_doc/efficientnet)** (from Google Brain) released with the paper [EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks](https://arxiv.org/abs/1905.11946) by Mingxing Tan, Quoc V. Le.
  1. **[ELECTRA](https://huggingface.co/docs/transformers/model_doc/electra)** (from Google Research/Stanford University) released with the paper [ELECTRA: Pre-training text encoders as discriminators rather than generators](https://arxiv.org/abs/2003.10555) by Kevin Clark, Minh-Thang Luong, Quoc V. Le, Christopher D. Manning.
  1. **[EncoderDecoder](https://huggingface.co/docs/transformers/model_doc/encoder-decoder)** (from Google Research) released with the paper [Leveraging Pre-trained Checkpoints for Sequence Generation Tasks](https://arxiv.org/abs/1907.12461) by Sascha Rothe, Shashi Narayan, Aliaksei Severyn.
  1. **[ERNIE](https://huggingface.co/docs/transformers/model_doc/ernie)** (from Baidu) released with the paper [ERNIE: Enhanced Representation through Knowledge Integration](https://arxiv.org/abs/1904.09223) by Yu Sun, Shuohuan Wang, Yukun Li, Shikun Feng, Xuyi Chen, Han Zhang, Xin Tian, Danxiang Zhu, Hao Tian, Hua Wu.
  1. **[ErnieM](https://huggingface.co/docs/transformers/model_doc/ernie_m)** (from Baidu) released with the paper [ERNIE-M: Enhanced Multilingual Representation by Aligning Cross-lingual Semantics with Monolingual Corpora](https://arxiv.org/abs/2012.15674) by Xuan Ouyang, Shuohuan Wang, Chao Pang, Yu Sun, Hao Tian, Hua Wu, Haifeng Wang.
  1. **[ESM](https://huggingface.co/docs/transformers/model_doc/esm)** (from Meta AI) are transformer protein language models.  **ESM-1b** was released with the paper [Biological structure and function emerge from scaling unsupervised learning to 250 million protein sequences](https://www.pnas.org/content/118/15/e2016239118) by Alexander Rives, Joshua Meier, Tom Sercu, Siddharth Goyal, Zeming Lin, Jason Liu, Demi Guo, Myle Ott, C. Lawrence Zitnick, Jerry Ma, and Rob Fergus. **ESM-1v** was released with the paper [Language models enable zero-shot prediction of the effects of mutations on protein function](https://doi.org/10.1101/2021.07.09.450648) by Joshua Meier, Roshan Rao, Robert Verkuil, Jason Liu, Tom Sercu and Alexander Rives. **ESM-2 and ESMFold** were released with the paper [Language models of protein sequences at the scale of evolution enable accurate structure prediction](https://doi.org/10.1101/2022.07.20.500902) by Zeming Lin, Halil Akin, Roshan Rao, Brian Hie, Zhongkai Zhu, Wenting Lu, Allan dos Santos Costa, Maryam Fazel-Zarandi, Tom Sercu, Sal Candido, Alexander Rives.
  1. **[FLAN-T5](https://huggingface.co/docs/transformers/model_doc/flan-t5)** (from Google AI) released in the repository [google-research/t5x](https://github.com/google-research/t5x/blob/main/docs/models.md#flan-t5-checkpoints) by Hyung Won Chung, Le Hou, Shayne Longpre, Barret Zoph, Yi Tay, William Fedus, Eric Li, Xuezhi Wang, Mostafa Dehghani, Siddhartha Brahma, Albert Webson, Shixiang Shane Gu, Zhuyun Dai, Mirac Suzgun, Xinyun Chen, Aakanksha Chowdhery, Sharan Narang, Gaurav Mishra, Adams Yu, Vincent Zhao, Yanping Huang, Andrew Dai, Hongkun Yu, Slav Petrov, Ed H. Chi, Jeff Dean, Jacob Devlin, Adam Roberts, Denny Zhou, Quoc V. Le, and Jason Wei
  1. **[FLAN-UL2](https://huggingface.co/docs/transformers/model_doc/flan-ul2)** (from Google AI) released in the repository [google-research/t5x](https://github.com/google-research/t5x/blob/main/docs/models.md#flan-ul2-checkpoints) by Hyung Won Chung, Le Hou, Shayne Longpre, Barret Zoph, Yi Tay, William Fedus, Eric Li, Xuezhi Wang, Mostafa Dehghani, Siddhartha Brahma, Albert Webson, Shixiang Shane Gu, Zhuyun Dai, Mirac Suzgun, Xinyun Chen, Aakanksha Chowdhery, Sharan Narang, Gaurav Mishra, Adams Yu, Vincent Zhao, Yanping Huang, Andrew Dai, Hongkun Yu, Slav Petrov, Ed H. Chi, Jeff Dean, Jacob Devlin, Adam Roberts, Denny Zhou, Quoc V. Le, and Jason Wei
  1. **[FlauBERT](https://huggingface.co/docs/transformers/model_doc/flaubert)** (from CNRS) released with the paper [FlauBERT: Unsupervised Language Model Pre-training for French](https://arxiv.org/abs/1912.05372) by Hang Le, Loïc Vial, Jibril Frej, Vincent Segonne, Maximin Coavoux, Benjamin Lecouteux, Alexandre Allauzen, Benoît Crabbé, Laurent Besacier, Didier Schwab.
  1. **[FLAVA](https://huggingface.co/docs/transformers/model_doc/flava)** (from Facebook AI) released with the paper [FLAVA: A Foundational Language And Vision Alignment Model](https://arxiv.org/abs/2112.04482) by Amanpreet Singh, Ronghang Hu, Vedanuj Goswami, Guillaume Couairon, Wojciech Galuba, Marcus Rohrbach, and Douwe Kiela.
  1. **[FNet](https://huggingface.co/docs/transformers/model_doc/fnet)** (from Google Research) released with the paper [FNet: Mixing Tokens with Fourier Transforms](https://arxiv.org/abs/2105.03824) by James Lee-Thorp, Joshua Ainslie, Ilya Eckstein, Santiago Ontanon.
  1. **[Funnel Transformer](https://huggingface.co/docs/transformers/model_doc/funnel)** (from CMU/Google Brain) released with the paper [Funnel-Transformer: Filtering out Sequential Redundancy for Efficient Language Processing](https://arxiv.org/abs/2006.03236) by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le.
  1. **[GIT](https://huggingface.co/docs/transformers/model_doc/git)** (from Microsoft Research) released with the paper [GIT: A Generative Image-to-text Transformer for Vision and Language](https://arxiv.org/abs/2205.14100) by Jianfeng Wang, Zhengyuan Yang, Xiaowei Hu, Linjie Li, Kevin Lin, Zhe Gan, Zicheng Liu, Ce Liu, Lijuan Wang.
  1. **[GLPN](https://huggingface.co/docs/transformers/model_doc/glpn)** (from KAIST) released with the paper [Global-Local Path Networks for Monocular Depth Estimation with Vertical CutDepth](https://arxiv.org/abs/2201.07436) by Doyeon Kim, Woonghyun Ga, Pyungwhan Ahn, Donggyu Joo, Sehwan Chun, Junmo Kim.
  1. **[GPT](https://huggingface.co/docs/transformers/model_doc/openai-gpt)** (from OpenAI) released with the paper [Improving Language Understanding by Generative Pre-Training](https://blog.openai.com/language-unsupervised/) by Alec Radford, Karthik Narasimhan, Tim Salimans and Ilya Sutskever.
  1. **[GPT Neo](https://huggingface.co/docs/transformers/model_doc/gpt_neo)** (from EleutherAI) released in the repository [EleutherAI/gpt-neo](https://github.com/EleutherAI/gpt-neo) by Sid Black, Stella Biderman, Leo Gao, Phil Wang and Connor Leahy.
  1. **[GPT NeoX](https://huggingface.co/docs/transformers/model_doc/gpt_neox)** (from EleutherAI) released with the paper [GPT-NeoX-20B: An Open-Source Autoregressive Language Model](https://arxiv.org/abs/2204.06745) by Sid Black, Stella Biderman, Eric Hallahan, Quentin Anthony, Leo Gao, Laurence Golding, Horace He, Connor Leahy, Kyle McDonell, Jason Phang, Michael Pieler, USVSN Sai Prashanth, Shivanshu Purohit, Laria Reynolds, Jonathan Tow, Ben Wang, Samuel Weinbach
  1. **[GPT NeoX Japanese](https://huggingface.co/docs/transformers/model_doc/gpt_neox_japanese)** (from ABEJA) released by Shinya Otani, Takayoshi Makabe, Anuj Arora, and Kyo Hattori.
  1. **[GPT-2](https://huggingface.co/docs/transformers/model_doc/gpt2)** (from OpenAI) released with the paper [Language Models are Unsupervised Multitask Learners](https://blog.openai.com/better-language-models/) by Alec Radford*, Jeffrey Wu*, Rewon Child, David Luan, Dario Amodei** and Ilya Sutskever**.
  1. **[GPT-J](https://huggingface.co/docs/transformers/model_doc/gptj)** (from EleutherAI) released in the repository [kingoflolz/mesh-transformer-jax](https://github.com/kingoflolz/mesh-transformer-jax/) by Ben Wang and Aran Komatsuzaki.
  1. **[GPT-Sw3](https://huggingface.co/docs/transformers/model_doc/gpt-sw3)** (from AI-Sweden) released with the paper [Lessons Learned from GPT-SW3: Building the First Large-Scale Generative Language Model for Swedish](http://www.lrec-conf.org/proceedings/lrec2022/pdf/2022.lrec-1.376.pdf) by Ariel Ekgren, Amaru Cuba Gyllensten, Evangelia Gogoulou, Alice Heiman, Severine Verlinden, Joey Öhman, Fredrik Carlsson, Magnus Sahlgren.
  1. **[GPTSAN-japanese](https://huggingface.co/docs/transformers/model_doc/gptsan-japanese)** released in the repository [tanreinama/GPTSAN](https://github.com/tanreinama/GPTSAN/blob/main/report/model.md) by Toshiyuki Sakamoto(tanreinama).
  1. **[Graphormer](https://huggingface.co/docs/transformers/model_doc/graphormer)** (from Microsoft) released with the paper [Do Transformers Really Perform Bad for Graph Representation?](https://arxiv.org/abs/2106.05234) by Chengxuan Ying, Tianle Cai, Shengjie Luo, Shuxin Zheng, Guolin Ke, Di He, Yanming Shen, Tie-Yan Liu.
  1. **[GroupViT](https://huggingface.co/docs/transformers/model_doc/groupvit)** (from UCSD, NVIDIA) released with the paper [GroupViT: Semantic Segmentation Emerges from Text Supervision](https://arxiv.org/abs/2202.11094) by Jiarui Xu, Shalini De Mello, Sifei Liu, Wonmin Byeon, Thomas Breuel, Jan Kautz, Xiaolong Wang.
  1. **[Hubert](https://huggingface.co/docs/transformers/model_doc/hubert)** (from Facebook) released with the paper [HuBERT: Self-Supervised Speech Representation Learning by Masked Prediction of Hidden Units](https://arxiv.org/abs/2106.07447) by Wei-Ning Hsu, Benjamin Bolte, Yao-Hung Hubert Tsai, Kushal Lakhotia, Ruslan Salakhutdinov, Abdelrahman Mohamed.
  1. **[I-BERT](https://huggingface.co/docs/transformers/model_doc/ibert)** (from Berkeley) released with the paper [I-BERT: Integer-only BERT Quantization](https://arxiv.org/abs/2101.01321) by Sehoon Kim, Amir Gholami, Zhewei Yao, Michael W. Mahoney, Kurt Keutzer.
  1. **[ImageGPT](https://huggingface.co/docs/transformers/model_doc/imagegpt)** (from OpenAI) released with the paper [Generative Pretraining from Pixels](https://openai.com/blog/image-gpt/) by Mark Chen, Alec Radford, Rewon Child, Jeffrey Wu, Heewoo Jun, David Luan, Ilya Sutskever.
  1. **[Informer](https://huggingface.co/docs/transformers/model_doc/informer)** (from Beihang University, UC Berkeley, Rutgers University, SEDD Company) released with the paper [Informer: Beyond Efficient Transformer for Long Sequence Time-Series Forecasting](https://arxiv.org/abs/2012.07436) by Haoyi Zhou, Shanghang Zhang, Jieqi Peng, Shuai Zhang, Jianxin Li, Hui Xiong, and Wancai Zhang.
  1. **[Jukebox](https://huggingface.co/docs/transformers/model_doc/jukebox)** (from OpenAI) released with the paper [Jukebox: A Generative Model for Music](https://arxiv.org/pdf/2005.00341.pdf) by Prafulla Dhariwal, Heewoo Jun, Christine Payne, Jong Wook Kim, Alec Radford, Ilya Sutskever.
  1. **[LayoutLM](https://huggingface.co/docs/transformers/model_doc/layoutlm)** (from Microsoft Research Asia) released with the paper [LayoutLM: Pre-training of Text and Layout for Document Image Understanding](https://arxiv.org/abs/1912.13318) by Yiheng Xu, Minghao Li, Lei Cui, Shaohan Huang, Furu Wei, Ming Zhou.
  1. **[LayoutLMv2](https://huggingface.co/docs/transformers/model_doc/layoutlmv2)** (from Microsoft Research Asia) released with the paper [LayoutLMv2: Multi-modal Pre-training for Visually-Rich Document Understanding](https://arxiv.org/abs/2012.14740) by Yang Xu, Yiheng Xu, Tengchao Lv, Lei Cui, Furu Wei, Guoxin Wang, Yijuan Lu, Dinei Florencio, Cha Zhang, Wanxiang Che, Min Zhang, Lidong Zhou.
  1. **[LayoutLMv3](https://huggingface.co/docs/transformers/model_doc/layoutlmv3)** (from Microsoft Research Asia) released with the paper [LayoutLMv3: Pre-training for Document AI with Unified Text and Image Masking](https://arxiv.org/abs/2204.08387) by Yupan Huang, Tengchao Lv, Lei Cui, Yutong Lu, Furu Wei.
  1. **[LayoutXLM](https://huggingface.co/docs/transformers/model_doc/layoutxlm)** (from Microsoft Research Asia) released with the paper [LayoutXLM: Multimodal Pre-training for Multilingual Visually-rich Document Understanding](https://arxiv.org/abs/2104.08836) by Yiheng Xu, Tengchao Lv, Lei Cui, Guoxin Wang, Yijuan Lu, Dinei Florencio, Cha Zhang, Furu Wei.
  1. **[LED](https://huggingface.co/docs/transformers/model_doc/led)** (from AllenAI) released with the paper [Longformer: The Long-Document Transformer](https://arxiv.org/abs/2004.05150) by Iz Beltagy, Matthew E. Peters, Arman Cohan.
  1. **[LeViT](https://huggingface.co/docs/transformers/model_doc/levit)** (from Meta AI) released with the paper [LeViT: A Vision Transformer in ConvNet's Clothing for Faster Inference](https://arxiv.org/abs/2104.01136) by Ben Graham, Alaaeldin El-Nouby, Hugo Touvron, Pierre Stock, Armand Joulin, Hervé Jégou, Matthijs Douze.
  1. **[LiLT](https://huggingface.co/docs/transformers/model_doc/lilt)** (from South China University of Technology) released with the paper [LiLT: A Simple yet Effective Language-Independent Layout Transformer for Structured Document Understanding](https://arxiv.org/abs/2202.13669) by Jiapeng Wang, Lianwen Jin, Kai Ding.
  1. **[Longformer](https://huggingface.co/docs/transformers/model_doc/longformer)** (from AllenAI) released with the paper [Longformer: The Long-Document Transformer](https://arxiv.org/abs/2004.05150) by Iz Beltagy, Matthew E. Peters, Arman Cohan.
  1. **[LongT5](https://huggingface.co/docs/transformers/model_doc/longt5)** (from Google AI) released with the paper [LongT5: Efficient Text-To-Text Transformer for Long Sequences](https://arxiv.org/abs/2112.07916) by Mandy Guo, Joshua Ainslie, David Uthus, Santiago Ontanon, Jianmo Ni, Yun-Hsuan Sung, Yinfei Yang.
  1. **[LUKE](https://huggingface.co/docs/transformers/model_doc/luke)** (from Studio Ousia) released with the paper [LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention](https://arxiv.org/abs/2010.01057) by Ikuya Yamada, Akari Asai, Hiroyuki Shindo, Hideaki Takeda, Yuji Matsumoto.
  1. **[LXMERT](https://huggingface.co/docs/transformers/model_doc/lxmert)** (from UNC Chapel Hill) released with the paper [LXMERT: Learning Cross-Modality Encoder Representations from Transformers for Open-Domain Question Answering](https://arxiv.org/abs/1908.07490) by Hao Tan and Mohit Bansal.
  1. **[M-CTC-T](https://huggingface.co/docs/transformers/model_doc/mctct)** (from Facebook) released with the paper [Pseudo-Labeling For Massively Multilingual Speech Recognition](https://arxiv.org/abs/2111.00161) by Loren Lugosch, Tatiana Likhomanenko, Gabriel Synnaeve, and Ronan Collobert.
  1. **[M2M100](https://huggingface.co/docs/transformers/model_doc/m2m_100)** (from Facebook) released with the paper [Beyond English-Centric Multilingual Machine Translation](https://arxiv.org/abs/2010.11125) by Angela Fan, Shruti Bhosale, Holger Schwenk, Zhiyi Ma, Ahmed El-Kishky, Siddharth Goyal, Mandeep Baines, Onur Celebi, Guillaume Wenzek, Vishrav Chaudhary, Naman Goyal, Tom Birch, Vitaliy Liptchinsky, Sergey Edunov, Edouard Grave, Michael Auli, Armand Joulin.
  1. **[MarianMT](https://huggingface.co/docs/transformers/model_doc/marian)** Machine translation models trained using [OPUS](http://opus.nlpl.eu/) data by Jörg Tiedemann. The [Marian Framework](https://marian-nmt.github.io/) is being developed by the Microsoft Translator Team.
  1. **[MarkupLM](https://huggingface.co/docs/transformers/model_doc/markuplm)** (from Microsoft Research Asia) released with the paper [MarkupLM: Pre-training of Text and Markup Language for Visually-rich Document Understanding](https://arxiv.org/abs/2110.08518) by Junlong Li, Yiheng Xu, Lei Cui, Furu Wei.
  1. **[Mask2Former](https://huggingface.co/docs/transformers/model_doc/mask2former)** (from FAIR and UIUC) released with the paper [Masked-attention Mask Transformer for Universal Image Segmentation](https://arxiv.org/abs/2112.01527) by Bowen Cheng, Ishan Misra, Alexander G. Schwing, Alexander Kirillov, Rohit Girdhar.
  1. **[MaskFormer](https://huggingface.co/docs/transformers/model_doc/maskformer)** (from Meta and UIUC) released with the paper [Per-Pixel Classification is Not All You Need for Semantic Segmentation](https://arxiv.org/abs/2107.06278) by Bowen Cheng, Alexander G. Schwing, Alexander Kirillov.
  1. **[mBART](https://huggingface.co/docs/transformers/model_doc/mbart)** (from Facebook) released with the paper [Multilingual Denoising Pre-training for Neural Machine Translation](https://arxiv.org/abs/2001.08210) by Yinhan Liu, Jiatao Gu, Naman Goyal, Xian Li, Sergey Edunov, Marjan Ghazvininejad, Mike Lewis, Luke Zettlemoyer.
  1. **[mBART-50](https://huggingface.co/docs/transformers/model_doc/mbart)** (from Facebook) released with the paper [Multilingual Translation with Extensible Multilingual Pretraining and Finetuning](https://arxiv.org/abs/2008.00401) by Yuqing Tang, Chau Tran, Xian Li, Peng-Jen Chen, Naman Goyal, Vishrav Chaudhary, Jiatao Gu, Angela Fan.
  1. **[Megatron-BERT](https://huggingface.co/docs/transformers/model_doc/megatron-bert)** (from NVIDIA) released with the paper [Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism](https://arxiv.org/abs/1909.08053) by Mohammad Shoeybi, Mostofa Patwary, Raul Puri, Patrick LeGresley, Jared Casper and Bryan Catanzaro.
  1. **[Megatron-GPT2](https://huggingface.co/docs/transformers/model_doc/megatron_gpt2)** (from NVIDIA) released with the paper [Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism](https://arxiv.org/abs/1909.08053) by Mohammad Shoeybi, Mostofa Patwary, Raul Puri, Patrick LeGresley, Jared Casper and Bryan Catanzaro.
  1. **[MGP-STR](https://huggingface.co/docs/transformers/model_doc/mgp-str)** (from Alibaba Research) released with the paper [Multi-Granularity Prediction for Scene Text Recognition](https://arxiv.org/abs/2209.03592) by Peng Wang, Cheng Da, and Cong Yao.
  1. **[mLUKE](https://huggingface.co/docs/transformers/model_doc/mluke)** (from Studio Ousia) released with the paper [mLUKE: The Power of Entity Representations in Multilingual Pretrained Language Models](https://arxiv.org/abs/2110.08151) by Ryokan Ri, Ikuya Yamada, and Yoshimasa Tsuruoka.
  1. **[MobileBERT](https://huggingface.co/docs/transformers/model_doc/mobilebert)** (from CMU/Google Brain) released with the paper [MobileBERT: a Compact Task-Agnostic BERT for Resource-Limited Devices](https://arxiv.org/abs/2004.02984) by Zhiqing Sun, Hongkun Yu, Xiaodan Song, Renjie Liu, Yiming Yang, and Denny Zhou.
  1. **[MobileNetV1](https://huggingface.co/docs/transformers/model_doc/mobilenet_v1)** (from Google Inc.) released with the paper [MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications](https://arxiv.org/abs/1704.04861) by Andrew G. Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, Hartwig Adam.
  1. **[MobileNetV2](https://huggingface.co/docs/transformers/model_doc/mobilenet_v2)** (from Google Inc.) released with the paper [MobileNetV2: Inverted Residuals and Linear Bottlenecks](https://arxiv.org/abs/1801.04381) by Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, Liang-Chieh Chen.
  1. **[MobileViT](https://huggingface.co/docs/transformers/model_doc/mobilevit)** (from Apple) released with the paper [MobileViT: Light-weight, General-purpose, and Mobile-friendly Vision Transformer](https://arxiv.org/abs/2110.02178) by Sachin Mehta and Mohammad Rastegari.
  1. **[MPNet](https://huggingface.co/docs/transformers/model_doc/mpnet)** (from Microsoft Research) released with the paper [MPNet: Masked and Permuted Pre-training for Language Understanding](https://arxiv.org/abs/2004.09297) by Kaitao Song, Xu Tan, Tao Qin, Jianfeng Lu, Tie-Yan Liu.
  1. **[MT5](https://huggingface.co/docs/transformers/model_doc/mt5)** (from Google AI) released with the paper [mT5: A massively multilingual pre-trained text-to-text transformer](https://arxiv.org/abs/2010.11934) by Linting Xue, Noah Constant, Adam Roberts, Mihir Kale, Rami Al-Rfou, Aditya Siddhant, Aditya Barua, Colin Raffel.
  1. **[MVP](https://huggingface.co/docs/transformers/model_doc/mvp)** (from RUC AI Box) released with the paper [MVP: Multi-task Supervised Pre-training for Natural Language Generation](https://arxiv.org/abs/2206.12131) by Tianyi Tang, Junyi Li, Wayne Xin Zhao and Ji-Rong Wen.
  1. **[NAT](https://huggingface.co/docs/transformers/model_doc/nat)** (from SHI Labs) released with the paper [Neighborhood Attention Transformer](https://arxiv.org/abs/2204.07143) by Ali Hassani, Steven Walton, Jiachen Li, Shen Li, and Humphrey Shi.
  1. **[Nezha](https://huggingface.co/docs/transformers/model_doc/nezha)** (from Huawei Noah’s Ark Lab) released with the paper [NEZHA: Neural Contextualized Representation for Chinese Language Understanding](https://arxiv.org/abs/1909.00204) by Junqiu Wei, Xiaozhe Ren, Xiaoguang Li, Wenyong Huang, Yi Liao, Yasheng Wang, Jiashu Lin, Xin Jiang, Xiao Chen and Qun Liu.
  1. **[NLLB](https://huggingface.co/docs/transformers/model_doc/nllb)** (from Meta) released with the paper [No Language Left Behind: Scaling Human-Centered Machine Translation](https://arxiv.org/abs/2207.04672) by the NLLB team.
  1. **[Nyströmformer](https://huggingface.co/docs/transformers/model_doc/nystromformer)** (from the University of Wisconsin - Madison) released with the paper [Nyströmformer: A Nyström-Based Algorithm for Approximating Self-Attention](https://arxiv.org/abs/2102.03902) by Yunyang Xiong, Zhanpeng Zeng, Rudrasis Chakraborty, Mingxing Tan, Glenn Fung, Yin Li, Vikas Singh.
  1. **[OneFormer](https://huggingface.co/docs/transformers/model_doc/oneformer)** (from SHI Labs) released with the paper [OneFormer: One Transformer to Rule Universal Image Segmentation](https://arxiv.org/abs/2211.06220) by Jitesh Jain, Jiachen Li, MangTik Chiu, Ali Hassani, Nikita Orlov, Humphrey Shi.
  1. **[OPT](https://huggingface.co/docs/transformers/master/model_doc/opt)** (from Meta AI) released with the paper [OPT: Open Pre-trained Transformer Language Models](https://arxiv.org/abs/2205.01068) by Susan Zhang, Stephen Roller, Naman Goyal, Mikel Artetxe, Moya Chen, Shuohui Chen et al.
  1. **[OWL-ViT](https://huggingface.co/docs/transformers/model_doc/owlvit)** (from Google AI) released with the paper [Simple Open-Vocabulary Object Detection with Vision Transformers](https://arxiv.org/abs/2205.06230) by Matthias Minderer, Alexey Gritsenko, Austin Stone, Maxim Neumann, Dirk Weissenborn, Alexey Dosovitskiy, Aravindh Mahendran, Anurag Arnab, Mostafa Dehghani, Zhuoran Shen, Xiao Wang, Xiaohua Zhai, Thomas Kipf, and Neil Houlsby.
  1. **[Pegasus](https://huggingface.co/docs/transformers/model_doc/pegasus)** (from Google) released with the paper [PEGASUS: Pre-training with Extracted Gap-sentences for Abstractive Summarization](https://arxiv.org/abs/1912.08777) by Jingqing Zhang, Yao Zhao, Mohammad Saleh and Peter J. Liu.
  1. **[PEGASUS-X](https://huggingface.co/docs/transformers/model_doc/pegasus_x)** (from Google) released with the paper [Investigating Efficiently Extending Transformers for Long Input Summarization](https://arxiv.org/abs/2208.04347) by Jason Phang, Yao Zhao, and Peter J. Liu.
  1. **[Perceiver IO](https://huggingface.co/docs/transformers/model_doc/perceiver)** (from Deepmind) released with the paper [Perceiver IO: A General Architecture for Structured Inputs & Outputs](https://arxiv.org/abs/2107.14795) by Andrew Jaegle, Sebastian Borgeaud, Jean-Baptiste Alayrac, Carl Doersch, Catalin Ionescu, David Ding, Skanda Koppula, Daniel Zoran, Andrew Brock, Evan Shelhamer, Olivier Hénaff, Matthew M. Botvinick, Andrew Zisserman, Oriol Vinyals, João Carreira.
  1. **[PhoBERT](https://huggingface.co/docs/transformers/model_doc/phobert)** (from VinAI Research) released with the paper [PhoBERT: Pre-trained language models for Vietnamese](https://www.aclweb.org/anthology/2020.findings-emnlp.92/) by Dat Quoc Nguyen and Anh Tuan Nguyen.
  1. **[PLBart](https://huggingface.co/docs/transformers/model_doc/plbart)** (from UCLA NLP) released with the paper [Unified Pre-training for Program Understanding and Generation](https://arxiv.org/abs/2103.06333) by Wasi Uddin Ahmad, Saikat Chakraborty, Baishakhi Ray, Kai-Wei Chang.
  1. **[PoolFormer](https://huggingface.co/docs/transformers/model_doc/poolformer)** (from Sea AI Labs) released with the paper [MetaFormer is Actually What You Need for Vision](https://arxiv.org/abs/2111.11418) by Yu, Weihao and Luo, Mi and Zhou, Pan and Si, Chenyang and Zhou, Yichen and Wang, Xinchao and Feng, Jiashi and Yan, Shuicheng.
  1. **[ProphetNet](https://huggingface.co/docs/transformers/model_doc/prophetnet)** (from Microsoft Research) released with the paper [ProphetNet: Predicting Future N-gram for Sequence-to-Sequence Pre-training](https://arxiv.org/abs/2001.04063) by Yu Yan, Weizhen Qi, Yeyun Gong, Dayiheng Liu, Nan Duan, Jiusheng Chen, Ruofei Zhang and Ming Zhou.
  1. **[QDQBert](https://huggingface.co/docs/transformers/model_doc/qdqbert)** (from NVIDIA) released with the paper [Integer Quantization for Deep Learning Inference: Principles and Empirical Evaluation](https://arxiv.org/abs/2004.09602) by Hao Wu, Patrick Judd, Xiaojie Zhang, Mikhail Isaev and Paulius Micikevicius.
  1. **[RAG](https://huggingface.co/docs/transformers/model_doc/rag)** (from Facebook) released with the paper [Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks](https://arxiv.org/abs/2005.11401) by Patrick Lewis, Ethan Perez, Aleksandara Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, Sebastian Riedel, Douwe Kiela.
  1. **[REALM](https://huggingface.co/docs/transformers/model_doc/realm.html)** (from Google Research) released with the paper [REALM: Retrieval-Augmented Language Model Pre-Training](https://arxiv.org/abs/2002.08909) by Kelvin Guu, Kenton Lee, Zora Tung, Panupong Pasupat and Ming-Wei Chang.
  1. **[Reformer](https://huggingface.co/docs/transformers/model_doc/reformer)** (from Google Research) released with the paper [Reformer: The Efficient Transformer](https://arxiv.org/abs/2001.04451) by Nikita Kitaev, Łukasz Kaiser, Anselm Levskaya.
  1. **[RegNet](https://huggingface.co/docs/transformers/model_doc/regnet)** (from META Platforms) released with the paper [Designing Network Design Space](https://arxiv.org/abs/2003.13678) by Ilija Radosavovic, Raj Prateek Kosaraju, Ross Girshick, Kaiming He, Piotr Dollár.
  1. **[RemBERT](https://huggingface.co/docs/transformers/model_doc/rembert)** (from Google Research) released with the paper [Rethinking embedding coupling in pre-trained language models](https://arxiv.org/abs/2010.12821) by Hyung Won Chung, Thibault Févry, Henry Tsai, M. Johnson, Sebastian Ruder.
  1. **[ResNet](https://huggingface.co/docs/transformers/model_doc/resnet)** (from Microsoft Research) released with the paper [Deep Residual Learning for Image Recognition](https://arxiv.org/abs/1512.03385) by Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun.
  1. **[RoBERTa](https://huggingface.co/docs/transformers/model_doc/roberta)** (from Facebook), released together with the paper [RoBERTa: A Robustly Optimized BERT Pretraining Approach](https://arxiv.org/abs/1907.11692) by Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, Veselin Stoyanov.
  1. **[RoBERTa-PreLayerNorm](https://huggingface.co/docs/transformers/model_doc/roberta-prelayernorm)** (from Facebook) released with the paper [fairseq: A Fast, Extensible Toolkit for Sequence Modeling](https://arxiv.org/abs/1904.01038) by Myle Ott, Sergey Edunov, Alexei Baevski, Angela Fan, Sam Gross, Nathan Ng, David Grangier, Michael Auli.
  1. **[RoCBert](https://huggingface.co/docs/transformers/model_doc/roc_bert)** (from WeChatAI) released with the paper [RoCBert: Robust Chinese Bert with Multimodal Contrastive Pretraining](https://aclanthology.org/2022.acl-long.65.pdf) by HuiSu, WeiweiShi, XiaoyuShen, XiaoZhou, TuoJi, JiaruiFang, JieZhou.
  1. **[RoFormer](https://huggingface.co/docs/transformers/model_doc/roformer)** (from ZhuiyiTechnology), released together with the paper [RoFormer: Enhanced Transformer with Rotary Position Embedding](https://arxiv.org/abs/2104.09864) by Jianlin Su and Yu Lu and Shengfeng Pan and Bo Wen and Yunfeng Liu.
  1. **[SegFormer](https://huggingface.co/docs/transformers/model_doc/segformer)** (from NVIDIA) released with the paper [SegFormer: Simple and Efficient Design for Semantic Segmentation with Transformers](https://arxiv.org/abs/2105.15203) by Enze Xie, Wenhai Wang, Zhiding Yu, Anima Anandkumar, Jose M. Alvarez, Ping Luo.
  1. **[SEW](https://huggingface.co/docs/transformers/model_doc/sew)** (from ASAPP) released with the paper [Performance-Efficiency Trade-offs in Unsupervised Pre-training for Speech Recognition](https://arxiv.org/abs/2109.06870) by Felix Wu, Kwangyoun Kim, Jing Pan, Kyu Han, Kilian Q. Weinberger, Yoav Artzi.
  1. **[SEW-D](https://huggingface.co/docs/transformers/model_doc/sew_d)** (from ASAPP) released with the paper [Performance-Efficiency Trade-offs in Unsupervised Pre-training for Speech Recognition](https://arxiv.org/abs/2109.06870) by Felix Wu, Kwangyoun Kim, Jing Pan, Kyu Han, Kilian Q. Weinberger, Yoav Artzi.
  1. **[SpeechT5](https://huggingface.co/docs/transformers/model_doc/speecht5)** (from Microsoft Research) released with the paper [SpeechT5: Unified-Modal Encoder-Decoder Pre-Training for Spoken Language Processing](https://arxiv.org/abs/2110.07205) by Junyi Ao, Rui Wang, Long Zhou, Chengyi Wang, Shuo Ren, Yu Wu, Shujie Liu, Tom Ko, Qing Li, Yu Zhang, Zhihua Wei, Yao Qian, Jinyu Li, Furu Wei.
  1. **[SpeechToTextTransformer](https://huggingface.co/docs/transformers/model_doc/speech_to_text)** (from Facebook), released together with the paper [fairseq S2T: Fast Speech-to-Text Modeling with fairseq](https://arxiv.org/abs/2010.05171) by Changhan Wang, Yun Tang, Xutai Ma, Anne Wu, Dmytro Okhonko, Juan Pino.
  1. **[SpeechToTextTransformer2](https://huggingface.co/docs/transformers/model_doc/speech_to_text_2)** (from Facebook), released together with the paper [Large-Scale Self- and Semi-Supervised Learning for Speech Translation](https://arxiv.org/abs/2104.06678) by Changhan Wang, Anne Wu, Juan Pino, Alexei Baevski, Michael Auli, Alexis Conneau.
  1. **[Splinter](https://huggingface.co/docs/transformers/model_doc/splinter)** (from Tel Aviv University), released together with the paper [Few-Shot Question Answering by Pretraining Span Selection](https://arxiv.org/abs/2101.00438) by Ori Ram, Yuval Kirstain, Jonathan Berant, Amir Globerson, Omer Levy.
  1. **[SqueezeBERT](https://huggingface.co/docs/transformers/model_doc/squeezebert)** (from Berkeley) released with the paper [SqueezeBERT: What can computer vision teach NLP about efficient neural networks?](https://arxiv.org/abs/2006.11316) by Forrest N. Iandola, Albert E. Shaw, Ravi Krishna, and Kurt W. Keutzer.
  1. **[Swin Transformer](https://huggingface.co/docs/transformers/model_doc/swin)** (from Microsoft) released with the paper [Swin Transformer: Hierarchical Vision Transformer using Shifted Windows](https://arxiv.org/abs/2103.14030) by Ze Liu, Yutong Lin, Yue Cao, Han Hu, Yixuan Wei, Zheng Zhang, Stephen Lin, Baining Guo.
  1. **[Swin Transformer V2](https://huggingface.co/docs/transformers/model_doc/swinv2)** (from Microsoft) released with the paper [Swin Transformer V2: Scaling Up Capacity and Resolution](https://arxiv.org/abs/2111.09883) by Ze Liu, Han Hu, Yutong Lin, Zhuliang Yao, Zhenda Xie, Yixuan Wei, Jia Ning, Yue Cao, Zheng Zhang, Li Dong, Furu Wei, Baining Guo.
  1. **[Swin2SR](https://huggingface.co/docs/transformers/model_doc/swin2sr)** (from University of Würzburg) released with the paper [Swin2SR: SwinV2 Transformer for Compressed Image Super-Resolution and Restoration](https://arxiv.org/abs/2209.11345) by Marcos V. Conde, Ui-Jin Choi, Maxime Burchi, Radu Timofte.
  1. **[SwitchTransformers](https://huggingface.co/docs/transformers/model_doc/switch_transformers)** (from Google) released with the paper [Switch Transformers: Scaling to Trillion Parameter Models with Simple and Efficient Sparsity](https://arxiv.org/abs/2101.03961) by William Fedus, Barret Zoph, Noam Shazeer.
  1. **[T5](https://huggingface.co/docs/transformers/model_doc/t5)** (from Google AI) released with the paper [Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer](https://arxiv.org/abs/1910.10683) by Colin Raffel and Noam Shazeer and Adam Roberts and Katherine Lee and Sharan Narang and Michael Matena and Yanqi Zhou and Wei Li and Peter J. Liu.
  1. **[T5v1.1](https://huggingface.co/docs/transformers/model_doc/t5v1.1)** (from Google AI) released in the repository [google-research/text-to-text-transfer-transformer](https://github.com/google-research/text-to-text-transfer-transformer/blob/main/released_checkpoints.md#t511) by Colin Raffel and Noam Shazeer and Adam Roberts and Katherine Lee and Sharan Narang and Michael Matena and Yanqi Zhou and Wei Li and Peter J. Liu.
  1. **[Table Transformer](https://huggingface.co/docs/transformers/model_doc/table-transformer)** (from Microsoft Research) released with the paper [PubTables-1M: Towards Comprehensive Table Extraction From Unstructured Documents](https://arxiv.org/abs/2110.00061) by Brandon Smock, Rohith Pesala, Robin Abraham.
  1. **[TAPAS](https://huggingface.co/docs/transformers/model_doc/tapas)** (from Google AI) released with the paper [TAPAS: Weakly Supervised Table Parsing via Pre-training](https://arxiv.org/abs/2004.02349) by Jonathan Herzig, Paweł Krzysztof Nowak, Thomas Müller, Francesco Piccinno and Julian Martin Eisenschlos.
  1. **[TAPEX](https://huggingface.co/docs/transformers/model_doc/tapex)** (from Microsoft Research) released with the paper [TAPEX: Table Pre-training via Learning a Neural SQL Executor](https://arxiv.org/abs/2107.07653) by Qian Liu, Bei Chen, Jiaqi Guo, Morteza Ziyadi, Zeqi Lin, Weizhu Chen, Jian-Guang Lou.
  1. **[Time Series Transformer](https://huggingface.co/docs/transformers/model_doc/time_series_transformer)** (from HuggingFace).
  1. **[TimeSformer](https://huggingface.co/docs/transformers/model_doc/timesformer)** (from Facebook) released with the paper [Is Space-Time Attention All You Need for Video Understanding?](https://arxiv.org/abs/2102.05095) by Gedas Bertasius, Heng Wang, Lorenzo Torresani.
  1. **[Trajectory Transformer](https://huggingface.co/docs/transformers/model_doc/trajectory_transformers)** (from the University of California at Berkeley) released with the paper [Offline Reinforcement Learning as One Big Sequence Modeling Problem](https://arxiv.org/abs/2106.02039) by Michael Janner, Qiyang Li, Sergey Levine
  1. **[Transformer-XL](https://huggingface.co/docs/transformers/model_doc/transfo-xl)** (from Google/CMU) released with the paper [Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context](https://arxiv.org/abs/1901.02860) by Zihang Dai*, Zhilin Yang*, Yiming Yang, Jaime Carbonell, Quoc V. Le, Ruslan Salakhutdinov.
  1. **[TrOCR](https://huggingface.co/docs/transformers/model_doc/trocr)** (from Microsoft), released together with the paper [TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models](https://arxiv.org/abs/2109.10282) by Minghao Li, Tengchao Lv, Lei Cui, Yijuan Lu, Dinei Florencio, Cha Zhang, Zhoujun Li, Furu Wei.
  1. **[TVLT](https://huggingface.co/docs/transformers/model_doc/tvlt)** (from UNC Chapel Hill) released with the paper [TVLT: Textless Vision-Language Transformer](https://arxiv.org/abs/2209.14156) by Zineng Tang, Jaemin Cho, Yixin Nie, Mohit Bansal.
  1. **[UL2](https://huggingface.co/docs/transformers/model_doc/ul2)** (from Google Research) released with the paper [Unifying Language Learning Paradigms](https://arxiv.org/abs/2205.05131v1) by Yi Tay, Mostafa Dehghani, Vinh Q. Tran, Xavier Garcia, Dara Bahri, Tal Schuster, Huaixiu Steven Zheng, Neil Houlsby, Donald Metzler
  1. **[UniSpeech](https://huggingface.co/docs/transformers/model_doc/unispeech)** (from Microsoft Research) released with the paper [UniSpeech: Unified Speech Representation Learning with Labeled and Unlabeled Data](https://arxiv.org/abs/2101.07597) by Chengyi Wang, Yu Wu, Yao Qian, Kenichi Kumatani, Shujie Liu, Furu Wei, Michael Zeng, Xuedong Huang.
  1. **[UniSpeechSat](https://huggingface.co/docs/transformers/model_doc/unispeech-sat)** (from Microsoft Research) released with the paper [UNISPEECH-SAT: UNIVERSAL SPEECH REPRESENTATION LEARNING WITH SPEAKER AWARE PRE-TRAINING](https://arxiv.org/abs/2110.05752) by Sanyuan Chen, Yu Wu, Chengyi Wang, Zhengyang Chen, Zhuo Chen, Shujie Liu, Jian Wu, Yao Qian, Furu Wei, Jinyu Li, Xiangzhan Yu.
  1. **[UPerNet](https://huggingface.co/docs/transformers/model_doc/upernet)** (from Peking University) released with the paper [Unified Perceptual Parsing for Scene Understanding](https://arxiv.org/abs/1807.10221) by Tete Xiao, Yingcheng Liu, Bolei Zhou, Yuning Jiang, Jian Sun.
  1. **[VAN](https://huggingface.co/docs/transformers/model_doc/van)** (from Tsinghua University and Nankai University) released with the paper [Visual Attention Network](https://arxiv.org/abs/2202.09741) by Meng-Hao Guo, Cheng-Ze Lu, Zheng-Ning Liu, Ming-Ming Cheng, Shi-Min Hu.
  1. **[VideoMAE](https://huggingface.co/docs/transformers/model_doc/videomae)** (from Multimedia Computing Group, Nanjing University) released with the paper [VideoMAE: Masked Autoencoders are Data-Efficient Learners for Self-Supervised Video Pre-Training](https://arxiv.org/abs/2203.12602) by Zhan Tong, Yibing Song, Jue Wang, Limin Wang.
  1. **[ViLT](https://huggingface.co/docs/transformers/model_doc/vilt)** (from NAVER AI Lab/Kakao Enterprise/Kakao Brain) released with the paper [ViLT: Vision-and-Language Transformer Without Convolution or Region Supervision](https://arxiv.org/abs/2102.03334) by Wonjae Kim, Bokyung Son, Ildoo Kim.
  1. **[Vision Transformer (ViT)](https://huggingface.co/docs/transformers/model_doc/vit)** (from Google AI) released with the paper [An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale](https://arxiv.org/abs/2010.11929) by Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, Jakob Uszkoreit, Neil Houlsby.
  1. **[VisualBERT](https://huggingface.co/docs/transformers/model_doc/visual_bert)** (from UCLA NLP) released with the paper [VisualBERT: A Simple and Performant Baseline for Vision and Language](https://arxiv.org/pdf/1908.03557) by Liunian Harold Li, Mark Yatskar, Da Yin, Cho-Jui Hsieh, Kai-Wei Chang.
  1. **[ViT Hybrid](https://huggingface.co/docs/transformers/model_doc/vit_hybrid)** (from Google AI) released with the paper [An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale](https://arxiv.org/abs/2010.11929) by Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, Jakob Uszkoreit, Neil Houlsby.
  1. **[ViTMAE](https://huggingface.co/docs/transformers/model_doc/vit_mae)** (from Meta AI) released with the paper [Masked Autoencoders Are Scalable Vision Learners](https://arxiv.org/abs/2111.06377) by Kaiming He, Xinlei Chen, Saining Xie, Yanghao Li, Piotr Dollár, Ross Girshick.
  1. **[ViTMSN](https://huggingface.co/docs/transformers/model_doc/vit_msn)** (from Meta AI) released with the paper [Masked Siamese Networks for Label-Efficient Learning](https://arxiv.org/abs/2204.07141) by Mahmoud Assran, Mathilde Caron, Ishan Misra, Piotr Bojanowski, Florian Bordes, Pascal Vincent, Armand Joulin, Michael Rabbat, Nicolas Ballas.
  1. **[Wav2Vec2](https://huggingface.co/docs/transformers/model_doc/wav2vec2)** (from Facebook AI) released with the paper [wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations](https://arxiv.org/abs/2006.11477) by Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, Michael Auli.
  1. **[Wav2Vec2-Conformer](https://huggingface.co/docs/transformers/model_doc/wav2vec2-conformer)** (from Facebook AI) released with the paper [FAIRSEQ S2T: Fast Speech-to-Text Modeling with FAIRSEQ](https://arxiv.org/abs/2010.05171) by Changhan Wang, Yun Tang, Xutai Ma, Anne Wu, Sravya Popuri, Dmytro Okhonko, Juan Pino.
  1. **[Wav2Vec2Phoneme](https://huggingface.co/docs/transformers/model_doc/wav2vec2_phoneme)** (from Facebook AI) released with the paper [Simple and Effective Zero-shot Cross-lingual Phoneme Recognition](https://arxiv.org/abs/2109.11680) by Qiantong Xu, Alexei Baevski, Michael Auli.
  1. **[WavLM](https://huggingface.co/docs/transformers/model_doc/wavlm)** (from Microsoft Research) released with the paper [WavLM: Large-Scale Self-Supervised Pre-Training for Full Stack Speech Processing](https://arxiv.org/abs/2110.13900) by Sanyuan Chen, Chengyi Wang, Zhengyang Chen, Yu Wu, Shujie Liu, Zhuo Chen, Jinyu Li, Naoyuki Kanda, Takuya Yoshioka, Xiong Xiao, Jian Wu, Long Zhou, Shuo Ren, Yanmin Qian, Yao Qian, Jian Wu, Michael Zeng, Furu Wei.
  1. **[Whisper](https://huggingface.co/docs/transformers/model_doc/whisper)** (from OpenAI) released with the paper [Robust Speech Recognition via Large-Scale Weak Supervision](https://cdn.openai.com/papers/whisper.pdf) by Alec Radford, Jong Wook Kim, Tao Xu, Greg Brockman, Christine McLeavey, Ilya Sutskever.
  1. **[X-CLIP](https://huggingface.co/docs/transformers/model_doc/xclip)** (from Microsoft Research) released with the paper [Expanding Language-Image Pretrained Models for General Video Recognition](https://arxiv.org/abs/2208.02816) by Bolin Ni, Houwen Peng, Minghao Chen, Songyang Zhang, Gaofeng Meng, Jianlong Fu, Shiming Xiang, Haibin Ling.
  1. **[X-MOD](https://huggingface.co/docs/transformers/model_doc/xmod)** (from Meta AI) released with the paper [Lifting the Curse of Multilinguality by Pre-training Modular Transformers](http://dx.doi.org/10.18653/v1/2022.naacl-main.255) by Jonas Pfeiffer, Naman Goyal, Xi Lin, Xian Li, James Cross, Sebastian Riedel, Mikel Artetxe.
  1. **[XGLM](https://huggingface.co/docs/transformers/model_doc/xglm)** (From Facebook AI) released with the paper [Few-shot Learning with Multilingual Language Models](https://arxiv.org/abs/2112.10668) by Xi Victoria Lin, Todor Mihaylov, Mikel Artetxe, Tianlu Wang, Shuohui Chen, Daniel Simig, Myle Ott, Naman Goyal, Shruti Bhosale, Jingfei Du, Ramakanth Pasunuru, Sam Shleifer, Punit Singh Koura, Vishrav Chaudhary, Brian O'Horo, Jeff Wang, Luke Zettlemoyer, Zornitsa Kozareva, Mona Diab, Veselin Stoyanov, Xian Li.
  1. **[XLM](https://huggingface.co/docs/transformers/model_doc/xlm)** (from Facebook) released together with the paper [Cross-lingual Language Model Pretraining](https://arxiv.org/abs/1901.07291) by Guillaume Lample and Alexis Conneau.
  1. **[XLM-ProphetNet](https://huggingface.co/docs/transformers/model_doc/xlm-prophetnet)** (from Microsoft Research) released with the paper [ProphetNet: Predicting Future N-gram for Sequence-to-Sequence Pre-training](https://arxiv.org/abs/2001.04063) by Yu Yan, Weizhen Qi, Yeyun Gong, Dayiheng Liu, Nan Duan, Jiusheng Chen, Ruofei Zhang and Ming Zhou.
  1. **[XLM-RoBERTa](https://huggingface.co/docs/transformers/model_doc/xlm-roberta)** (from Facebook AI), released together with the paper [Unsupervised Cross-lingual Representation Learning at Scale](https://arxiv.org/abs/1911.02116) by Alexis Conneau*, Kartikay Khandelwal*, Naman Goyal, Vishrav Chaudhary, Guillaume Wenzek, Francisco Guzmán, Edouard Grave, Myle Ott, Luke Zettlemoyer and Veselin Stoyanov.
  1. **[XLM-RoBERTa-XL](https://huggingface.co/docs/transformers/model_doc/xlm-roberta-xl)** (from Facebook AI), released together with the paper [Larger-Scale Transformers for Multilingual Masked Language Modeling](https://arxiv.org/abs/2105.00572) by Naman Goyal, Jingfei Du, Myle Ott, Giri Anantharaman, Alexis Conneau.
  1. **[XLM-V](https://huggingface.co/docs/transformers/model_doc/xlm-v)** (from Meta AI) released with the paper [XLM-V: Overcoming the Vocabulary Bottleneck in Multilingual Masked Language Models](https://arxiv.org/abs/2301.10472) by Davis Liang, Hila Gonen, Yuning Mao, Rui Hou, Naman Goyal, Marjan Ghazvininejad, Luke Zettlemoyer, Madian Khabsa.
  1. **[XLNet](https://huggingface.co/docs/transformers/model_doc/xlnet)** (from Google/CMU) released with the paper [​XLNet: Generalized Autoregressive Pretraining for Language Understanding](https://arxiv.org/abs/1906.08237) by Zhilin Yang*, Zihang Dai*, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, Quoc V. Le.
  1. **[XLS-R](https://huggingface.co/docs/transformers/model_doc/xls_r)** (from Facebook AI) released with the paper [XLS-R: Self-supervised Cross-lingual Speech Representation Learning at Scale](https://arxiv.org/abs/2111.09296) by Arun Babu, Changhan Wang, Andros Tjandra, Kushal Lakhotia, Qiantong Xu, Naman Goyal, Kritika Singh, Patrick von Platen, Yatharth Saraf, Juan Pino, Alexei Baevski, Alexis Conneau, Michael Auli.
  1. **[XLSR-Wav2Vec2](https://huggingface.co/docs/transformers/model_doc/xlsr_wav2vec2)** (from Facebook AI) released with the paper [Unsupervised Cross-Lingual Representation Learning For Speech Recognition](https://arxiv.org/abs/2006.13979) by Alexis Conneau, Alexei Baevski, Ronan Collobert, Abdelrahman Mohamed, Michael Auli.
  1. **[YOLOS](https://huggingface.co/docs/transformers/model_doc/yolos)** (from Huazhong University of Science & Technology) released with the paper [You Only Look at One Sequence: Rethinking Transformer in Vision through Object Detection](https://arxiv.org/abs/2106.00666) by Yuxin Fang, Bencheng Liao, Xinggang Wang, Jiemin Fang, Jiyang Qi, Rui Wu, Jianwei Niu, Wenyu Liu.
  1. **[YOSO](https://huggingface.co/docs/transformers/model_doc/yoso)** (from the University of Wisconsin - Madison) released with the paper [You Only Sample (Almost) Once: Linear Cost Self-Attention Via Bernoulli Sampling](https://arxiv.org/abs/2111.09714) by Zhanpeng Zeng, Yunyang Xiong, Sathya N. Ravi, Shailesh Acharya, Glenn Fung, Vikas Singh.
  1. Want to contribute a new model? We have added a **detailed guide and templates** to guide you in the process of adding a new model. You can find them in the [`templates`](./templates) folder of the repository. Be sure to check the [contributing guidelines](./CONTRIBUTING.md) and contact the maintainers or open an issue to collect feedbacks before starting your PR.

  To check if each model has an implementation in Flax, PyTorch or TensorFlow, or has an associated tokenizer backed by the 🤗 Tokenizers library, refer to [this table](https://huggingface.co/docs/transformers/index#supported-frameworks).

  These implementations have been tested on several datasets (see the example scripts) and should match the performance of the original implementations. You can find more details on performance in the Examples section of the [documentation](https://github.com/huggingface/transformers/tree/main/examples).




  | Section | Description |
  |-|-|
  | [Documentation](https://huggingface.co/docs/transformers/) | Full API documentation and tutorials |
  | [Task summary](https://huggingface.co/docs/transformers/task_summary) | Tasks supported by 🤗 Transformers |
  | [Preprocessing tutorial](https://huggingface.co/docs/transformers/preprocessing) | Using the `Tokenizer` class to prepare data for the models |
  | [Training and fine-tuning](https://huggingface.co/docs/transformers/training) | Using the models provided by 🤗 Transformers in a PyTorch/TensorFlow training loop and the `Trainer` API |
  | [Quick tour: Fine-tuning/usage scripts](https://github.com/huggingface/transformers/tree/main/examples) | Example scripts for fine-tuning models on a wide range of tasks |
  | [Model sharing and uploading](https://huggingface.co/docs/transformers/model_sharing) | Upload and share your fine-tuned models with the community |
  | [Migration](https://huggingface.co/docs/transformers/migration) | Migrate to 🤗 Transformers from `pytorch-transformers` or `pytorch-pretrained-bert` |



  We now have a [paper](https://www.aclweb.org/anthology/2020.emnlp-demos.6/) you can cite for the 🤗 Transformers library:
  ```bibtex
  @inproceedings{wolf-etal-2020-transformers,
      title = "Transformers: State-of-the-Art Natural Language Processing",
      author = "Thomas Wolf and Lysandre Debut and Victor Sanh and Julien Chaumond and Clement Delangue and Anthony Moi and Pierric Cistac and Tim Rault and Rémi Louf and Morgan Funtowicz and Joe Davison and Sam Shleifer and Patrick von Platen and Clara Ma and Yacine Jernite and Julien Plu and Canwen Xu and Teven Le Scao and Sylvain Gugger and Mariama Drame and Quentin Lhoest and Alexander M. Rush",
      booktitle = "Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: System Demonstrations",
      month = oct,
      year = "2020",
      address = "Online",
      publisher = "Association for Computational Linguistics",
      url = "https://www.aclweb.org/anthology/2020.emnlp-demos.6",
      pages = "38--45"
  }
  ```


pkgId: bb0450397056e0cdefd462f0b7c9a3410f6763e63804b049e7ebf8a5296e8fe1
name: python-transforms3d
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Functions for 3D coordinate transformations
url: http://github.com/matthew-brett/transforms3d
rpm_license: BSD license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b4f88b85-15fa-46f0-887e-f696279a3de3
location_href: 00005329-python-transforms3d/python-transforms3d-0.4.1-1.src.rpm
checksum_type: sha256
description:
  Transforms3d


  Code to convert between various geometric transformations.

  * Composing rotations / zooms / shears / translations into affine matrix;
  * Decomposing affine matrix into rotations / zooms / shears / translations;
  * Conversions between different representations of rotations, including:

    * 3x3 Rotation matrices;
    * Euler angles;
    * quaternions.

  We have tried to document the algorithms carefully and write clear code in the
  hope that this code can be a teaching reference.  We document the math behind
  some of the algorithms using `sympy <http://www.sympy.org>`_ in
  ``transforms3d/derivations``.  We would be very pleased if y'all would like to
  add your own algorithms and derivations - please get a copy of the code from
  https://github.com/matthew-brett/transforms3d and get on down,
  algorithmically.  Feel free to use the github issue tracker and pull request
  system to ask for advice and support.

  *************
  Documentation
  *************

  Documentation for latest released version at
  http://matthew-brett.github.io/transforms3d

  ****
  Code
  ****

  See https://github.com/matthew-brett/transforms3d

  Released under the BSD two-clause license - see the file ``LICENSE`` in the
  source distribution.

  Much of the code comes from `transformations.py
  <http://www.lfd.uci.edu/~gohlke/code/transformations.py.html>`_ by Christoph
  Gohlke, also released under the BSD license.

  We use Github actions to test the code automatically under Pythons 3.7 through
  3.10.

  We depend on numpy >= 1.15.  You may be able to make it work on an earlier
  numpy if you really needed that.

  The latest released version is at https://pypi.python.org/pypi/transforms3d

  *******
  Support
  *******

  Please put up issues on the `transforms3d issue tracker
  <https://github.com/matthew-brett/transforms3d/issues>`_.


pkgId: 7efa609ed60d335294f0a4c334b611caf546bda75e44b6ccc5b8d6437433d707
name: python-transifex-client
arch: src
version: 0.14.4
epoch: 0
release: 1
summary: A command line interface for Transifex
url: https://www.transifex.com
rpm_license: GPLv2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-80588fe4-a628-44ba-8073-9e0b120790dd
location_href: 00011459-python-transifex-client/python-transifex-client-0.14.4-1.src.rpm
checksum_type: sha256
description:
  [![image](https://circleci.com/gh/transifex/transifex-client/tree/master.svg?style=shield&circle-token=33aafd984726261eff1b73278a0cf761382c478a)](https://circleci.com/gh/transifex/transifex-client/tree/master)
  [![image](https://ci.appveyor.com/api/projects/status/github/transifex/transifex-client?branch=master&svg=true)](https://ci.appveyor.com/project/transifex/transifex-client/branch/master)
  [![codecov](https://codecov.io/gh/transifex/transifex-client/branch/master/graph/badge.svg)](https://codecov.io/gh/transifex/transifex-client)
  [![PyPI version](https://badge.fury.io/py/transifex-client.svg)](https://badge.fury.io/py/transifex-client)
  > _⚠️ A new client, compatible with the [new API](https://transifex.github.io/openapi/), is under development. Check out the Alpha version [here](https://github.com/transifex/cli)._

  Whether you have experience with the command line or not, [this interactive tutorial](https://www.transifex.com/learn/txclient/) is intended for everyone who wishes to learn how the Transifex client works. There is no need to download anything - Just click on the link provided above, and follow the instructions.
  For more information about TX client, please visit our [documentation guide here](https://docs.transifex.com/client/introduction).


pkgId: 2ff294e9ac517ef810c3436aee0a5f2a1a47aeffec9431dc24901bae2d9f4751
name: python-transitions
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: A lightweight, object-oriented Python state machine implementation with many extensions.
url: http://github.com/pytransitions/transitions
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-52eccd58-0f36-42ba-a32f-b5d68e67ccf8
location_href: 00005330-python-transitions/python-transitions-0.9.0-1.src.rpm
checksum_type: sha256
description:
  They say [a good example is worth](https://www.google.com/webhp?ie=UTF-8#q=%22a+good+example+is+worth%22&start=20) 100 pages of API documentation, a million directives, or a thousand words.

  Well, "they" probably lie... but here's an example anyway:

  ```python
  from transitions import Machine
  import random

  class NarcolepticSuperhero(object):

      
      
      states = ['asleep', 'hanging out', 'hungry', 'sweaty', 'saving the world']

      def __init__(self, name):

          
          
          self.name = name

          
          self.kittens_rescued = 0

          
          self.machine = Machine(model=self, states=NarcolepticSuperhero.states, initial='asleep')

          
          
          

          
          self.machine.add_transition(trigger='wake_up', source='asleep', dest='hanging out')

          
          self.machine.add_transition('work_out', 'hanging out', 'hungry')

          
          self.machine.add_transition('eat', 'hungry', 'hanging out')

          
          
          self.machine.add_transition('distress_call', '*', 'saving the world',
                           before='change_into_super_secret_costume')

          
          
          
          self.machine.add_transition('complete_mission', 'saving the world', 'sweaty',
                           after='update_journal')

          
          
          self.machine.add_transition('clean_up', 'sweaty', 'asleep', conditions=['is_exhausted'])
          self.machine.add_transition('clean_up', 'sweaty', 'hanging out')

          
          self.machine.add_transition('nap', '*', 'asleep')

      def update_journal(self):
          """ Dear Diary, today I saved Mr. Whiskers. Again. """
          self.kittens_rescued += 1

      @property
      def is_exhausted(self):
          """ Basically a coin toss. """
          return random.random() < 0.5

      def change_into_super_secret_costume(self):
          print("Beauty, eh?")
  ```

  There, now you've baked a state machine into `NarcolepticSuperhero`. Let's take him/her/it out for a spin...

  ```python
  >>> batman = NarcolepticSuperhero("Batman")
  >>> batman.state
  'asleep'

  >>> batman.wake_up()
  >>> batman.state
  'hanging out'

  >>> batman.nap()
  >>> batman.state
  'asleep'

  >>> batman.clean_up()
  MachineError: "Can't trigger event clean_up from state asleep!"

  >>> batman.wake_up()
  >>> batman.work_out()
  >>> batman.state
  'hungry'


  >>> batman.kittens_rescued
  0


  >>> batman.distress_call()
  'Beauty, eh?'
  >>> batman.state
  'saving the world'


  >>> batman.complete_mission()
  >>> batman.state
  'sweaty'

  >>> batman.clean_up()
  >>> batman.state
  'asleep'   # Too tired to shower!


  >>> batman.kittens_rescued
  1
  ```

  While we cannot read the mind of the actual batman, we surely can visualize the current state of our `NarcolepticSuperhero`.

  ![batman diagram](https://user-images.githubusercontent.com/205986/104932302-c2f24580-59a7-11eb-8963-5dce738b9305.png)

  Have a look at the [Diagrams](#diagrams) extensions if you want to know how.





  Getting a state machine up and running is pretty simple. Let's say you have the object `lump` (an instance of class `Matter`), and you want to manage its states:

  ```python
  class Matter(object):
      pass

  lump = Matter()
  ```

  You can initialize a (_minimal_) working state machine bound to `lump` like this:

  ```python
  from transitions import Machine
  machine = Machine(model=lump, states=['solid', 'liquid', 'gas', 'plasma'], initial='solid')


  lump.state
  >>> 'solid'
  ```

  I say "minimal", because while this state machine is technically operational, it doesn't actually _do_ anything. It starts in the `'solid'` state, but won't ever move into another state, because no transitions are defined... yet!

  Let's try again.

  ```python

  states=['solid', 'liquid', 'gas', 'plasma']



  transitions = [
      { 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid' },
      { 'trigger': 'evaporate', 'source': 'liquid', 'dest': 'gas' },
      { 'trigger': 'sublimate', 'source': 'solid', 'dest': 'gas' },
      { 'trigger': 'ionize', 'source': 'gas', 'dest': 'plasma' }
  ]


  machine = Machine(lump, states=states, transitions=transitions, initial='liquid')


  lump.state
  >>> 'liquid'


  lump.evaporate()
  lump.state
  >>> 'gas'
  lump.trigger('ionize')
  lump.state
  >>> 'plasma'
  ```

  Notice the shiny new methods attached to the `Matter` instance (`evaporate()`, `ionize()`, etc.). Each method triggers the corresponding transition. You don't have to explicitly define these methods anywhere; the name of each transition is bound to the model passed to the `Machine` initializer (in this case, `lump`).
  To be more precise, your model **should not** already contain methods with the same name as event triggers since `transitions` will only attach convenience methods to your model if the spot is not already taken.
  If you want to modify that behaviour, have a look at the [FAQ](examples/Frequently%20asked%20questions.ipynb).
  Furthermore, there is a method called `trigger` now attached to your model (if it hasn't been there before).
  This method lets you execute transitions by name in case dynamic triggering is required.



  The soul of any good state machine (and of many bad ones, no doubt) is a set of states. Above, we defined the valid model states by passing a list of strings to the `Machine` initializer. But internally, states are actually represented as `State` objects.

  You can initialize and modify States in a number of ways. Specifically, you can:

  - pass a string to the `Machine` initializer giving the name(s) of the state(s), or
  - directly initialize each new `State` object, or
  - pass a dictionary with initialization arguments

  The following snippets illustrate several ways to achieve the same goal:

  ```python

  from transitions import Machine, State




  states = [
      State(name='solid'),
      'liquid',
      { 'name': 'gas'}
      ]
  machine = Machine(lump, states)




  machine = Machine(lump)
  solid = State('solid')
  liquid = State('liquid')
  gas = State('gas')
  machine.add_states([solid, liquid, gas])
  ```

  States are initialized _once_ when added to the machine and will persist until they are removed from it. In other words: if you alter the attributes of a state object, this change will NOT be reset the next time you enter that state. Have a look at how to [extend state features](#state-features) in case you require some other behaviour.



  A `State` can also be associated with a list of `enter` and `exit` callbacks, which are called whenever the state machine enters or leaves that state. You can specify callbacks during initialization by passing them to a `State` object constructor, in a state property dictionary, or add them later.

  For convenience, whenever a new `State` is added to a `Machine`, the methods `on_enter_«state name»` and `on_exit_«state name»` are dynamically created on the Machine (not on the model!), which allow you to dynamically add new enter and exit callbacks later if you need them.

  ```python


  class Matter(object):
      def say_hello(self): print("hello, new state!")
      def say_goodbye(self): print("goodbye, old state!")

  lump = Matter()


  states = [
      State(name='solid', on_exit=['say_goodbye']),
      'liquid',
      { 'name': 'gas', 'on_exit': ['say_goodbye']}
      ]

  machine = Machine(lump, states=states)
  machine.add_transition('sublimate', 'solid', 'gas')





  machine.on_enter_gas('say_hello')


  machine.set_state('solid')
  lump.sublimate()
  >>> 'goodbye, old state!'
  >>> 'hello, new state!'
  ```

  Note that `on_enter_«state name»` callback will _not_ fire when a Machine is first initialized. For example if you have an `on_enter_A()` callback defined, and initialize the `Machine` with `initial='A'`, `on_enter_A()` will not be fired until the next time you enter state `A`. (If you need to make sure `on_enter_A()` fires at initialization, you can simply create a dummy initial state and then explicitly call `to_A()` inside the `__init__` method.)

  In addition to passing in callbacks when initializing a `State`, or adding them dynamically, it's also possible to define callbacks in the model class itself, which may increase code clarity. For example:

  ```python
  class Matter(object):
      def say_hello(self): print("hello, new state!")
      def say_goodbye(self): print("goodbye, old state!")
      def on_enter_A(self): print("We've just entered state A!")

  lump = Matter()
  machine = Machine(lump, states=['A', 'B', 'C'])
  ```

  Now, any time `lump` transitions to state `A`, the `on_enter_A()` method defined in the `Matter` class will fire.



  You can always check the current state of the model by either:

  - inspecting the `.state` attribute, or
  - calling `is_«state name»()`

  And if you want to retrieve the actual `State` object for the current state, you can do that through the `Machine` instance's `get_state()` method.

  ```python
  lump.state
  >>> 'solid'
  lump.is_gas()
  >>> False
  lump.is_solid()
  >>> True
  machine.get_state(lump.state).name
  >>> 'solid'
  ```

  If you'd like you can choose your own state attribute name by passing the `model_attribute` argument while initializing the `Machine`. This will also change the name of `is_«state name»()` to `is_«model_attribute»_«state name»()` though. Similarly, auto transitions will be named `to_«model_attribute»_«state name»()` instead of `to_«state name»()`. This is done to allow multiple machines to work on the same model with individual state attribute names.

  ```python
  lump = Matter()
  machine = Machine(lump, states=['solid', 'liquid', 'gas'],  model_attribute='matter_state', initial='solid')
  lump.matter_state
  >>> 'solid'

  lump.is_matter_state_solid()
  >>> True
  lump.to_matter_state_gas()
  >>> True
  ```



  So far we have seen how we can give state names and use these names to work with our state machine.
  If you favour stricter typing and more IDE code completion (or you just can't type 'sesquipedalophobia' any longer because the word scares you) using [Enumerations](https://docs.python.org/3/library/enum.html) might be what you are looking for:

  ```python
  import enum  # Python 2.7 users need to have 'enum34' installed
  from transitions import Machine

  class States(enum.Enum):
      ERROR = 0
      RED = 1
      YELLOW = 2
      GREEN = 3

  transitions = [['proceed', States.RED, States.YELLOW],
                 ['proceed', States.YELLOW, States.GREEN],
                 ['error', '*', States.ERROR]]

  m = Machine(states=States, transitions=transitions, initial=States.RED)
  assert m.is_RED()
  assert m.state is States.RED
  state = m.get_state(States.RED)  # get transitions.State object
  print(state.name)  # >>> RED
  m.proceed()
  m.proceed()
  assert m.is_GREEN()
  m.error()
  assert m.state is States.ERROR
  ```

  You can mix enums and strings if you like (e.g. `[States.RED, 'ORANGE', States.YELLOW, States.GREEN]`) but note that internally, `transitions` will still handle states by name (`enum.Enum.name`).
  Thus, it is not possible to have the states `'GREEN'` and `States.GREEN` at the same time.



  Some of the above examples already illustrate the use of transitions in passing, but here we'll explore them in more detail.

  As with states, each transition is represented internally as its own object – an instance of class `Transition`. The quickest way to initialize a set of transitions is to pass a dictionary, or list of dictionaries, to the `Machine` initializer. We already saw this above:

  ```python
  transitions = [
      { 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid' },
      { 'trigger': 'evaporate', 'source': 'liquid', 'dest': 'gas' },
      { 'trigger': 'sublimate', 'source': 'solid', 'dest': 'gas' },
      { 'trigger': 'ionize', 'source': 'gas', 'dest': 'plasma' }
  ]
  machine = Machine(model=Matter(), states=states, transitions=transitions)
  ```

  Defining transitions in dictionaries has the benefit of clarity, but can be cumbersome. If you're after brevity, you might choose to define transitions using lists. Just make sure that the elements in each list are in the same order as the positional arguments in the `Transition` initialization (i.e., `trigger`, `source`, `destination`, etc.).

  The following list-of-lists is functionally equivalent to the list-of-dictionaries above:

  ```python
  transitions = [
      ['melt', 'solid', 'liquid'],
      ['evaporate', 'liquid', 'gas'],
      ['sublimate', 'solid', 'gas'],
      ['ionize', 'gas', 'plasma']
  ]
  ```

  Alternatively, you can add transitions to a `Machine` after initialization:

  ```python
  machine = Machine(model=lump, states=states, initial='solid')
  machine.add_transition('melt', source='solid', dest='liquid')
  ```

  The `trigger` argument defines the name of the new triggering method that gets attached to the base model. When this method is called, it will try to execute the transition:

  ```python
  >>> lump.melt()
  >>> lump.state
  'liquid'
  ```

  By default, calling an invalid trigger will raise an exception:

  ```python
  >>> lump.to_gas()
  >>> # This won't work because only objects in a solid state can melt
  >>> lump.melt()
  transitions.core.MachineError: "Can't trigger event melt from state gas!"
  ```

  This behavior is generally desirable, since it helps alert you to problems in your code. But in some cases, you might want to silently ignore invalid triggers. You can do this by setting `ignore_invalid_triggers=True` (either on a state-by-state basis, or globally for all states):

  ```python
  >>> # Globally suppress invalid trigger exceptions
  >>> m = Machine(lump, states, initial='solid', ignore_invalid_triggers=True)
  >>> # ...or suppress for only one group of states
  >>> states = ['new_state1', 'new_state2']
  >>> m.add_states(states, ignore_invalid_triggers=True)
  >>> # ...or even just for a single state. Here, exceptions will only be suppressed when the current state is A.
  >>> states = [State('A', ignore_invalid_triggers=True), 'B', 'C']
  >>> m = Machine(lump, states)
  >>> # ...this can be inverted as well if just one state should raise an exception
  >>> # since the machine's global value is not applied to a previously initialized state.
  >>> states = ['A', 'B', State('C')] # the default value for 'ignore_invalid_triggers' is False
  >>> m = Machine(lump, states, ignore_invalid_triggers=True)
  ```

  If you need to know which transitions are valid from a certain state, you can use `get_triggers`:

  ```python
  m.get_triggers('solid')
  >>> ['melt', 'sublimate']
  m.get_triggers('liquid')
  >>> ['evaporate']
  m.get_triggers('plasma')
  >>> []

  m.get_triggers('solid', 'liquid', 'gas', 'plasma')
  >>> ['melt', 'evaporate', 'sublimate', 'ionize']
  ```



  In addition to any transitions added explicitly, a `to_«state»()` method is created automatically whenever a state is added to a `Machine` instance. This method transitions to the target state no matter which state the machine is currently in:

  ```python
  lump.to_liquid()
  lump.state
  >>> 'liquid'
  lump.to_solid()
  lump.state
  >>> 'solid'
  ```

  If you desire, you can disable this behavior by setting `auto_transitions=False` in the `Machine` initializer.



  A given trigger can be attached to multiple transitions, some of which can potentially begin or end in the same state. For example:

  ```python
  machine.add_transition('transmogrify', ['solid', 'liquid', 'gas'], 'plasma')
  machine.add_transition('transmogrify', 'plasma', 'solid')

  machine.add_transition('transmogrify', 'plasma', 'gas')
  ```

  In this case, calling `transmogrify()` will set the model's state to `'solid'` if it's currently `'plasma'`, and set it to `'plasma'` otherwise. (Note that only the _first_ matching transition will execute; thus, the transition defined in the last line above won't do anything.)

  You can also make a trigger cause a transition from _all_ states to a particular destination by using the `'*'` wildcard:

  ```python
  machine.add_transition('to_liquid', '*', 'liquid')
  ```

  Note that wildcard transitions will only apply to states that exist at the time of the add_transition() call. Calling a wildcard-based transition when the model is in a state added after the transition was defined will elicit an invalid transition message, and will not transition to the target state.



  A reflexive trigger (trigger that has the same state as source and destination) can easily be added specifying `=` as destination.
  This is handy if the same reflexive trigger should be added to multiple states.
  For example:

  ```python
  machine.add_transition('touch', ['liquid', 'gas', 'plasma'], '=', after='change_shape')
  ```

  This will add reflexive transitions for all three states with `touch()` as trigger and with `change_shape` executed after each trigger.



  In contrast to reflexive transitions, internal transitions will never actually leave the state.
  This means that transition-related callbacks such as `before` or `after` will be processed while state-related callbacks `exit` or `enter` will not.
  To define a transition to be internal, set the destination to `None`.

  ```python
  machine.add_transition('internal', ['liquid', 'gas'], None, after='change_shape')
  ```



  A common desire is for state transitions to follow a strict linear sequence. For instance, given states `['A', 'B', 'C']`, you might want valid transitions for `A` → `B`, `B` → `C`, and `C` → `A` (but no other pairs).

  To facilitate this behavior, Transitions provides an `add_ordered_transitions()` method in the `Machine` class:

  ```python
  states = ['A', 'B', 'C']
   
  machine = Machine(states=states, initial='A')
  machine.add_ordered_transitions()
  machine.next_state()
  print(machine.state)
  >>> 'B'

  machine = Machine(states=states, initial='A')
  machine.add_ordered_transitions(['A', 'C', 'B'])
  machine.next_state()
  print(machine.state)
  >>> 'C'


  machine = Machine(states=states, initial='A')
  machine.add_ordered_transitions(conditions='check')


  machine = Machine(states=states, initial='A')
  machine.add_ordered_transitions(conditions=['check_A2B', ..., 'check_X2A'])

  machine = Machine(states=states, initial='B')
  machine.add_ordered_transitions(conditions=['check_B2C', ..., 'check_A2B'])


  machine = Machine(states=states, initial='A')
  machine.add_ordered_transitions(loop=False)
  machine.next_state()
  machine.next_state()
  machine.next_state() # transitions.core.MachineError: "Can't trigger event next_state from state C!"
  ```



  The default behaviour in Transitions is to process events instantly. This means events within an `on_enter` method will be processed _before_ callbacks bound to `after` are called.

  ```python
  def go_to_C():
      global machine
      machine.to_C()

  def after_advance():
      print("I am in state B now!")

  def entering_C():
      print("I am in state C now!")

  states = ['A', 'B', 'C']
  machine = Machine(states=states, initial='A')


  machine.add_transition('advance', 'A', 'B', after=after_advance)


  machine.on_enter_B(go_to_C)


  machine.on_enter_C(entering_C)
  machine.advance()
  >>> 'I am in state C now!'
  >>> 'I am in state B now!' # what?
  ```

  The execution order of this example is

  ```
  prepare -> before -> on_enter_B -> on_enter_C -> after.
  ```

  If queued processing is enabled, a transition will be finished before the next transition is triggered:

  ```python
  machine = Machine(states=states, queued=True, initial='A')
  ...
  machine.advance()
  >>> 'I am in state B now!'
  >>> 'I am in state C now!' # That's better!
  ```

  This results in

  ```
  prepare -> before -> on_enter_B -> queue(to_C) -> after  -> on_enter_C.
  ```

  **Important note:** when processing events in a queue, the trigger call will _always_ return `True`, since there is no way to determine at queuing time whether a transition involving queued calls will ultimately complete successfully. This is true even when only a single event is processed.

  ```python
  machine.add_transition('jump', 'A', 'C', conditions='will_fail')
  ...

  machine.jump()
  >>> False

  machine.jump()
  >>> True
  ```

  When a model is removed from the machine, `transitions` will also remove all related events from the queue.

  ```python
  class Model:
      def on_enter_B(self):
          self.to_C()  # add event to queue ...
          self.machine.remove_model(self)  # aaaand it's gone
  ```



  Sometimes you only want a particular transition to execute if a specific condition occurs. You can do this by passing a method, or list of methods, in the `conditions` argument:

  ```python

  class Matter(object):
      def is_flammable(self): return False
      def is_really_hot(self): return True

  machine.add_transition('heat', 'solid', 'gas', conditions='is_flammable')
  machine.add_transition('heat', 'solid', 'liquid', conditions=['is_really_hot'])
  ```

  In the above example, calling `heat()` when the model is in state `'solid'` will transition to state `'gas'` if `is_flammable` returns `True`. Otherwise, it will transition to state `'liquid'` if `is_really_hot` returns `True`.

  For convenience, there's also an `'unless'` argument that behaves exactly like conditions, but inverted:

  ```python
  machine.add_transition('heat', 'solid', 'gas', unless=['is_flammable', 'is_really_hot'])
  ```

  In this case, the model would transition from solid to gas whenever `heat()` fires, provided that both `is_flammable()` and `is_really_hot()` return `False`.

  Note that condition-checking methods will passively receive optional arguments and/or data objects passed to triggering methods. For instance, the following call:

  ```python
  lump.heat(temp=74)

  ```

  ... would pass the `temp=74` optional kwarg to the `is_flammable()` check (possibly wrapped in an `EventData` instance). For more on this, see the [Passing data](#passing-data) section below.



  If you want to check whether a transition is possible before you execute it ('look before you leap'), you can use `may_<trigger_name>` convenience functions that have been attached to your model:

  ```python

  if lump.may_heat():
      lump.heat()
  ```

  This will execute all `prepare` callbacks and evaluate the conditions assigned to the potential transitions.
  Transition checks can also be used when a transition's destination is not available (yet):

  ```python
  machine.add_transition('elevate', 'solid', 'spiritual')
  assert not lump.may_elevate()  # not ready yet :(
  ```



  You can attach callbacks to transitions as well as states. Every transition has `'before'` and `'after'` attributes that contain a list of methods to call before and after the transition executes:

  ```python
  class Matter(object):
      def make_hissing_noises(self): print("HISSSSSSSSSSSSSSSS")
      def disappear(self): print("where'd all the liquid go?")

  transitions = [
      { 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid', 'before': 'make_hissing_noises'},
      { 'trigger': 'evaporate', 'source': 'liquid', 'dest': 'gas', 'after': 'disappear' }
  ]

  lump = Matter()
  machine = Machine(lump, states, transitions=transitions, initial='solid')
  lump.melt()
  >>> "HISSSSSSSSSSSSSSSS"
  lump.evaporate()
  >>> "where'd all the liquid go?"
  ```

  There is also a `'prepare'` callback that is executed as soon as a transition starts, before any `'conditions'` are checked or other callbacks are executed.

  ```python
  class Matter(object):
      heat = False
      attempts = 0
      def count_attempts(self): self.attempts += 1
      def heat_up(self): self.heat = random.random() < 0.25
      def stats(self): print('It took you %i attempts to melt the lump!' %self.attempts)

      @property
      def is_really_hot(self):
          return self.heat


  states=['solid', 'liquid', 'gas', 'plasma']

  transitions = [
      { 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid', 'prepare': ['heat_up', 'count_attempts'], 'conditions': 'is_really_hot', 'after': 'stats'},
  ]

  lump = Matter()
  machine = Machine(lump, states, transitions=transitions, initial='solid')
  lump.melt()
  lump.melt()
  lump.melt()
  lump.melt()
  >>> "It took you 4 attempts to melt the lump!"
  ```

  Note that `prepare` will not be called unless the current state is a valid source for the named transition.

  Default actions meant to be executed before or after _every_ transition can be passed to `Machine` during initialization with
  `before_state_change` and `after_state_change` respectively:

  ```python
  class Matter(object):
      def make_hissing_noises(self): print("HISSSSSSSSSSSSSSSS")
      def disappear(self): print("where'd all the liquid go?")

  states=['solid', 'liquid', 'gas', 'plasma']

  lump = Matter()
  m = Machine(lump, states, before_state_change='make_hissing_noises', after_state_change='disappear')
  lump.to_gas()
  >>> "HISSSSSSSSSSSSSSSS"
  >>> "where'd all the liquid go?"
  ```

  There are also two keywords for callbacks which should be executed _independently_ a) of how many transitions are possible,
  b) if any transition succeeds and c) even if an error is raised during the execution of some other callback.
  Callbacks passed to `Machine` with `prepare_event` will be executed _once_ before processing possible transitions
  (and their individual `prepare` callbacks) takes place.
  Callbacks of `finalize_event` will be executed regardless of the success of the processed transitions.
  Note that if an error occurred it will be attached to `event_data` as `error` and can be retrieved with `send_event=True`.

  ```python
  from transitions import Machine

  class Matter(object):
      def raise_error(self, event): raise ValueError("Oh no")
      def prepare(self, event): print("I am ready!")
      def finalize(self, event): print("Result: ", type(event.error), event.error)

  states=['solid', 'liquid', 'gas', 'plasma']

  lump = Matter()
  m = Machine(lump, states, prepare_event='prepare', before_state_change='raise_error',
              finalize_event='finalize', send_event=True)
  try:
      lump.to_gas()
  except ValueError:
      pass
  print(lump.state)




  ```

  Sometimes things just don't work out as intended and we need to handle exceptions and clean up the mess to keep things going.
  We can pass callbacks to `on_exception` to do this:

  ```python
  from transitions import Machine

  class Matter(object):
      def raise_error(self, event): raise ValueError("Oh no")
      def handle_error(self, event):
          print("Fixing things ...")
          del event.error  # it did not happen if we cannot see it ...

  states=['solid', 'liquid', 'gas', 'plasma']

  lump = Matter()
  m = Machine(lump, states, before_state_change='raise_error', on_exception='handle_error', send_event=True)
  try:
      lump.to_gas()
  except ValueError:
      pass
  print(lump.state)



  ```



  As you have probably already realized, the standard way of passing callables to states, conditions and transitions is by name. When processing callbacks and conditions, `transitions` will use their name to retrieve the related callable from the model. If the method cannot be retrieved and it contains dots, `transitions` will treat the name as a path to a module function and try to import it. Alternatively, you can pass names of properties or attributes. They will be wrapped into functions but cannot receive event data for obvious reasons. You can also pass callables such as (bound) functions directly. As mentioned earlier, you can also pass lists/tuples of callables names to the callback parameters. Callbacks will be executed in the order they were added.

  ```python
  from transitions import Machine
  from mod import imported_func

  import random


  class Model(object):

      def a_callback(self):
          imported_func()

      @property
      def a_property(self):
          """ Basically a coin toss. """
          return random.random() < 0.5

      an_attribute = False


  model = Model()
  machine = Machine(model=model, states=['A'], initial='A')
  machine.add_transition('by_name', 'A', 'A', conditions='a_property', after='a_callback')
  machine.add_transition('by_reference', 'A', 'A', unless=['a_property', 'an_attribute'], after=model.a_callback)
  machine.add_transition('imported', 'A', 'A', after='mod.imported_func')

  model.by_name()
  model.by_reference()
  model.imported()
  ```

  The callable resolution is done in `Machine.resolve_callable`.
  This method can be overridden in case more complex callable resolution strategies are required.

  **Example**

  ```python
  class CustomMachine(Machine):
      @staticmethod
      def resolve_callable(func, event_data):
          
          super(CustomMachine, CustomMachine).resolve_callable(func, event_data)
  ```



  In summary, there are currently three ways to trigger events. You can call a model's convenience functions like `lump.melt()`,
  execute triggers by name such as `lump.trigger("melt")` or dispatch events on multiple models with `machine.dispatch("melt")`
  (see section about multiple models in [alternative initialization patterns](#alternative-initialization-patterns)).
  Callbacks on transitions are then executed in the following order:

  | Callback                        |    Current State     | Comments                                                                                    |
  | ------------------------------- | :------------------: | ------------------------------------------------------------------------------------------- |
  | `'machine.prepare_event'`       |       `source`       | executed _once_ before individual transitions are processed                                 |
  | `'transition.prepare'`          |       `source`       | executed as soon as the transition starts                                                   |
  | `'transition.conditions'`       |       `source`       | conditions _may_ fail and halt the transition                                               |
  | `'transition.unless'`           |       `source`       | conditions _may_ fail and halt the transition                                               |
  | `'machine.before_state_change'` |       `source`       | default callbacks declared on model                                                         |
  | `'transition.before'`           |       `source`       |                                                                                             |
  | `'state.on_exit'`               |       `source`       | callbacks declared on the source state                                                      |
  | `<STATE CHANGE>`                |                      |                                                                                             |
  | `'state.on_enter'`              |    `destination`     | callbacks declared on the destination state                                                 |
  | `'transition.after'`            |    `destination`     |                                                                                             |
  | `'machine.after_state_change'`  |    `destination`     | default callbacks declared on model                                                         |
  | `'machine.on_exception'`        | `source/destination` | callbacks will be executed when an exception has been raised                                |
  | `'machine.finalize_event'`      | `source/destination` | callbacks will be executed even if no transition took place or an exception has been raised |

  If any callback raises an exception, the processing of callbacks is not continued. This means that when an error occurs before the transition (in `state.on_exit` or earlier), it is halted. In case there is a raise after the transition has been conducted (in `state.on_enter` or later), the state change persists and no rollback is happening. Callbacks specified in `machine.finalize_event` will always be executed unless the exception is raised by a finalizing callback itself. Note that each callback sequence has to be finished before the next stage is executed. Blocking callbacks will halt the execution order and therefore block the `trigger` or `dispatch` call itself. If you want callbacks to be executed in parallel, you could have a look at the [extensions](#extensions) `AsyncMachine` for asynchronous processing or `LockedMachine` for threading.



  Sometimes you need to pass the callback functions registered at machine initialization some data that reflects the model's current state.
  Transitions allows you to do this in two different ways.

  First (the default), you can pass any positional or keyword arguments directly to the trigger methods (created when you call `add_transition()`):

  ```python
  class Matter(object):
      def __init__(self): self.set_environment()
      def set_environment(self, temp=0, pressure=101.325):
          self.temp = temp
          self.pressure = pressure
      def print_temperature(self): print("Current temperature is %d degrees celsius." % self.temp)
      def print_pressure(self): print("Current pressure is %.2f kPa." % self.pressure)

  lump = Matter()
  machine = Machine(lump, ['solid', 'liquid'], initial='solid')
  machine.add_transition('melt', 'solid', 'liquid', before='set_environment')

  lump.melt(45)  # positional arg;

  lump.print_temperature()
  >>> 'Current temperature is 45 degrees celsius.'

  machine.set_state('solid')  # reset state so we can melt again
  lump.melt(pressure=300.23)  # keyword args also work
  lump.print_pressure()
  >>> 'Current pressure is 300.23 kPa.'

  ```

  You can pass any number of arguments you like to the trigger.

  There is one important limitation to this approach: every callback function triggered by the state transition must be able to handle _all_ of the arguments. This may cause problems if the callbacks each expect somewhat different data.

  To get around this, Transitions supports an alternate method for sending data. If you set `send_event=True` at `Machine` initialization, all arguments to the triggers will be wrapped in an `EventData` instance and passed on to every callback. (The `EventData` object also maintains internal references to the source state, model, transition, machine, and trigger associated with the event, in case you need to access these for anything.)

  ```python
  class Matter(object):

      def __init__(self):
          self.temp = 0
          self.pressure = 101.325

      
      
      
      def set_environment(self, event):
          self.temp = event.kwargs.get('temp', 0)
          self.pressure = event.kwargs.get('pressure', 101.325)

      def print_pressure(self): print("Current pressure is %.2f kPa." % self.pressure)

  lump = Matter()
  machine = Machine(lump, ['solid', 'liquid'], send_event=True, initial='solid')
  machine.add_transition('melt', 'solid', 'liquid', before='set_environment')

  lump.melt(temp=45, pressure=1853.68)  # keyword args
  lump.print_pressure()
  >>> 'Current pressure is 1853.68 kPa.'

  ```



  In all of the examples so far, we've attached a new `Machine` instance to a separate model (`lump`, an instance of class `Matter`). While this separation keeps things tidy (because you don't have to monkey patch a whole bunch of new methods into the `Matter` class), it can also get annoying, since it requires you to keep track of which methods are called on the state machine, and which ones are called on the model that the state machine is bound to (e.g., `lump.on_enter_StateA()` vs. `machine.add_transition()`).

  Fortunately, Transitions is flexible, and supports two other initialization patterns.

  First, you can create a standalone state machine that doesn't require another model at all. Simply omit the model argument during initialization:

  ```python
  machine = Machine(states=states, transitions=transitions, initial='solid')
  machine.melt()
  machine.state
  >>> 'liquid'
  ```

  If you initialize the machine this way, you can then attach all triggering events (like `evaporate()`, `sublimate()`, etc.) and all callback functions directly to the `Machine` instance.

  This approach has the benefit of consolidating all of the state machine functionality in one place, but can feel a little bit unnatural if you think state logic should be contained within the model itself rather than in a separate controller.

  An alternative (potentially better) approach is to have the model inherit from the `Machine` class. Transitions is designed to support inheritance seamlessly. (just be sure to override class `Machine`'s `__init__` method!):

  ```python
  class Matter(Machine):
      def say_hello(self): print("hello, new state!")
      def say_goodbye(self): print("goodbye, old state!")

      def __init__(self):
          states = ['solid', 'liquid', 'gas']
          Machine.__init__(self, states=states, initial='solid')
          self.add_transition('melt', 'solid', 'liquid')

  lump = Matter()
  lump.state
  >>> 'solid'
  lump.melt()
  lump.state
  >>> 'liquid'
  ```

  Here you get to consolidate all state machine functionality into your existing model, which often feels more natural than sticking all of the functionality we want in a separate standalone `Machine` instance.

  A machine can handle multiple models which can be passed as a list like `Machine(model=[model1, model2, ...])`.
  In cases where you want to add models _as well as_ the machine instance itself, you can pass the class variable placeholder (string) `Machine.self_literal` during initialization like `Machine(model=[Machine.self_literal, model1, ...])`.
  You can also create a standalone machine, and register models dynamically via `machine.add_model` by passing `model=None` to the constructor.
  Furthermore, you can use `machine.dispatch` to trigger events on all currently added models.
  Remember to call `machine.remove_model` if machine is long-lasting and your models are temporary and should be garbage collected:

  ```python
  class Matter():
      pass

  lump1 = Matter()
  lump2 = Matter()


  machine = Machine(model=None, states=states, transitions=transitions, initial='solid')

  machine.add_model(lump1)
  machine.add_model(lump2, initial='liquid')

  lump1.state
  >>> 'solid'
  lump2.state
  >>> 'liquid'


  machine.dispatch("to_plasma")

  lump1.state
  >>> 'plasma'
  assert lump1.state == lump2.state

  machine.remove_model([lump1, lump2])
  del lump1  # lump1 is garbage collected
  del lump2  # lump2 is garbage collected
  ```

  If you don't provide an initial state in the state machine constructor, `transitions` will create and add a default state called `'initial'`.
  If you do not want a default initial state, you can pass `initial=None`.
  However, in this case you need to pass an initial state every time you add a model.

  ```python
  machine = Machine(model=None, states=states, transitions=transitions, initial=None)

  machine.add_model(Matter())
  >>> "MachineError: No initial state configured for machine, must specify when adding model."
  machine.add_model(Matter(), initial='liquid')
  ```

  Models with multiple states could attach multiple machines using different `model_attribute` values. As mentioned in [Checking state](#checking-state), this will add custom `is/to_<model_attribute>_<state_name>` functions:

  ```python
  lump = Matter()

  matter_machine = Machine(lump, states=['solid', 'liquid', 'gas'], initial='solid')

  shipment_machine = Machine(lump, states=['delivered', 'shipping'], initial='delivered', model_attribute='shipping_state')

  lump.state
  >>> 'solid'
  lump.is_solid()  # check the default field
  >>> True
  lump.shipping_state
  >>> 'delivered'
  lump.is_shipping_state_delivered()  # check the custom field.
  >>> True
  lump.to_shipping_state_shipping()
  >>> True
  lump.is_shipping_state_delivered()
  >>> False
  ```



  Transitions includes very rudimentary logging capabilities. A number of events – namely, state changes, transition triggers, and conditional checks – are logged as INFO-level events using the standard Python `logging` module. This means you can easily configure logging to standard output in a script:

  ```python

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

  logging.getLogger('transitions').setLevel(logging.INFO)


  machine = Machine(states=states, transitions=transitions, initial='solid')
  ...
  ```



  Machines are picklable and can be stored and loaded with `pickle`. For Python 3.3 and earlier `dill` is required.

  ```python
  import dill as pickle # only required for Python 3.3 and earlier

  m = Machine(states=['A', 'B', 'C'], initial='A')
  m.to_B()
  m.state
  >>> B


  dump = pickle.dumps(m)


  m2 = pickle.loads(dump)

  m2.state
  >>> B

  m2.states.keys()
  >>> ['A', 'B', 'C']
  ```



  Even though the core of transitions is kept lightweight, there are a variety of MixIns to extend its functionality. Currently supported are:

  - **Diagrams** to visualize the current state of a machine
  - **Hierarchical State Machines** for nesting and reuse
  - **Threadsafe Locks** for parallel execution
  - **Async callbacks** for asynchronous execution
  - **Custom States** for extended state-related behaviour

  There are two mechanisms to retrieve a state machine instance with the desired features enabled.
  The first approach makes use of the convenience `factory` with the four parameters `graph`, `nested`, `locked` or `asyncio` set to `True` if the feature is required:

  ```python
  from transitions.extensions import MachineFactory


  diagram_cls = MachineFactory.get_predefined(graph=True)
  nested_locked_cls = MachineFactory.get_predefined(nested=True, locked=True)
  async_machine_cls = MachineFactory.get_predefined(asyncio=True)



  machine1 = diagram_cls(model, state, transitions)
  machine2 = nested_locked_cls(model, state, transitions)
  ```

  This approach targets experimental use since in this case the underlying classes do not have to be known.
  However, classes can also be directly imported from `transitions.extensions`. The naming scheme is as follows:

  |                                | Diagrams | Nested | Locked | Asyncio |
  | -----------------------------: | :------: | :----: | :----: | :-----: |
  |                        Machine |    ✘     |   ✘    |   ✘    |    ✘    |
  |                   GraphMachine |    ✓     |   ✘    |   ✘    |    ✘    |
  |            HierarchicalMachine |    ✘     |   ✓    |   ✘    |    ✘    |
  |                  LockedMachine |    ✘     |   ✘    |   ✓    |    ✘    |
  |       HierarchicalGraphMachine |    ✓     |   ✓    |   ✘    |    ✘    |
  |             LockedGraphMachine |    ✓     |   ✘    |   ✓    |    ✘    |
  |      LockedHierarchicalMachine |    ✘     |   ✓    |   ✓    |    ✘    |
  | LockedHierarchicalGraphMachine |    ✓     |   ✓    |   ✓    |    ✘    |
  |                   AsyncMachine |    ✘     |   ✘    |   ✘    |    ✓    |
  |              AsyncGraphMachine |    ✓     |   ✘    |   ✘    |    ✓    |
  |       HierarchicalAsyncMachine |    ✘     |   ✓    |   ✘    |    ✓    |
  |  HierarchicalAsyncGraphMachine |    ✓     |   ✓    |   ✘    |    ✓    |

  To use a feature-rich state machine, one could write:

  ```python
  from transitions.extensions import LockedHierarchicalGraphMachine as LHGMachine

  machine = LHGMachine(model, states, transitions)
  ```



  Additional Keywords:

  - `title` (optional): Sets the title of the generated image.
  - `show_conditions` (default False): Shows conditions at transition edges
  - `show_auto_transitions` (default False): Shows auto transitions in graph
  - `show_state_attributes` (default False): Show callbacks (enter, exit), tags and timeouts in graph

  Transitions can generate basic state diagrams displaying all valid transitions between states. To use the graphing functionality, you'll need to have `graphviz` and/or `pygraphviz` installed:
  To generate graphs with the package `graphviz`, you need to install [Graphviz](https://graphviz.org/) manually or via a package manager.

      sudo apt-get install graphviz graphviz-dev  # Ubuntu and Debian
      brew install graphviz  # MacOS
      conda install graphviz python-graphviz  # (Ana)conda

  Now you can install the actual Python packages

      pip install graphviz pygraphviz # install graphviz and/or pygraphviz manually...
      pip install transitions[diagrams]  # ... or install transitions with 'diagrams' extras which currently depends on pygraphviz

  Currently, `GraphMachine` will use `pygraphviz` when available and fall back to `graphviz` when `pygraphviz` cannot be
  found. This can be overridden by passing `use_pygraphviz=False` to the constructor. Note that this default might change
  in the future and `pygraphviz` support may be dropped.
  With `Model.get_graph()` you can get the current graph or the region of interest (roi) and draw it like this:

  ```python


  from transitions.extensions import GraphMachine
  m = Model()

  machine = GraphMachine(model=m, ...)

  machine = GraphMachine(model=m, use_pygraphviz=False, ...)

  machine = GraphMachine(model=m, show_auto_transitions=True, ...)


  m.get_graph().draw('my_state_diagram.png', prog='dot')


  roi = m.get_graph(show_roi=True).draw('my_state_diagram.png', prog='dot')
  ```

  This produces something like this:

  ![state diagram example](https://user-images.githubusercontent.com/205986/47524268-725c1280-d89a-11e8-812b-1d3b6e667b91.png)

  Independent of the backend you use, the draw function also accepts a file descriptor or a binary stream as the first argument. If you set this parameter to `None`, the byte stream will be returned:

  ```python
  import io

  with open('a_graph.png', 'bw') as f:
      
      m.get_graph().draw(f, format="png", prog='dot')


  b = io.BytesIO()
  m.get_graph().draw(b, format="png", prog='dot')


  result = m.get_graph().draw(None, format="png", prog='dot')
  assert result == b.getvalue()
  ```

  References and partials passed as callbacks will be resolved as good as possible:

  ```python
  from transitions.extensions import GraphMachine
  from functools import partial


  class Model:

      def clear_state(self, deep=False, force=False):
          print("Clearing state ...")
          return True


  model = Model()
  machine = GraphMachine(model=model, states=['A', 'B', 'C'],
                         transitions=[
                             {'trigger': 'clear', 'source': 'B', 'dest': 'A', 'conditions': model.clear_state},
                             {'trigger': 'clear', 'source': 'C', 'dest': 'A',
                              'conditions': partial(model.clear_state, False, force=True)},
                         ],
                         initial='A', show_conditions=True)

  model.get_graph().draw('my_state_diagram.png', prog='dot')
  ```

  This should produce something similar to this:

  ![state diagram references_example](https://user-images.githubusercontent.com/205986/110783076-39087f80-8268-11eb-8fa1-fc7bac97f4cf.png)

  If the format of references does not suit your needs, you can override the static method `GraphMachine.format_references`. If you want to skip reference entirely, just let `GraphMachine.format_references` return `None`.
  Also, have a look at our [example](./examples) IPython/Jupyter notebooks for a more detailed example about how to use and edit graphs.



  Transitions includes an extension module which allows nesting states.
  This allows us to create contexts and to model cases where states are related to certain subtasks in the state machine.
  To create a nested state, either import `NestedState` from transitions or use a dictionary with the initialization arguments `name` and `children`.
  Optionally, `initial` can be used to define a sub state to transit to, when the nested state is entered.

  ```python
  from transitions.extensions import HierarchicalMachine

  states = ['standing', 'walking', {'name': 'caffeinated', 'children':['dithering', 'running']}]
  transitions = [
    ['walk', 'standing', 'walking'],
    ['stop', 'walking', 'standing'],
    ['drink', '*', 'caffeinated'],
    ['walk', ['caffeinated', 'caffeinated_dithering'], 'caffeinated_running'],
    ['relax', 'caffeinated', 'standing']
  ]

  machine = HierarchicalMachine(states=states, transitions=transitions, initial='standing', ignore_invalid_triggers=True)

  machine.walk() # Walking now
  machine.stop() # let's stop for a moment
  machine.drink() # coffee time
  machine.state
  >>> 'caffeinated'
  machine.walk() # we have to go faster
  machine.state
  >>> 'caffeinated_running'
  machine.stop() # can't stop moving!
  machine.state
  >>> 'caffeinated_running'
  machine.relax() # leave nested state
  machine.state # phew, what a ride
  >>> 'standing'

  ```

  A configuration making use of `initial` could look like this:

  ```python

  states = ['standing', 'walking', {'name': 'caffeinated', 'initial': 'dithering', 'children': ['dithering', 'running']}]
  transitions = [
    ['walk', 'standing', 'walking'],
    ['stop', 'walking', 'standing'],
    
    ['drink', '*', 'caffeinated'],
    
    ['walk', 'caffeinated_dithering', 'caffeinated_running'],
    ['relax', 'caffeinated', 'standing']
  ]

  ```

  The `initial` keyword of the `HierarchicalMachine` constructor accepts nested states (e.g. `initial='caffeinated_running'`) and a list of states which is considered to be a parallel state (e.g. `initial=['A', 'B']`) or the current state of another model (`initial=model.state`) which should be effectively one of the previous mentioned options. Note that when passing a string, `transition` will check the targeted state for `initial` substates and use this as an entry state. This will be done recursively until a substate does not mention an initial state. Parallel states or a state passed as a list will be used 'as is' and no further initial evaluation will be conducted.

  Note that your previously created state object _must be_ a `NestedState` or a derived class of it.
  The standard `State` class used in simple `Machine` instances lacks features required for nesting.

  ```python
  from transitions.extensions.nesting import HierarchicalMachine, NestedState
  from transitions import  State
  m = HierarchicalMachine(states=['A'], initial='initial')
  m.add_state('B')  # fine
  m.add_state({'name': 'C'})  # also fine
  m.add_state(NestedState('D'))  # fine as well
  m.add_state(State('E'))  # does not work!
  ```

  Some things that have to be considered when working with nested states: State _names are concatenated_ with `NestedState.separator`.
  Currently the separator is set to underscore ('\_') and therefore behaves similar to the basic machine.
  This means a substate `bar` from state `foo` will be known by `foo_bar`. A substate `baz` of `bar` will be referred to as `foo_bar_baz` and so on.
  When entering a substate, `enter` will be called for all parent states. The same is true for exiting substates.
  Third, nested states can overwrite transition behaviour of their parents.
  If a transition is not known to the current state it will be delegated to its parent.

  **This means that in the standard configuration, state names in HSMs MUST NOT contain underscores.**
  For `transitions` it's impossible to tell whether `machine.add_state('state_name')` should add a state named `state_name` or add a substate `name` to the state `state`.
  In some cases this is not sufficient however.
  For instance if state names consist of more than one word and you want/need to use underscore to separate them instead of `CamelCase`.
  To deal with this, you can change the character used for separation quite easily.
  You can even use fancy unicode characters if you use Python 3.
  Setting the separator to something else than underscore changes some of the behaviour (auto_transition and setting callbacks) though:

  ```python
  from transitions.extensions import HierarchicalMachine
  from transitions.extensions.nesting import NestedState
  NestedState.separator = '↦'
  states = ['A', 'B',
    {'name': 'C', 'children':['1', '2',
      {'name': '3', 'children': ['a', 'b', 'c']}
    ]}
  ]

  transitions = [
      ['reset', 'C', 'A'],
      ['reset', 'C↦2', 'C']  # overwriting parent reset
  ]


  machine = HierarchicalMachine(states=states, transitions=transitions, initial='A')
  machine.to_B()  # exit state A, enter state B
  machine.to_C()  # exit B, enter C
  machine.to_C.s3.a()  # enter C↦a; enter C↦3↦a;
  machine.state
  >>> 'C↦3↦a'
  assert machine.is_C.s3.a()
  machine.to('C↦2')  # not interactive; exit C↦3↦a, exit C↦3, enter C↦2
  machine.reset()  # exit C↦2; reset C has been overwritten by C↦3
  machine.state
  >>> 'C'
  machine.reset()  # exit C, enter A
  machine.state
  >>> 'A'

  ```

  Instead of `to_C_3_a()` auto transition is called as `to_C.s3.a()`. If your substate starts with a digit, transitions adds a prefix 's' ('3' becomes 's3') to the auto transition `FunctionWrapper` to comply with the attribute naming scheme of Python.
  If interactive completion is not required, `to('C↦3↦a')` can be called directly. Additionally, `on_enter/exit_<<state name>>` is replaced with `on_enter/exit(state_name, callback)`. State checks can be conducted in a similar fashion. Instead of `is_C_3_a()`, the `FunctionWrapper` variant `is_C.s3.a()` can be used.

  To check whether the current state is a substate of a specific state, `is_state` supports the keyword `allow_substates`:

  ```python
  machine.state
  >>> 'C.2.a'
  machine.is_C() # checks for specific states
  >>> False
  machine.is_C(allow_substates=True)
  >>> True
  assert machine.is_C.s2() is False
  assert machine.is_C.s2(allow_substates=True)  # FunctionWrapper support allow_substate as well
  ```

  _new in 0.8.0_
  You can use enumerations in HSMs as well but keep in mind that `Enum` are compared by value.
  If you have a value more than once in a state tree those states cannot be distinguished.

  ```python
  states = [States.RED, States.YELLOW, {'name': States.GREEN, 'children': ['tick', 'tock']}]
  states = ['A', {'name': 'B', 'children': states, 'initial': States.GREEN}, States.GREEN]
  machine = HierarchicalMachine(states=states)
  machine.to_B()
  machine.is_GREEN()  # returns True even though the actual state is B_GREEN
  ```

  _new in 0.8.0_
  `HierarchicalMachine` has been rewritten from scratch to support parallel states and better isolation of nested states.
  This involves some tweaks based on community feedback.
  To get an idea of processing order and configuration have a look at the following example:

  ```python
  from transitions.extensions.nesting import HierarchicalMachine
  import logging
  states = ['A', 'B', {'name': 'C', 'parallel': [{'name': '1', 'children': ['a', 'b', 'c'], 'initial': 'a',
                                                  'transitions': [['go', 'a', 'b']]},
                                                 {'name': '2', 'children': ['x', 'y', 'z'], 'initial': 'z'}],
                        'transitions': [['go', '2_z', '2_x']]}]

  transitions = [['reset', 'C_1_b', 'B']]
  logging.basicConfig(level=logging.INFO)
  machine = HierarchicalMachine(states=states, transitions=transitions, initial='A')
  machine.to_C()






  machine.go()




  machine.reset()






  ```

  When using `parallel` instead of `children`, `transitions` will enter all states of the passed list at the same time.
  Which substate to enter is defined by `initial` which should _always_ point to a direct substate.
  A novel feature is to define local transitions by passing the `transitions` keyword in a state definition.
  The above defined transition `['go', 'a', 'b']` is only valid in `C_1`.
  While you can reference substates as done in `['go', '2_z', '2_x']` you cannot reference parent states directly in locally defined transitions.
  When a parent state is exited, its children will also be exited.
  In addition to the processing order of transitions known from `Machine` where transitions are considered in the order they were added, `HierarchicalMachine` considers hierarchy as well.
  Transitions defined in substates will be evaluated first (e.g. `C_1_a` is left before `C_2_z`) and transitions defined with wildcard `*` will (for now) only add transitions to root states (in this example `A`, `B`, `C`)
  Starting with _0.8.0_ nested states can be added directly and will issue the creation of parent states on-the-fly:

  ```python
  m = HierarchicalMachine(states=['A'], initial='A')
  m.add_state('B_1_a')
  m.to_B_1()
  assert m.is_B(allow_substates=True)
  ```



  Besides semantic order, nested states are very handy if you want to specify state machines for specific tasks and plan to reuse them.
  Before _0.8.0_, a `HierarchicalMachine` would not integrate the machine instance itself but the states and transitions by creating copies of them.
  However, since _0.8.0_ `(Nested)State` instances are just **referenced** which means changes in one machine's collection of states and events will influence the other machine instance. Models and their state will not be shared though.
  Note that events and transitions are also copied by reference and will be shared by both instances if you do not use the `remap` keyword.
  This change was done to be more in line with `Machine` which also uses passed `State` instances by reference.

  ```python
  count_states = ['1', '2', '3', 'done']
  count_trans = [
      ['increase', '1', '2'],
      ['increase', '2', '3'],
      ['decrease', '3', '2'],
      ['decrease', '2', '1'],
      ['done', '3', 'done'],
      ['reset', '*', '1']
  ]

  counter = HierarchicalMachine(states=count_states, transitions=count_trans, initial='1')

  counter.increase() # love my counter
  states = ['waiting', 'collecting', {'name': 'counting', 'children': counter}]

  transitions = [
      ['collect', '*', 'collecting'],
      ['wait', '*', 'waiting'],
      ['count', 'collecting', 'counting']
  ]

  collector = HierarchicalMachine(states=states, transitions=transitions, initial='waiting')
  collector.collect()  # collecting
  collector.count()  # let's see what we got; counting_1
  collector.increase()  # counting_2
  collector.increase()  # counting_3
  collector.done()  # collector.state == counting_done
  collector.wait()  # collector.state == waiting
  ```

  If a `HierarchicalMachine` is passed with the `children` keyword, the initial state of this machine will be assigned to the new parent state.
  In the above example we see that entering `counting` will also enter `counting_1`.
  If this is undesired behaviour and the machine should rather halt in the parent state, the user can pass `initial` as `False` like `{'name': 'counting', 'children': counter, 'initial': False}`.

  Sometimes you want such an embedded state collection to 'return' which means after it is done it should exit and transit to one of your super states.
  To achieve this behaviour you can remap state transitions.
  In the example above we would like the counter to return if the state `done` was reached.
  This is done as follows:

  ```python
  states = ['waiting', 'collecting', {'name': 'counting', 'children': counter, 'remap': {'done': 'waiting'}}]

  ... # same as above

  collector.increase() # counting_3
  collector.done()
  collector.state
  >>> 'waiting' # be aware that 'counting_done' will be removed from the state machine
  ```

  As mentioned above, using `remap` will **copy** events and transitions since they could not be valid in the original state machine.
  If a reused state machine does not have a final state, you can of course add the transitions manually.
  If 'counter' had no 'done' state, we could just add `['done', 'counter_3', 'waiting']` to achieve the same behaviour.

  In cases where you want states and transitions to be copied by value rather than reference (for instance, if you want to keep the pre-0.8 behaviour) you can do so by creating a `NestedState` and assigning deep copies of the machine's events and states to it.

  ```python
  from transitions.extensions.nesting import NestedState
  from copy import deepcopy



  counting_state = NestedState(name="counting", initial='1')
  counting_state.states = deepcopy(counter.states)
  counting_state.events = deepcopy(counter.events)

  states = ['waiting', 'collecting', counting_state]
  ```

  For complex state machines, sharing configurations rather than instantiated machines might be more feasible.
  Especially since instantiated machines must be derived from `HierarchicalMachine`.
  Such configurations can be stored and loaded easily via JSON or YAML (see the [FAQ](examples/Frequently%20asked%20questions.ipynb)).
  `HierarchicalMachine` allows defining substates either with the keyword `children` or `states`.
  If both are present, only `children` will be considered.

  ```python
  counter_conf = {
      'name': 'counting',
      'states': ['1', '2', '3', 'done'],
      'transitions': [
          ['increase', '1', '2'],
          ['increase', '2', '3'],
          ['decrease', '3', '2'],
          ['decrease', '2', '1'],
          ['done', '3', 'done'],
          ['reset', '*', '1']
      ],
      'initial': '1'
  }

  collector_conf = {
      'name': 'collector',
      'states': ['waiting', 'collecting', counter_conf],
      'transitions': [
          ['collect', '*', 'collecting'],
          ['wait', '*', 'waiting'],
          ['count', 'collecting', 'counting']
      ],
      'initial': 'waiting'
  }

  collector = HierarchicalMachine(**collector_conf)
  collector.collect()
  collector.count()
  collector.increase()
  assert collector.is_counting_2()
  ```



  In cases where event dispatching is done in threads, one can use either `LockedMachine` or `LockedHierarchicalMachine` where **function access** (!sic) is secured with reentrant locks.
  This does not save you from corrupting your machine by tinkering with member variables of your model or state machine.

  ```python
  from transitions.extensions import LockedMachine
  from threading import Thread
  import time

  states = ['A', 'B', 'C']
  machine = LockedMachine(states=states, initial='A')


  thread = Thread(target=machine.to_B)
  thread.start()
  time.sleep(0.01) # thread requires some time to start
  machine.to_C() # synchronized access; won't execute before thread is done

  thread = Thread(target=machine.to_B)
  thread.start()
  machine.new_attrib = 42 # not synchronized! will mess with execution order
  ```

  Any python context manager can be passed in via the `machine_context` keyword argument:

  ```python
  from transitions.extensions import LockedMachine
  from threading import RLock

  states = ['A', 'B', 'C']

  lock1 = RLock()
  lock2 = RLock()

  machine = LockedMachine(states=states, initial='A', machine_context=[lock1, lock2])
  ```

  Any contexts via `machine_model` will be shared between all models registered with the `Machine`.
  Per-model contexts can be added as well:

  ```python
  lock3 = RLock()

  machine.add_model(model, model_context=lock3)
  ```

  It's important that all user-provided context managers are re-entrant since the state machine will call them multiple
  times, even in the context of a single trigger invocation.



  If you are using Python 3.7 or later, you can use `AsyncMachine` to work with asynchronous callbacks.
  You can mix synchronous and asynchronous callbacks if you like but this may have undesired side effects.
  Note that events need to be awaited and the event loop must also be handled by you.

  ```python
  from transitions.extensions.asyncio import AsyncMachine
  import asyncio
  import time


  class AsyncModel:

      def prepare_model(self):
          print("I am synchronous.")
          self.start_time = time.time()

      async def before_change(self):
          print("I am asynchronous and will block now for 100 milliseconds.")
          await asyncio.sleep(0.1)
          print("I am done waiting.")

      def sync_before_change(self):
          print("I am synchronous and will block the event loop (what I probably shouldn't)")
          time.sleep(0.1)
          print("I am done waiting synchronously.")

      def after_change(self):
          print(f"I am synchronous again. Execution took {int((time.time() - self.start_time) * 1000)} ms.")


  transition = dict(trigger="start", source="Start", dest="Done", prepare="prepare_model",
                    before=["before_change"] * 5 + ["sync_before_change"],
                    after="after_change")  # execute before function in asynchronously 5 times
  model = AsyncModel()
  machine = AsyncMachine(model, states=["Start", "Done"], transitions=[transition], initial='Start')

  asyncio.get_event_loop().run_until_complete(model.start())














  assert model.is_Done()
  ```

  So, why do you need to use Python 3.7 or later you may ask.
  Async support has been introduced earlier.
  `AsyncMachine` makes use of `contextvars` to handle running callbacks when new events arrive before a transition
  has been finished:

  ```python
  async def await_never_return():
      await asyncio.sleep(100)
      raise ValueError("That took too long!")

  async def fix():
      await m2.fix()

  m1 = AsyncMachine(states=['A', 'B', 'C'], initial='A', name="m1")
  m2 = AsyncMachine(states=['A', 'B', 'C'], initial='A', name="m2")
  m2.add_transition(trigger='go', source='A', dest='B', before=await_never_return)
  m2.add_transition(trigger='fix', source='A', dest='C')
  m1.add_transition(trigger='go', source='A', dest='B', after='go')
  m1.add_transition(trigger='go', source='B', dest='C', after=fix)
  asyncio.get_event_loop().run_until_complete(asyncio.gather(m2.go(), m1.go()))

  assert m1.state == m2.state
  ```

  This example actually illustrates two things:
  First, that 'go' called in m1's transition from `A` to be `B` is not cancelled and second, calling `m2.fix()` will
  halt the transition attempt of m2 from `A` to `B` by executing 'fix' from `A` to `C`.
  This separation would not be possible without `contextvars`.
  Note that `prepare` and `conditions` are NOT treated as ongoing transitions.
  This means that after `conditions` have been evaluated, a transition is executed even though another event already happened.
  Tasks will only be cancelled when run as a `before` callback or later.

  `AsyncMachine` features a model-special queue mode which can be used when `queued='model'` is passed to the constructor.
  With a model-specific queue, events will only be queued when they belong to the same model.
  Furthermore, a raised exception will only clear the event queue of the model that raised that exception.
  For the sake of simplicity, let's assume that every event in `asyncio.gather` below is not triggered at the same time but slightly delayed:

  ```python
  asyncio.gather(model1.event1(), model1.event2(), model2.event1())





  asyncio.gather(model1.event1(), model1.error(), model1.event3(), model2.event1(), model2.event2(), model2.event3())




  ```

  Note that queue modes must not be changed after machine construction.



  If your superheroes need some custom behaviour, you can throw in some extra functionality by decorating machine states:

  ```python
  from time import sleep
  from transitions import Machine
  from transitions.extensions.states import add_state_features, Tags, Timeout


  @add_state_features(Tags, Timeout)
  class CustomStateMachine(Machine):
      pass


  class SocialSuperhero(object):
      def __init__(self):
          self.entourage = 0

      def on_enter_waiting(self):
          self.entourage += 1


  states = [{'name': 'preparing', 'tags': ['home', 'busy']},
            {'name': 'waiting', 'timeout': 1, 'on_timeout': 'go'},
            {'name': 'away'}]  # The city needs us!

  transitions = [['done', 'preparing', 'waiting'],
                 ['join', 'waiting', 'waiting'],  # Entering Waiting again will increase our entourage
                 ['go', 'waiting', 'away']]  # Okay, let' move

  hero = SocialSuperhero()
  machine = CustomStateMachine(model=hero, states=states, transitions=transitions, initial='preparing')
  assert hero.state == 'preparing'  # Preparing for the night shift
  assert machine.get_state(hero.state).is_busy  # We are at home and busy
  hero.done()
  assert hero.state == 'waiting'  # Waiting for fellow superheroes to join us
  assert hero.entourage == 1  # It's just us so far
  sleep(0.7)  # Waiting...
  hero.join()  # Weeh, we got company
  sleep(0.5)  # Waiting...
  hero.join()  # Even more company \o/
  sleep(2)  # Waiting...
  assert hero.state == 'away'  # Impatient superhero already left the building
  assert machine.get_state(hero.state).is_home is False  # Yupp, not at home anymore
  assert hero.entourage == 3  # At least he is not alone
  ```

  Currently, transitions comes equipped with the following state features:

  - **Timeout** -- triggers an event after some time has passed

    - keyword: `timeout` (int, optional) -- if passed, an entered state will timeout after `timeout` seconds
    - keyword: `on_timeout` (string/callable, optional) -- will be called when timeout time has been reached
    - will raise an `AttributeError` when `timeout` is set but `on_timeout` is not
    - Note: A timeout is triggered in a thread. This implies several limitations (e.g. catching Exceptions raised in timeouts). Consider an event queue for more sophisticated applications.

  - **Tags** -- adds tags to states

    - keyword: `tags` (list, optional) -- assigns tags to a state
    - `State.is_<tag_name>` will return `True` when the state has been tagged with `tag_name`, else `False`

  - **Error** -- raises a `MachineError` when a state cannot be left
    - inherits from `Tags` (if you use `Error` do not use `Tags`)
    - keyword: `accepted` (bool, optional) -- marks a state as accepted
    - alternatively the keyword `tags` can be passed, containing 'accepted'
    - Note: Errors will only be raised if `auto_transitions` has been set to `False`. Otherwise every state can be exited with `to_<state>` methods.
  - **Volatile** -- initialises an object every time a state is entered
    - keyword: `volatile` (class, optional) -- every time the state is entered an object of type class will be assigned to the model. The attribute name is defined by `hook`. If omitted, an empty VolatileObject will be created instead
    - keyword: `hook` (string, default='scope') -- The model's attribute name for the temporal object.

  You can write your own `State` extensions and add them the same way. Just note that `add_state_features` expects _Mixins_. This means your extension should always call the overridden methods `__init__`, `enter` and `exit`. Your extension may inherit from _State_ but will also work without it.
  Using `@add_state_features` has a drawback which is that decorated machines cannot be pickled (more precisely, the dynamically generated `CustomState` cannot be pickled).
  This might be a reason to write a dedicated custom state class instead.
  Depending on the chosen state machine, your custom state class may need to provide certain state features. For instance, `HierarchicalMachine` requires your custom state to be an instance of `NestedState` (`State` is not sufficient). To inject your states you can either assign them to your `Machine`'s class attribute `state_cls` or override `Machine.create_state` in case you need some specific procedures done whenever a state is created:

  ```python
  from transitions import Machine, State

  class MyState(State):
      pass

  class CustomMachine(Machine):
      
      state_cls = MyState


  class VerboseMachine(Machine):

      
      
      def _create_state(self, *args, **kwargs):
          print("Creating a new state with machine '{0}'".format(self.name))
          return MyState(*args, **kwargs)
  ```

  If you want to avoid threads in your `AsyncMachine` entirely, you can replace the `Timeout` state feature with `AsyncTimeout` from the `asyncio` extension:

  ```python
  import asyncio
  from transitions.extensions.states import add_state_features
  from transitions.extensions.asyncio import AsyncTimeout, AsyncMachine

  @add_state_features(AsyncTimeout)
  class TimeoutMachine(AsyncMachine):
      pass

  states = ['A', {'name': 'B', 'timeout': 0.2, 'on_timeout': 'to_C'}, 'C']
  m = TimeoutMachine(states=states, initial='A', queued=True)  # see remark below
  asyncio.run(asyncio.wait([m.to_B(), asyncio.sleep(0.1)]))
  assert m.is_B()  # timeout shouldn't be triggered
  asyncio.run(asyncio.wait([m.to_B(), asyncio.sleep(0.3)]))
  assert m.is_C()   # now timeout should have been processed
  ```

  You should consider passing `queued=True` to the `TimeoutMachine` constructor. This will make sure that events are processed sequentially and avoid asynchronous [racing conditions](https://github.com/pytransitions/transitions/issues/459) that may appear when timeout and event happen in close proximity.



  You can have a look at the [FAQ](examples/Frequently%20asked%20questions.ipynb) for some inspiration or checkout `django-transitions`.
  It has been developed by Christian Ledermann and is also hosted on [Github](https://github.com/PrimarySite/django-transitions).
  [The documentation](https://django-transitions.readthedocs.io/en/latest/) contains some usage examples.



  First, congratulations! You reached the end of the documentation!
  If you want to try out `transitions` before you install it, you can do that in an interactive Jupyter notebook at mybinder.org.
  Just click this button 👉 [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/pytransitions/transitions/master?filepath=examples%2FPlayground.ipynb).

  For bug reports and other issues, please [open an issue](https://github.com/pytransitions/transitions) on GitHub.

  For usage questions, post on Stack Overflow, making sure to tag your question with the [`pytransitions` tag](https://stackoverflow.com/questions/tagged/pytransitions). Do not forget to have a look at the [extended examples](./examples)!

  For any other questions, solicitations, or large unrestricted monetary gifts, email [Tal Yarkoni](mailto:tyarkoni@gmail.com) (initial author) and/or [Alexander Neumann](mailto:aleneum@gmail.com) (current maintainer).


pkgId: 88e8f8d556b4564d7bb3d3d7b8d81624d56ba1c469d102611c9554dcf5b761d4
name: python-translationstring
arch: src
version: 1.4
epoch: 0
release: 1
summary: Utility library for i18n relied on by various Repoze and Pyramid packages
url: https://github.com/Pylons/translationstring
rpm_license: BSD-like (http://repoze.org/license.html)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-15fa27f9-41ec-4fab-baa6-17da05d2ee90
location_href: 00005331-python-translationstring/python-translationstring-1.4-1.src.rpm
checksum_type: sha256
description:
  A library used by various `Pylons Project <https://pylonsproject.org>`_ packages
  for internationalization (i18n) duties related to translation.
  This package provides a *translation string* class, a *translation string
  factory* class, translation and pluralization primitives, and a utility that
  helps `Chameleon <https://chameleon.readthedocs.io/en/latest/>`_ templates use
  translation facilities of this package.  It does not depend on `Babel
  <http://babel.pocoo.org/en/latest/>`_, but its translation and pluralization
  services are meant to work best when provided with an instance of the
  ``babel.support.Translations`` class.
  Please see https://docs.pylonsproject.org/projects/translationstring/en/latest/
  for the documentation.


pkgId: 7beda1b90748a723359a27692ba8f9ceacd7c95182569154d2657213868c1d0b
name: python-tree-format
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: http://github.com/jml/tree-format
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f6b87dbc-30fd-4f4e-83ea-f78dbced270e
location_href: 00005333-python-tree-format/python-tree-format-0.1.2-1.src.rpm
checksum_type: sha256
description:
  Python library to generate nicely formatted trees, like the UNIX `tree`
  command.



  Produce output like this:

  ```
  foo
  ├── bar
  │   ├── a
  │   └── b
  ├── baz
  └── qux
      └── c⏎
          d
  ```

  using code like this:

  ```python
  from operator import itemgetter

  from tree_format import format_tree

  tree = (
      'foo', [
          ('bar', [
              ('a', []),
              ('b', []),
          ]),
          ('baz', []),
          ('qux', [
              ('c\nd', []),
          ]),
      ],
  )

  print format_tree(
      tree, format_node=itemgetter(0), get_children=itemgetter(1))
  ```



  This is made available under the Apache Software License, version 2.0.

  Copyright (c) 2015 - Jonathan M. Lange



  Run tests with:

  ```
  python -m testtools.run discover
  ```


pkgId: cdabef751c059b65c016a0c6f60f0897f424e5427270fd90f705c31f9b031353
name: python-treq
arch: src
version: 22.2.0
epoch: 0
release: 1
summary: High-level Twisted HTTP Client API
url: https://github.com/twisted/treq
rpm_license: MIT/X
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-36c78048-516c-433d-aae9-c78106d61b69
location_href: 00005334-python-treq/python-treq-22.2.0-1.src.rpm
checksum_type: sha256
description:
  |pypi|_
  |calver|_
  |coverage|_
  |documentation|_
  ``treq`` is an HTTP library inspired by
  `requests <https://requests.readthedocs.io/>`_ but written on top of
  `Twisted <https://www.twistedmatrix.com>`_'s
  `Agents <https://twistedmatrix.com/documents/current/api/twisted.web.client.Agent.html>`_.
  It provides a simple, higher level API for making HTTP requests when
  using Twisted.
      >>> import treq
      >>> def done(response):
      >>> treq.get("https://github.com").addCallback(done)
      >>> from twisted.internet import reactor
      >>> reactor.run()
      200
  For more info `read the docs <https://treq.readthedocs.org>`_.


pkgId: 0d3b963b30dc2ae4d7a61ce42ef53c50dfb13fdbbac21c27ffbb6ac462ef9742
name: python-trezor
arch: src
version: 0.13.5
epoch: 0
release: 1
summary: Python library for communicating with Trezor Hardware Wallet
url: https://github.com/trezor/trezor-firmware/tree/master/python
rpm_license: LGPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ae3e0cec-bd52-4192-8a53-1aa248e58f97
location_href: 00005335-python-trezor/python-trezor-0.13.5-1.src.rpm
checksum_type: sha256
description:
  [![repology](https://repology.org/badge/tiny-repos/python:trezor.svg)](https://repology.org/metapackage/python:trezor) [![image](https://badges.gitter.im/trezor/community.svg)](https://gitter.im/trezor/community)

  Python library and command-line client for communicating with Trezor
  Hardware Wallet.

  See <https://trezor.io> for more information.



  Python Trezor tools require Python 3.6 or higher, and libusb 1.0. The easiest
  way to install it is with `pip`. The rest of this guide assumes you have
  a working `pip`; if not, you can refer to [this
  guide](https://packaging.python.org/tutorials/installing-packages/).

  On a typical system, you already have all you need. Install `trezor` with:

  ```sh
  pip3 install trezor
  ```

  On Windows, you also need to either install [Trezor Bridge](https://suite.trezor.io/web/bridge/), or
  [libusb](https://github.com/libusb/libusb/wiki/Windows) and the appropriate
  [drivers](https://zadig.akeo.ie/).



  Current trezorlib version supports Trezor One version 1.8.0 and up, and Trezor T version
  2.1.0 and up.

  For firmware versions below 1.8.0 and 2.1.0 respectively, the only supported operation
  is "upgrade firmware".

  Trezor One with firmware _older than 1.7.0_ and bootloader _older than 1.6.0_
  (including pre-2021 fresh-out-of-the-box units) will not be recognized, unless
  you install HIDAPI support (see below).



  * **Ethereum**: To support Ethereum signing from command line, additional packages are
    needed. Install with:

    ```sh
    pip3 install trezor[ethereum]
    ```

  * **Stellar**: To support Stellar signing from command line, additional packages are
    needed. Install with:

    ```sh
    pip3 install trezor[stellar]
    ```

  * **Firmware-less Trezor One**: If you are setting up a brand new Trezor One
    manufactured before 2021 (with pre-installed bootloader older than 1.6.0), you will
    need HIDAPI support. On Linux, you will need the following packages (or their
    equivalents) as prerequisites: `python3-dev`, `cython3`, `libusb-1.0-0-dev`,
    `libudev-dev`.

    Install with:

    ```sh
    pip3 install trezor[hidapi]
    ```

  To install all three, use `pip3 install trezor[hidapi,ethereum,stellar]`.



  Check out [Repology](https://repology.org/metapackage/python:trezor) to see if your
  operating system has an up-to-date python-trezor package.



  ```sh
  pip3 install "git+https://github.com/trezor/trezor-firmware#egg=trezor&subdirectory=python"
  ```



  Install the [Poetry](https://python-poetry.org/) tool, checkout
  `trezor-firmware` from git, and enter the poetry shell:

  ```sh
  pip3 install poetry
  git clone https://github.com/trezor/trezor-firmware
  cd trezor-firmware
  poetry install
  poetry shell
  ```

  In this environment, trezorlib and the `trezorctl` tool is running from the live
  sources, so your changes are immediately effective.



  The included `trezorctl` python script can perform various tasks such as
  changing setting in the Trezor, signing transactions, retrieving account
  info and addresses. See the
  [python/docs/](https://github.com/trezor/trezor-firmware/tree/master/python/docs)
  sub folder for detailed examples and options.

  NOTE: An older version of the `trezorctl` command is [available for
  Debian Stretch](https://packages.debian.org/en/stretch/python-trezor)
  (and comes pre-installed on [Tails OS](https://tails.boum.org/)).



  You can use this python library to interact with a Trezor and use its capabilities in
  your application. See examples here in the
  [tools/](https://github.com/trezor/trezor-firmware/tree/master/python/docs/tools)
  sub folder.



  When you are asked for PIN, you have to enter scrambled PIN. Follow the
  numbers shown on Trezor display and enter the their positions using the
  numeric keyboard mapping:

  |   |   |   |
  |---|---|---|
  | 7 | 8 | 9 |
  | 4 | 5 | 6 |
  | 1 | 2 | 3 |

  Example: your PIN is **1234** and Trezor is displaying the following:

  |   |   |   |
  |---|---|---|
  | 2 | 8 | 3 |
  | 5 | 4 | 6 |
  | 7 | 9 | 1 |

  You have to enter: **3795**



  If you want to change protobuf or coin definitions, you will need to regenerate
  definitions in the `python/` subdirectory.

  First, make sure your submodules are up-to-date with:

  ```sh
  git submodule update --init --recursive
  ```

  Then, rebuild the protobuf messages by running, from the `trezor-firmware` top-level
  directory:

  ```sh
  make gen
  ```

  To get support for BTC-like coins, these steps are enough and no further
  changes to the library are necessary.




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

  The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
  and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).


  [0.13.5]: https://github.com/trezor/trezor-firmware/compare/python/v0.13.4...python/v0.13.5


  - Add support for model field in firmware image.  [#2701]
  - Add support for v3-style Trezor One signatures.  [#2701]


  - More structured information about signing keys for different models.  [#2701]


  - Instead of accepting a list of public keys, `FirmwareType.verify()` accepts a parameter configuring whether to use production or development keys.  [#2701]



  [0.13.4]: https://github.com/trezor/trezor-firmware/compare/python/v0.13.3...python/v0.13.4


  - Add UnlockPath message.  [#2289]
  - Added new TOI formats - little endian full-color and even-high grayscale  [#2414]
  - Add device set-busy command to trezorctl.  [#2445]
  - Support SLIP-25 accounts in get-public-node and get-address.  [#2517]
  - Add possibility to save emulator screenshots.  [#2547]
  - Support for Cardano CIP-36 governance registration format  [#2561]


  - Remove DATA parameter from trezorctl cosi commit.
  - Remove firmware dumping capability.  [#2433]


  - Fixed issue where type declarations were not visible to consumer packages.  [#2542]


  - Refactored firmware parsing and validation to a more object oriented approach.  [#2576]



  [0.13.3]: https://github.com/trezor/trezor-firmware/compare/python/v0.13.2...python/v0.13.3


  - Support for Cardano Babbage era transaction items  [#2354]


  - Fix Click 7.x compatibility.  [#2364]



  [0.13.2]: https://github.com/trezor/trezor-firmware/compare/python/v0.13.1...python/v0.13.2


  - Fixed dependency error when running trezorctl without PIL.
  - Fixed dependency error when running trezorctl on Python 3.6 without rlp.
  - Fix `trezorctl --version` crash.  [#1702]



  [0.13.1]: https://github.com/trezor/trezor-firmware/compare/python/v0.13.0...python/v0.13.1


  - New exception type `DeviceIsBusy` indicates that the device is in use by another process.  [#1026]
  - Support payment requests and GetNonce command.  [#1430]
  - Add press_info() to DebugLink.  [#1430]
  - Add support for blind EIP-712 signing for Trezor One  [#1970]
  - Add ScriptUI for trezorctl, spawned by --script option  [#2023]
  - Support T1 screenshot saving in Debuglink  [#2093]
  - Support generating Electrum-compatible message signatures in CLI.  [#2100]
  - Support Cardano Alonzo-era transaction items and --include-network-id flag  [#2114]
  - trezorctl: Bitcoin commands can detect script type from derivation path.  [#2159]
  - Add support for model R  [#2230]
  - Add firmware get-hash command.  [#2239]
  - Jump and stay in bootloader from firmware through SVC call reverse trampoline.  [#2284]


  - Unify boolean arguments/options in trezorlib commands to on/off  [#2123]
  - Rename `normalize_nfc` to `prepare_message_bytes` in tools.py  [#2126]
  - `trezorctl monero` network type arguments now accept symbolic names instead of numbers.  [#2219]


  - trezorctl will correctly report that device is in use.  [#1026]
  - Allow passing empty `message_hash` for domain-only EIP-712 hashes
    for Trezor T1 (i.e. when `primaryType`=`EIP712Domain`)  [#2036]
  - Fixed error when printing protobuf message with a missing required field.  [#2135]
  - Add compatibility with Click 8.1  [#2199]



  [0.13.0]: https://github.com/trezor/trezor-firmware/compare/python/v0.12.4...python/v0.13.0


  - `trezorctl firmware update` shows progress bar (Model T only)
  - Enabled session management via `EndSession`  [#1227]
  - Added parameters to enable Cardano derivation when calling `init_device()`.  [#1231]
  - two new trezorctl commands - `trezorctl firmware download` and `trezorctl firmware verify`  [#1258]
  - Support no_script_type option in SignMessage.  [#1586]
  - Support for Ethereum EIP1559 transactions  [#1604]
  - Debuglink can automatically scroll through paginated views.  [#1671]
  - Support for Taproot descriptors  [#1710]
  - `trezorlib.stellar.from_envelope` was added, it includes support for the Stellar [TransactionV1](https://github.com/stellar/stellar-protocol/blob/master/core/cap-0015.md#xdr) format transaction.  [#1745]
  - Ethereum: support 64-bit chain IDs  [#1771]
  - Support for Cardano multi-sig transactions, token minting, script addresses, multi-sig keys, minting keys and native script verification  [#1772]
  - Added parameters to specify kind of Cardano derivation to all functions and `trezorctl` commands.  [#1783]
  - Support for EIP-712 in library and `trezorctl ethereum sign-typed-data`  [#1835]
  - Add script_pubkey field to TxInput message.  [#1857]
  - Full type hinting checkable with pyright  [#1893]


  - protobuf is aware of `required` fields and default values  [#379]
  - `trezorctl firmware-update` command changed to `trezorctl firmware update`  [#1258]
  - `btc.sign_tx()` accepts keyword arguments for transaction metadata  [#1266]
  - Raise `ValueError` when the txid for an input is not present in `prev_txes` during `btc.sign_tx`  [#1442]
  - `trezorlib.mappings` was refactored for easier customization  [#1449]
  - Refactor protobuf codec for better clarity  [#1541]
  - `UdpTransport.wait_until_ready` no longer sets socket to nonblocking  [#1668]
  - Cardano transaction parameters are now streamed into the device one by one instead of being sent as one large object  [#1683]
  - `trezorlib.stellar` will refuse to process transactions containing MuxedAccount  [#1838]
  - Use unified descriptors format.  [#1885]
  - Introduce Trezor models as an abstraction over USB IDs, vendor strings, and possibly protobuf mappings.  [#1967]


  - instantiating protobuf objects with positional arguments is deprecated  [#379]
  - `details` argument to `btc.sign_tx()` is deprecated. Use keyword arguments instead.  [#379]
  - values of required fields must be supplied at instantiation time. Omitting them is deprecated.  [#379]


  - dropped Python 3.5 support  [#810]
  - dropped debug-only `trezorctl debug show-text` functionality  [#1531]
  - Removed support for Lisk  [#1765]


  - fix operator precedence issue for ethereum sign-tx command  [#1867]
  - Updated `tools/build_tx.py` to work with Blockbook's API protections.  [#1896]
  - Fix PIN and passphrase entry in certain terminals on Windows  [#1959]


  - `client.init_device(derive_cardano=True)` must be used before calling Cardano functions.  [#1231]
  - The type of argument to `ui.button_request(x)` is changed from int to ButtonRequest.
    The original int value can be accessed as `x.code`  [#1671]
  - Due to transaction streaming in Cardano, it isn't possible to return the whole serialized transaction anymore. Instead the transaction hash, transaction witnesses and auxiliary data supplement are returned and the serialized transaction needs to be assembled by the client.  [#1683]
  - `trezorlib.stellar` was reworked to use stellar-sdk instead of providing local implementations  [#1745]
  - Cardano derivation now defaults to Icarus method. This will result in different keys for users with 24-word seed.  [#1783]



  [0.12.4]: https://github.com/trezor/trezor-firmware/compare/python/v0.12.3...python/v0.12.4



  - trezorctl: fixed "Invalid value for <param>" when using Click 8 and param is not specified [#1798]


  [0.12.3]: https://github.com/trezor/trezor-firmware/compare/python/v0.12.2...python/v0.12.3



  - `trezorctl btc get-descriptor` support [#1363]
  - `trezorctl btc reboot-to-bootloader` support [#1738]
  - distinguishing between temporary and permanent safety checks
  - trezorctl accepts PIN entered by letters (useful on laptops)
  - support for 50-digit PIN for T1



  - allowed Click 8.x as a requirement
  - replaced all references to Trezor Wallet with Trezor Suite, and modified all mentions
    of Beta Wallet



  - added missing requirement `attrs`
  - properly parse big numbers in `tools/build_tx.py` [#1257], [#1296]
  - it is now possible to set safety checks for T1



  [0.12.2]: https://github.com/trezor/trezor-firmware/compare/python/v0.12.1...python/v0.12.2



  - `trezorlib.toif` module (moved from internal) can encode and decode TOIF image format
  - `trezorctl set homescreen` was improved and extended to support PNG images for Trezor T



  - trezorctl will correctly notify the user if the image decoding library is missing



  - fix exception in `trezorctl btc get-address`  [#1179]
  - fix exception in `trezorctl lisk sign-message`
  - fix exception in trezorctl commands that accept filenames  [#1196]
  - fix "Invalid homescreen" error when un-setting homescreen



  - removed option `--skip-vendor-header` from `trezorctl firmware-update` which did nothing  [#1210]



  [0.12.1]: https://github.com/trezor/trezor-firmware/compare/python/v0.12.0...python/v0.12.1



  - `trezorctl set safety-checks` controls the new "safety checks" feature.  [#1126]
  - `trezorctl btc get-address` can create multisig addresses.
  - the following commands are now equivalent in trezorctl: `firmware-update`, `firmware-upgrade`,
    `update-firmware`, `upgrade-firmware`
  - support for EXTERNAL input type  [#38], [#1052]
  - support for ownership proofs
  - support for pre-authorized CoinJoin transactions  [#37]
  - support for Cardano Shelley  [#948]



  - do not allow setting auto-lock delay unless PIN is configured



  - correctly calculate hashes for very small firmwares  [f#1082]
  - unified file arguments in trezorctl
  - `TrezorClient.ping()` does not crash when device is PIN-locked



  [0.12.0]: https://github.com/trezor/trezor-firmware/compare/python/v0.11.6...python/v0.12.0



  - `trezorlib.coins`, `trezorlib.tx_api`, and the file `coins.json`, were removed
  - `TrezorClient` argument `ui` is now mandatory. `state` argument was renamed to `session_id`.
  - UI callback `get_passphrase()` has a new argument `available_on_device`.
  - API for `cosi` module was changed
  - other changes may also introduce incompatibilities, please review the full list below



  - support for firmwares 1.9.0 and 2.3.0
  - Model T now defaults to entering passphrase on device. New trezorctl option `-P`
    enforces entering passphrase on host.
  - support for "passphrase always on device" mode on model T
  - new trezorctl command `get-session` and option `-s` allows entering passphrase once
    for multiple subsequent trezorctl operations
  - built-in functionality of UdpTransport to wait until an emulator comes up, and the
    related command `trezorctl wait-for-emulator`
  - `trezorctl debug send-bytes` can send raw messages to the device [f#116]
  - when updating firmware, user is warned that the requested version does not match their device [f#823]
  - `trezorctl list` can now show name, model and id of device



  - `trezorlib.tx_api.json_to_tx` was reduced to only support Bitcoin fields, and moved
    to `trezorlib.btc.from_json`.
  - API for `cosi` module was streamlined: `verify_m_of_n` is now `verify`, the old
    `verify` is `verify_combined`
  - internals of firmware parsing were reworked to support signing firmware headers
  - `get_default_client` respects `TREZOR_PATH` environment variable
  - UI callback `get_passphrase` has an additional argument `available_on_device`,
    indicating that the connected Trezor is capable of on-device entry
  - `Transport.write` and `read` method signatures changed to accept bytes instead of
    protobuf messages
  - trezorctl subcommands have a common `@with_client` decorator that manages exception
    handling and connecting to device



  - trezorctl does not print empty line when there is no output
  - trezorctl cleanly reports wire exceptions [f#226]



  - `trezorlib.tx_api` was removed
  - `trezorlib.coins` and coin data was removed
  - `trezorlib.ckd_public`, which was deprecated in 0.10, was now removed.
  - `btc.sign_tx` will not preload transaction data from `prev_txes`, as usage with TxApi
    is being removed
  - PIN protection and passphrase protection for `ping()` command was removed
  - compatibility no-op code from trezorlib 0.9 was removed from `trezorlib.client`
  - `trezorlib.tools.CallException` was dropped, use `trezorlib.exceptions.TrezorFailure` instead



  [0.11.6]: https://github.com/trezor/trezor-firmware/compare/python/v0.11.5...python/v0.11.6



  - support for get-and-increase FIDO counter operation
  - support for setting wipe code
  - `trezorctl device recover` supports `--u2f-counter` option to set the FIDO counter to a custom value



  - `trezorctl` command was reworked for ease of use and maintenance. See `trezorctl --help` and `OPTIONS.rst` for details. [f#510]
  - updated EOS transaction parser to match `cleos` in `delegatebw` and `undelegatebw` actions [f#680] [f#681]
  - `RecoveryDevice` does not set fields when doing dry-run recovery [f#666]



  - fixed "expand words" functionality in `trezorctl device recover` [f#778]



  - trezorctl no longer interactively signs Bitcoin-like transactions, the only allowed
    input format is JSON. See [`docs/transaction-format.md`](docs/transaction-format.md)
    for details.
  - support for "load device by xprv" was removed from firmware and trezorlib




  [0.11.5]: https://github.com/trezor/trezor-firmware/compare/python/v0.11.4...python/v0.11.5



  - trezorctl can dump raw protobuf bytes in debug output [f#117]
  - trezorctl shows a warning when activating Shamir Backup if the device does not support it [f#445]
  - warnings are emitted when encountering unknown value for a protobuf enum [f#363]
  - debug messages show enum value names instead of raw numbers
  - support for packed repeated encoding in the protobuf decoder
  - in `trezorctl firmware-update`, the new `--beta` switch enables downloading beta
    firmwares. By default, only stable firmware is used. [f#411], [f#420]
  - in `trezorctl firmware-update`, the new `--bitcoin-only` switch enables downloading
    Bitcoin-only firmware
  - support for FIDO2 resident credential management
  - support for SD-protect features



  - package directory structure was changed: `src` subdirectory contains sources and
    `tests` subdirectory contains tests, so that cwd is not cluttered
  - `trezorctl` script was moved into a module `trezorlib.cli.trezorctl` and is launched
    through the `entry_points` mechanism. This makes it usable on Windows
  - `pyblake2` is no longer required on Python 3.6 and up
  - input flows can only be used in with-block (only relevant for unit tests)
  - if not specified, trezorctl will set label to "SLIP-0014" in SLIP-0014 mode
  - in `clear_session` the client also forgets the passphrase state for TT [f#525]



  - trezorctl will properly check if a firmware is present on a new T1 [f#224]



  - device test suite was moved out of trezor package



  [0.11.4]: https://github.com/trezor/trezor-firmware/compare/python/v0.11.3...python/v0.11.4



  - trezorctl support for SLIP-39 Shamir Backup
  - support for Binance Chain



  [0.11.3]: https://github.com/trezor/trezor-firmware/compare/python/v0.11.2...python/v0.11.3



  - trezorctl can now send ERC20 tokens
  - trezorctl usb-reset will perform USB reset on devices in inconsistent state
  - set-display-rotation command added for TT firmware 2.1.1
  - EOS support [f#87]
  - Tezos: add voting support [f#41]
  - `dict_to_proto` now allows enum values as strings



  - Minimum firmware versions bumped to 1.8.0 and 2.1.0
  - Cleaner errors when UI object is not supplied
  - Generated files are now part of the source tarball again. That means that `protoc` is no longer required.



  - Ethereum commands in trezorctl now work
  - Memory debugging tools now work again



  - Tron and Ontology support removed until implementations exist in Trezor firmware



  [0.11.2]: https://github.com/trezor/python-trezor/compare/v0.11.1...v0.11.2



  - full support for bootloader 1.8.0 and relevant firmware upgrade functionality
  - trezorctl: support fully offline signing JSON-encoded transaction data
  - trezorctl: dry-run for firmware upgrade command
  - client: new convenience function `get_default_client` for simple script usage
  - Dash: support DIP-2 special inputs [#351]
  - Ethereum: add get_public_key methods



  - coins with BIP-143 fork id (BCH, BTG) won't require prev_tx [#352]
  - device recovery will restore U2F counter
  - Cardano: change `network` to `protocol_magic`
  - tests can run interactively when `INTERACT=1` environment variable is set
  - protobuf: improved `to_dict` function



  - trezorctl: interactive signing with `sign-tx` is considered deprecated



  [0.11.1]: https://github.com/trezor/python-trezor/compare/v0.11.0...v0.11.1



  - crash when entering passphrase on device with Trezor T
  - Qt widgets should only import QtCore [#349]



  [0.11.0]: https://github.com/trezor/python-trezor/compare/v0.10.2...v0.11.0



  - removed support for Python 3.3 and 3.4
  - major refactor of `TrezorClient` and UI handling. Implementers must now provide a "UI" object instead of overriding callbacks [#307], [#314]
  - protobuf classes now use a `get_fields()` method instead of `FIELDS` field [#312]
  - all methods on `TrezorClient` class are now in separate modules and take a `TrezorClient` instance as argument [#276]
  - mixin classes are also removed, you are not supposed to extend `TrezorClient` anymore
  - `TrezorClientDebugLink` was moved to `debuglink` module
  - changed signature of `trezorlib.btc.sign_tx`
  - `@field` decorator was replaced by an argument to `@expect`



  - trezorlib now has a hardcoded check preventing use of outdated firmware versions [#283]
  - Ripple support [#286]
  - Zencash support [#287]
  - Cardano support [#300]
  - Ontology support [#301]
  - Tezos support [#302]
  - Capricoin support [#325]
  - limited Monero support (can only get address/watch key, monerowallet is required for signing)
  - support for input flow in tests makes it easier to control complex UI workflows [#314]
  - `protobuf.dict_to_proto` can create a protobuf instance from a plain dict
  - support for smarter methods in trezord 2.0.25 and up
  - support for seedless setup
  - trezorctl: firmware handling is greatly improved [#304], [#308]
  - trezorctl: Bitcoin-like signing flow is more user-friendly
  - `tx_api` now supports Blockbook backend servers



  - better reporting for debuglink expected messages
  - replaced Ed25519 module with a cleaner, optimized version
  - further reorganization of transports makes them more robust when dependencies are missing
  - codebase now follows [Black](https://github.com/ambv/black) code style
  - in Qt modules, Qt5 is imported first [#315]
  - `TxApiInsight` is just `TxApi`
  - `device.reset` and `device.recover` now have reasonable defaults for all arguments
  - protobuf classes are no longer part of the source distribution and must be compiled locally [#284]
  - Stellar: addresses are always strings



  - `set_tx_api` method on `TrezorClient` is replaced by an argument for `sign_tx`
  - caching functionality of `TxApi` was moved to a separate test-support class
  - Stellar: public key methods removed
  - `EncryptMessage` and `DecryptMessage` actions are gone



  - `TrezorClient` can now detect when a HID device is removed and a different one is plugged in on the same path
  - trezorctl now works with Click 7.0 and considers "`_`" and "`-`" as same in command names [#314]
  - bash completion fixed
  - Stellar: several bugs in the XDR parser were fixed



  [0.10.2]: https://github.com/trezor/python-trezor/compare/v0.10.1...v0.10.2



  - `stellar_get_address` and `_public_key` functions support `show_display` parameter
  - trezorctl: `stellar_get_address` and `_public_key` commands for the respective functionality



  - trezorctl: `list_coins` is removed because we no longer parse the relevant protobuf field
    (and newer Trezor firmwares don't send it) [#277]



  - test support module was not included in the release, so code relying on the deprecated `ckd_public` module would fail [#280]



  [0.10.1]: https://github.com/trezor/python-trezor/compare/v0.10.0...v0.10.1



  - previous release fails to build on Windows [#274]



  [0.10.0]: https://github.com/trezor/python-trezor/compare/v0.9.1...v0.10.0



  - Lisk support [#197]
  - Stellar support [#167], [#268]
  - Wanchain support [#230]
  - support for "auto lock delay" feature
  - `TrezorClient` takes an additional argument `state` that allows reusing the previously entered passphrase [#241]
  - USB transports mention udev rules in exception messages [#245]
  - `log.enable_debug_output` function turns on wire logging, instead of having to use `TrezorClientVerbose`
  - BIP32 paths now support `123h` in addition to `123'` to indicate hardening
  - trezorctl: `-p` now supports prefix search for device path [#226]
  - trezorctl: smarter handling of firmware updates [#242], [#269]



  - reorganized transports and moved into their own `transport` submodule
  - protobuf messages and coins info is now regenerated at build time from the `trezor-common` repository [#248]
  - renamed `ed25519raw` to `_ed25519` to indicate its privateness
  - renamed `ed25519cosi` to `cosi` and expanded its API
  - protobuf messages are now logged through Python's `logging` facility instead of custom printing through `VerboseWireMixin`
  - `client.format_protobuf` is moved to `protobuf.format_message`
  - `tools.Hash` is renamed to `tools.btc_hash`
  - `coins` module `coins_txapi` is renamed to `tx_api`.
    `coins_slip44` is renamed to `slip44`.
  - build: stricter flake8 checks
  - build: split requirements to separate files
  - tests: unified finding test device, while respecting `TREZOR_PATH` env variable.
  - tests: auto-skip appropriately marked tests based on Trezor device version
  - tests: only show wire output when run with `-v`
  - tests: allow running `xfail`ed tests selectively based on `pytest.ini`
  - docs: updated README with clearer install instructions [#185]
  - docs: switched changelog to Keep a Changelog format [#94]



  - `ckd_public` is only maintained in `tests.support` submodule and considered private
  - `TrezorClient.expand_path` is moved to plain function `tools.parse_path`
  - `TrezorDevice` is deprecated in favor of `transport.enumerate_devices` and `transport.get_transport`
  - XPUB-related handling in `tools` is slated for removal



  - most Python 2 compatibility constructs are gone [#229]
  - `TrezorClientVerbose` and `VerboseWireMixin` is removed
  - specific `tx_api.TxApi*` classes removed in favor of `coins.tx_api`
  - `client.PRIME_DERIVATION_FLAG` is removed in favor of `tools.HARDENED_FLAG` and `tools.H_()`
  - hard dependency on Ethereum libraries and HIDAPI is changed into extras that need to be
    specified explicitly. Require `trezor[hidapi]` or `trezor[ethereum]` to get them.



  - WebUSB enumeration returning bad devices on Windows 10 [#223]
  - `sign_tx` operation sending empty address string [#237]
  - Wrongly formatted Ethereum signatures [#236]
  - protobuf layer would wrongly encode signed integers [#249], [#250]
  - protobuf pretty-printing broken on Python 3.4 [#256]
  - trezorctl: Matrix recovery on Windows wouldn't allow backspace [#207]
  - aes_encfs_getpass.py: fixed Python 3 bug [#169]



  [0.9.1]: https://github.com/trezor/python-trezor/compare/v0.9.0...v0.9.1



  - proper support for Trezor model T
  - support for Monacoin
  - improvements to `trezorctl`:
    - add pretty-printing of features and protobuf debug dumps (fixes [#199])
    - support `TREZOR_PATH` environment variable to preselect a Trezor device.



  - gradually dropping Python 2 compatibility (pypi package will now be marked as Python 3 only)

  [f#41]: https://github.com/trezor/trezor-firmware/pull/41
  [f#87]: https://github.com/trezor/trezor-firmware/pull/87
  [f#116]: https://github.com/trezor/trezor-firmware/pull/116
  [f#117]: https://github.com/trezor/trezor-firmware/pull/117
  [f#224]: https://github.com/trezor/trezor-firmware/pull/224
  [f#226]: https://github.com/trezor/trezor-firmware/pull/226
  [f#363]: https://github.com/trezor/trezor-firmware/pull/363
  [f#411]: https://github.com/trezor/trezor-firmware/pull/411
  [f#420]: https://github.com/trezor/trezor-firmware/pull/420
  [f#445]: https://github.com/trezor/trezor-firmware/pull/445
  [f#510]: https://github.com/trezor/trezor-firmware/pull/510
  [f#525]: https://github.com/trezor/trezor-firmware/pull/525
  [f#666]: https://github.com/trezor/trezor-firmware/pull/666
  [f#680]: https://github.com/trezor/trezor-firmware/pull/680
  [f#681]: https://github.com/trezor/trezor-firmware/pull/681
  [f#778]: https://github.com/trezor/trezor-firmware/pull/778
  [f#823]: https://github.com/trezor/trezor-firmware/pull/823
  [f#1082]: https://github.com/trezor/trezor-firmware/pull/1082
  [#37]: https://github.com/trezor/trezor-firmware/pull/37
  [#38]: https://github.com/trezor/trezor-firmware/pull/38
  [#94]: https://github.com/trezor/python-trezor/pull/94
  [#167]: https://github.com/trezor/python-trezor/pull/167
  [#169]: https://github.com/trezor/python-trezor/pull/169
  [#185]: https://github.com/trezor/python-trezor/pull/185
  [#197]: https://github.com/trezor/python-trezor/pull/197
  [#199]: https://github.com/trezor/python-trezor/pull/199
  [#207]: https://github.com/trezor/python-trezor/pull/207
  [#223]: https://github.com/trezor/python-trezor/pull/223
  [#226]: https://github.com/trezor/python-trezor/pull/226
  [#229]: https://github.com/trezor/python-trezor/pull/229
  [#230]: https://github.com/trezor/python-trezor/pull/230
  [#236]: https://github.com/trezor/python-trezor/pull/236
  [#237]: https://github.com/trezor/python-trezor/pull/237
  [#241]: https://github.com/trezor/python-trezor/pull/241
  [#242]: https://github.com/trezor/python-trezor/pull/242
  [#245]: https://github.com/trezor/python-trezor/pull/245
  [#248]: https://github.com/trezor/python-trezor/pull/248
  [#249]: https://github.com/trezor/python-trezor/pull/249
  [#250]: https://github.com/trezor/python-trezor/pull/250
  [#256]: https://github.com/trezor/python-trezor/pull/256
  [#268]: https://github.com/trezor/python-trezor/pull/268
  [#269]: https://github.com/trezor/python-trezor/pull/269
  [#274]: https://github.com/trezor/python-trezor/pull/274
  [#276]: https://github.com/trezor/python-trezor/pull/276
  [#277]: https://github.com/trezor/python-trezor/pull/277
  [#280]: https://github.com/trezor/python-trezor/pull/280
  [#283]: https://github.com/trezor/python-trezor/pull/283
  [#284]: https://github.com/trezor/python-trezor/pull/284
  [#286]: https://github.com/trezor/python-trezor/pull/286
  [#287]: https://github.com/trezor/python-trezor/pull/287
  [#300]: https://github.com/trezor/python-trezor/pull/300
  [#301]: https://github.com/trezor/python-trezor/pull/301
  [#302]: https://github.com/trezor/python-trezor/pull/302
  [#304]: https://github.com/trezor/python-trezor/pull/304
  [#307]: https://github.com/trezor/python-trezor/pull/307
  [#308]: https://github.com/trezor/python-trezor/pull/308
  [#312]: https://github.com/trezor/python-trezor/pull/312
  [#314]: https://github.com/trezor/python-trezor/pull/314
  [#315]: https://github.com/trezor/python-trezor/pull/315
  [#325]: https://github.com/trezor/python-trezor/pull/325
  [#349]: https://github.com/trezor/python-trezor/pull/349
  [#351]: https://github.com/trezor/python-trezor/pull/351
  [#352]: https://github.com/trezor/python-trezor/pull/352
  [#379]: https://github.com/trezor/trezor-firmware/pull/379
  [#810]: https://github.com/trezor/trezor-firmware/pull/810
  [#948]: https://github.com/trezor/trezor-firmware/pull/948
  [#1026]: https://github.com/trezor/trezor-firmware/pull/1026
  [#1052]: https://github.com/trezor/trezor-firmware/pull/1052
  [#1126]: https://github.com/trezor/trezor-firmware/pull/1126
  [#1179]: https://github.com/trezor/trezor-firmware/pull/1179
  [#1196]: https://github.com/trezor/trezor-firmware/pull/1196
  [#1210]: https://github.com/trezor/trezor-firmware/pull/1210
  [#1227]: https://github.com/trezor/trezor-firmware/pull/1227
  [#1231]: https://github.com/trezor/trezor-firmware/pull/1231
  [#1257]: https://github.com/trezor/trezor-firmware/pull/1257
  [#1258]: https://github.com/trezor/trezor-firmware/pull/1258
  [#1266]: https://github.com/trezor/trezor-firmware/pull/1266
  [#1296]: https://github.com/trezor/trezor-firmware/pull/1296
  [#1363]: https://github.com/trezor/trezor-firmware/pull/1363
  [#1430]: https://github.com/trezor/trezor-firmware/pull/1430
  [#1442]: https://github.com/trezor/trezor-firmware/pull/1442
  [#1449]: https://github.com/trezor/trezor-firmware/pull/1449
  [#1531]: https://github.com/trezor/trezor-firmware/pull/1531
  [#1541]: https://github.com/trezor/trezor-firmware/pull/1541
  [#1586]: https://github.com/trezor/trezor-firmware/pull/1586
  [#1604]: https://github.com/trezor/trezor-firmware/pull/1604
  [#1668]: https://github.com/trezor/trezor-firmware/pull/1668
  [#1671]: https://github.com/trezor/trezor-firmware/pull/1671
  [#1683]: https://github.com/trezor/trezor-firmware/pull/1683
  [#1702]: https://github.com/trezor/trezor-firmware/pull/1702
  [#1710]: https://github.com/trezor/trezor-firmware/pull/1710
  [#1738]: https://github.com/trezor/trezor-firmware/pull/1738
  [#1745]: https://github.com/trezor/trezor-firmware/pull/1745
  [#1765]: https://github.com/trezor/trezor-firmware/pull/1765
  [#1771]: https://github.com/trezor/trezor-firmware/pull/1771
  [#1772]: https://github.com/trezor/trezor-firmware/pull/1772
  [#1783]: https://github.com/trezor/trezor-firmware/pull/1783
  [#1798]: https://github.com/trezor/trezor-firmware/pull/1798
  [#1835]: https://github.com/trezor/trezor-firmware/pull/1835
  [#1838]: https://github.com/trezor/trezor-firmware/pull/1838
  [#1857]: https://github.com/trezor/trezor-firmware/pull/1857
  [#1867]: https://github.com/trezor/trezor-firmware/pull/1867
  [#1885]: https://github.com/trezor/trezor-firmware/pull/1885
  [#1893]: https://github.com/trezor/trezor-firmware/pull/1893
  [#1896]: https://github.com/trezor/trezor-firmware/pull/1896
  [#1959]: https://github.com/trezor/trezor-firmware/pull/1959
  [#1967]: https://github.com/trezor/trezor-firmware/pull/1967
  [#1970]: https://github.com/trezor/trezor-firmware/pull/1970
  [#2023]: https://github.com/trezor/trezor-firmware/pull/2023
  [#2036]: https://github.com/trezor/trezor-firmware/pull/2036
  [#2093]: https://github.com/trezor/trezor-firmware/pull/2093
  [#2100]: https://github.com/trezor/trezor-firmware/pull/2100
  [#2114]: https://github.com/trezor/trezor-firmware/pull/2114
  [#2123]: https://github.com/trezor/trezor-firmware/pull/2123
  [#2126]: https://github.com/trezor/trezor-firmware/pull/2126
  [#2135]: https://github.com/trezor/trezor-firmware/pull/2135
  [#2159]: https://github.com/trezor/trezor-firmware/pull/2159
  [#2199]: https://github.com/trezor/trezor-firmware/pull/2199
  [#2219]: https://github.com/trezor/trezor-firmware/pull/2219
  [#2230]: https://github.com/trezor/trezor-firmware/pull/2230
  [#2239]: https://github.com/trezor/trezor-firmware/pull/2239
  [#2284]: https://github.com/trezor/trezor-firmware/pull/2284
  [#2289]: https://github.com/trezor/trezor-firmware/pull/2289
  [#2354]: https://github.com/trezor/trezor-firmware/pull/2354
  [#2364]: https://github.com/trezor/trezor-firmware/pull/2364
  [#2414]: https://github.com/trezor/trezor-firmware/pull/2414
  [#2433]: https://github.com/trezor/trezor-firmware/pull/2433
  [#2445]: https://github.com/trezor/trezor-firmware/pull/2445
  [#2517]: https://github.com/trezor/trezor-firmware/pull/2517
  [#2542]: https://github.com/trezor/trezor-firmware/pull/2542
  [#2547]: https://github.com/trezor/trezor-firmware/pull/2547
  [#2561]: https://github.com/trezor/trezor-firmware/pull/2561
  [#2576]: https://github.com/trezor/trezor-firmware/pull/2576
  [#2701]: https://github.com/trezor/trezor-firmware/pull/2701


pkgId: 85da29ed52b8f7368b602a789e2b30dcd47c666bdc4104c4a4e4f0f1234fe56b
name: python-tribool
arch: src
version: 0.7.3
epoch: 0
release: 1
summary: Three-valued logic data type.
url: http://www.grantjenks.com/docs/tribool/
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f8bceef1-40b4-41c9-aa78-54ae97289c5c
location_href: 00010939-python-tribool/python-tribool-0.7.3-1.src.rpm
checksum_type: sha256
description:
  `Tribool <http://www.grantjenks.com/docs/tribool/>`_ is an Apache2 licensed
  Python module that implements three-valued logic.
  Suppose for a moment that you're attempting to store a value across a network
  connection. You begin with a simple protocol in which the server stores the
  received value and then sends an acknowledgement to the client.  In this
  design, the client experiences a delay between when the request is sent and the
  acknowledgement is received. In that delay, it is impossible for the client to
  know whether the value has been committed on the server.  In such cases, it's
  useful to describe the commit state of the server from the client's perspective
  as True, False, or Indeterminate.
  Another example occurs in database systems. Consider a record that contains
  a boolean field. Such a field may only be either True or False. But we want
  to support the notion of committing a partial record in the case that the
  record is large or the client does not have all relevant information. In this
  scenario, we wish to commit neither True nor False as the value is currently
  Unknown.
  The Python Tribool module was designed for these cases by describing a logical
  data type that supports three values: True, False, and Indeterminate. The third
  value is best thought of as a state being either True or False. Given these
  three values it's possible to define truth tables over the logical operators
  `and`, `or` and `not` and to define equality and inequality relationships.


pkgId: afeb01d1316dfefad98e898fa4f759377f16016513dd5f289893bbdae7d8e78f
name: python-trino
arch: src
version: 0.322.0
epoch: 0
release: 1
summary: Client for the Trino distributed SQL Engine
url: https://github.com/trinodb/trino-python-client
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7f3b6b3e-da6c-4d2b-90e9-cde26a69916c
location_href: 00010418-python-trino/python-trino-0.322.0-1.src.rpm
checksum_type: sha256
description:
  Client for Trino (https://trino.io), a distributed SQL engine for
  interactive and batch big data processing. Provides a low-level client and
  a DBAPI 2.0 implementation.


pkgId: 5360800267a55612311ae8afc48b594d1e997868b9fd59d1eeff28b2fb7bc529
name: python-trio
arch: src
version: 0.22.0
epoch: 0
release: 1
summary: A friendly Python library for async concurrency and I/O
url: https://github.com/python-trio/trio
rpm_license: MIT OR Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f96332f2-7875-440f-9039-c8cf9c113546
location_href: 00005339-python-trio/python-trio-0.22.0-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://raw.githubusercontent.com/python-trio/trio/9b0bec646a31e0d0f67b8b6ecc6939726faf3e17/logo/logo-with-background.svg
     :width: 200px
     :align: right

  The Trio project's goal is to produce a production-quality, `permissively
  licensed <https://github.com/python-trio/trio/blob/master/LICENSE>`__,
  async/await-native I/O library for Python. Like all async libraries,
  its main purpose is to help you write programs that do **multiple
  things at the same time** with **parallelized I/O**. A web spider that
  wants to fetch lots of pages in parallel, a web server that needs to
  juggle lots of downloads and websocket connections at the same time, a
  process supervisor monitoring multiple subprocesses... that sort of
  thing. Compared to other libraries, Trio attempts to distinguish
  itself with an obsessive focus on **usability** and
  **correctness**. Concurrency is complicated; we try to make it *easy*
  to get things *right*.

  Trio was built from the ground up to take advantage of the `latest
  Python features <https://www.python.org/dev/peps/pep-0492/>`__, and
  draws inspiration from `many sources
  <https://github.com/python-trio/trio/wiki/Reading-list>`__, in
  particular Dave Beazley's `Curio <https://curio.readthedocs.io/>`__.
  The resulting design is radically simpler than older competitors like
  `asyncio <https://docs.python.org/3/library/asyncio.html>`__ and
  `Twisted <https://twistedmatrix.com/>`__, yet just as capable. Trio is
  the Python I/O library I always wanted; I find it makes building
  I/O-oriented programs easier, less error-prone, and just plain more
  fun. `Perhaps you'll find the same
  <https://github.com/python-trio/trio/wiki/Testimonials>`__.

  This project is young and still somewhat experimental: the overall
  design is solid and the existing features are fully tested and
  documented, but you may encounter missing functionality or rough
  edges. We *do* encourage you do use it, but you should `read and
  subscribe to issue #1
  <https://github.com/python-trio/trio/issues/1>`__ to get warning and a
  chance to give feedback about any compatibility-breaking changes.

  Vital statistics:

  * Supported environments: Linux, macOS, or Windows running some kind of Python
    3.7-or-better (either CPython or PyPy3 is fine). \*BSD and illumos likely
    work too, but are not tested.

  * Install: ``python3 -m pip install -U trio`` (or on Windows, maybe
    ``py -3 -m pip install -U trio``). No compiler needed.

  * Tutorial and reference manual: https://trio.readthedocs.io

  * Bug tracker and source code: https://github.com/python-trio/trio

  * Real-time chat: https://gitter.im/python-trio/general

  * Discussion forum: https://trio.discourse.group

  * License: MIT or Apache 2, your choice

  * Contributor guide: https://trio.readthedocs.io/en/latest/contributing.html

  * Code of conduct: Contributors are requested to follow our `code of
    conduct
    <https://trio.readthedocs.io/en/latest/code-of-conduct.html>`_
    in all project spaces.


pkgId: 1aff70f6e8d4d05c76f4d56c08ea1d1128301d48778e256facd1e40c80eb7d88
name: python-trio-websocket
arch: src
version: 0.10.2
epoch: 0
release: 1
summary: WebSocket library for Trio
url: https://github.com/HyperionGray/trio-websocket
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dbb54d35-a9f0-4abf-b61a-af4354f71431
location_href: 00009261-python-trio-websocket/python-trio-websocket-0.10.2-1.src.rpm
checksum_type: sha256
description:
  This library implements both server and client aspects of the [the WebSocket
  protocol](https://tools.ietf.org/html/rfc6455), striving for safety,
  correctness, and ergonomics. It is based on the [wsproto
  project](https://wsproto.readthedocs.io/en/latest/), which is a
  [Sans-IO](https://sans-io.readthedocs.io/) state machine that implements the
  majority of the WebSocket protocol, including framing, codecs, and events. This
  library handles I/O using [the Trio
  framework](https://trio.readthedocs.io/en/latest/). This library passes the
  [Autobahn Test Suite](https://github.com/crossbario/autobahn-testsuite).

  This README contains a brief introduction to the project. Full documentation [is
  available here](https://trio-websocket.readthedocs.io).

  [![PyPI](https://img.shields.io/pypi/v/trio-websocket.svg?style=flat-square)](https://pypi.org/project/trio-websocket/)
  ![Python Versions](https://img.shields.io/pypi/pyversions/trio-websocket.svg?style=flat-square)
  [![Build Status](https://img.shields.io/github/actions/workflow/status/HyperionGray/trio-websocket/ci.yml)](https://github.com/HyperionGray/trio-websocket/actions/workflows/ci.yml)
  [![Read the Docs](https://img.shields.io/readthedocs/trio-websocket.svg)](https://trio-websocket.readthedocs.io)



  If you happen to only need a server, using Quart via the [quart-trio](https://github.com/pgjones/quart-trio)
  extension may suffice.  While trio-websocket is more flexible, Quart covers
  both HTTP and WebSocket within a single framework, and serving both from the
  same port is straightforward.  There has yet to be a performance comparison.



  This library requires Python 3.7 or greater. To install from PyPI:

      pip install trio-websocket



  This example demonstrates how to open a WebSocket URL:

  ```python
  import trio
  from sys import stderr
  from trio_websocket import open_websocket_url


  async def main():
      try:
          async with open_websocket_url('wss://echo.websocket.org') as ws:
              await ws.send_message('hello world!')
              message = await ws.get_message()
              print('Received message: %s' % message)
      except OSError as ose:
          print('Connection attempt failed: %s' % ose, file=stderr)

  trio.run(main)
  ```

  The WebSocket context manager connects automatically before entering the block
  and disconnects automatically before exiting the block. The full API offers a
  lot of flexibility and additional options.



  A WebSocket server requires a bind address, a port, and a coroutine to handle
  incoming connections. This example demonstrates an "echo server" that replies to
  each incoming message with an identical outgoing message.

  ```python
  import trio
  from trio_websocket import serve_websocket, ConnectionClosed

  async def echo_server(request):
      ws = await request.accept()
      while True:
          try:
              message = await ws.get_message()
              await ws.send_message(message)
          except ConnectionClosed:
              break

  async def main():
      await serve_websocket(echo_server, '127.0.0.1', 8000, ssl_context=None)

  trio.run(main)
  ```

  The server's handler ``echo_server(…)`` receives a connection request object.
  This object can be used to inspect the client's request and modify the
  handshake, then it can be exchanged for an actual WebSocket object ``ws``.
  Again, the full API offers a lot of flexibility and additional options.


pkgId: 27fefa85f93bd786bd47796db189ab57807cbd73a2019339acbd895bf6e903f0
name: python-trueskill
arch: src
version: 0.4.5
epoch: 0
release: 1
summary: The video game rating system
url: http://trueskill.org/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4e3bb60f-54f5-4bbe-97cb-c6b43db87eb3
location_href: 00014361-python-trueskill/python-trueskill-0.4.5-1.src.rpm
checksum_type: sha256
description:
  TrueSkill
  ~~~~~~~~~

  An implementation of the TrueSkill algorithm for Python.  TrueSkill is a rating
  system among game players and it is used on Xbox Live to rank and match
  players.

  .. sourcecode:: python

     from trueskill import Rating, quality_1vs1, rate_1vs1
     alice, bob = Rating(25), Rating(30)  # assign Alice and Bob's ratings
     if quality_1vs1(alice, bob) < 0.50:
         print('This match seems to be not so fair')
     alice, bob = rate_1vs1(alice, bob)  # update the ratings after the match

  Links
  `````

  Documentation
     http://trueskill.org/
  GitHub:
     http://github.com/sublee/trueskill
  Mailing list:
     trueskill@librelist.com
  List archive:
     http://librelist.com/browser/trueskill
  Continuous integration (Travis CI)
     https://travis-ci.org/sublee/trueskill

     .. image:: https://api.travis-ci.org/sublee/trueskill.png

  See Also
  ````````

  - `TrueSkill(TM) Ranking System by Microsoft
    <http://research.microsoft.com/en-us/projects/trueskill/>`_
  - `"Computing Your Skill" by Jeff Moser <http://bit.ly/moserware-trueskill>`_
  - `"The Math Behind TrueSkill" by Jeff Moser <http://bit.ly/trueskill-math>`_
  - `TrueSkill Calcurator by Microsoft
    <http://atom.research.microsoft.com/trueskill/rankcalculator.aspx>`_


pkgId: aa489db4b168fe043b15b2ee71819e4c8d097ab4e29686e22d221c91ed23d0b6
name: python-tsfresh
arch: src
version: 0.20.0
epoch: 0
release: 1
summary: tsfresh extracts relevant characteristics from time series
url: https://github.com/blue-yonder/tsfresh
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-20c0a37e-5003-4bc8-b945-83edb8023d90
location_href: 00010517-python-tsfresh/python-tsfresh-0.20.0-1.src.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/tsfresh/badge/?version=latest)](https://tsfresh.readthedocs.io/en/latest/?badge=latest)
  [![Build Status](https://github.com/blue-yonder/tsfresh/workflows/Test%20Default%20Branch/badge.svg)](https://github.com/blue-yonder/tsfresh/actions)
  [![codecov](https://codecov.io/gh/blue-yonder/tsfresh/branch/main/graph/badge.svg)](https://codecov.io/gh/blue-yonder/tsfresh)
  [![license](https://img.shields.io/github/license/mashape/apistatus.svg)](https://github.com/blue-yonder/tsfresh/blob/main/LICENSE.txt)
  [![py36 status](https://img.shields.io/badge/python3.6.10-supported-green.svg)](https://github.com/blue-yonder/tsfresh/issues/8)
  [![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/blue-yonder/tsfresh/main?filepath=notebooks)
  [![Downloads](https://pepy.tech/badge/tsfresh)](https://pepy.tech/project/tsfresh)
  This repository contains the *TSFRESH* python package. The abbreviation stands for
  *"Time Series Feature extraction based on scalable hypothesis tests"*.
  The package provides systematic time-series feature extraction by combining established algorithms from statistics, time-series analysis, signal processing, and nonlinear dynamics with a robust feature selection algorithm. In this context, the term *time-series* is interpreted in the broadest possible sense, such that any types of sampled data or even event sequences can be characterised.

  Data Scientists often spend most of their time either cleaning data or building features.
  While we cannot change the first thing, the second can be automated.
  *TSFRESH* frees your time spent on building features by extracting them automatically.
  Hence, you have more time to study the newest deep learning paper, read hacker news or build better models.

  *TSFRESH* automatically extracts 100s of features from time series.
  Those features describe basic characteristics of the time series such as the number of peaks, the average or maximal value or more complex features such as the time reversal symmetry statistic.
  ![The features extracted from a exemplary time series](docs/images/introduction_ts_exa_features.png)
  The set of features can then be used to construct statistical or machine learning models on the time series to be used for example in regression or
  classification tasks.

  Time series often contain noise, redundancies or irrelevant information.
  As a result most of the extracted features will not be useful for the machine learning task at hand.
  To avoid extracting irrelevant features, the *TSFRESH* package has a built-in filtering procedure.
  This filtering procedure evaluates the explaining power and importance of each characteristic for the regression or classification tasks at hand.
  It is based on the well developed theory of hypothesis testing and uses a multiple test procedure.
  As a result the filtering process mathematically controls the percentage of irrelevant extracted features.
  The  *TSFRESH* package is described in the following open access paper:
  * Christ, M., Braun, N., Neuffer, J., and Kempa-Liehr A.W. (2018).
     _Time Series FeatuRe Extraction on basis of Scalable Hypothesis tests (tsfresh -- A Python package)._
     Neurocomputing 307, p. 72-77, [doi: 10.1016/j.neucom.2018.03.067](https://doi.org/10.1016/j.neucom.2018.03.067).
  The FRESH algorithm is described in the following whitepaper:
  * Christ, M., Kempa-Liehr, A.W., and Feindt, M. (2017).
      _Distributed and parallel time series feature extraction for industrial big data applications._
      ArXiv e-print 1610.07717,  [https://arxiv.org/abs/1610.07717](https://arxiv.org/abs/1610.07717).
  Systematic time-series feature extraction even works for unsupervised problems:
  * Teh, H.Y., Wang, K.I-K., Kempa-Liehr, A.W. (2021).
      _Expect the Unexpected: Unsupervised feature selection for automated sensor anomaly detection._
      IEEE Sensors Journal 15.16, p. 18033-18046, [doi: 10.1109/JSEN.2021.3084970](https://doi.org/10.1109/JSEN.2021.3084970).
  Due to the fact that tsfresh basically provides time-series feature extraction for free, you can now concentrate on engineering new time-series,
  like e.g. differences of signals from synchronous measurements, which provide even better time-series features:
  * Kempa-Liehr, A.W., Oram, J., Wong, A., Finch, M., Besier, T. (2020).
      _Feature engineering workflow for activity recognition from synchronized inertial measurement units._
      In: Pattern Recognition. ACPR 2019. Ed. by M. Cree et al. Vol. 1180. Communications in Computer and Information Science (CCIS).
      Singapore: Springer, p. 223–231. [doi: 10.1007/978-981-15-3651-9_20](https://doi.org/10.1007/978-981-15-3651-9_20).
  * Simmons, S., Jarvis, L., Dempsey, D., Kempa-Liehr, A.W. (2021).
      _Data Mining on Extremely Long Time-Series._
      In: 2021 International Conference on Data Mining Workshops (ICDMW). Ed. by B. Xue et al.
      Los Alamitos: IEEE, p. 1057-1066. [doi: 10.1109/ICDMW53433.2021.00137](https://doi.org/10.1109/ICDMW53433.2021.00137).
  Systematic time-series features engineering allows to work with time-series samples of different lengths, because every time-series is projected
  into a well-defined feature space. This approach allows the design of robust machine learning algorithms in applications with missing data.
  * Kennedy, A., Gemma, N., Rattenbury, N., Kempa-Liehr, A.W. (2021).
      _Modelling the projected separation of microlensing events using systematic time-series feature engineering._
      Astronomy and Computing 35.100460, p. 1–14, [doi: 10.1016/j.ascom.2021.100460](https://doi.org/10.1016/j.ascom.2021.100460)
  Is your time-series classification problem imbalanced? There is a good chance that undersampling of time-series feature matrices
  might solve your problem:
  * Dempsey, D.E., Cronin, S.J., Mei, S., Kempa-Liehr, A.W. (2020).
      _Automatic precursor recognition and real-time forecasting of sudden explosive volcanic eruptions at Whakaari, New Zealand_.
      Nature Communications 11.3562, p. 1-8, [doi: 10.1038/s41467-020-17375-2](https://doi.org/10.1038/s41467-020-17375-2).
  Natural language processing of written texts is an example of applying systematic time-series feature engineering to event sequences,
  which is described in the following open access paper:
  * Tang, Y., Blincoe, K., Kempa-Liehr, A.W. (2020).
      _Enriching Feature Engineering for Short Text Samples by Language Time Series Analysis._
      EPJ Data Science 9.26, p. 1–59. [doi: 10.1140/epjds/s13688-020-00244-9](https://doi.org/10.1140/epjds/s13688-020-00244-9)

  *TSFRESH* has several selling points, for example
  1. it is field tested
  2. it is unit tested
  3. the filtering process is statistically/mathematically correct
  4. it has a comprehensive documentation
  5. it is compatible with sklearn, pandas and numpy
  6. it allows anyone to easily add their favorite features
  7. it both runs on your local machine or even on a cluster

  If you are interested in the technical workings, go to see our comprehensive Read-The-Docs documentation at [http://tsfresh.readthedocs.io](http://tsfresh.readthedocs.io).
  The algorithm, especially the filtering part are also described in the paper mentioned above.
  We appreciate any contributions, if you are interested in helping us to make *TSFRESH* the biggest archive of feature extraction methods in python, just head over to our [How-To-Contribute](http://tsfresh.readthedocs.io/en/latest/text/how_to_contribute.html) instructions.
  If you want to try out `tsfresh` quickly or if you want to integrate it into your workflow, we also have a docker image available:
      docker pull nbraun/tsfresh

  If you need to reproduce or update time-series features, which were computed with the `matrixprofile` feature calculators, you need to create a Python 3.8 environment:
      conda create --name tsfresh__py_3.8 python=3.8
      conda activate tsfresh__py_3.8
      pip install tsfresh[matrixprofile]

  The research and development of *TSFRESH* was funded in part by the German Federal Ministry of Education and Research under grant number 01IS14004 (project iPRODICT).


pkgId: c8ed4728ff430f70622a929def3850dd1b490835177422eab93ac33f115cc601
name: python-tswift
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: MetroLyrics API
url: https://github.com/brenns10/tswift
rpm_license: Revised BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b3705779-35fc-4850-a6e2-f28dbe6c4fc7
location_href: 00011147-python-tswift/python-tswift-0.7.0-1.src.rpm
checksum_type: sha256
description:
  This repo is actually not directly related to Taylor Swift.  It's just a simple
  Python API for getting lyrics from MetroLyrics.  Here is how easy it is:
      from tswift import Artist
      import random
      tswift = Artist('Taylor Swift')
      song = random.choice(tswift.songs)
      print(song.format())


pkgId: dfc596a6cb37b0f8a470d7f147d07eb2c3d47b2d0f4df2cfd85de598ed82c5a1
name: python-ttkwidgets
arch: src
version: 0.13.0
epoch: 0
release: 1
summary: A collection of widgets for Tkinter's ttk extensions by various authors
url: https://www.github.com/RedFantom/ttkwidgets
rpm_license: AGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8fa9b313-6f36-4204-85c2-1aa689a4fb46
location_href: 00012587-python-ttkwidgets/python-ttkwidgets-0.13.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/TkinterEP/ttkwidgets.svg?branch=master)](https://travis-ci.org/TkinterEP/ttkwidgets)
  [![Build status](https://ci.appveyor.com/api/projects/status/eegux50s3kmb5w9g/branch/master?svg=true)](https://ci.appveyor.com/project/RedFantom/ttkwidgets-pq6y3)
  [![codecov](https://codecov.io/gh/TkinterEP/ttkwidgets/branch/master/graph/badge.svg)](https://codecov.io/gh/TkinterEP/ttkwidgets)
  [![PyPI version](https://badge.fury.io/py/ttkwidgets.svg)](https://badge.fury.io/py/ttkwidgets)
  [![License: GPL v3](https://img.shields.io/badge/License-GPL%20v3-blue.svg)](http://www.gnu.org/licenses/gpl-3.0)
  [![Documentation Status](https://readthedocs.org/projects/ttkwidgets/badge/?version=latest)](https://ttkwidgets.readthedocs.io/en/latest/)

  A collection of widgets for Tkinter's ttk extensions by various authors.


      ttkwidgets: A collection of widgets for Tkinter's ttk extensions by various authors
      Copyright (c) 2008-2022 The ttkwidgets authors
      See AUTHORS.md for more details

      This program is free software: you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.

      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU General Public License for more details.

      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.


  - With pip:

          pip install ttkwidgets

  - Ubuntu: ttkwidgets is available in the PPA [ppa:j-4321-i/ttkwidgets](https://launchpad.net/~j-4321-i/+archive/ubuntu/ttkwidgets).

          sudo add-apt-repository ppa:j-4321-i/ttkwidgets
          sudo apt-get update
          sudo apt-get install python(3)-ttkwidgets

  - Archlinux: ttkwidgets is available in [AUR](https://aur.archlinux.org/packages/python-ttkwidgets).


  Online documentation is available here: https://ttkwidgets.readthedocs.io/en/latest/


  If you have created a widget that you think is worth adding, then feel free to fork the repository and create a Pull
  Request when you've added the widget to your copy of the repository. You will be credited for your work, and you can add
  headers to your files. You will also be added to the [AUTHORS.md](AUTHORS.md) file.


  If you find any bugs or have any ideas, feel free to open an issue here in the repository, and it will be looked at.


