# packages

pkgId: 179678fac29ad4c89186bcca4705d24f2379f2c7ce3fa491c5db3c4139e7ffbf
name: python-alchemy-sdk
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/alchemyplatform/alchemy-sdk-py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alchemy-sdk-0.1.1-1.src.rpm
checksum_type: sha256
description:
  An Alchemy SDK to use the [Alchemy API](https://www.alchemy.com/).

  It supports the exact same syntax and functionality of the Web3 `eth`,
  making it a 1:1 mapping for anyone using the Web3 `eth`. However, it adds a
  significant amount of improved functionality on top of Web3, such as easy
  access to Alchemy’s Enhanced and NFT APIs, and quality-of-life improvements
  such as automated retries.

  The SDK leverages Alchemy's hardened node infrastructure,
  guaranteeing best-in-class node reliability, scalability, and data correctness,
  and is undergoing active development by Alchemy's engineers.

  > 🙋‍♀️ **FEATURE REQUESTS:**
  >
  > We'd love your thoughts on what would improve your web3 dev process the most! If you have 5 minutes, tell us what you want on our [Feature Request feedback form](https://alchemyapi.typeform.com/sdk-feedback), and we'd love to build it for you.

  The SDK currently supports the following chains:

  - **Ethereum**: Mainnet, Goerli
  - **Polygon**: Mainnet, Mumbai
  - **Optimism**: Mainnet, Goerli, Kovan
  - **Arbitrum**: Mainnet, Goerli, Rinkeby
  - **Astar**: Mainnet



  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install alchemy_sdk.

  ```bash
  pip3 install alchemy-sdk
  ```

  After installing the app, you can then import and use the SDK:

  ```python
  from alchemy import Alchemy, Network


  api_key = "your_api_key"


  network = Network.ETH_MAINNET


  max_retries = 3


  alchemy = Alchemy(api_key, network, max_retries=max_retries)
  ```

  > **ℹ️ Creating a unique Alchemy API Key**
  >
  > The public "demo" API key may be rate limited based on traffic. To create your own API key, **[sign up for an Alchemy account here](https://alchemy.com/?a=SDKquickstart)** and use the key created on your dashboard for the first app.



  The Alchemy SDK currently supports 2 different namespaces, including:

  - `core`: All web3.eth methods and Alchemy Enhanced API methods
  - `nft`: All Alchemy NFT API methods

  If you are already using web3.eth, you should be simply able to replace the web3.eth object with `alchemy.core` and it should work properly.

  > **ℹ️ ENS Name Resolution**
  >
  > The Alchemy SDK supports ENS names (e.g. `vitalik.eth`) for every parameter where you can pass in a Externally Owned Address, or user address (e.g. `0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045`).

  ```python
  from alchemy import Alchemy
  alchemy = Alchemy()


  block_hash = Alchemy.to_hex(alchemy.core.get_block('latest')['hash'])


  alchemy.core.get_transaction_receipts(block_hash=block_hash)


  contract = "0x01234567bac6ff94d7e4f0ee23119cf848f93245"
  print(alchemy.nft.get_contract_metadata(contract).opensea.collection_name)
  ```

  The Alchemy class also supports static methods from Web3 object that streamline the development process:
   - Encoding, Decoding, Hashing: `to_bytes`, `to_int`, `to_hex`, `to_text`, `to_json`, `keccak`
   - Currency Utility: `to_wei`, `from_wei`
   - Address Utility: `is_address`, `is_checksum_address`, `to_checksum_address`




  The core namespace contains all commonly-used Web3.eth methods.

  It also includes the majority of Alchemy Enhanced APIs, including:

  - `get_token_metadata()`: Get the metadata for a token contract address.
  - `get_token_balances()`: Gets the token balances for an owner given a list of contracts.
  - `get_asset_transfers()`: Get transactions for specific addresses.
  - `get_transaction_receipts()`: Gets all transaction receipts for a given block.



  The SDK currently supports the following [NFT API](https://docs.alchemy.com/alchemy/enhanced-apis/nft-api) endpoints
  under the `alchemy.nft` namespace:

  - `get_nft_metadata()`: Get the NFT metadata for an NFT contract address and tokenId.
  - `get_nft_metada_batch()`: Get the NFT metadata for multiple NFT contract addresses/token id pairs.
  - `get_contract_metadata()`: Get the metadata associated with an NFT contract.
  - `get_contracts_for_owner()`: Get all NFT contracts that the provided owner address owns.
  - `get_nfts_for_owner()`: Get NFTs for an owner address.
  - `get_nfts_for_contract()`: Get all NFTs for a contract address.
  - `get_owners_for_nft()`: Get all the owners for a given NFT contract address and a particular token ID.
  - `get_owners_for_contract()`: Get all the owners for a given NFT contract address.
  - `get_minted_nfts()`: Get all the NFTs minted by the owner address.
  - `is_spam_contract()`: Check whether the given NFT contract address is a spam contract as defined by Alchemy (see the [NFT API FAQ](https://docs.alchemy.com/alchemy/enhanced-apis/nft-api/nft-api-faq#nft-spam-classification))
  - `get_spam_contracts()`: Returns a list of all spam contracts marked by Alchemy.
  - `refresh_contract()`: Enqueues the specified contract address to have all token ids' metadata refreshed.
  - `get_floor_price()`: Return the floor prices of a NFT contract by marketplace.
  - `compute_rarity()`: Get the rarity of each attribute of an NFT.



  The Alchemy NFT endpoints return 100 results per page. To get the next page, you can pass in
  the `pageKey` returned by the previous call.



  The NFT API in the SDK standardizes response types to reduce developer friction, but note this results in some
  differences compared to the Alchemy REST endpoints:

  - Methods referencing `Collection` have been renamed to use the name `Contract` for greater accuracy: e.g. `get_nfts_for_contract`.
  - Some methods have different naming that the REST API counterparts in order to provide a consistent API interface (
    e.g. `get_nfts_for_owner()` is `alchemy_getNfts`, `get_owners_for_nft()` is `alchemy_getOwnersForToken`).
  - SDK standardizes to `omit_metadata` parameter (vs. `withMetadata`).
  - Standardization to `page_key` parameter for pagination (vs. `nextToken`/`startToken`)
  - Empty `token_uri` fields are omitted.
  - Token ID is always normalized to an integer string on `BaseNft` and `Nft`.
  - Some fields omitted in the REST response are included in the SDK response in order to return an `Nft` object.
  - Some fields in the SDK's `Nft` object are named differently than the REST response.



  Below are a few usage examples.



  ```python
  from alchemy import Alchemy
  from alchemy.nft import NftFilters

  alchemy = Alchemy()


  response = alchemy.nft.get_nfts_for_owner('vitalik.eth')
  print(response['total_count'])


  for nft in response['owned_nfts']:
      print(nft.media)


  nfts_without_spam = alchemy.nft.get_nfts_for_owner('vitalik.eth', exclude_filters=[NftFilters.SPAM])
  ```



  ```python
  from alchemy import Alchemy

  alchemy = Alchemy()


  bayc_address = '0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D'


  response = alchemy.nft.get_nfts_for_contract(bayc_address, omit_metadata=True, page_size=5)
  for nft in response['nfts']:
      owners = alchemy.nft.get_owners_for_nft(
          contract_address=nft.contract.address, token_id=nft.token_id
      )
      print(f"owners: {owners}, tokenId: {nft.token_id}")
  ```



  ```python
  from alchemy import Alchemy

  alchemy = Alchemy()
  print(alchemy.core.get_token_balances('vitalik.eth'))
  ```




  If you have any questions, issues, or feedback, please file an issue
  on [GitHub](https://github.com/alchemyplatform/alchemy-sdk-js/issues), or drop us a message on
  our [Discord](https://discord.com/channels/735965332958871634/983472322998575174) channel for the SDK.



  [MIT](https://choosealicense.com/licenses/mit/)


pkgId: 8b4745aab4e1145bd0abc273318928a93c07e8412ca363b4bccee4872d112192
name: python-alchimia
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: (SQLAlchemy - ORM) + Twisted = win
url: https://github.com/alex/alchimia
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alchimia-0.8.1-1.src.rpm
checksum_type: sha256
description:
  ``alchimia`` lets you use most of the SQLAlchemy-core API with Twisted, it does
  not allow you to use the ORM.


pkgId: bba94c4c839886451993d0de816c619269f5fcbc2f4259ac6b86fb59f7bfb02a
name: python-alchy
arch: src
version: 2.2.2
epoch: 0
release: 1
url: https://github.com/dgilland/alchy
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alchy-2.2.2-1.src.rpm
checksum_type: sha256
summary:
  A SQLAlchemy extension for its declarative ORM that provides enhancements for model classes, queries, and sessions.

description:
  **PROJECT IS IN MAINTENANCE MODE: NO NEW FEATURES, BUG FIXES ONLY**
  Use `sqlservice <https://github.com/dgilland/sqlservice>`_ instead.


pkgId: a6d696d1cee46a8cfdac557dfd9e9b689d2ff2a8ac3a16e792d5a874b7bbadac
name: python-aldryn-boilerplates
arch: src
version: 0.8.0
epoch: 0
release: 1
url: https://github.com/aldryn/aldryn-boilerplates/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aldryn-boilerplates-0.8.0-1.src.rpm
checksum_type: sha256
summary:
  An extension that allows re-usable apps to provide sets of templates and staticfiles for different boilerplates.

description:
  In general configuration stays the same but you should respect changes that
  were introduced by django 1.8.
  In particular in Django 1.8 context processors were moved from ``django.core``
  to ``django.template``.
  Be sure to include ``aldryn_boilerplates`` to ``INSTALLED_APPS``, adjust
  ``STATICFILES_FINDERS`` and finally configure ``TEMPLATES``.
  For ``TEMPLATES`` you need to add
  ``aldryn_boilerplates.context_processors.boilerplate`` to ``context_processors``
  and alter ``loaders`` in the same way as we do it for Django versions prior
  to 1.8.
  **Note** that in the example below we are altering the default values,
  so if you are using something that is custom - don't forget to add that too.
  Here is an example of a simple configuration:
      INSTALLED_APPS = [
          'aldryn_boilerplates',
      ]
      STATICFILES_FINDERS = (
          'django.contrib.staticfiles.finders.FileSystemFinder',
          'aldryn_boilerplates.staticfile_finders.AppDirectoriesFinder',
          'django.contrib.staticfiles.finders.AppDirectoriesFinder',
      )
      TEMPLATES = [
          {
              'BACKEND': 'django.template.backends.django.DjangoTemplates',
              'OPTIONS': {
                  'context_processors': [
                      'django.contrib.auth.context_processors.auth',
                      'django.contrib.messages.context_processors.messages',
                      'django.template.context_processors.i18n',
                      'django.template.context_processors.debug',
                      'django.template.context_processors.request',
                      'django.template.context_processors.media',
                      'django.template.context_processors.csrf',
                      'django.template.context_processors.tz',
                      'sekizai.context_processors.sekizai',
                      'django.template.context_processors.static',
                      'cms.context_processors.cms_settings',
                      'aldryn_boilerplates.context_processors.boilerplate',
                  ],
                  'loaders': [
                      'django.template.loaders.filesystem.Loader',
                      'aldryn_boilerplates.template_loaders.AppDirectoriesLoader',
                      'django.template.loaders.app_directories.Loader',
                  ],
              },
          },
      ]
  ******************************************************
  Adding aldryn-boilerplate support to existing packages
  ******************************************************
  The recommended approach is to add a dependency to aldryn-boilerplates and to move existing
  ``static`` and ``template`` files to a boilerplate folder (completely remove ``static`` and
  ``templates``). If you're in the process of re-factoring your existing templates with something
  new, put them into the ``legacy`` boilerplate folder and set ``ALDRYN_BOILERPLATE_NAME='legacy'``
  on projects that are still using the old templates.
  The new and shiny project can then use ``ALDRYN_BOILERPLATE_NAME='bootstrap3'`` to use the new
  Aldryn Bootstrap Boilerplate (`aldryn-boilerplate-bootstrap3`_). Or any other
  boilerplate for that matter.
  Removing ``static`` and ``templates`` has the benefit of removing likely deprecated templates
  from the very prominent location, that will confuse newcomers. It also prevents having not-relevant
  templates and static files messing up your setup.


pkgId: 879c1894f322b2f992b2002f8f2a0555b497c88f09e32f20d9e751439f784403
name: python-aldryn-events
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: An events app for Aldryn
url: https://github.com/aldryn/aldryn-events
rpm_license: LICENSE.txt
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aldryn-events-3.0.0-1.src.rpm
checksum_type: sha256
description:
  Aldryn-Events for django CMS


  |PyPI Version| |Build Status| |Coverage Status| |codeclimate| |requires_io|

  Aldryn Events is an Aldryn-compatible application for publishing information
  about events in django CMS.

  Please see the official `Aldryn Events documentation <http://aldryn-events.readthedocs.org>`_,
  which includes information on installation and getting started.

  It also contains `documentation for content editors and end-users
  <http://aldryn-events.readthedocs.org/en/latest/user/index.html>`_.


  ************
  Contributing
  ************

  Aldryn Events is a an open-source project. We'll be delighted to receive your
  feedback in the form of issues and pull requests. Before submitting your pull
  request, please review our `guidelines for Aldryn addons <http://docs.aldryn.com/en/latest/reference/addons/index.html>`_.


  ************
  Requirements
  ************

  * Python 2.7, 3.4, 3.5
  * django CMS 3.4 or later
  * Django 1.8 - 1.11


  .. |PyPI Version| image:: http://img.shields.io/pypi/v/aldryn-events.svg
     :target: https://pypi.python.org/pypi/aldryn-events
  .. |Build Status| image:: http://img.shields.io/travis/aldryn/aldryn-events/master.svg
     :target: https://travis-ci.org/aldryn/aldryn-events
  .. |Coverage Status| image:: http://img.shields.io/coveralls/aldryn/aldryn-events/master.svg
     :target: https://coveralls.io/r/aldryn/aldryn-events?branch=master
  .. |codeclimate| image:: https://codeclimate.com/github/aldryn/aldryn-events/badges/gpa.svg
     :target: https://codeclimate.com/github/aldryn/aldryn-events
     :alt: Code Climate
  .. |requires_io| image:: https://requires.io/github/aldryn/aldryn-events/requirements.svg?branch=master
     :target: https://requires.io/github/aldryn/aldryn-events/requirements/?branch=master
     :alt: Requirements Status


pkgId: 9e123f5b9daf8300e822598d469e225ecc47519399c66a17f78c3fb9e3f36f62
name: python-aldryn-jobs
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Publish job openings on your site
url: https://github.com/aldryn/aldryn-jobs
rpm_license: LICENSE.txt
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aldryn-jobs-3.0.0-1.src.rpm
checksum_type: sha256
description:
  Aldryn Jobs for django CMS


  |PyPI_Version| |Build_Status| |Coverage_Status| |codeclimate| |requires_io|

  Aldryn Jobs is an Aldryn-compatible django CMS application for publishing
  job openings and receiving applications.

  Please see the `Aldryn Jobs documentation <http://aldryn-jobs.readthedocs.org>`_,
  which includes information on installation and getting started.

  It also contains `documentation for content editors and end-users
  <http://aldryn-jobs.readthedocs.org/en/latest/user/index.html>`_.

  ************
  Contributing
  ************

  Aldryn Jobs is a an open-source project. We'll be delighted to receive your
  feedback in the form of issues and pull requests. Before submitting your pull
  request, please review our
  `guidelines for Aldryn Addons <http://docs.aldryn.com/en/latest/reference/addons/index.html>`_.


  ************
  Requirements
  ************

  * django CMS 3.4+
  * Django 1.8 - 1.11


  .. |PyPI_Version| image:: http://img.shields.io/pypi/v/aldryn-jobs.svg
     :target: https://pypi.python.org/pypi/aldryn-jobs
  .. |Build_Status| image:: http://img.shields.io/travis/aldryn/aldryn-jobs/master.svg
     :target: https://travis-ci.org/aldryn/aldryn-jobs
  .. |Coverage_Status| image:: http://img.shields.io/coveralls/aldryn/aldryn-jobs/master.svg
     :target: https://coveralls.io/r/aldryn/aldryn-jobs?branch=master
  .. |codeclimate| image:: https://codeclimate.com/github/aldryn/aldryn-jobs/badges/gpa.svg
     :target: https://codeclimate.com/github/aldryn/aldryn-jobs
     :alt: Code Climate
  .. |requires_io| image:: https://requires.io/github/aldryn/aldryn-jobs/requirements.svg?branch=master
     :target: https://requires.io/github/aldryn/aldryn-jobs/requirements/?branch=master
     :alt: Requirements Status


pkgId: 51000e27b420a4c7c201a568aa6abeff1fc978dbd54e90c9c6f126fd428b1ea7
name: python-aldryn-reversion
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Support for django-reversion on models with translatable fields and django-cms placeholder fields.
url: https://github.com/aldryn/aldryn-reversion
rpm_license: LICENSE.txt
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aldryn-reversion-1.1.0-1.src.rpm
checksum_type: sha256
description:
  * django CMS 3.0.12 or later
  * django-parler
  ************
  Installation
  ************
  Most likely you won't need to install this addon - it will be installed as a dependency for some
  other addon. If you do need to install it manually, follow these steps:
  1) Run `pip install aldryn-reversion`.
  2) Add below apps to ``INSTALLED_APPS``: ::
      INSTALLED_APPS = [
          …
          'reversion',
          'aldryn_reversion',
          …
      ]
  3) (Re-)Start your application server.
  `More detailed installation guidance
  <http://aldryn-reversion.readthedocs.org/en/latest/introduction/installation.html>`_ is also
  available.


pkgId: 0e6f5938326a6389dc4e785527317af1103a2f50d908b321936b59807d5febde
name: python-aldryn-sites
arch: src
version: 0.6.0
epoch: 0
release: 1
description: Extensions to django.contrib.sites.
url: https://github.com/aldryn/aldryn-sites/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aldryn-sites-0.6.0-1.src.rpm
checksum_type: sha256
summary:
  An extension for django.contrib.sites, featuring domain redirects and automatic population of the django.contrib.sites.Site table based on settings.


pkgId: 937f4acd74de2ce61d15afd5b23d0ec7186dfdaacd288f4f9a7b32999e03e10d
name: python-alea-inference
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: A tool to perform toyMC-based inference constructions
url: https://github.com/XENONnT/alea
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alea-inference-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/654100988.svg)](https://zenodo.org/badge/latestdoi/654100988)
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/XENONnT/alea/HEAD?labpath=notebooks)
  [![Test package](https://github.com/XENONnT/alea/actions/workflows/pytest.yml/badge.svg?branch=main)](https://github.com/XENONnT/alea/actions/workflows/pytest.yml)
  [![Coverage Status](https://coveralls.io/repos/github/XENONnT/alea/badge.svg?branch=main&kill_cache=1)](https://coveralls.io/github/XENONnT/alea?branch=main&kill_cache=1)
  [![PyPI version shields.io](https://img.shields.io/pypi/v/alea-inference.svg)](https://pypi.python.org/pypi/alea-inference/)
  [![Readthedocs Badge](https://readthedocs.org/projects/alea/badge/?version=latest)](https://alea.readthedocs.io/en/latest/?badge=latest)
  [![CodeFactor](https://www.codefactor.io/repository/github/xenonnt/alea/badge)](https://www.codefactor.io/repository/github/xenonnt/alea)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/XENONnT/alea/main.svg)](https://results.pre-commit.ci/latest/github/XENONnT/alea/main)

  alea is a flexible statistical inference framework. The Python package is designed for constructing, handling, and fitting statistical models, computing confidence intervals and conducting sensitivity studies. It is primarily developed for the [XENONnT dark matter experiment](https://xenonexperiment.org/), but can be used for any statistical inference problem.

  Alea aims to model the statistical behaviour of an experiment, which again depends on your knowledge of the underlying physics-- this can range from the very simple, such as measuring a gaussian-distributed random variable, to complex likelihoods where each model component is created by physics simulations (GEANT4), fast detector simulations (for example [appletree](https://github.com/XENONnT/appletree/) for XENONnT) or a data-driven method.

  If you use alea in your research, please consider citing the software published on [zenodo](https://zenodo.org/badge/latestdoi/654100988).


  You can install alea from PyPI using pip but **beware that it is listed there as alea-inference!** Thus, you need to run
  ```
  pip install alea-inference
  ```

  For the latest version, you can install directly from the GitHub repository by cloning the repository and running
  ```
  cd alea
  pip install .
  ```
  You are now ready to use alea!


  The best way to get started is to check out the [documentation](https://alea.readthedocs.io/en/latest/) and have a look at our [tutorial notebooks](https://github.com/XENONnT/alea/tree/main/notebooks). To explore the notebooks interactively, you can use [Binder](https://mybinder.org/v2/gh/XENONnT/alea/HEAD?labpath=notebooks).


  `alea` is a public package inherited the spirits of previously private XENON likelihood definition and inference construction code `binference` that based on the blueice repo https://github.com/JelleAalbers/blueice.

  Binference was developed for XENON1T WIMP searches by Knut Dundas Morå, and for the first XENONnT results by Robert Hammann, Knut Dundas Morå and Tim Wolf.


pkgId: c97fc0a6bee75b4d81c61c988f13e913f04aced513a47347364fff07782537f8
name: python-alembic
arch: src
version: 1.13.2
epoch: 0
release: 1
summary: A database migration tool for SQLAlchemy.
url: https://alembic.sqlalchemy.org
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alembic-1.13.2-1.src.rpm
checksum_type: sha256
description:
  Alembic is part of the `SQLAlchemy Project <https://www.sqlalchemy.org>`_ and
  adheres to the same standards and conventions as the core project.
  Development / Bug reporting / Pull requests
  ___________________________________________
  Please refer to the
  `SQLAlchemy Community Guide <https://www.sqlalchemy.org/develop.html>`_ for
  guidelines on coding and participating in this project.
  Code of Conduct
  _______________
  Above all, SQLAlchemy places great emphasis on polite, thoughtful, and
  constructive communication between users and developers.
  Please see our current Code of Conduct at
  `Code of Conduct <https://www.sqlalchemy.org/codeofconduct.html>`_.


pkgId: faa155d2773f12b56e8d3ea515e44b7bcee19f0d3685126fd86a7ab1047d108e
name: python-alembic-autogen-check
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: CLI to check with alembic migrations are in sync with your SQLAlchemy models.
url: https://github.com/4Catalyzer/alembic-autogen-check
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alembic-autogen-check-1.1.1-1.src.rpm
checksum_type: sha256
description:
  [![Travis-CI](https://badgen.net/travis/4Catalyzer/alembic-autogen-check/master)](https://travis-ci.org/4Catalyzer/alembic-autogen-check)



  ```
  pip install alembic-autogen-check
  ```



  ```
  PYTHONPATH=. alembic-autogen-check
  ```

  This assumes that an `alembic.ini` file exists in the current working
  directory. You can explicitly pass a config file:

  ```
  PYTHONPATH=. alembic-autogen-check --config path/to/alembic.ini
  ```


pkgId: 6627251d9b60157a1e99acbe0efbeebe3deaf17c2d19a342690516cf798151a0
name: python-alembic-autogenerate-enums
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Alembic hook that allows enums values to be upgraded and downgraded in migrations automatically
url: https://pypi.org/project/alembic-autogenerate-enums/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alembic-autogenerate-enums-0.1.2-1.src.rpm
checksum_type: sha256
description:
  This package implements an Alembic hook that causes ``alembic revision
  --autogenerate`` to output PostgreSQL ``ALTER TYPE .. ADD VALUE`` SQL
  statements as part of new migrations.




  Add the line:

      import alembic_autogenerate_enums

  To the top of your ``env.py``.




  Since ``ALTER TYPE .. ADD VALUE`` cannot run transactionally, each
  ``op.sync_enum_values()`` call creates its own temporary private DB connection.
  See https://bitbucket.org/zzzeek/alembic/issues/123/a-way-to-run-non-transactional-ddl



  We have incredibly basic tests in a [sample project](./test-harness).

  ```
  mkvirtualenv alembic-autogenerate
  ```

  Install the main autogenerate package and then the test harness:

  ```
  pip install -e .
  pip install -e test-harness
  ```

  ```
  createuser alembic-autogenerate
  createdb -O alembic-autogenerate alembic-autogenerate_db
  ```

  ```
  cd test-harness && pytest
  ```


pkgId: 9f026e3d899f94cd54c12c011d76eb3daced71d064186ee3a054775b669628c8
name: python-alembic-dddl
arch: src
version: 0.1.2
epoch: 0
release: 1
url: https://github.com/Vanderhoof/alembic-dddl
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alembic-dddl-0.1.2-1.src.rpm
checksum_type: sha256
summary:
  Alembic extension that adds support for arbitrary user-defined objects like views or functions in autogenerate command.

description:
  [![](https://img.shields.io/pypi/v/alembic-dddl.svg)](https://pypi.org/project/alembic-dddl/) [![](https://img.shields.io/github/v/tag/Vanderhoof/alembic-dddl.svg?label=GitHub)](https://github.com/Vanderhoof/alembic-dddl) ![tests](https://github.com/Vanderhoof/alembic-dddl/actions/workflows/tests.yml/badge.svg) [![codecov](https://codecov.io/gh/Vanderhoof/alembic-dddl/graph/badge.svg?token=BQJBA9PXPN)](https://codecov.io/gh/Vanderhoof/alembic-dddl)

  A plugin for [Alembic](https://alembic.sqlalchemy.org/en/latest/) DB migration tool that adds support for arbitrary user-defined objects like views, functions, triggers, etc. in autogenerate command.

  Alembic DDDL _does not_ compare the objects in the code with their state in the database. Instead, it **only tracks if the source code of the script has changed**, compared to the previous revision.



  You can install Alembic Dumb DDL from pip:

  ```shell
  pip install alembic-dddl
  ```



  Step 1: save your DDL script in a file, and make sure that it overwrites the entities, not just creates them (e.g. start with `DROP ... IF EXISTS` or a similar construct for your DBMS).

  ```sql
  -- myapp/scripts/last_month_orders.sql

  DROP VIEW IF EXISTS last_month_orders;

  CREATE VIEW last_month_orders AS
      SELECT *
      FROM orders
      WHERE order_date > current_date - interval '30 days';
  ```

  Step 2: Wrap your script in a `DDL` class:

  ```python


  from alembic_dddl import DDL
  from pathlib import Path

  SCRIPTS = Path(__file__).parent / "scripts"


  def load_sql(filename: str) -> str:
      """Helper function to load the contents of a file from a `scripts` directory"""
      return (SCRIPTS / filename).read_text()


  my_ddl = DDL(
      
      name="last_month_orders",
      
      sql=load_sql("last_month_orders.sql"),
      
      down_sql="DROP VIEW IF EXISTS last_month_orders;",
  )
  ```

  Step 3: Register your script in alembic's `env.py`:

  ```python


  from myapp.models import my_ddl
  from alembic_dddl import register_ddl

  register_ddl(my_ddl)  # also supports a list



  ```

  From now on the alembic autogenerate command will keep track of `last_month_orders.sql`, and if it changes — automatically add update code to your migration scripts to update your entities.

  Run the migration:

  ```shell
  $ alembic revision --autogenerate -m "last_month_orders"
  ...
  INFO  [alembic_dddl.dddl] Detected new DDL "last_month_orders"
    Generating myapp/migrations/versions/2024_01_08_0955-0c897e9399a9_last_month_orders.py ...  done
  ```

  The generated revision script:

  ```python

  ...

  def upgrade() -> None:
      
      op.run_ddl_script("2024_01_08_0955_last_month_orders_0c897e9399a9.sql")
      


  def downgrade() -> None:
      
      op.execute("DROP VIEW IF EXISTS last_month_orders;")
      

  ```

  For more info see [tutorial](docs/tutorial.md) or take a look at the [Example Project](https://github.com/Vanderhoof/alembic-dddl/tree/master/example/).



  Managing your custom entities with Alembic DDDL has several benefits:

  1. The DDL scripts are defined in one place in the source code, any change to them is reflected in git history through direct diffs.
  2. Any kind of SQL script and any DBMS is supported because the plugin does not interact with the database.
  3. The migrations for your DDL scripts are fully autogenerated, they are also clean and concise.



  * [Tutorial](docs/tutorial.md)
  * [How it Works](docs/how_it_works.md)
  * [Configuration](docs/configuration.md)
  * [Setting up Logging](docs/logging.md)


pkgId: 9c46241e33b6cd41ed4d2e7e2cfe6612852fe29500720b34cd23b21d92504531
name: python-alembic-enums
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Support for migrating PostgreSQL enums with Alembic
url: https://github.com/imankulov/alembic-enums
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alembic-enums-0.4.1-1.src.rpm
checksum_type: sha256
description:
  ![example workflow](https://github.com/imankulov/alembic-enums/actions/workflows/tests.yml/badge.svg)

  **Support for migrating PostgreSQL enums with Alembic**

  The package doesn't detect enum changes or generate migration code automatically, but it provides a helper class to run the enum migrations in Alembic migration scripts.



  When you define an enum column with SQLAlchemy, the initial migration defines a custom [enum type](https://www.postgresql.org/docs/current/datatype-enum.html).

  Once the enum type is created, [ALTER TYPE](https://www.postgresql.org/docs/current/sql-altertype.html) allows you to add new values or rename existing ones, but not delete them.

  If you need to delete a value from an enum, you must create a new enum type and migrate all the columns to use the new type.




  ```bash
  pip install alembic-enums
  ```




  Assume you decided to rename the `state` enum values `active` and `inactive` to `enabled` and `disabled`:

  ```diff
   class Resource(Base):
       __tablename__ = "resources"
       id = Column(Integer, primary_key=True)
       name = Column(String(255), nullable=False)
  -    state = Column(Enum("enabled", "disabled", name="resource_state"), nullable=False)
  +    state = Column(Enum("active", "archived", name="resource_state"), nullable=False)
  ```

  To migrate the database, we create a new empty migration with `alembic revision -m "Rename enum values"` and add the following code to the generated migration script:

  ```python
  from alembic import op

  from alembic_enums import EnumMigration, Column





  column = Column("resources", "state", old_server_default=None, new_server_default=None)



  enum_migration = EnumMigration(
      op=op,
      enum_name="resource_state",
      old_options=["enabled", "disabled"],
      new_options=["active", "archived"],
      columns=[column],
  )




  def upgrade():
      with enum_migration.upgrade_ctx():
          enum_migration.update_value(column, "enabled", "active")
          enum_migration.update_value(column, "disabled", "archived")


  def downgrade():
      with enum_migration.downgrade_ctx():
          enum_migration.update_value(column, "active", "enabled")
          enum_migration.update_value(column, "archived", "disabled")
  ```

  Under the hood, the `EnumMigration` class creates a new enum type, updates the target columns to use the new enum type, and deletes the old enum type.





  To change the column default values, pass corresponding values to new_server_default and old_server_default arguments of the Column constructor. The new_server_default is used on upgrade, and the old_server_default is used on downgrade.

  IMPORTANT: Setting the server_default value to None will remove the default value from the column. If you want to keep the default value as is, set old_server_default and new_server_default to the same value.

  For example, to change the default value of the `state` column from `enabled` to `active`:


  ```python
  from alembic_enums import Column

  column = Column(
      "resources",
      "state",
      old_server_default="enabled",
      new_server_default="active",
  )
  ```





  A helper class to run enum migrations in Alembic migration scripts.

  **Constructor arguments:**

  - `op`: an instance of `alembic.operations.Operations`
  - `enum_name`: the name of the enum type
  - `old_options`: a list of old enum values
  - `new_options`: a list of new enum values
  - `columns`: a list of `Column` instances that use the enum type
  - `schema`: the optional schema of the enum

  **Methods:**

  - `upgrade_ctx()`: a context manager that creates a new enum type, updates the target columns to use the new enum type, and deletes the old enum type
  - `downgrade_ctx()`: a context manager that performs the opposite operations.
  - `update_value(column, old_value, new_value)`: a helper method to update the value of the `column` to `new_value` where it was `old_value` before. It's useful to update the data in the upgrade and downgrade operations within the `upgrade_ctx` and `downgrade_ctx` context managers.
  - `upgrade()`: a shorthand for `with upgrade_ctx(): pass`.
  - `downgrade()`: a shorthand for `with downgrade_ctx(): pass`.



  A data class to define a target column for an enum migration.

  **Constructor arguments:**

  - `table_name`: the name of the table
  - `column_name`: the name of the column
  - `old_server_default`: the old server_default value. When set to None, the server_default value is removed on downgrade.
  - `new_server_default`: the new server_default value. When set to None, the server_default value is removed on upgrade.
  - `schema`: the optional schema of the table


pkgId: 44126567de98c1bfd49776ff89fb2676d08d7dba232d2842c5845879236651ec
name: python-alembic-offline
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Offline extensions for Alembic database migration framework for SQLAlchemy
url: https://github.com/paylogic/alembic-offline
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alembic-offline-2.0.0-1.src.rpm
checksum_type: sha256
description:
  alembic-offline is an extension for Alembic to enrich offline functionality of migrations using SQLAlchemy


pkgId: a2f65345f67bb24d80d49b7734467865162263a3b404a8994740f3b803f35d44
name: python-alembic-postgresql-enum
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Alembic autogenerate support for creation, alteration and deletion of enums
url: https://pypi.org/project/alembic-postgresql-enum/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alembic-postgresql-enum-1.3.0-1.src.rpm
checksum_type: sha256
description:
  [<img src="https://img.shields.io/pypi/pyversions/alembic-postgresql-enum">](https://pypi.org/project/alembic-postgresql-enum/)
  [<img src="https://img.shields.io/pypi/v/alembic-postgresql-enum">](https://pypi.org/project/alembic-postgresql-enum/)
  [<img src="https://img.shields.io/pypi/l/alembic-postgresql-enum">](https://pypi.org/project/alembic-postgresql-enum/)

  Alembic autogenerate support for creation, alteration and deletion of enums

  Alembic will now automatically:
  - Create enums that currently are not in postgres schema
  - Remove/add/alter enum values
  - Reorder enum values
  - Delete unused enums from schema

  If you are curious to know about analogs and reasons for this library to exist see [alternatives and motivation](https://github.com/Pogchamp-company/alembic-postgresql-enum/blob/master/docs/alternatives.md)



  Install library:
  ```
  pip install alembic-postgresql-enum
  ```

  Add the line:

  ```python

  import alembic_postgresql_enum
  ...
  ```

  To the top of your migrations/env.py file.



  * [Creation of enums](#creation-of-enum)
  * [Deletion of unreferenced enums](#deletion-of-unreferenced-enum)
  * [Creation of new enum values](#creation-of-new-enum-values)
  * [Deletion of enums values](#deletion-of-enums-values)
  * [Renaming of enum values](#rename-enum-value)





  ```python
  class MyEnum(enum.Enum):
      one = 1
      two = 2
      three = 3


  class ExampleTable(BaseModel):
      test_field = Column(Integer, primary_key=True, autoincrement=False)
      enum_field = Column(postgresql.ENUM(MyEnum))
  ```
  This code will generate migration given below:
  ```python
  def upgrade():
      
      
      sa.Enum('one', 'two', 'three', name='myenum').create(op.get_bind())
      op.create_table('example_table',
      sa.Column('test_field', sa.Integer(), nullable=False),
      
      sa.Column('enum_field', postgresql.ENUM('one', 'two', 'three', name='myenum', create_type=False), nullable=True),
      sa.PrimaryKeyConstraint('test_field')
      )
      


  def downgrade():
      
      
      op.drop_table('example_table')
      
      sa.Enum('one', 'two', 'three', name='myenum').drop(op.get_bind())
      
  ```


  ```python
  class MyEnum(enum.Enum):
      one = 1
      two = 2
      three = 3


  class ExampleTable(BaseModel):
      test_field = Column(Integer, primary_key=True, autoincrement=False)
      
      enum_field = Column(postgresql.ENUM(MyEnum))
  ```
  This code will generate migration given below:
  ```python
  def upgrade():
      
      
      sa.Enum('one', 'two', 'three', name='myenum').create(op.get_bind())
      
      op.add_column('example_table', sa.Column('enum_field', postgresql.ENUM('one', 'two', 'three', name='myenum', create_type=False), nullable=False))
      


  def downgrade():
      
      op.drop_column('example_table', 'enum_field')
      
      sa.Enum('one', 'two', 'three', name='myenum').drop(op.get_bind())
      
  ```


  If enum is defined in postgres schema, but its mentions removed from code - It will be automatically removed
  ```python
  class ExampleTable(BaseModel):
      test_field = Column(Integer, primary_key=True, autoincrement=False)
      
  ```

  ```python
  def upgrade():
      
      op.drop_column('example_table', 'enum_field')
      sa.Enum('one', 'two', 'four', name='myenum').drop(op.get_bind())
      


  def downgrade():
      
      sa.Enum('one', 'two', 'four', name='myenum').create(op.get_bind())
      op.add_column('example_table', sa.Column('enum_field', postgresql.ENUM('one', 'two', 'four', name='myenum', create_type=False), autoincrement=False, nullable=True))
      
  ```



  If new enum value is defined sync_enum_values function call will be added to migration to account for it

  ```python
  class MyEnum(enum.Enum):
      one = 1
      two = 2
      three = 3
      four = 4 # New enum value
  ```

  ```python
  def upgrade():
      
      op.sync_enum_values('public', 'myenum', ['one', 'two', 'three', 'four'],
                          [('example_table', 'enum_field')],
                          enum_values_to_rename=[])
      


  def downgrade():
      
      op.sync_enum_values('public', 'myenum', ['one', 'two', 'three'],
                          [('example_table', 'enum_field')],
                          enum_values_to_rename=[])
      
  ```



  If enum value is removed it also will be detected

  ```python
  class MyEnum(enum.Enum):
      one = 1
      two = 2
      
  ```

  ```python
  def upgrade():
      
      op.sync_enum_values('public', 'myenum', ['one', 'two'],
                          [('example_table', 'enum_field')],
                          enum_values_to_rename=[])
      


  def downgrade():
      
      op.sync_enum_values('public', 'myenum', ['one', 'two', 'three'],
                          [('example_table', 'enum_field')],
                          enum_values_to_rename=[])
      
  ```


  In this case you must manually edit migration

  ```python
  class MyEnum(enum.Enum):
      one = 1
      two = 2
      three = 3 # renamed from `tree`
  ```

  This code will generate this migration:
  ```python
  def upgrade():
      
      op.sync_enum_values('public', 'myenum', ['one', 'two', 'three'],
                          [('example_table', 'enum_field')],
                          enum_values_to_rename=[])
      


  def downgrade():
      
      op.sync_enum_values('public', 'myenum', ['one', 'two', 'tree'],
                          [('example_table', 'enum_field')],
                          enum_values_to_rename=[])
      
  ```

  This migration will cause problems with existing rows that references MyEnum

  So adjust migration like that

  ```python
  def upgrade():
      op.sync_enum_values('public', 'myenum', ['one', 'two', 'three'],
                          [('example_table', 'enum_field')],
                          enum_values_to_rename=[('tree', 'three')])


  def downgrade():
      op.sync_enum_values('public', 'myenum', ['one', 'two', 'tree'],
                          [('example_table', 'enum_field')],
                          enum_values_to_rename=[('three', 'tree')])
  ```

  Do not forget to switch places old and new values for downgrade

  All defaults in postgres will be renamed automatically as well


pkgId: 68505ba2c000864bcaa44c7a5a92232fc51616e5537756a761e601737f15909b
name: python-alembic-postgresql-enum
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Alembic autogenerate support for creation, alteration and deletion of enums
url: https://pypi.org/project/alembic-postgresql-enum/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alembic-postgresql-enum-1.4.0-1.src.rpm
checksum_type: sha256
description:
  from alembic_postgresql_enum.configuration import Config


  [<img src="https://img.shields.io/pypi/pyversions/alembic-postgresql-enum">](https://pypi.org/project/alembic-postgresql-enum/)
  [<img src="https://img.shields.io/pypi/v/alembic-postgresql-enum">](https://pypi.org/project/alembic-postgresql-enum/)
  [<img src="https://img.shields.io/pypi/l/alembic-postgresql-enum">](https://pypi.org/project/alembic-postgresql-enum/)

  Alembic autogenerate support for creation, alteration and deletion of enums

  Alembic will now automatically:
  - Create enums that currently are not in postgres schema
  - Remove/add/alter enum values
  - Reorder enum values
  - Delete unused enums from schema

  If you are curious to know about analogs and reasons for this library to exist see [alternatives and motivation](https://github.com/Pogchamp-company/alembic-postgresql-enum/blob/master/docs/alternatives.md)



  Install library:
  ```
  pip install alembic-postgresql-enum
  ```

  Add the line:

  ```python

  import alembic_postgresql_enum
  ...
  ```

  To the top of your migrations/env.py file.



  You can configure this extension to disable parts of it, or to enable some feature flags

  To do so you need to call set_configuration function after the import:

  ```python
  import alembic_postgresql_enum

  alembic_postgresql_enum.set_configuration(
      alembic_postgresql_enum.Config(
          add_type_ignore=True,
      )
  )
  ```


  * [Creation of enums](#creation-of-enum)
  * [Deletion of unreferenced enums](#deletion-of-unreferenced-enum)
  * [Creation of new enum values](#creation-of-new-enum-values)
  * [Deletion of enums values](#deletion-of-enums-values)
  * [Renaming of enum values](#rename-enum-value)





  ```python
  class MyEnum(enum.Enum):
      one = 1
      two = 2
      three = 3


  class ExampleTable(BaseModel):
      test_field = Column(Integer, primary_key=True, autoincrement=False)
      enum_field = Column(postgresql.ENUM(MyEnum))
  ```
  This code will generate migration given below:
  ```python
  def upgrade():
      
      
      sa.Enum('one', 'two', 'three', name='myenum').create(op.get_bind())
      op.create_table('example_table',
      sa.Column('test_field', sa.Integer(), nullable=False),
      
      sa.Column('enum_field', postgresql.ENUM('one', 'two', 'three', name='myenum', create_type=False), nullable=True),
      sa.PrimaryKeyConstraint('test_field')
      )
      


  def downgrade():
      
      
      op.drop_table('example_table')
      
      sa.Enum('one', 'two', 'three', name='myenum').drop(op.get_bind())
      
  ```


  ```python
  class MyEnum(enum.Enum):
      one = 1
      two = 2
      three = 3


  class ExampleTable(BaseModel):
      test_field = Column(Integer, primary_key=True, autoincrement=False)
      
      enum_field = Column(postgresql.ENUM(MyEnum))
  ```
  This code will generate migration given below:
  ```python
  def upgrade():
      
      
      sa.Enum('one', 'two', 'three', name='myenum').create(op.get_bind())
      
      op.add_column('example_table', sa.Column('enum_field', postgresql.ENUM('one', 'two', 'three', name='myenum', create_type=False), nullable=False))
      


  def downgrade():
      
      op.drop_column('example_table', 'enum_field')
      
      sa.Enum('one', 'two', 'three', name='myenum').drop(op.get_bind())
      
  ```


  If enum is defined in postgres schema, but its mentions removed from code - It will be automatically removed
  ```python
  class ExampleTable(BaseModel):
      test_field = Column(Integer, primary_key=True, autoincrement=False)
      
  ```

  ```python
  def upgrade():
      
      op.drop_column('example_table', 'enum_field')
      sa.Enum('one', 'two', 'four', name='myenum').drop(op.get_bind())
      


  def downgrade():
      
      sa.Enum('one', 'two', 'four', name='myenum').create(op.get_bind())
      op.add_column('example_table', sa.Column('enum_field', postgresql.ENUM('one', 'two', 'four', name='myenum', create_type=False), autoincrement=False, nullable=True))
      
  ```



  If new enum value is defined sync_enum_values function call will be added to migration to account for it

  ```python
  class MyEnum(enum.Enum):
      one = 1
      two = 2
      three = 3
      four = 4 # New enum value
  ```

  ```python
  def upgrade():
      
      op.sync_enum_values(
          enum_schema='public',
          enum_name='myenum',
          new_values=['one', 'two', 'three', 'four'],
          affected_columns=[TableReference(table_schema='public', table_name='example_table', column_name='enum_field')],
          enum_values_to_rename=[],
      )
      


  def downgrade():
      
      op.sync_enum_values(
          enum_schema='public',
          enum_name='myenum',
          new_values=['one', 'two', 'three'],
          affected_columns=[TableReference(table_schema='public', table_name='example_table', column_name='enum_field')],
          enum_values_to_rename=[],
      )
      
  ```



  If enum value is removed it also will be detected

  ```python
  class MyEnum(enum.Enum):
      one = 1
      two = 2
      
  ```

  ```python
  def upgrade():
      
      op.sync_enum_values(
          enum_schema='public',
          enum_name='myenum',
          new_values=['one', 'two'],
          affected_columns=[TableReference(table_schema='public', table_name='example_table', column_name='enum_field')],
          enum_values_to_rename=[],
      )
      


  def downgrade():
      
      op.sync_enum_values(
          enum_schema='public',
          enum_name='myenum',
          new_values=['one', 'two', 'three'],
          affected_columns=[TableReference(table_schema='public', table_name='example_table', column_name='enum_field')],
          enum_values_to_rename=[],
      )
      
  ```


  In this case you must manually edit migration

  ```python
  class MyEnum(enum.Enum):
      one = 1
      two = 2
      three = 3 # renamed from `tree`
  ```

  This code will generate this migration:
  ```python
  def upgrade():
      
      op.sync_enum_values(
          enum_schema='public',
          enum_name='myenum',
          new_values=['one', 'two', 'three'],
          affected_columns=[TableReference(table_schema='public', table_name='example_table', column_name='enum_field')],
          enum_values_to_rename=[],
      )
      


  def downgrade():
      
      op.sync_enum_values(
          enum_schema='public',
          enum_name='myenum',
          new_values=['one', 'two', 'tree'],
          affected_columns=[TableReference(table_schema='public', table_name='example_table', column_name='enum_field')],
          enum_values_to_rename=[],
      )
      
  ```

  This migration will cause problems with existing rows that references MyEnum

  So adjust migration like that

  ```python
  def upgrade():
      op.sync_enum_values(
          enum_schema='public',
          enum_name='myenum',
          new_values=['one', 'two', 'three'],
          affected_columns=[TableReference(table_schema='public', table_name='example_table', column_name='enum_field')],
          enum_values_to_rename=[('tree', 'three')],
      )


  def downgrade():
      op.sync_enum_values(
          enum_schema='public',
          enum_name='myenum',
          new_values=['one', 'two', 'tree'],
          affected_columns=[TableReference(table_schema='public', table_name='example_table', column_name='enum_field')],
          enum_values_to_rename=[('three', 'tree')],
      )
  ```

  Do not forget to switch places old and new values for downgrade

  All defaults in postgres will be renamed automatically as well


pkgId: 77580db491505596205ea9bc26c498f99a35540be9bc5b0dd2fe35198af5de42
name: python-aleph-alpha-client
arch: src
version: 7.5.1
epoch: 0
release: 1
summary: python client to interact with Aleph Alpha api endpoints
url: https://github.com/Aleph-Alpha/aleph-alpha-client
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aleph-alpha-client-7.5.1-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <img src="https://i.imgur.com/FSM2NNV.png" width="50%" />
  </p>

  [![License](https://img.shields.io/crates/l/aleph-alpha-client)](https://github.com/Aleph-Alpha/aleph-alpha-client/blob/main/LICENSE)
  [![PyPI version](https://badge.fury.io/py/aleph-alpha-client.svg)](https://pypi.org/project/aleph-alpha-client/)
  [![Documentation Status](https://readthedocs.org/projects/aleph-alpha-client/badge/?version=latest)](https://aleph-alpha-client.readthedocs.io/en/latest/?badge=latest)

  Python client for the [Aleph Alpha](https://aleph-alpha.com) API.





  ```python
  import os
  from aleph_alpha_client import Client, CompletionRequest, Prompt

  client = Client(token=os.getenv("AA_TOKEN"))
  request = CompletionRequest(
      prompt=Prompt.from_text("Provide a short description of AI:"),
      maximum_tokens=64,
  )
  response = client.complete(request, model="luminous-extended")

  print(response.completions[0].completion)
  ```



  ```python
  import os
  from aleph_alpha_client import AsyncClient, CompletionRequest, Prompt


  async with AsyncClient(token=os.environ["AA_TOKEN"]) as client:
      request = CompletionRequest(
          prompt=Prompt.from_text("Provide a short description of AI:"),
          maximum_tokens=64,
      )
      response = client.complete_with_streaming(request, model="luminous-base")
      async for stream_item in response:
          print(stream_item)
  ```



  This table contains interactive code examples, further exercises can be found in the [examples repository](https://github.com/Aleph-Alpha/examples).
  | Template | Description | Internal Link | Colab Link |
  |----------|-------------|---------------| -----------|
  | 1 | Calling the API | [Template 1](https://github.com/Aleph-Alpha/examples/blob/main/boilerplate/01_using_client.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Aleph-Alpha/examples/blob/main/boilerplate/01_using_client.ipynb)|
  | 2 | Simple completion | [Template 2](https://github.com/Aleph-Alpha/examples/blob/main/boilerplate/02_prompting.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Aleph-Alpha/examples/blob/main/boilerplate/02_prompting.ipynb)|
  | 3 | Simple search | [Template 3](https://github.com/Aleph-Alpha/examples/blob/main/boilerplate/03_simple_search.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Aleph-Alpha/examples/blob/main/boilerplate/03_simple_search.ipynb)|
  | 4 | Symmetric and Asymmetric Search | [Template 4](https://github.com/Aleph-Alpha/examples/blob/main/boilerplate/04_semantic_search.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Aleph-Alpha/examples/blob/main/boilerplate/04_semantic_search.ipynb)|
  | 5 | Hidden Embeddings | [Template 5](https://github.com/Aleph-Alpha/examples/blob/main/boilerplate/05_hidden_embeddings.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Aleph-Alpha/examples/blob/main/boilerplate/05_hidden_embeddings.ipynb)|
  | 6 | Task-specific Endpoints | [Template 6](https://github.com/Aleph-Alpha/examples/blob/main/boilerplate/06_task_specific_endpoints.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Aleph-Alpha/examples/blob/main/boilerplate/06_task_specific_endpoints.ipynb)|



  The latest stable version is deployed to PyPi so you can install this package via pip.

  ```sh
  pip install aleph-alpha-client
  ```

  Get started using the client by first [creating an account](https://app.aleph-alpha.com/signup). Afterwards head over to [your profile](https://app.aleph-alpha.com/profile) to create an API token. Read more about how you can manage your API tokens [here](https://docs.aleph-alpha.com/docs/account).



  For local development, start by creating a Python virtual environment as follows:

  ```shell
  python3 -m venv venv
  . ./venv/bin/activate
  ```

  Next, install the test and dev dependencies:

  ```shell
  poetry install --extras "dev"
  ```


  Now you should be able to ...

  * run all the tests using `pytest` or, `pytest -k <test_name>` to run a specific test
  * typecheck the code and tests using `mypy aleph_alpha_client` resp. `mypy tests`
  * format the code using `black .`



  - [HTTP API Docs](https://docs.aleph-alpha.com/api/)
  - [Interactive Playground](https://app.aleph-alpha.com/playground/)


pkgId: 4a9ff7fc469bc9b9730a8df86228be6e79a237842eea7375340210b88f8db4a7
name: python-aleph-alpha-client
arch: src
version: 7.6.0
epoch: 0
release: 1
summary: python client to interact with Aleph Alpha api endpoints
url: https://github.com/Aleph-Alpha/aleph-alpha-client
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aleph-alpha-client-7.6.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <img src="https://i.imgur.com/FSM2NNV.png" width="50%" />
  </p>

  [![License](https://img.shields.io/crates/l/aleph-alpha-client)](https://github.com/Aleph-Alpha/aleph-alpha-client/blob/main/LICENSE)
  [![PyPI version](https://badge.fury.io/py/aleph-alpha-client.svg)](https://pypi.org/project/aleph-alpha-client/)
  [![Documentation Status](https://readthedocs.org/projects/aleph-alpha-client/badge/?version=latest)](https://aleph-alpha-client.readthedocs.io/en/latest/?badge=latest)

  Python client for the [Aleph Alpha](https://aleph-alpha.com) API.





  ```python
  import os
  from aleph_alpha_client import Client, CompletionRequest, Prompt

  client = Client(token=os.getenv("AA_TOKEN"))
  request = CompletionRequest(
      prompt=Prompt.from_text("Provide a short description of AI:"),
      maximum_tokens=64,
  )
  response = client.complete(request, model="luminous-extended")

  print(response.completions[0].completion)
  ```



  ```python
  import os
  from aleph_alpha_client import AsyncClient, CompletionRequest, Prompt


  async with AsyncClient(token=os.environ["AA_TOKEN"]) as client:
      request = CompletionRequest(
          prompt=Prompt.from_text("Provide a short description of AI:"),
          maximum_tokens=64,
      )
      response = client.complete_with_streaming(request, model="luminous-base")

      async for stream_item in response:
          print(stream_item)
  ```



  This table contains interactive code examples, further exercises can be found in the [examples repository](https://github.com/Aleph-Alpha/examples).
  | Template | Description | Internal Link | Colab Link |
  |----------|-------------|---------------| -----------|
  | 1 | Calling the API | [Template 1](https://github.com/Aleph-Alpha/examples/blob/main/boilerplate/01_using_client.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Aleph-Alpha/examples/blob/main/boilerplate/01_using_client.ipynb)|
  | 2 | Simple completion | [Template 2](https://github.com/Aleph-Alpha/examples/blob/main/boilerplate/02_prompting.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Aleph-Alpha/examples/blob/main/boilerplate/02_prompting.ipynb)|
  | 3 | Simple search | [Template 3](https://github.com/Aleph-Alpha/examples/blob/main/boilerplate/03_simple_search.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Aleph-Alpha/examples/blob/main/boilerplate/03_simple_search.ipynb)|
  | 4 | Symmetric and Asymmetric Search | [Template 4](https://github.com/Aleph-Alpha/examples/blob/main/boilerplate/04_semantic_search.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Aleph-Alpha/examples/blob/main/boilerplate/04_semantic_search.ipynb)|
  | 5 | Hidden Embeddings | [Template 5](https://github.com/Aleph-Alpha/examples/blob/main/boilerplate/05_hidden_embeddings.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Aleph-Alpha/examples/blob/main/boilerplate/05_hidden_embeddings.ipynb)|
  | 6 | Task-specific Endpoints | [Template 6](https://github.com/Aleph-Alpha/examples/blob/main/boilerplate/06_task_specific_endpoints.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Aleph-Alpha/examples/blob/main/boilerplate/06_task_specific_endpoints.ipynb)|



  The latest stable version is deployed to PyPi so you can install this package via pip.

  ```sh
  pip install aleph-alpha-client
  ```

  Get started using the client by first [creating an account](https://app.aleph-alpha.com/signup). Afterwards head over to [your profile](https://app.aleph-alpha.com/profile) to create an API token. Read more about how you can manage your API tokens [here](https://docs.aleph-alpha.com/docs/account).



  For local development, start by creating a Python virtual environment as follows:

  ```shell
  python3 -m venv venv
  . ./venv/bin/activate
  ```

  Next, install the test and dev dependencies:

  ```shell
  poetry install --extras "dev"
  ```


  Now you should be able to ...

  * run all the tests using `pytest` or, `pytest -k <test_name>` to run a specific test
  * typecheck the code and tests using `mypy aleph_alpha_client` resp. `mypy tests`
  * format the code using `black .`



  - [HTTP API Docs](https://docs.aleph-alpha.com/api/)
  - [Interactive Playground](https://app.aleph-alpha.com/playground/)


pkgId: ac2b7bb385f1239b8e5d4bd4d14767eec9caf61deb923c211c3ef9a269da9eb5
name: python-aleph-alpha-client
arch: src
version: 8.0.0
epoch: 0
release: 1
summary: python client to interact with Aleph Alpha api endpoints
url: https://github.com/Aleph-Alpha/aleph-alpha-client
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aleph-alpha-client-8.0.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <img src="https://i.imgur.com/FSM2NNV.png" width="50%" />
  </p>

  [![License](https://img.shields.io/crates/l/aleph-alpha-client)](https://github.com/Aleph-Alpha/aleph-alpha-client/blob/main/LICENSE)
  [![PyPI version](https://badge.fury.io/py/aleph-alpha-client.svg)](https://pypi.org/project/aleph-alpha-client/)
  [![Documentation Status](https://readthedocs.org/projects/aleph-alpha-client/badge/?version=latest)](https://aleph-alpha-client.readthedocs.io/en/latest/?badge=latest)

  Python client for the [Aleph Alpha](https://aleph-alpha.com) API.





  ```python
  import os
  from aleph_alpha_client import Client, CompletionRequest, Prompt

  client = Client(
      token=os.environ["TEST_TOKEN"],
      host=os.environ["TEST_API_URL"],
  )
  request = CompletionRequest(
      prompt=Prompt.from_text("Provide a short description of AI:"),
      maximum_tokens=64,
  )
  response = client.complete(request, model="pharia-1-llm-7b-control")

  print(response.completions[0].completion)
  ```



  ```python
  import os
  from aleph_alpha_client import AsyncClient, CompletionRequest, Prompt


  async with AsyncClient(
      token=os.environ["TEST_TOKEN"],
      host=os.environ["TEST_API_URL"],
  ) as client:
      request = CompletionRequest(
          prompt=Prompt.from_text("Provide a short description of AI:"),
          maximum_tokens=64,
      )
      response = client.complete_with_streaming(request, model="pharia-1-llm-7b-control")

      async for stream_item in response:
          print(stream_item)
  ```



  This table contains interactive code examples, further exercises can be found in the [examples repository](https://github.com/Aleph-Alpha/examples).
  | Template | Description | Internal Link | Colab Link |
  |----------|-------------|---------------| -----------|
  | 1 | Calling the API | [Template 1](https://github.com/Aleph-Alpha/examples/blob/main/boilerplate/01_using_client.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Aleph-Alpha/examples/blob/main/boilerplate/01_using_client.ipynb)|
  | 2 | Simple completion | [Template 2](https://github.com/Aleph-Alpha/examples/blob/main/boilerplate/02_prompting.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Aleph-Alpha/examples/blob/main/boilerplate/02_prompting.ipynb)|
  | 3 | Simple search | [Template 3](https://github.com/Aleph-Alpha/examples/blob/main/boilerplate/03_simple_search.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Aleph-Alpha/examples/blob/main/boilerplate/03_simple_search.ipynb)|
  | 4 | Symmetric and Asymmetric Search | [Template 4](https://github.com/Aleph-Alpha/examples/blob/main/boilerplate/04_semantic_search.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Aleph-Alpha/examples/blob/main/boilerplate/04_semantic_search.ipynb)|
  | 5 | Hidden Embeddings | [Template 5](https://github.com/Aleph-Alpha/examples/blob/main/boilerplate/05_hidden_embeddings.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Aleph-Alpha/examples/blob/main/boilerplate/05_hidden_embeddings.ipynb)|
  | 6 | Task-specific Endpoints | [Template 6](https://github.com/Aleph-Alpha/examples/blob/main/boilerplate/06_task_specific_endpoints.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Aleph-Alpha/examples/blob/main/boilerplate/06_task_specific_endpoints.ipynb)|



  The latest stable version is deployed to PyPi so you can install this package via pip.

  ```sh
  pip install aleph-alpha-client
  ```

  Get started using the client by first [creating an account](https://app.aleph-alpha.com/signup). Afterwards head over to [your profile](https://app.aleph-alpha.com/profile) to create an API token. Read more about how you can manage your API tokens [here](https://docs.aleph-alpha.com/docs/account).



  For local development, start by creating a Python virtual environment as follows:

  ```shell
  python3 -m venv venv
  . ./venv/bin/activate
  ```

  Next, install the test and dev dependencies:

  ```shell
  poetry install --extras "dev"
  ```


  Now you should be able to ...

  * run all the tests using `pytest` or, `pytest -k <test_name>` to run a specific test
  * typecheck the code and tests using `mypy aleph_alpha_client` resp. `mypy tests`
  * format the code using `black .`



  - [HTTP API Docs](https://docs.aleph-alpha.com/api/)
  - [Interactive Playground](https://app.aleph-alpha.com/playground/)


pkgId: fc51b83b907558627b53d7567a765871e705aa4be405b950b70b15545d22c251
name: python-aleph-client
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Python Client library for the Aleph.im network
url: https://pypi.org/project/aleph-client/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aleph-client-1.2.0-1.src.rpm
checksum_type: sha256
description:
  Python Client for the [aleph.im network](https://www.aleph.im), next generation network of
  decentralized big data applications. Development follows the [Aleph
  Whitepaper](https://github.com/aleph-im/aleph-whitepaper).



  Documentation can be found on https://docs.aleph.im/tools/aleph-client/





  Some cryptographic functionalities use curve secp256k1 and require
  installing [libsecp256k1](https://github.com/bitcoin-core/secp256k1).

  > apt-get install -y python3-pip libsecp256k1-dev



  > brew tap cuber/homebrew-libsecp256k1
  > brew install libsecp256k1



  The software is not tested on Windows, but should work using
  the Windows Subsystem for Linux (WSL).





  Using pip and [PyPI](https://pypi.org/project/aleph-client/):

  > pip install aleph-client



  Use the Aleph client and it\'s CLI from within Docker or Podman with:

  > docker run --rm -ti -v $(pwd)/<data:/data> ghcr.io/aleph-im/aleph-client/aleph-client:master --help

  Warning: This will use an ephemeral key pair that will be discarded when
  stopping the container



  We recommend using [hatch](https://hatch.pypa.io/) for development.

  Hatch is a modern, extensible Python project manager.
  It creates a virtual environment for each project and manages dependencies.

  > pip install hatch



  > hatch test

  or

  > hatch run testing:cov



  > hatch run linting:format



  > hatch run linting:typing



  > hatch build
  > hatch upload

  If you want NULS2 support you will need to install nuls2-python
  (currently only available on github):

  > pip install aleph-sdk-python[nuls2]

  To install from source and still be able to modify the source code:

  > pip install -e .

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


pkgId: b90b3641daa3ae4252d14a396a69dbef27ceb84b828525c200a66d83933c1085
name: python-aleph-client
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Python Client library for the Aleph.im network
url: https://pypi.org/project/aleph-client/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aleph-client-1.3.0-1.src.rpm
checksum_type: sha256
description:
  Python Client for the [aleph.im network](https://www.aleph.im), next generation network of
  decentralized big data applications. Development follows the [Aleph
  Whitepaper](https://github.com/aleph-im/aleph-whitepaper).



  Documentation can be found on https://docs.aleph.im/tools/aleph-client/





  Some cryptographic functionalities use curve secp256k1 and require
  installing [libsecp256k1](https://github.com/bitcoin-core/secp256k1).

  > apt-get install -y python3-pip libsecp256k1-dev



  > brew tap cuber/homebrew-libsecp256k1
  > brew install libsecp256k1



  The software is not tested on Windows, but should work using
  the Windows Subsystem for Linux (WSL).





  Using pip and [PyPI](https://pypi.org/project/aleph-client/):

  > pip install aleph-client



  Use the Aleph client and it\'s CLI from within Docker or Podman with:

  > docker run --rm -ti -v $(pwd)/<data:/data> ghcr.io/aleph-im/aleph-client/aleph-client:master --help

  Warning: This will use an ephemeral key pair that will be discarded when
  stopping the container



  We recommend using [hatch](https://hatch.pypa.io/) for development.

  Hatch is a modern, extensible Python project manager.
  It creates a virtual environment for each project and manages dependencies.

  > pip install hatch



  > hatch test

  or

  > hatch run testing:cov



  > hatch run linting:format



  > hatch run linting:typing



  > hatch build
  > hatch upload

  If you want NULS2 support you will need to install nuls2-python
  (currently only available on github):

  > pip install aleph-sdk-python[nuls2]

  To install from source and still be able to modify the source code:

  > pip install -e .



  The user documentation for Aleph is maintained in the `aleph-docs` repository. When releasing a new version, it's
  important to update the documentation as part of the release process.



  Documentation is generated using the `typer` command.

  If you have the `aleph-docs` repository cloned as a sibling folder to your current directory, you can use the following
  command to generate updated documentation:

  ```shell
  ./scripts/gendoc.py   src/aleph_client/__main__.py docs --name aleph --title 'Aleph CLI Documentation' --output ../aleph-docs/docs/tools/aleph-client/usage.md
  ```

  After generating the documentation, you may need to update the path for the private key, as this depends on the user
  configuration. This can be fixed manually using the `sed` command. For example:

  ```shell
  sed -i 's#/home/olivier/.aleph-im/private-keys/sol2.key#~/.aleph-im/private-keys/ethereum.key#' ../aleph-docs/docs/tools/aleph-client/usage.md
  ```

  This command replaces any hardcoded private key paths with the correct configuration path (
  `~/.aleph-im/private-keys/ethereum.key`).

  Once the documentation is updated, open a Pull Request (PR) on the `aleph-docs` repository with your changes.

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


pkgId: bc6f246dc557c4580d5075d04e01e12f78358a464c4c900e14e04ddec18fdf2e
name: python-aleph-message
arch: src
version: 0.4.9
epoch: 0
release: 1
summary: Aleph.im message specification
url: https://github.com/aleph-im/aleph-message
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aleph-message-0.4.9-1.src.rpm
checksum_type: sha256
description:
  This library aims to provide an easy way to create, update and manipulate
  messages from Aleph.im.

  It mainly consists in [pydantic](https://pydantic-docs.helpmanual.io/)
  models that provide field type validation and IDE autocompletion for messages.

  This library provides:
  * schema validation when parsing messages.
  * cryptographic hash validation that the `item_hash` matches the content of the message.
  * type validation using type checkers such as [mypy](https://www.mypy-lang.org/) in development environments.
  * autocompletion support in development editors.

  The `item_hash` is commonly used as unique message identifier on Aleph.im.

  Cryptographic signatures are out of scope of this library and part of the `aleph-sdk-python`
  project, due to their extended scope and dependency on cryptographic libraries.

  This library is used in both client and node software of Aleph.im.



  ```shell
  pip install aleph-message
  ```

  ```python
  import requests
  from aleph_message import parse_message
  from pydantic import ValidationError

  ALEPH_API_SERVER = "https://official.aleph.cloud"
  MESSAGE_ITEM_HASH = "9b21eb870d01bf64d23e1d4475e342c8f958fcd544adc37db07d8281da070b00"

  message_dict = requests.get(ALEPH_API_SERVER + "/api/v0/messages.json?hashes=" + MESSAGE_ITEM_HASH).json()

  try:
      message = parse_message(message_dict["messages"][0])
      print(message.sender)
  except ValidationError as e:
      print(e.json(indent=4))
  ```


pkgId: 3bde1bd3c0f51b54e75b75c3e2231fac34a4a3a2001ea777e323dc3118542cb1
name: python-aleph-sdk-python
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Lightweight Python Client library for the Aleph.im network
url: https://github.com/aleph-im/aleph-sdk-python
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aleph-sdk-python-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Python SDK for the Aleph.im network, next generation network of decentralized big data applications.

  Development follows the [Aleph Whitepaper](https://github.com/aleph-im/aleph-whitepaper).


  The latest documentation, albeit incomplete, is available at [https://docs.aleph.im/libraries/python-sdk/](https://docs.aleph.im/libraries/python-sdk/).

  For the full documentation, please refer to the docstrings in the source code.



  Some cryptographic functionalities use curve secp256k1 and require installing [libsecp256k1](https://github.com/bitcoin-core/secp256k1).

  ```shell
  $ apt-get install -y python3-pip libsecp256k1-dev
  ```
  Using some chains may also require installing `libgmp3-dev`.


  This project does not support Python 3.12 on macOS. Please use Python 3.11 instead.
  ```shell
  $ brew tap cuber/homebrew-libsecp256k1
  $ brew install libsecp256k1
  ```


  Using pip and [PyPI](https://pypi.org/project/aleph-sdk-python/):

  ```shell
  $ pip install aleph-sdk-python
  ```


  Some functionalities require additional dependencies. They can be installed like this:

  ```shell
  $ pip install aleph-sdk-python[solana, dns]
  ```

  The following extra dependencies are available:
  - `solana` for Solana accounts and signatures
  - `cosmos` for Substrate/Cosmos accounts and signatures
  - `nuls2` for NULS2 accounts and signatures
  - `polkadot` for Polkadot accounts and signatures
  - `ledger` for Ledger hardware wallet support, see [Usage with LedgerHQ hardware](#usage-with-ledgerhq-hardware)
  - `mqtt` for MQTT-related functionalities, see [examples/mqtt.py](examples/mqtt.py)
  - `docs` for building the documentation, see [Documentation](#documentation)
  - `dns` for DNS-related functionalities
  - `all` installs all extra dependencies



  Setup a virtual environment using [hatch](https://hatch.pypa.io/):
  ```shell
  $ hatch shell
  ```

  Then install the SDK from source with all extra dependencies:

  ```shell
  $ pip install -e .[all]
  ```


  You can use the test env defined for hatch to run the tests:

  ```shell
  $ hatch run testing:run
  ```

  See `hatch env show` for more information about all the environments and their scripts.


  The documentation is built using [Sphinx](https://www.sphinx-doc.org/).

  To build the documentation, install the SDK with the `docs` extra dependencies:

  ```shell
  $ pip install -e .[docs]
  ```

  Then build the documentation:

  ```shell
  $ cd docs
  $ make html
  ```



  The SDK supports signatures using [app-ethereum](https://github.com/LedgerHQ/app-ethereum),
  the Ethereum app for the Ledger hardware wallets.

  This has been tested successfully on Linux (amd64).
  Let us know if it works for you on other operating systems.

  Using a Ledger device on Linux requires root access or the setup of udev rules.

  Unlocking the device is required before using the relevant SDK functions.



  Install [ledger-wallets-udev](https://packages.debian.org/bookworm/ledger-wallets-udev).

  `sudo apt-get install ledger-wallets-udev`



  Configure `hardware.ledger.enable = true`.



  See https://github.com/LedgerHQ/udev-rules

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


pkgId: 487b86fa18fc9b8f1cf782fc488fdc818a0fe74a84a583d7303d458bd0b6e751
name: python-alephclient
arch: src
version: 2.6.0
epoch: 0
release: 1
summary: Command-line client for Aleph API
url: http://github.com/alephdata/alephclient
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alephclient-2.6.0-1.src.rpm
checksum_type: sha256
description:
  Command-line client for Aleph. It can be used to bulk import document sets via
  the API, without direct access to the server. It requires an active API client
  to perform uploads.



  Install using `pip`.

  ```bash
  pip install alephclient
  ```



  Refer to the `aleph` handbook for an introduction on how to use `alephclient`,
  e.g. to crawl a local file directory, or to stream entities:

  * https://docs.alephdata.org/developers/alephclient


pkgId: 59ab648c4759c0ba843c1f6260f147e98c23d5fe0ca0fccf73d17cac09f79734
name: python-alert-exporter
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: Extract alerts configured in different sources (eg: Prometheus Rules, CloudWatch Alarms, Pingdom)
url: https://github.com/BapRx/alert-exporter
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alert-exporter-0.5.1-1.src.rpm
checksum_type: sha256
description:
  <p>
  <a href="https://pypi.org/project/alert-exporter/"><img alt="PyPI" src="https://img.shields.io/pypi/v/alert-exporter"></a>
  <a href="https://pypi.org/project/alert-exporter/"><img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/alert-exporter"></a>
  <a href="https://github.com/BapRx/alert-exporter/"><img alt="GitHub repo size" src="https://img.shields.io/github/repo-size/BapRx/alert-exporter"></a>
  <a href="https://pypi.org/project/alert-exporter/"><img alt="PyPI - Status" src="https://img.shields.io/pypi/status/alert-exporter"></a>
  </p>



  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install alert-exporter.

  ```bash
  pip install alert-exporter
  ```



  ```bash
  ❯ alert-exporter --help
  Extract alerts configured in different sources (eg: Prometheus Rules, CloudWatch Alarms, Pingdom)

  optional arguments:
    -h, --help            show this help message and exit
    -v, --version         show program's version number and exit
    --log-level {DEBUG,INFO,WARNING,ERROR}
    -o OUTPUT_FILE, --output-file OUTPUT_FILE
    --jinja-template [JINJA_TEMPLATE]
    -f {markdown,yaml,html}, --format {markdown,yaml,html}
    --prometheus
    --prometheus-filters PROMETHEUS_FILTERS
    --context [CONTEXT]
    --cloudwatch
    --aws-profile AWS_PROFILE
    --aws-region AWS_REGION
                          Specific region to target. Default: Iterate over all regions available.
    --pingdom
    --pingdom-api-key PINGDOM_API_KEY
    --pingdom-tags PINGDOM_TAGS
                          Comma separated list of tags. Eg: tag1,tag2
  ```





  The current context is used unless you provide the `--context` flag.

  ```bash
  alert-exporter -o minikube.html --prometheus --context minikube
  ```

  You can filter prometheus rule to match specific labels using the '--prometheus-filters' flag.

  ```bash
  alert-exporter -o minikube.html --prometheus --context minikube --prometheus-filters '{"severity": "critical"}'
  ```



  All available regions are parsed unless you provide the `--aws-region` flag.

  You need to be authenticated before using this tool.

  ```bash
  alert-exporter -o aws.html --cloudwatch --aws-region eu-west-1 --aws-profile profile
  ```



  An API key with read only permission is required to fetch the checks. The key can be provided in the `PINGDOM_API_KEY` environment variable.

  ```bash
  alert-exporter -o pingdom.html --pingdom --pingdom-tags example-tag
  ```



  ```bash
  alert-exporter -o combined.html --prometheus --cloudwatch --aws-region eu-west-1
  ```



  Predefined formats are provided with this tool:

  - HTML
  - Markdown
  - YAML

  You can use a custom format by providing a Jinja2 file with the `--jinja-template` flag.



  <a href="https://raw.githubusercontent.com/BapRx/alert-exporter/master/docs/alerts-html.png"><img alt="HTML output" src="https://raw.githubusercontent.com/BapRx/alert-exporter/master/docs/alerts-html.png"></a>



  Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

rpm_license:
  GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007  Extract a list of alerts configured in different sources (eg: Prometheus Rules, CloudWatch Alarms, etc.) Copyright (C) 2022  Baptiste ROUX  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/>.  Also add information on how to contact you by electronic and paper mail.  You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see <http://www.gnu.org/licenses/>.  The GNU General Public License does not permit incorporating your program into proprietary programs.  If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library.  If this is what you want to do, use the GNU Lesser General Public License instead of this License.  But first, please read <http://www.gnu.org/philosophy/why-not-lgpl.html>.


pkgId: 4f68fdb982c3a10b583cf7c05b8dee99aa2a65bae69612b1b729e059d18683d3
name: python-alerta
arch: src
version: 8.5.3
epoch: 0
release: 1
summary: Alerta unified command-line tool and SDK
url: https://github.com/guardian/python-alerta
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alerta-8.5.3-1.src.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/alerta/python-alerta-client/workflows/CI%20Tests/badge.svg)](https://github.com/alerta/python-alerta-client/actions)
   [![Slack chat](https://img.shields.io/badge/chat-on%20slack-blue?logo=slack)](https://slack.alerta.dev) [![Coverage Status](https://coveralls.io/repos/github/alerta/python-alerta-client/badge.svg?branch=master)](https://coveralls.io/github/alerta/python-alerta-client?branch=master)
  Unified command-line tool, terminal GUI and python SDK for the Alerta monitoring system.
  ![screen shot](/docs/images/alerta-top-80x25.png?raw=true&v=1)
  Related projects can be found on the Alerta Org Repo at <https://github.com/alerta/>.


pkgId: e4ff07313feaa3c23dc9c6834b3e7811c9e5344001ecd950cc00b0cad7f8a1ec
name: python-alerta-blackout-regex
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: Alerta Blackout enhancement plugin
url: https://github.com/mirceaulinic/alerta-blackout-regex
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alerta-blackout-regex-3.1.0-1.src.rpm
checksum_type: sha256
description:
  `Alerta <https://alerta.io/>`_ plugin to enhance the blackout management, by
  matching the alerts against blackouts with PCRE (Perl Compatible Regular
  Expression) on attributes.
  A blackout is considered matched when all its attributes are matched.
  Once an alert is identified as matching a blackout, a special label is applied,
  with the format: ``regex_blackout=<blackout id>``, where *blackout id* is the
  ID of the matched blackout, e.g.,
  ``regex_blackout=d8ba1d3b-dbfd-4677-ab00-e7f8469d7ad3``. This way, when the
  alert is fired again, there's no need to verify the matching again, but simply
  verify whether the blackout referenced is still active.
      Beginning with version 2.0.0, the behaviour has changed, and instead of
      evaluating the alert into the `post_receive` hook, this plugin now
      evaluates the alerts through the `pre_receive` hook. The reasoning was that
      `post_receive` would set the `blackout` status *after* the alert has been
      sent to other plugins, which has resulted in confusing behaviour.
      That said, the plugin has been changed to process the alert in
      ``pre_receive`` and therefore before the alert has been correlated. As the
      Blackouts are retrieved from the Alerta API as unfortunately there's no
      other way to gather the Blackouts from a plugin via other internal
      mechanisms, processing each and every alert throguh `pre_receive` would put
      a lot more workload on your Alerta API. To reduce this, the
      `blackout_regex` plugin now caches the Blackouts locally, into a file. To
      fine tune this behaviour for your own setup you are able to set a few
      environment variables. See more details below, under the _Configuration_
      section.
      Starting with version 3.0.0 onwards, the plugin will gather the list of
      Blackouts straight from the database (instead of using the API, as
      previously). This should normally improve reliability, but as there's no
      caching involved, every alert notification coming in (before being
      evaluated and correlated) will cause a DB query.


pkgId: f5d42a54a00c17c4fd6b7c839fda0d65f89f06f86380717fd7c0acf12c6bbac9
name: python-alerta-server
arch: src
version: 9.0.4
epoch: 0
release: 1
summary: Alerta server WSGI application
url: https://github.com/guardian/alerta
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alerta-server-9.0.4-1.src.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/alerta/alerta/workflows/CI%20Tests/badge.svg)](https://github.com/alerta/alerta/actions)
  [![Slack chat](https://img.shields.io/badge/chat-on%20slack-blue?logo=slack)](https://slack.alerta.dev)
  [![Coverage Status](https://coveralls.io/repos/github/alerta/alerta/badge.svg?branch=master)](https://coveralls.io/github/alerta/alerta?branch=master)
  [![Docker Pulls](https://img.shields.io/docker/pulls/alerta/alerta-web.svg)](https://hub.docker.com/r/alerta/alerta-web)
  The Alerta monitoring tool was developed with the following aims in mind:
  *   distributed and de-coupled so that it is **SCALABLE**
  *   minimal **CONFIGURATION** that easily accepts alerts from any source
  *   quick at-a-glance **VISUALISATION** with drill-down to detail


pkgId: da2d527fc68da0c6c6ad69078b9367d1aa7e5ef24cefdb4445cd918dd264b92d
name: python-alertlogic-sdk-definitions
arch: src
version: 0.1.154
epoch: 0
release: 1
summary: The Alert Logic API definitions.
url: https://github.com/alertlogic/alertlogic-sdk-definitions
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alertlogic-sdk-definitions-0.1.154-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/alertlogic/alertlogic-sdk-definitions.svg?branch=master)](https://travis-ci.com/alertlogic/alertlogic-sdk-definitions)
  [![PyPI version](https://badge.fury.io/py/alertlogic-sdk-definitions.svg)](https://badge.fury.io/py/alertlogic-sdk-definitions)

  Repository contains static definitions of Alert Logic APIs, used for documentation generation,
  [SDK](https://github.com/alertlogic/alertlogic-sdk-python) and [CLI](https://github.com/alertlogic/alcli).




  `pip install alertlogic-sdk-definitions`

  For the one who doesn't require python code, GitHub releases are produced
  containing an archive with OpenAPI definitions only, see
  [here](https://github.com/alertlogic/alertlogic-sdk-definitions/releases)


  `python -m unittest`



  List available service definitions:
  ```
  >>> import alsdkdefs
  >>> alsdkdefs.list_services()
  OrderedDict([('aecontent', ServiceDefinition(aecontent)), ('aefr', ServiceDefinition(aefr)), ('aepublish', ServiceDefinition(aepublish)), ('aerta', ServiceDefinition(aerta)), ('aetag', ServiceDefinition(aetag)), ('aetuner', ServiceDefinition(aetuner)), ('aims', ServiceDefinition(aims)), ('assets_query', ServiceDefinition(assets_query)), ('assets_write', ServiceDefinition(assets_write)), ('connectors', ServiceDefinition(connectors)), ('credentials', ServiceDefinition(credentials)), ('deployments', ServiceDefinition(deployments)), ('herald', ServiceDefinition(herald)), ('ingest', ServiceDefinition(ingest)), ('iris', ServiceDefinition(iris)), ('kalm', ServiceDefinition(kalm)), ('notify', ServiceDefinition(notify)), ('otis', ServiceDefinition(otis)), ('policies', ServiceDefinition(policies)), ('remediations', ServiceDefinition(remediations)), ('responder', ServiceDefinition(responder)), ('search', ServiceDefinition(search)), ('subscriptions', ServiceDefinition(subscriptions)), ('themis', ServiceDefinition(themis))])
  ```

  Get path to a service definitions paths:
  ```
  >>> import alsdkdefs
  >>> alsdkdefs.get_service_defs("aerta")
  ['/usr/local/lib/python3.8/site-packages/alsdkdefs/apis/aerta/aerta.v1.yaml']
  ```

  Get normalised service spec of a service(all refs resolved,
                                   path parameters moved to the methods,
                                   allOfs are merged if possible):
  ```
  >>> import alsdkdefs
  >>> alsdkdefs.load_service_spec("aerta")
  ```

  Validate service spec:
  ```
  >>> import alsdkdefs
  >>> service_spec = alsdkdefs.load_service_spec("aerta")
  >>> alsdkdefs.validate(service_spec)
  ```



  While YAML definition is developed apart from the current package and current repo,
  it is required to validate it prior to push, please add this to your `Makefile`
  in order to achieve quick validation:

  `curl -s https://raw.githubusercontent.com/alertlogic/alertlogic-sdk-definitions/master/scripts/validate_my_definition.sh | bash -s <path/to/definitions/directory>`

  If no directory is specified, by default `doc/openapi/` directory will be used, if such behaviour is desired, use following line instead:

  `curl -s https://raw.githubusercontent.com/alertlogic/alertlogic-sdk-definitions/master/scripts/validate_my_definition.sh | bash `

  It is recommended to invoke it via curl, since validation of the definitions might be extended with time.
  Script requires `python3` to be available in the system.

  Validation checks:
  * YAML of a definition is valid
  * Definition passes OpenAPI 3 schema validation



  Please submit a PR. Please note that API definitions are updated automatically and any changes to it will be overwritten, see:
  [automatic update process](doc/automatic_releases.md)


pkgId: 28b90deb3c514dd2f9467969644f3b2b3caf5bd68b7b2b16e0c72789a96fb11e
name: python-alertlogic-sdk-python
arch: src
version: 1.0.74
epoch: 0
release: 1
summary: Alert Logic Software Development Kit for Python.
url: https://github.com/alertlogic/alertlogic-sdk-python
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alertlogic-sdk-python-1.0.74-1.src.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/alertlogic-sdk-python.svg)](https://pypi.python.org/pypi/alertlogic-sdk-python)
  [![python](https://img.shields.io/pypi/pyversions/alertlogic-sdk-python.svg)](https://pypi.python.org/pypi/alertlogic-sdk-python)
  [![Build Status](https://travis-ci.com/alertlogic/alertlogic-sdk-python.svg?branch=master)](https://travis-ci.com/alertlogic/alertlogic-sdk-python)
  [![Docs](https://readthedocs.org/projects/pip/badge/?version=latest&style=plastic)](https://readthedocs.org/projects/alertlogic-sdk-python)

  Alert Logic Software Development Kit for Python allows developers to integrate with Alert Logic MDR Services.



  1. Install the library:

  	```pip install alertlogic-sdk-python```

  2. Set up configuration file (in e.g. ```~/.alertlogic/config```

  	```
  	[default]
  	access_key_id = YOUR_KEY
  	secret_key = YOUR_SECRET
  	```

  	To create and manage access keys, use the [Alert Logic Console](https://console.account.alertlogic.com/#/aims/users).  For information on creating an access key, see
  	[https://docs.alertlogic.com/prepare/access-key-management.htm](https://docs.alertlogic.com/prepare/access-key-management.htm)

  	Optionally you can specify if you are working with ***integration*** deployment of Alert Logic MDR Services or ***production*** by specifying:

  	```
  	global_endpoint=integration
  	```

  	```
  	global_endpoint=production
  	```

  	NOTE: If *global_endpoint* isn't present, SDK defaults to production.

  3. Test installation
  Launch python interpreter and then type:

  	```
  	import almdrlib
  	aims = almdrlib.client("aims")
  	res = aims.get_account_details()
  	print(f"{res.json()}")
  	```








  1. *Python v3.7* or newer
  2. *virtualenv* or *virtualenvwrapper* (We recommend ***virtualenvwrapper***  <https://virtualenvwrapper.readthedocs.io/en/latest/> )
  3. To produce RESTful APIs documentation install *redoc-cli* and *npx*:

      ```
      npm install --save redoc-cli
      npm install --save npx
      ```



  Setup your development environment and install required dependencies:

  ```
  export WORKON_HOME=~/environments
  mkdir -p $WORKON_HOME
  source /usr/local/bin/virtualenvwrapper.sh
  mkvirtualenv alsdk
  ```

  ```
  git clone https://github.com/alertlogic/alertlogic-sdk-python
  cd alertlogic-sdk-python
  pip install -r requirements_dev.txt
  pip install -e .
  ```



  - Setup a local profile:

  ```
  [aesolo]
  access_key_id=skip
  secret_key=skip
  global_endpoint=map
  endpoint_map_file=aesolo.json
  ```

  - Write an endpoint map (here, `~/.alertlogic/aesolo.json`; `endpoint_map_file` can also be an absolute path):

  ```
  {
    "aecontent" : "http://127.0.0.1:8810",
    "aefr" : "http://127.0.0.1:8808",
    "aepublish" : "http://127.0.0.1:8811",
    "aerta" : "http://127.0.0.1:8809",
    "aetag" : "http://127.0.0.1:8812",
    "aetuner": "http://127.0.0.1:3000",
    "ingest" : "http://127.0.0.1:9000"
  }
  ```

  Alternatively `global_endpoint` configuration option or `ALERTLOGIC_ENDPOINT` value might be set to the url value:
  ```
  [aesolo]
  access_key_id=skip
  secret_key=skip
  global_endpoint=http://api.aesolo.com
  ...
  global_endpoint=http://api.aesolo.com:3001
  ```

  ```
  export ALERTLOGIC_ENDPOINT="http://api.aesolo.com"
  ...
  export ALERTLOGIC_ENDPOINT="http://api.aesolo.com:3001"
  ```






  * Wed, 8 Mar 2023 08:54:55 -0600 - Merge pull request #123 from EvanBrown96/fix-service-name-bug-environment-creation
  * Tue, 7 Mar 2023 11:05:42 -0600 - Merge pull request #122 from alertlogic/update_workflow
  * Mon, 6 Mar 2023 13:16:59 -0500 - fix bug where the service name was not being used correctly when querying dynamodb/ssm for credentials
  * Fri, 3 Mar 2023 11:20:19 -0600 - Update workflow to stop using depricated node versions



  * Thu, 2 Mar 2023 09:09:13 -0600 - Merge pull request #121 from EvanBrown96/add-ssm-keys-check-2
  * Tue, 28 Feb 2023 13:58:20 -0500 - use raise from
  * Tue, 28 Feb 2023 13:52:05 -0500 - documentation clarity
  * Tue, 28 Feb 2023 13:50:37 -0500 - re-add both-source functionality
  * Tue, 28 Feb 2023 10:34:25 -0500 - fix a couple bugs and update tests
  * Tue, 28 Feb 2023 10:09:12 -0500 - switch to just one application in AlEnv creation
  * Tue, 28 Feb 2023 09:55:27 -0500 - update to fix bugs/better implementation



  * Thu, 23 Feb 2023 16:11:36 -0600 - Merge pull request #114 from alertlogic/fix_deprication_warning
  * Thu, 10 Nov 2022 10:26:22 -0600 - Update best practices when calling pip in the Makefile
  * Tue, 8 Nov 2022 13:10:36 -0600 - Remove unsupported python 3.6 from tox
  * Tue, 8 Nov 2022 10:48:55 -0600 - Move Session param to allowed_methods as previous version was depricated
  * Tue, 8 Nov 2022 10:48:10 -0600 - use _ version of description_file
  * Tue, 8 Nov 2022 10:47:33 -0600 - Stop invoking setup.py directly
  * Thu, 23 Feb 2023 15:45:06 -0600 - Merge pull request #120 from EvanBrown96/add-ssm-keys-check
  * Wed, 22 Feb 2023 14:38:31 -0500 - add tests for new ssm functionality
  * Wed, 22 Feb 2023 11:52:39 -0500 - add some documentation about SSM usage
  * Wed, 22 Feb 2023 11:41:37 -0500 - when creating an AL MDR config, check SSM for AIMS access key and secret
  * Wed, 22 Feb 2023 09:07:38 -0600 - Merge pull request #117 from alertlogic/dependabot/pip/wheel-0.38.1
  * Tue, 21 Feb 2023 15:09:47 -0600 - Merge pull request #119 from msayler/timeouts
  * Tue, 21 Feb 2023 13:35:07 -0600 - Add request timeout, default 300s
  * Mon, 26 Dec 2022 20:53:58 +0000 - Bump wheel from 0.33.1 to 0.38.1



  * Wed, 9 Nov 2022 09:17:41 -0600 - Merge pull request #115 from alertlogic/update_worflow
  * Tue, 8 Nov 2022 13:16:09 -0600 - Update github workflow to latest versions of python and deps
  * Thu, 20 Oct 2022 13:50:02 -0500 - Merge pull request #113 from msayler/cache_endpoints_lookup
  * Mon, 3 Oct 2022 14:25:24 +0200 - Merge pull request #109 from pavel-puchkin/patch-1
  * Mon, 3 Oct 2022 09:35:06 +0200 - Cache service/account endpoints lookup
  * Fri, 24 Dec 2021 14:23:46 +0200 - Authenticate dynamically if token is not set



  * Tue, 26 Jul 2022 15:55:09 -0500 - Merge pull request #112 from alertlogic/alcom_json
  * Tue, 26 Jul 2022 14:53:35 +0300 - fix alertlogic.com/json serialization



  * Mon, 31 Jan 2022 09:10:58 -0600 - Merge pull request #111 from zdaniel86/fmulti
  * Thu, 27 Jan 2022 23:44:47 +0000 - fix multiple content type issue for requestBody



  * Thu, 27 Jan 2022 10:54:07 +0000 - Merge pull request #110 from ivanu-at-AL/m2r2
  * Mon, 24 Jan 2022 16:31:35 +0000 - init



  * Wed, 1 Dec 2021 15:49:46 +0100 - Use AlmdrlibValueError instead of Exception (#108)



  * Fri, 26 Nov 2021 13:48:25 +0100 - Make opeanapi schema validation errors human readable (#107)
  * Fri, 19 Nov 2021 08:54:51 +0000 - Bump pip from 19.3.1 to 21.1 (#106)
  * Tue, 16 Nov 2021 07:58:01 -0600 - Merge pull request #105 from MikeBenza/format-validation-error-better
  * Fri, 12 Nov 2021 15:25:56 -0600 - Only emit schema in debug mode
  * Fri, 12 Nov 2021 15:20:51 -0600 - Merge branch 'master' of https://github.com/alertlogic/alertlogic-sdk-python into format-validation-error-better
  * Fri, 12 Nov 2021 15:20:31 -0600 - Merge pull request #104 from MikeBenza/good-doc
  * Fri, 12 Nov 2021 08:41:35 -0600 - Format validation errors better
  * Wed, 10 Nov 2021 13:49:42 -0600 - Fix tests to work in a bare environment
  * Wed, 10 Nov 2021 13:28:24 -0600 - Restore sorted parameters
  * Wed, 10 Nov 2021 13:25:24 -0600 - Add tests, use 'or'+empty instead of kwargs
  * Wed, 10 Nov 2021 11:25:06 -0600 - Handle the content_type param being present
  * Tue, 9 Nov 2021 22:56:12 -0600 - Flake8 client.py
  * Tue, 9 Nov 2021 22:43:32 -0600 - Lazily construct doc and signature
  * Tue, 9 Nov 2021 16:04:58 -0600 - Add type annotations for simple cases
  * Tue, 9 Nov 2021 15:51:45 -0600 - Consolidate default content type, add body parameter to signature
  * Tue, 9 Nov 2021 14:23:53 -0600 - Make useful documentation for generated functions



  * Wed, 27 Oct 2021 08:01:43 -0500 - Support byte RequestBodySimpleParameter (#101)



  * Mon, 25 Oct 2021 12:54:52 +0100 - pyyaml: pin to 5.4.1 (#102)



  * Mon, 28 Jun 2021 17:02:43 +0100 - Do full clone for the pypi release (#100)



  * Mon, 28 Jun 2021 16:57:05 +0100 - Adjust formatting for the release history (#99)



  * Mon, 28 Jun 2021 16:45:42 +0100 - Add automatic rel notes (#98)



  * Mon, 28 Jun 2021 14:18:35 +0100 - For each operation call try to resolve proper service endpoint if account_id is present in the args (#97)



  * Tue, 20 Apr 2021 14:10:27 +0100 - Update setup.py
  * Tue, 20 Apr 2021 14:09:57 +0100 - Update requirements.txt



  * Tue, 30 Mar 2021 17:17:46 +0100 - Bump pyyaml from 5.1.2 to 5.4 (#96)



  * Thu, 25 Mar 2021 06:52:07 -0700 - Add operations to dir(...) result on clients (#94)
  * Wed, 24 Mar 2021 06:55:02 -0700 - Merge pull request #95 from MikeBenza/dont-blap-moduletype
  * Sun, 21 Mar 2021 21:59:27 -0700 - Don't overwrite types.ModuleType



  * Thu, 18 Mar 2021 12:47:40 +0000 - Support raw endpoint url  (#93)
  * Thu, 28 Jan 2021 19:36:24 +0000 - Rename .travis.yml to .travis.yml.defunct



  * Wed, 27 Jan 2021 20:10:03 +0000 - Install newver setuptools on build
  * Wed, 27 Jan 2021 17:03:31 +0000 - PyPi act on tags



  * Wed, 27 Jan 2021 17:00:38 +0000 - AlEnv support for the mdr lib (#89)
  * Wed, 27 Jan 2021 16:54:03 +0000 - Bump definitions version (#90)
  * Wed, 27 Jan 2021 15:49:41 +0000 - Add test and deploy workflows



  * Sat, 24 Oct 2020 07:52:04 -0500 - Added user_id property to the session object (#87)



  * Mon, 5 Oct 2020 08:50:45 -0500 - Don't duplicate logger hander (#86)



  * Fri, 2 Oct 2020 11:50:11 +0100 - bump sdk definitions to v0.0.47 (#85)
  * Fri, 2 Oct 2020 05:37:20 -0500 - Don't log AIMS tokens (#84)



  * Tue, 29 Sep 2020 18:01:05 +0100 - bump alertlogic sdk defintions version (#83)



  * Tue, 29 Sep 2020 14:59:05 +0100 - bump definitions dependency (#82)



  * Thu, 17 Sep 2020 11:22:03 +0100 - bump definitions dep (#81)



  * Thu, 13 Aug 2020 16:41:41 +0100 - Revert "support python < 3.6 (#78)" (#79)



  * Wed, 12 Aug 2020 15:15:49 +0100 - support python < 3.6 (#78)



  * Mon, 10 Aug 2020 16:15:13 -0500 - Updated to indicate python 3.6 support (#77)
  * Mon, 10 Aug 2020 11:05:21 +0100 - Add docs test (#76)



  * Mon, 10 Aug 2020 10:10:44 +0100 - Update README.md
  * Mon, 10 Aug 2020 10:07:48 +0100 - add docs badge (#75)
  * Mon, 10 Aug 2020 10:05:06 +0100 - Support documentation case when yaml converted from json has <field>:{} empty object (#74)



  * Fri, 7 Aug 2020 16:00:07 +0100 - Serialize boolean parameters to lowercase (#73)
  * Fri, 7 Aug 2020 11:54:54 +0100 - Initialise _endpoints_map in the client since it is requested by default session (#72)
  * Fri, 31 Jul 2020 08:08:51 -0500 - Local services (#61)



  * Sun, 26 Jul 2020 16:23:15 +0100 - bump definitions dependency to 0.0.31 (#60)



  * Fri, 24 Jul 2020 19:23:37 +0100 - bump definitions dependency to  v0.0.30 (#59)



  * Fri, 24 Jul 2020 14:20:27 +0100 - bump sdk definitions to 0.0.28 (#58)
  * Fri, 24 Jul 2020 14:17:02 +0100 - Move parsing, loading and normalisation logic for the definitions to the alsdkdefs package (#57)



  * Fri, 17 Jul 2020 19:30:23 +0100 - bump definitions v0.0.23 (#56)



  * Thu, 16 Jul 2020 12:53:39 -0500 - Residency initialization and session initialization logging. (#54)



  * Wed, 15 Jul 2020 11:36:13 -0500 - Merge pull request #53 from alertlogic/init_residency_fix
  * Wed, 15 Jul 2020 10:47:04 -0500 - Fixed to correctly initialize default residency
  * Thu, 9 Jul 2020 15:46:35 +0100 - Change readme typo (#51)



  * Wed, 15 Jul 2020 06:39:11 -0500 - Support further query parameter serialization (#52)



  * Fri, 3 Jul 2020 14:09:38 -0500 - Merge pull request #50 from alertlogic/session_global_endpoint_fix
  * Fri, 3 Jul 2020 14:07:04 -0500 - Added missing global_endpoint parameter to the session initialization
  * Thu, 2 Jul 2020 22:37:02 +0100 - Doc generation requires install first (#49)



  * Thu, 2 Jul 2020 16:55:55 +0100 - Add CR into readme (#48)



  * Mon, 29 Jun 2020 20:49:20 +0100 - bump default definitions to 0.0.13 (#47)



  * Thu, 18 Jun 2020 13:08:44 +0100 - Move definitions to definitions package (#45)
  * Thu, 11 Jun 2020 18:48:46 -0500 - Fixed typo



  * Wed, 10 Jun 2020 10:58:35 +0100 - add token for pypi (#43)
  * Wed, 10 Jun 2020 10:30:30 +0100 - add skip cleanup to allow releases (#42)
  * Wed, 10 Jun 2020 04:08:26 -0500 - Request body object serialize fix (#41)
  * Thu, 4 Jun 2020 13:08:55 -0300 - Update AIMS OpenAPI documentation (#39)
  * Fri, 22 May 2020 14:33:41 -0500 - Merge pull request #38 from alertlogic/aerta
  * Fri, 22 May 2020 14:29:31 -0500 - Added initial version of aerta API spec
  * Fri, 22 May 2020 10:10:37 -0500 - Merge branch 'master' of github.com:alertlogic/alertlogic-sdk-python
  * Fri, 22 May 2020 10:09:50 -0500 - Bumped version number to indicate inclusion of IRIS API
  * Fri, 22 May 2020 10:07:17 -0500 - Merge pull request #36 from FinlayShepherd/iris
  * Thu, 21 May 2020 20:28:11 -0500 - Merge pull request #37 from alertlogic/configure_support
  * Thu, 21 May 2020 20:24:36 -0500 - Added support for configure operation. Use AIMS token when resolving endpoints
  * Thu, 21 May 2020 17:32:04 +0100 - Improve IRIS example responses
  * Thu, 21 May 2020 14:38:47 +0100 - Add IRIS docs
  * Mon, 18 May 2020 07:02:48 -0700 - Merge pull request #32 from alertlogic/windows_installer
  * Sat, 16 May 2020 20:57:54 -0500 - Ensure to read specs using utf-8 encoding to support running on windows
  * Sun, 10 May 2020 14:04:53 -0500 - Merge pull request #31 from alertlogic/ingest_schema_fix
  * Sun, 10 May 2020 13:39:49 -0500 - Fixed ingest service schema to pass 'anyOf' validation for send_data operation'
  * Sat, 9 May 2020 16:54:04 -0500 - Merge pull request #30 from alertlogic/request_body_param_fix
  * Sat, 9 May 2020 16:52:09 -0500 - Fixed to not use 'required' for object parameters as it breaks jsonschema validation
  * Fri, 8 May 2020 17:50:20 -0500 - Merge pull request #29 from alertlogic/windows_support
  * Fri, 8 May 2020 17:46:08 -0500 - Updated to work on windows plus other minor fixes
  * Thu, 7 May 2020 11:10:22 -0700 - Merge pull request #28 from mcnielsen/master
  * Thu, 7 May 2020 10:34:49 -0700 - Added a package.json to allow the repository to be consumed by NPM.
  * Tue, 5 May 2020 08:33:03 -0500 - Handle a case of m2r not being installed
  * Tue, 5 May 2020 08:27:01 -0500 - Merge pull request #27 from alertlogic/documentation
  * Mon, 4 May 2020 18:14:21 -0500 - Changed to use newer version of sphinx
  * Mon, 4 May 2020 18:09:07 -0500 - Changed to use newer version of sphinx
  * Mon, 4 May 2020 18:03:37 -0500 - Added support for indirect types and other documentation improvements
  * Thu, 23 Apr 2020 14:58:44 -0500 - Pinned to the supported version of m2r
  * Thu, 23 Apr 2020 14:46:10 -0500 - Pinned to the supported version of m2r
  * Thu, 23 Apr 2020 11:17:08 -0500 - Merge pull request #26 from alertlogic/incident_handling_support
  * Thu, 23 Apr 2020 11:14:15 -0500 - Updated to the latest version of aetuner that includes incident handling settings support
  * Mon, 20 Apr 2020 17:49:50 -0500 - Merge pull request #25 from alertlogic/config_init_fix
  * Mon, 20 Apr 2020 17:47:34 -0500 - Fixed to correctly intialize session configuration
  * Wed, 15 Apr 2020 14:15:31 -0500 - Merge pull request #24 from alertlogic/ingest-send-data-improvement
  * Wed, 15 Apr 2020 14:12:53 -0500 - Support binary format for simple parameters
  * Tue, 14 Apr 2020 16:07:07 -0500 - Merge pull request #23 from alertlogic/ingest-send-data-improvement
  * Tue, 14 Apr 2020 16:04:42 -0500 - Increased version number
  * Tue, 14 Apr 2020 16:03:33 -0500 - Added automatic retries for POST
  * Tue, 14 Apr 2020 16:02:00 -0500 - Updated to support publishing syslog data to ingest
  * Sun, 12 Apr 2020 14:16:04 -0500 - Merge pull request #22 from alertlogic/aetuner_release
  * Sun, 12 Apr 2020 14:05:34 -0500 - Updated to support new aetuner spec
  * Sat, 11 Apr 2020 15:40:56 -0500 - Merge pull request #21 from msayler/doc-fixes
  * Thu, 2 Apr 2020 15:11:48 -0500 - Improve docs for first-use
  * Fri, 3 Apr 2020 16:31:16 -0500 - Fixed aetuner paths and bumped up sdk version
  * Fri, 3 Apr 2020 15:59:22 -0500 - Erronously bumped the version number
  * Fri, 3 Apr 2020 15:41:59 -0500 - Fixed to actually have proper urls
  * Fri, 3 Apr 2020 15:29:12 -0500 - Added support for aetuner endpoints.
  * Fri, 3 Apr 2020 09:38:49 -0500 - Updated to use endpoints
  * Wed, 1 Apr 2020 14:03:48 -0500 - Merge pull request #20 from alertlogic/response_support
  * Wed, 1 Apr 2020 13:56:42 -0500 - Updated ingest api to have response information
  * Wed, 1 Apr 2020 13:53:40 -0500 - Removed the need for pydoc
  * Tue, 24 Mar 2020 17:11:54 -0500 - Added required module to sphinx doc generation
  * Tue, 24 Mar 2020 17:04:19 -0500 - Added initial support for response objects
  * Sun, 15 Mar 2020 16:16:38 -0500 - Merge pull request #19 from alertlogic/aims_token_fix
  * Sun, 15 Mar 2020 16:14:03 -0500 - Fixed handling object based request bodies
  * Sat, 14 Mar 2020 19:54:13 -0500 - Fixed to work with 'dictionary-like' payloadBody
  * Sat, 14 Mar 2020 19:53:20 -0500 - fixed lint error'
  * Sat, 14 Mar 2020 11:12:26 -0500 - Updated version number
  * Sat, 14 Mar 2020 11:06:18 -0500 - Updated to allow aims token based sessions
  * Fri, 13 Mar 2020 10:32:38 -0500 - Merge pull request #18 from alertlogic/ingest
  * Fri, 13 Mar 2020 10:28:03 -0500 - Added jsonschema to the list of requirements
  * Fri, 13 Mar 2020 10:00:41 -0500 - Updated tests
  * Fri, 13 Mar 2020 10:00:21 -0500 - Added examples
  * Fri, 13 Mar 2020 09:59:51 -0500 - Added new required for jsonschema validation
  * Fri, 13 Mar 2020 09:59:28 -0500 - Added new required for jsonschema validation
  * Fri, 13 Mar 2020 09:53:30 -0500 - Fixed lint errors
  * Fri, 13 Mar 2020 09:53:08 -0500 - Added support for indirect types: oneOf, anyOf, allOf
  * Fri, 13 Mar 2020 09:50:06 -0500 - Added logging.
  * Fri, 13 Mar 2020 09:47:19 -0500 - Bumping up version
  * Fri, 13 Mar 2020 09:46:58 -0500 - Enabled logging and put back AL image
  * Fri, 6 Mar 2020 14:33:50 -0600 - Merge pull request #17 from alertlogic/docs
  * Fri, 6 Mar 2020 14:31:15 -0600 - Bump version number
  * Fri, 6 Mar 2020 14:29:41 -0600 - Sort operations and parameters
  * Fri, 6 Mar 2020 09:41:25 -0600 - Updated readthedocs config to install sdk via setuptools
  * Fri, 6 Mar 2020 08:34:49 -0600 - Removed incorrect reference to AlertLogic_Logo_White.png
  * Thu, 5 Mar 2020 18:20:13 -0600 - Added response syntax
  * Wed, 4 Mar 2020 12:53:13 -0600 - Merged with redoc PR
  * Wed, 4 Mar 2020 12:43:15 -0600 - Merge branch 'master' of github.com:alertlogic/alertlogic-sdk-python into docs
  * Wed, 4 Mar 2020 12:43:05 -0600 - Added support for dict params and enums
  * Wed, 4 Mar 2020 12:42:12 -0600 - Merge pull request #16 from mcnielsen/docs
  * Tue, 3 Mar 2020 19:55:17 -0800 - Merge branch 'docs' of algithub.pd.alertlogic.net:knielsen/alertlogic-sdk-python into docs
  * Tue, 3 Mar 2020 19:47:27 -0800 - fix font family
  * Tue, 3 Mar 2020 19:45:51 -0800 - Merge branch 'docs' of algithub.pd.alertlogic.net:knielsen/alertlogic-sdk-python into docs
  * Tue, 3 Mar 2020 19:45:36 -0800 - A few finishing touches
  * Tue, 3 Mar 2020 19:45:12 -0800 - fix font family
  * Tue, 3 Mar 2020 19:42:05 -0800 - fix font family
  * Tue, 3 Mar 2020 19:30:22 -0800 - styles for the skeery Ukrainian
  * Tue, 3 Mar 2020 17:50:11 -0800 - Fixed some relative paths and added the  class to the API selector
  * Tue, 3 Mar 2020 17:27:42 -0800 - Merge branch 'docs' of github.com:alertlogic/alertlogic-sdk-python into docs
  * Tue, 3 Mar 2020 15:30:49 -0600 - Fixed to actually build for each service
  * Tue, 3 Mar 2020 13:21:01 -0800 - Added template
  * Tue, 3 Mar 2020 11:39:27 -0800 - Merge branch 'docs' of github.com:alertlogic/alertlogic-sdk-python into docs
  * Tue, 3 Mar 2020 13:32:34 -0600 - Added redoc support
  * Mon, 2 Mar 2020 14:29:50 -0600 - Merge pull request #15 from alertlogic/docs
  * Mon, 2 Mar 2020 14:24:28 -0600 - Removing “Edit on …” Buttons from Documentation
  * Mon, 2 Mar 2020 14:16:39 -0600 - Merge pull request #14 from alertlogic/docs
  * Mon, 2 Mar 2020 13:22:08 -0600 - Commented out formats setting
  * Mon, 2 Mar 2020 11:51:13 -0600 - Merge pull request #13 from alertlogic/docs
  * Mon, 2 Mar 2020 11:49:19 -0600 - Added configuration files for readthedocs.io
  * Mon, 2 Mar 2020 10:56:13 -0600 - Merge pull request #12 from alertlogic/docs
  * Mon, 2 Mar 2020 10:53:17 -0600 - Added missing docs generating module. Fixed lint errors
  * Mon, 2 Mar 2020 10:49:46 -0600 - Initial support of generating sphinx SDK documentation
  * Mon, 24 Feb 2020 16:44:18 -0600 - Merge branch 'master' of github.com:alertlogic/alertlogic-sdk-python
  * Mon, 24 Feb 2020 16:44:13 -0600 - Merge pull request #11 from alertlogic/bump_version
  * Mon, 24 Feb 2020 16:42:37 -0600 - Another try
  * Mon, 24 Feb 2020 16:34:29 -0600 - Increased version to enable push to pypi
  * Mon, 24 Feb 2020 16:32:54 -0600 - Merge pull request #10 from alertlogic/readme_travis
  * Mon, 24 Feb 2020 16:31:21 -0600 - Fixed formatting
  * Mon, 24 Feb 2020 16:28:40 -0600 - Added pypi and python versions
  * Mon, 24 Feb 2020 16:08:12 -0600 - Merge pull request #9 from alertlogic/readme_travis
  * Mon, 24 Feb 2020 16:05:44 -0600 - Added travis build status to readme
  * Mon, 24 Feb 2020 15:57:06 -0600 - Merge pull request #8 from alertlogic/travis_ci
  * Mon, 24 Feb 2020 15:54:52 -0600 - Initial version of travis-ci support
  * Mon, 24 Feb 2020 14:31:25 -0600 - Merge pull request #7 from alertlogic/payload_serialize_fix
  * Mon, 24 Feb 2020 14:30:26 -0600 - Bumped version number
  * Mon, 24 Feb 2020 14:29:27 -0600 - Fixed to return a dictionary not a tuple
  * Mon, 24 Feb 2020 10:56:02 -0600 - Merge pull request #6 from alertlogic/bug_fixes
  * Mon, 24 Feb 2020 10:54:12 -0600 - Fixed multiple bugs. Reworked RequestBody to support multiple content-types. Fixed lint violations. Added schema tests. Use explode OpenAPI keyword to indicate that an object properties are to be serialized. Introduce v1 of exceptions
  * Fri, 7 Feb 2020 15:56:50 -0600 - Merge pull request #4 from alertlogic/search_v2
  * Fri, 7 Feb 2020 15:55:45 -0600 - Search API (beta) support
  * Thu, 6 Feb 2020 15:25:03 -0600 - Updated to use new version of aetuner implementation
  * Thu, 6 Feb 2020 14:13:26 -0600 - Merge pull request #3 from alertlogic/publish_alpha
  * Thu, 6 Feb 2020 14:12:44 -0600 - Publish alpha to pypi
  * Wed, 5 Feb 2020 15:54:20 -0600 - Merge pull request #2 from alertlogic/config_support
  * Wed, 5 Feb 2020 15:50:46 -0600 - Bumped version number
  * Wed, 5 Feb 2020 15:48:56 -0600 - Added support for alcli to pass global configuration parameters
  * Tue, 4 Feb 2020 08:34:14 -0600 - Fixed to use SafeLoader for yaml
  * Tue, 28 Jan 2020 13:47:40 -0600 - Merge pull request #1 from alertlogic/bug_fixes
  * Tue, 28 Jan 2020 13:46:39 -0600 - Reworked to support lazy authentication
  * Tue, 28 Jan 2020 13:45:00 -0600 - Fixed to use proper package name
  * Tue, 28 Jan 2020 13:44:24 -0600 - Fixed to use proper package name
  * Tue, 28 Jan 2020 13:44:04 -0600 - Initial version of README.md
  * Sun, 26 Jan 2020 17:18:19 -0600 - Initial version OpenAPI based Python SDK
  * Wed, 15 Jan 2020 13:08:23 -0600 - Initial commit


pkgId: 52fb18f1c954c87624f874fc9aca1671bbd38a4f3982168f8ceddf04eea55f49
name: python-alertmanagermeshtastic
arch: src
version: 2024.8.4.9
epoch: 0
release: 1
summary: A proxy to forward messages received via HTTP to MESHTASTIC
url: https://github.com/Apfelwurm/alertmanagermeshtastic
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alertmanagermeshtastic-2024.8.4.9-1.src.rpm
checksum_type: sha256
description:
  [![linux/amd64](https://github.com/Apfelwurm/alertmanagermeshtastic/actions/workflows/build-linux-image.yml/badge.svg)](https://github.com/Apfelwurm/alertmanagermeshtastic/actions/workflows/build-linux-image.yml)
  [![dockerhub](https://img.shields.io/badge/dockerhub-images-important.svg?logo=Docker)](https://hub.docker.com/r/apfelwurm/alertmanagermeshtastic)
  [![github](https://img.shields.io/badge/github-repository-important.svg?logo=Github)](https://github.com/Apfelwurm/alertmanagermeshtastic)
  [![pypi](https://img.shields.io/badge/pypi-package-important.svg?logo=Pypi)](https://pypi.org/project/alertmanagermeshtastic)


  This little Adapter receives alertmanager webhooks and sends the notifications via a over serial attached Meshtastic device to the specified nodeID.

  > **Warning**
  > Caution: The Tests that are provided for the code in this repository are not currently updated! Also this is a quickly hacked together peace of software, that has not built any security in it at the moment. If you have the skill and the time to contribute in any way, take a look at the [Contribution section](#contribution)


  This is based on the work of https://github.com/homeworkprod/weitersager
  Thanks to [GUVWAF](https://github.com/GUVWAF) for the support and thanks to the whole meshtastic team for this awsome software!



  ```
  	receivers:
  	- name: 'meshtastic-webhook'
  	  webhook_configs:
  	  - url: http://alertmanager-meshtastic:9119/alert
  	    send_resolved: true
  ```



  This is an example config, that shows all of the config options.

  ```
  log_level = "debug"

  [general]
  inputtimeshift = 2      # this time in hours will be added to the "in" time of the message that gets sent to the client
  statustimeshift = 2     # this time in hours will be added to the "status" time of the message (startsAt/endsAt) that gets sent to the client

  [http]
  host = "0.0.0.0"
  port = 9119
  clearsecret = "your_secret_key"

  [meshtastic.connection]
  tty = "/tmp/vcom0"
  nodeid = 631724152
  maxsendingattempts = 30
  timeout = 60
  ```




  To integrate this bridge into your composed prometheus/alertmanager cluster, this is a good startingpoint.

  ```
      alertmanagermeshtastic:
        image: apfelwurm/alertmanagermeshtastic
        ports:
          - 9119:9119
        devices:
          -/dev/ttyACM0
        volumes:
          - ./alertmanager-meshtastic/config.toml:/app/config.toml
        restart: always
  ```



  To integrate this bridge into your composed prometheus/alertmanager cluster, this is a good startingpoint.
  If you plan to use a virtual serial port that is provided with socat you have to use the socat connector in this container or run your alertmanagermeshtastic instance on the terminating linux machine, because the reconnecting is not working if you either mount it as volume or as a device.

  ```
      alertmanagermeshtastic:
        image: apfelwurm/alertmanagermeshtastic
        ports:
          - 9119:9119
        environment:
          - SOCAT_ENABLE=TRUE
          - SOCAT_CONNECTION=tcp:192.168.178.46:5000
        volumes:
          - ./alertmanager-meshtastic/config.toml:/app/config.toml
        restart: always
  ```

  Note: If you set SOCAT_ENABLE to TRUE, the tty option from [meshtastic.connection] in config.toml will be overwritten with /tmp/vcom0 as thats the virtual serial port.



  ```
      docker run -d --name alertmanagermeshtastic \
  		--device=/dev/ttyACM0 \
  		-v ./alertmanager-meshtastic/config.toml:/app/config.toml \
      -p 9119:9119 apfelwurm/alertmanagermeshtastic:latest
  ```



  If you plan to use a virtual serial port that is provided with socat you have to use the socat connector in this container or run your alertmanagermeshtastic instance on the terminating linux machine, because the reconnecting is not working if you either mount it as volume or as a device.

  ```
      docker run -d --name alertmanagermeshtastic \
  		--env SOCAT_ENABLE=TRUE --env SOCAT_CONNECTION=tcp:192.168.178.46:5000 \
  		-v ./alertmanager-meshtastic/config.toml:/app/config.toml \
      -p 9119:9119 apfelwurm/alertmanagermeshtastic:latest
  ```
  Note: If you set SOCAT_ENABLE to TRUE, the tty option from [meshtastic.connection] in config.toml will be overwritten with /tmp/vcom0 as thats the virtual serial port.



  You cann add this as an exporter to your scrape config, for example:

  ```
  scrape_configs:
    - job_name: "alertmanager-meshtastic"
      scrape_interval: 10s
      static_configs:
        - targets: ["alertmanager-meshtastic:9119"]
  ```

  it will return the metrics

  `message_queue_size` (int/gauge)
  `meshtastic_connected` (bool/gauge)



  This is currently a minimal implementation that supports only a single node as a receiver. If you need additional features, you are welcome to open an issue, or even better, submit a pull request. You can also take a look on the opened Issues, where i have opened some for planned features and work on them if you want. I would appreciate any help.




  You can use the test.sh or the test single.sh or the following curl command to test alertmanager-meshtastic
  ```
  	curl -XPOST --data '{"status":"resolved","groupLabels":{"alertname":"instance_down"},"commonAnnotations":{"description":"i-0d7188fkl90bac100 of job ec2-sp-node_exporter has been down for more than 2 minutes.","summary":"Instance i-0d7188fkl90bac100 down"},"alerts":[{"status":"resolved","labels":{"name":"olokinho01-prod","instance":"i-0d7188fkl90bac100","job":"ec2-sp-node_exporter","alertname":"instance_down","os":"linux","severity":"page"},"endsAt":"2019-07-01T16:16:19.376244942-03:00","generatorURL":"http://pmts.io:9090","startsAt":"2019-07-01T16:02:19.376245319-03:00","annotations":{"description":"i-0d7188fkl90bac100 of job ec2-sp-node_exporter has been down for more than 2 minutes.","summary":"Instance i-0d7188fkl90bac100 down"}}],"version":"4","receiver":"infra-alert","externalURL":"http://alm.io:9093","commonLabels":{"name":"olokinho01-prod","instance":"i-0d7188fkl90bac100","job":"ec2-sp-node_exporter","alertname":"instance_down","os":"linux","severity":"page"}}' http://alertmanager-meshtastic:9119/alert
  ```


pkgId: 7d55723d6b919368126a7aea10f555cf2b707194f182d00d08fb369dc095e99d
name: python-alexflipnote.py
arch: src
version: 4.0.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/alexflipnote.py/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alexflipnote.py-4.0.2-1.src.rpm
checksum_type: sha256
description:
  [![Downloads Total](https://pepy.tech/badge/alexflipnote-py)](https://pepy.tech/project/alexflipnote-py)
  [![Downloads Month](https://pepy.tech/badge/alexflipnote-py/month)](https://pepy.tech/project/alexflipnote-py)
  [![Downloads Week](https://pepy.tech/badge/alexflipnote-py/week)](https://pepy.tech/project/alexflipnote-py)
  [![PyPi Version](https://img.shields.io/pypi/v/alexflipnote.py.svg)](https://pypi.python.org/pypi/alexflipnote.py/)
  [![MIT License](https://img.shields.io/apm/l/atomic-design-ui.svg?)](https://github.com/tterb/atomic-design-ui/blob/master/LICENSEs)



  An easy-to-use Python Wrapper for the AlexFlipnote API



  - Python 3.8 or above
  - aiohttp (``python -m pip install -U aiohttp``)



  Install the package by doing one of the following commands:

  **Using pip (recommended)**:

  - `pip install alexflipnote.py -U`
  - `python -m pip install alexflipnote.py -U`



  See the full and detailed [docs here][docs]



  [API][base_url] | [Changelogs][changelog] | [Examples][examples] | [Github][github] | [PyPi][pypi]



  This wrapper is made by **Soheab_#6240** (150665783268212746), DM me on Discord or join my server [here][discord_mine]
  for anything related to this wrapper.

  Join AlexFlipnote's server [here][discord_alexflipnote] to suggest or report anything on the API.

  [docs]: start-docs.md
  [changelog]: https://github.com/Soheab/alexflipnote.py/blob/master/changelog.md
  [examples]: start-docs.md#examples
  [base_url]: https://api.alexflipnote.dev
  [github]: https://github.com/Soheab/alexflipnote.py
  [pypi]: https://pypi.org/project/alexflipnote.py/
  [discord_alexflipnote]: https://discord.gg/Alexflipnote
  [discord_mine]: https://discord.gg/yCzcfju

rpm_license:
  Mozilla Public License Version 2.0 ==================================  1. Definitions --------------  1.1. "Contributor" means each individual or legal entity that creates, contributes to the creation of, or owns Covered Software.  1.2. "Contributor Version" means the combination of the Contributions of others (if any) used by a Contributor and that particular Contributor's Contribution.  1.3. "Contribution" means Covered Software of a particular Contributor.  1.4. "Covered Software" means Source Code Form to which the initial Contributor has attached the notice in Exhibit A, the Executable Form of such Source Code Form, and Modifications of such Source Code Form, in each case including portions thereof.  1.5. "Incompatible With Secondary Licenses" means  (a) that the initial Contributor has attached the notice described in Exhibit B to the Covered Software; or  (b) that the Covered Software was made available under the terms of version 1.1 or earlier of the License, but not also under the terms of a Secondary License.  1.6. "Executable Form" means any form of the work other than Source Code Form.  1.7. "Larger Work" means a work that combines Covered Software with other material, in a separate file or files, that is not Covered Software.  1.8. "License" means this document.  1.9. "Licensable" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently, any and all of the rights conveyed by this License.  1.10. "Modifications" means any of the following:  (a) any file in Source Code Form that results from an addition to, deletion from, or modification of the contents of Covered Software; or  (b) any new file in Source Code Form that contains any Covered Software.  1.11. "Patent Claims" of a Contributor means any patent claim(s), including without limitation, method, process, and apparatus claims, in any patent Licensable by such Contributor that would be infringed, but for the grant of the License, by the making, using, selling, offering for sale, having made, import, or transfer of either its Contributions or its Contributor Version.  1.12. "Secondary License" means either the GNU General Public License, Version 2.0, the GNU Lesser General Public License, Version 2.1, the GNU Affero General Public License, Version 3.0, or any later versions of those licenses.  1.13. "Source Code Form" means the form of the work preferred for making modifications.  1.14. "You" (or "Your") means an individual or a legal entity exercising rights under this License. For legal entities, "You" includes any entity that controls, is controlled by, or is under common control with You. For purposes of this definition, "control" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity.  2. License Grants and Conditions --------------------------------  2.1. Grants  Each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license:  (a) under intellectual property rights (other than patent or trademark) Licensable by such Contributor to use, reproduce, make available, modify, display, perform, distribute, and otherwise exploit its Contributions, either on an unmodified basis, with Modifications, or as part of a Larger Work; and  (b) under Patent Claims of such Contributor to make, use, sell, offer for sale, have made, import, and otherwise transfer either its Contributions or its Contributor Version.  2.2. Effective Date  The licenses granted in Section 2.1 with respect to any Contribution become effective for each Contribution on the date the Contributor first distributes such Contribution.  2.3. Limitations on Grant Scope  The licenses granted in this Section 2 are the only rights granted under this License. No additional rights or licenses will be implied from the distribution or licensing of Covered Software under this License. Notwithstanding Section 2.1(b) above, no patent license is granted by a Contributor:  (a) for any code that a Contributor has removed from Covered Software; or  (b) for infringements caused by: (i) Your and any other third party's modifications of Covered Software, or (ii) the combination of its Contributions with other software (except as part of its Contributor Version); or  (c) under Patent Claims infringed by Covered Software in the absence of its Contributions.  This License does not grant any rights in the trademarks, service marks, or logos of any Contributor (except as may be necessary to comply with the notice requirements in Section 3.4).  2.4. Subsequent Licenses  No Contributor makes additional grants as a result of Your choice to distribute the Covered Software under a subsequent version of this License (see Section 10.2) or under the terms of a Secondary License (if permitted under the terms of Section 3.3).  2.5. Representation  Each Contributor represents that the Contributor believes its Contributions are its original creation(s) or it has sufficient rights to grant the rights to its Contributions conveyed by this License.  2.6. Fair Use  This License is not intended to limit any rights You have under applicable copyright doctrines of fair use, fair dealing, or other equivalents.  2.7. Conditions  Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in Section 2.1.  3. Responsibilities -------------------  3.1. Distribution of Source Form  All distribution of Covered Software in Source Code Form, including any Modifications that You create or to which You contribute, must be under the terms of this License. You must inform recipients that the Source Code Form of the Covered Software is governed by the terms of this License, and how they can obtain a copy of this License. You may not attempt to alter or restrict the recipients' rights in the Source Code Form.  3.2. Distribution of Executable Form  If You distribute Covered Software in Executable Form then:  (a) such Covered Software must also be made available in Source Code Form, as described in Section 3.1, and You must inform recipients of the Executable Form how they can obtain a copy of such Source Code Form by reasonable means in a timely manner, at a charge no more than the cost of distribution to the recipient; and  (b) You may distribute such Executable Form under the terms of this License, or sublicense it under different terms, provided that the license for the Executable Form does not attempt to limit or alter the recipients' rights in the Source Code Form under this License.  3.3. Distribution of a Larger Work  You may create and distribute a Larger Work under terms of Your choice, provided that You also comply with the requirements of this License for the Covered Software. If the Larger Work is a combination of Covered Software with a work governed by one or more Secondary Licenses, and the Covered Software is not Incompatible With Secondary Licenses, this License permits You to additionally distribute such Covered Software under the terms of such Secondary License(s), so that the recipient of the Larger Work may, at their option, further distribute the Covered Software under the terms of either this License or such Secondary License(s).  3.4. Notices  You may not remove or alter the substance of any license notices (including copyright notices, patent notices, disclaimers of warranty, or limitations of liability) contained within the Source Code Form of the Covered Software, except that You may alter any license notices to the extent required to remedy known factual inaccuracies.  3.5. Application of Additional Terms  You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Software. However, You may do so only on Your own behalf, and not on behalf of any Contributor. You must make it absolutely clear that any such warranty, support, indemnity, or liability obligation is offered by You alone, and You hereby agree to indemnify every Contributor for any liability incurred by such Contributor as a result of warranty, support, indemnity or liability terms You offer. You may include additional disclaimers of warranty and limitations of liability specific to any jurisdiction.  4. Inability to Comply Due to Statute or Regulation ---------------------------------------------------  If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Software due to statute, judicial order, or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be placed in a text file included with all distributions of the Covered Software under this License. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.  5. Termination --------------  5.1. The rights granted under this License will terminate automatically if You fail to comply with any of its terms. However, if You become compliant, then the rights granted under this License from a particular Contributor are reinstated (a) provisionally, unless and until such Contributor explicitly and finally terminates Your grants, and (b) on an ongoing basis, if such Contributor fails to notify You of the non-compliance by some reasonable means prior to 60 days after You have come back into compliance. Moreover, Your grants from a particular Contributor are reinstated on an ongoing basis if such Contributor notifies You of the non-compliance by some reasonable means, this is the first time You have received notice of non-compliance with this License from such Contributor, and You become compliant prior to 30 days after Your receipt of the notice.  5.2. If You initiate litigation against any entity by asserting a patent infringement claim (excluding declaratory judgment actions, counter-claims, and cross-claims) alleging that a Contributor Version directly or indirectly infringes any patent, then the rights granted to You by any and all Contributors for the Covered Software under Section 2.1 of this License shall terminate.  5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by You or Your distributors under this License prior to termination shall survive termination.  ************************************************************************ *                                                                      * *  6. Disclaimer of Warranty                                           * *  -------------------------                                           * *                                                                      * *  Covered Software is provided under this License on an "as is"       * *  basis, without warranty of any kind, either expressed, implied, or  * *  statutory, including, without limitation, warranties that the       * *  Covered Software is free of defects, merchantable, fit for a        * *  particular purpose or non-infringing. The entire risk as to the     * *  quality and performance of the Covered Software is with You.        * *  Should any Covered Software prove defective in any respect, You     * *  (not any Contributor) assume the cost of any necessary servicing,   * *  repair, or correction. This disclaimer of warranty constitutes an   * *  essential part of this License. No use of any Covered Software is   * *  authorized under this License except under this disclaimer.         * *                                                                      * ************************************************************************  ************************************************************************ *                                                                      * *  7. Limitation of Liability                                          * *  --------------------------                                          * *                                                                      * *  Under no circumstances and under no legal theory, whether tort      * *  (including negligence), contract, or otherwise, shall any           * *  Contributor, or anyone who distributes Covered Software as          * *  permitted above, be liable to You for any direct, indirect,         * *  special, incidental, or consequential damages of any character      * *  including, without limitation, damages for lost profits, loss of    * *  goodwill, work stoppage, computer failure or malfunction, or any    * *  and all other commercial damages or losses, even if such party      * *  shall have been informed of the possibility of such damages. This   * *  limitation of liability shall not apply to liability for death or   * *  personal injury resulting from such party's negligence to the       * *  extent applicable law prohibits such limitation. Some               * *  jurisdictions do not allow the exclusion or limitation of           * *  incidental or consequential damages, so this exclusion and          * *  limitation may not apply to You.                                    * *                                                                      * ************************************************************************  8. Litigation -------------  Any litigation relating to this License may be brought only in the courts of a jurisdiction where the defendant maintains its principal place of business and such litigation shall be governed by laws of that jurisdiction, without reference to its conflict-of-law provisions. Nothing in this Section shall prevent a party's ability to bring cross-claims or counter-claims.  9. Miscellaneous ----------------  This License represents the complete agreement concerning the subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not be used to construe this License against a Contributor.  10. Versions of the License ---------------------------  10.1. New Versions  Mozilla Foundation is the license steward. Except as provided in Section 10.3, no one other than the license steward has the right to modify or publish new versions of this License. Each version will be given a distinguishing version number.  10.2. Effect of New Versions  You may distribute the Covered Software under the terms of the version of the License under which You originally received the Covered Software, or under the terms of any subsequent version published by the license steward.  10.3. Modified Versions  If you create software not governed by this License, and you want to create a new license for such software, you may create and use a modified version of this License if you rename the license and remove any references to the name of the license steward (except to note that such modified license differs from this License).  10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses  If You choose to distribute Source Code Form that is Incompatible With Secondary Licenses under the terms of this version of the License, the notice described in Exhibit B of this License must be attached.  Exhibit A - Source Code Form License Notice -------------------------------------------  This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.  If it is not possible or desirable to put the notice in a particular file, then You may include the notice in a location (such as a LICENSE file in a relevant directory) where a recipient would be likely to look for such a notice.  You may add additional accurate notices of copyright ownership.  Exhibit B - "Incompatible With Secondary Licenses" Notice ---------------------------------------------------------  This Source Code Form is "Incompatible With Secondary Licenses", as defined by the Mozilla Public License, v. 2.0.


pkgId: 31c57739823e99cd590b7e0a16e1d935e11f85560ee53a7167c80b9733ff374a
name: python-alexlib
arch: src
version: 1.9.0
epoch: 0
release: 1
summary: Making Python even more convenient by extending list and dict and pathlib and more.
url: https://github.com/thisismygitrepo/alexlib
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alexlib-1.9.0-1.src.rpm
checksum_type: sha256
description:
  Fill your life with one-liners, take your code to artistic level of brevity and readability while simultaneously being more productive by typing less boilerplate lines of code that are needless to say.

  This package extends many native Python classes to equip you with an uneasy-to-tame power. The major classes extended are:

   * `list` is  extended to `List`
      * Forget that `for` loops exist, because with this class, `for` loops are implicitly used to apply a function to all items.
        Inevitably while programming, one will encounter objects of the same type and you will be struggling to get a tough grab on them.  `List` is a powerful structure that put at your disposal a grip, so tough, that the objects you have at hand start behaving like one object. Behaviour is ala-JavaScript implementation of ``forEach`` method of Arrays.

    * `dict` is  extended to `Struct`.
      * Combines the power of dot notation like classes and key access like dictionaries.

     * `pathlib.Path` is  extended to `P`
          * `P` objects are incredibly powerful for parsing paths, *no* more than one line of code is required to do **any** operation. Take a shufti at this:
          ```
       path = tb.P("dataset/type1/meta/images/file3.ext")
       >> path[0]  # allows indexing!
          P("dataset")
       >> path[-1]  # nifty!
          P("file3.ext")
       >> path[2:-1]  # even slicing!
          P("meta/images/file3.ext")
       ```
       This and much more, is only on top of the indespensible `pathlib.Path` functionalities.

     * Additionally, the package provides many other new classes, e.g. `Read` and `Save`. Together with `P`, they provide comprehensible support for file management. Life cannot get easier with those. Every class inherits attributes that allow saving and loading in one line.


  Furthermore, those classes are inextricably connected. For example, globbing a path `P` object returns a `List` object. You can move back and forth between `List` and `Struct` and `DataFrame` with one method, and so on.



  In the commandline:
  `pip install alexlib`.

  Being a thin extension on top of almost pure Python, you need to worry **not** about your venv, the package is not aggressive in requirements, it installs itself peacefully, never interfere with your other packages. If you do not have `numpy`, `matplotlib` and `pandas`, it simply throws `ImportError` at runtime, that's it.

  [comment]: # (The package is not fussy about versions either. It can though at runtime, install packages on the fly, e.g. `dill` and `tqdm` which are very lightweight libraries.)


  That's as easy as taking candy from a baby; whenever you start a Python file, preface it with following in order to unleash the library:

  ```
  import alexlib.toolbox as tb
  ```



  Suppose you want to know how many lines of code in your repository. The procedure is to glob all `.py` files recursively, read string code, split each one of them by lines, count the lines, add up everything from all strings of code.


  To achieve this, all you need is an eminently readable one-liner.
  ```
  tb.P.cwd().search("*.py", r=True).read_text().split('\n').apply(len).to_numpy().sum()
  ```

  How does this make perfect sense?
  * `search` returns `List` of `P` path objects
  * `read_text` is a `P` method, but it is being run against `List` object. Behind the scenes, **responsible black magic** fails to find such a method in `List` and realizes it is a method of items inside the list, so it runs it against them and thus read all files and containerize them in another `List` object and returns it.
  * A similar story applies to `split` which is a method of strings in Python.
  * Next, `apply` is a method of `List`. Sure enough, it lives up to its apt name and applies the passed function `len` to all items in the list and returns another `List` object that contains the results.
  * `.to_numpy()` converts `List` to `numpy` array, then `.sum` is a method of `numpy`, which gives the final result.

  Methods naming convention like `apply` and `to_numpy` are inspired from the popular `pandas` library, resulting in almost non-existing learning curve.


  Please refer to [Here](<https://github.com/thisismygitrepo/alexlib/blob/master/tutorial.ipynb>) on the main git repo.


  Click [Here](<https://alexlib.readthedocs.io/en/latest/>)


  Alex Al-Saffar. [email](mailto:programmer@usa.com)


pkgId: e315a982ef6ddf9c739169f88beac9175b41ebf54ff45fb190710f060be81609
name: python-alexnet-pytorch
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: An improved version of the AlexNet model, adding parameter initialization from ResNet.
url: https://github.com/Lornatang/AlexNet-PyTorch
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alexnet-pytorch-0.2.0-1.src.rpm
checksum_type: sha256
description:
  Now you can install this library directly using pip!

  ```text
  pip3 install --upgrade alexnet_pytorch
  ```



  The update is for ease of use and deployment.

   * [Example: Export to ONNX](#example-export-to-onnx)
   * [Example: Extract features](#example-feature-extraction)
   * [Example: Visual](#example-visual)

  It is also now incredibly simple to load a pretrained model with a new number of classes for transfer learning:

  ```python
  from alexnet_pytorch import AlexNet
  model = AlexNet.from_pretrained('alexnet', num_classes=10)
  ```



  This update allows you to use NVIDIA's Apex tool for accelerated training. By default choice `hybrid training precision` + `dynamic loss amplified` version, if you need to learn more and details about `apex` tools, please visit https://github.com/NVIDIA/apex.


  This repository contains an op-for-op PyTorch reimplementation of [AlexNet](http://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf).

  The goal of this implementation is to be simple, highly extensible, and easy to integrate into your own projects. This implementation is a work in progress -- new features are currently being implemented.

  At the moment, you can easily:
   * Load pretrained AlexNet models
   * Use AlexNet models for classification or feature extraction

  _Upcoming features_: In the next few days, you will be able to:
   * Quickly finetune an AlexNet on your own dataset
   * Export AlexNet models for production


  1. [About AlexNet](#about-alexnet)
  2. [Model Description](#model-description)
  3. [Installation](#installation)
  4. [Usage](#usage)
      * [Load pretrained models](#loading-pretrained-models)
      * [Example: Classify](#example-classification)
      * [Example: Extract features](#example-feature-extraction)
      * [Example: Export to ONNX](#example-export-to-onnx)
      * [Example: Visual](#example-visual)
  5. [Contributing](#contributing)



  If you're new to AlexNets, here is an explanation straight from the official PyTorch implementation:

  Current approaches to object recognition make essential use of machine learning methods. To improve their performance, we can collect larger datasets, learn more powerful models, and use better techniques for preventing overfitting. Until recently, datasets of labeled images were relatively
  small — on the order of tens of thousands of images (e.g., NORB [16], Caltech-101/256 [8, 9], and
  CIFAR-10/100 [12]). Simple recognition tasks can be solved quite well with datasets of this size,
  especially if they are augmented with label-preserving transformations. For example, the currentbest error rate on the MNIST digit-recognition task (<0.3%) approaches human performance [4].
  But objects in realistic settings exhibit considerable variability, so to learn to recognize them it is
  necessary to use much larger training sets. And indeed, the shortcomings of small image datasets
  have been widely recognized (e.g., Pinto et al. [21]), but it has only recently become possible to collect labeled datasets with millions of images. The new larger datasets include LabelMe [23], which
  consists of hundreds of thousands of fully-segmented images, and ImageNet [6], which consists of
  over 15 million labeled high-resolution images in over 22,000 categories.



  AlexNet competed in the ImageNet Large Scale Visual Recognition Challenge on September 30, 2012. The network achieved a top-5 error of 15.3%, more than 10.8 percentage points lower than that of the runner up. The original paper's primary result was that the depth of the model was essential for its high performance, which was computationally expensive, but made feasible due to the utilization of graphics processing units (GPUs) during training.

  The 1-crop error rates on the imagenet dataset with the pretrained model are listed below.

  |Model structure|*Top-1 error*|*Top-5 error*|
  |:-------------:|:-----------:|:-----------:|
  |    alexnet    |    43.48    |    20.93    |



  Install from pypi:
  ```bash
  pip install alexnet_pytorch
  ```

  Install from source:
  ```bash
  git clone https://github.com/lornatang/AlexNet-PyTorch.git
  cd AlexNet-PyTorch
  pip install -e .
  ```





  Load an AlexNet:
  ```python
  from alexnet_pytorch import AlexNet
  model = AlexNet.from_name('alexnet')
  ```

  Load a pretrained AlexNet:
  ```python
  from alexnet_pytorch import AlexNet
  model = AlexNet.from_pretrained('alexnet')
  ```



  We assume that in your current directory, there is a `img.jpg` file and a `labels_map.txt` file (ImageNet class names). These are both included in `examples/simple`.

  All pre-trained models expect input images normalized in the same way,
  i.e. mini-batches of 3-channel RGB images of shape `(3 x H x W)`, where `H` and `W` are expected to be at least `224`.
  The images have to be loaded in to a range of `[0, 1]` and then normalized using `mean = [0.485, 0.456, 0.406]`
  and `std = [0.229, 0.224, 0.225]`.

  Here's a sample execution.

  ```python
  import json

  import torch
  import torchvision.transforms as transforms
  from PIL import Image

  from alexnet_pytorch import AlexNet


  input_image = Image.open("img.jpg")


  preprocess = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
  ])
  input_tensor = preprocess(input_image)
  input_batch = input_tensor.unsqueeze(0)  # create a mini-batch as expected by the model


  labels_map = json.load(open("labels_map.txt"))
  labels_map = [labels_map[str(i)] for i in range(1000)]


  model = AlexNet.from_pretrained("alexnet")
  model.eval()


  if torch.cuda.is_available():
    input_batch = input_batch.to("cuda")
    model.to("cuda")

  with torch.no_grad():
    logits = model(input_batch)
  preds = torch.topk(logits, k=5).indices.squeeze(0).tolist()

  print("-----")
  for idx in preds:
    label = labels_map[idx]
    prob = torch.softmax(logits, dim=1)[0, idx].item()
    print(f"{label:<75} ({prob * 100:.2f}%)")
  ```



  You can easily extract features with `model.extract_features`:
  ```python
  import torch
  from alexnet_pytorch import AlexNet
  model = AlexNet.from_pretrained('alexnet')


  inputs = torch.randn(1, 3, 224, 224)
  print(inputs.shape) # torch.Size([1, 3, 224, 224])

  features = model.extract_features(inputs)
  print(features.shape) # torch.Size([1, 256, 6, 6])
  ```



  Exporting to ONNX for deploying to production is now simple:
  ```python
  import torch
  from alexnet_pytorch import AlexNet

  model = AlexNet.from_pretrained('alexnet')
  dummy_input = torch.randn(16, 3, 224, 224)

  torch.onnx.export(model, dummy_input, "demo.onnx", verbose=True)
  ```



  ```text
  cd $REPO$/framework
  sh start.sh
  ```

  Then open the browser and type in the browser address [http://127.0.0.1:20000/](http://127.0.0.1:20000/).

  Enjoy it.



  See `examples/imagenet` for details about evaluating on ImageNet.

  For more datasets result. Please see `research/README.md`.



  If you find a bug, create a GitHub issue, or even better, submit a pull request. Similarly, if you have questions, simply post them as GitHub issues.

  I look forward to seeing what the community does with these models!






  *Alex Krizhevsky,Ilya Sutskever,Geoffrey E. Hinton*



  We trained a large, deep convolutional neural network to classify the 1.2 million
  high-resolution images in the ImageNet LSVRC-2010 contest into the 1000 different classes. On the test data, we achieved top-1 and top-5 error rates of 37.5%
  and 17.0% which is considerably better than the previous state-of-the-art. The
  neural network, which has 60 million parameters and 650,000 neurons, consists
  of five convolutional layers, some of which are followed by max-pooling layers,
  and three fully-connected layers with a final 1000-way softmax. To make training faster, we used non-saturating neurons and a very efficient GPU implementation of the convolution operation. To reduce overfitting in the fully-connected
  layers we employed a recently-developed regularization method called “dropout”
  that proved to be very effective. We also entered a variant of this model in the
  ILSVRC-2012 competition and achieved a winning top-5 test error rate of 15.3%,
  compared to 26.2% achieved by the second-best entry.

  [paper](https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf)

  ```text
  @article{AlexNet,
  title:{ImageNet Classification with Deep Convolutional Neural Networks},
  author:{Alex Krizhevsky,Ilya Sutskever,Geoffrey E. Hinton},
  journal={nips},
  year={2012}
  }
  ```


pkgId: f2259587d47618a2d6cb5d66e0e4079df44166ced17bc94774caf48d1bf587ec
name: python-alfa-utilities
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: ALFA utilities for base detectors
url: https://svn.fra.syrocon.net:8181/scm/git/syrocon/ai-adas/machineLearning_env/alfa-utils-master
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alfa-utilities-0.5.2-1.src.rpm
checksum_type: sha256
description:
  This python package contains all ALFA related utilities, so that the base detectors and the ALFA detector can interact with each other.


pkgId: 2fb1918e596eb053339fa3b33595432e8782bc344e6d400369c99b891b46e165
name: python-alfalfa-client
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: A standalone client for the NREL Alfalfa application
url: https://pypi.org/project/alfalfa-client/
rpm_license: LICENSE.txt
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alfalfa-client-0.7.0-1.src.rpm
checksum_type: sha256
description:
  The purpose of this repository is to provide a standalone client for use with the Alfalfa application. It additionally includes a Historian to quickly/easily enable saving of results from Alfalfa simulations.



  This repo is packaged and hosted on [PyPI here](https://pypi.org/project/alfalfa-client/).

  ```bash
  pip install alfalfa-client
  ```

  ```python
  from alfalfa_client.alfalfa_client import AlfalfaClient

  client = AlfalfaClient("http://localhost")
  ```

  Additional documentation for the functions of `alfalfa-client` can be found [here](https://nrel.github.io/alfalfa-client/).



  Prerequisites:

  - [poetry](https://python-poetry.org/docs/#installation) for managing environment

  Cloning and Installing:

  ```bash
  git clone https://github.com/NREL/alfalfa-client.git
  cd alfalfa-client
  poetry install
  ```

  Running Tests:
  All `alfalfa-client` tests currently require a running instance of [Alfalfa](https://github.com/NREL/alfalfa) with at least 2 workers.

  ```bash
  poetry run pytest -m integration
  ```



  1. Finish merging PRs into develop
  1. Confirm all tests pass
  1. Update the version (assume version is 0.1.2): `poetry version 0.1.2`
  1. Create PR to merge version update
  1. Rebase develop onto main, make sure tests pass
  1. Create a tag: `git tag 0.1.2`
  1. Build: `poetry build`
  1. Publish `poetry publish` (this will push to pypi)
  1. Create a new release on the Github repository using the tag and link to PyPI


pkgId: e5d40112fd81002bebcfa32abe5909eef3e6e819e29b1a55e66e818bd534ad1f
name: python-alfort
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: Elm-like interactive application framework for Python
url: https://github.com/ar90n/alfort
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alfort-0.1.9-1.src.rpm
checksum_type: sha256
description:
  [![Build][build-shiled]][build-url]
  [![Version][version-shield]][version-url]
  [![Downloads][download-shield]][download-url]
  [![Contributors][contributors-shield]][contributors-url]
  [![Issues][issues-shield]][issues-url]
  [![Codecov][codecov-shield]][codecov-url]
  [![Apache License 2.0 License][license-shield]][license-url]

  Alfort is simple and plain ELM-like interactive applicaiton framework for Python.
  Alfort is motivated to provide declaretive UI framework independent from any backends.

  Alfort is developping now. So there will be breaking changes.


  * Rendering with Virtual DOM (this feature is truely inspired from hyperapp)
  * Elm-like Movel-View-Update architecture
  * Independent from Real DOM
  * Simple implementation (under 1k loc)


  ```bash
  $ pip install alfort
  ```


  Code
  ```python
  from typing import Callable
  from enum import Enum, auto

  from click import prompt

  from alfort import Alfort, Dispatch, Effect
  from alfort.vdom import Node, Patch, PatchText, Props, VDOM


  handlers: dict[str, Callable[[], None]] = {}


  class Msg(Enum):
      Up = auto()
      Down = auto()


  class TextNode(Node):
      def __init__(self, text: str) -> None:
          print(text)

      def apply(self, patch: Patch) -> None:
          match patch:
              case PatchText(new_text):
                  print(new_text)
              case _:
                  raise ValueError(f"Invalid patch: {patch}")


  class AlfortSimpleCounter(Alfort[int, Msg, TextNode]):
      def create_text(
          self,
          text: str,
          dispatch: Dispatch[Msg],
      ) -> TextNode:
          handlers["u"] = lambda: dispatch(Msg.Up)
          handlers["d"] = lambda: dispatch(Msg.Down)
          return TextNode(text)

      def create_element(
          self,
          tag: str,
          props: Props,
          children: list[TextNode],
          dispatch: Dispatch[Msg],
      ) -> TextNode:
          raise ValueError("create_element should not be called")

      def main(
          self,
      ) -> None:
          self._main()
          while True:
              c = prompt("press u or d")
              if handle := handlers.get(c):
                  handle()


  def main() -> None:
      def view(state: int) -> VDOM:
          return f"Count: {state}"

      def init() -> tuple[int, list[Effect[Msg]]]:
          return (0, [])

      def update(msg: Msg, state: int) -> tuple[int, list[Effect[Msg]]]:
          match msg:
              case Msg.Up:
                  return (state + 1, [])
              case Msg.Down:
                  return (state - 1, [])

      app = AlfortSimpleCounter(init=init, view=view, update=update)
      app.main()


  if __name__ == "__main__":
      main()
  ```

  Output
  ```
  Count: 0
  press u or d: u
  Count: 1
  press u or d: u
  Count: 2
  press u or d: u
  Count: 3
  press u or d: d
  Count: 2
  press u or d: d
  Count: 1
  ```

  If you need more exmplaes, please check the [examples](https://github.com/ar90n/alfort/tree/main/examples).


  Alfort is inspired by TEA(The Elm Architecture). So Alfort makes you create an interactive application with `View`, `Model` and `Update`. If you need more specification about TEA, please see this [documentation](https://guide.elm-lang.org/architecture/).

  Therefore, Alfort doesn't support Command. So Alfort uses functions whose type is `Callable[[Callable[[Msg], None]], Coroutine[None, None, Any]]` to achieve side effect.
  You can run some tasks which have side effects in this function.  And, if you need, you can pass the result of side effect as Message to `dicpatch` which is given as an argument.
  This idea is inspired by [hyperapp](https://github.com/jorgebucaran/hyperapp).

  For now, Alfort doesn't support the following features.

  * Event subscription
  * Virtual DOM comparison by key
  * Port to the outside of runtime.

  Alfort doesn't provide Real DOM or other Widgets manupulation.
  But there is an iterface between your concrete target and Alfort's Virtual DOM.
  It is `Patche`.  So you have to implement some codes to handle some patches.
  [alfort-dom](https://github.com/ar90n/alfort-dom) is an implementation for manupulation DOM.



  ```bash
  $ poetry self add "poethepoet[poetry_plugin]"
  ```


  ```bash
  $ poetry poe test
  ```


  ```bash
  $ poetry poe check
  ```


  * [Elm](https://elm-lang.org/)
  * [hyperapp](https://elm-lang.org/)


  [Apache-2.0](https://github.com/ar90n/alfort/blob/main/LICENSE)

  [download-shield]: https://img.shields.io/pypi/dm/alfort?style=flat
  [download-url]: https://pypi.org/project/alfort/
  [version-shield]: https://img.shields.io/pypi/v/alfort?style=flat
  [version-url]: https://pypi.org/project/alfort/
  [build-shiled]: https://img.shields.io/github/workflow/status/ar90n/alfort/CI%20testing/main
  [build-url]: https://github.com/ar90n/alfort/actions/workflows/ci-testing.yml
  [contributors-shield]: https://img.shields.io/github/contributors/ar90n/alfort.svg?style=flat
  [contributors-url]: https://github.com/ar90n/alfort/graphs/contributors
  [issues-shield]: https://img.shields.io/github/issues/ar90n/alfort.svg?style=flat
  [issues-url]: https://github.com/ar90n/alfort/issues
  [license-shield]: https://img.shields.io/github/license/ar90n/alfort.svg?style=flat
  [license-url]: https://github.com/ar90n/alfort/blob/master/LICENSE.txt
  [codecov-shield]: https://codecov.io/gh/ar90n/alfort/branch/main/graph/badge.svg?token=8GKU96ODLY
  [codecov-url]: https://codecov.io/gh/ar90n/alfort


pkgId: 3d9f9f94be0c633680a61ae49ae8fcb3bc0422198e722961894eaa7bbcabb235
name: python-alfred-cli
arch: src
version: 2.2.7
epoch: 0
release: 1
url: https://github.com/FabienArcellier/alfred-cli#alfred
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alfred-cli-2.2.7-1.src.rpm
checksum_type: sha256
summary:
  Alfred is an extensible automation tool. It allows you to build your continuous integration scripts in python, and much more. You can replace any scripts using the best of both worlds, shell and python.

description:
  [![PyPi](https://img.shields.io/pypi/v/alfred-cli.svg?label=Version)](https://pypi.org/project/alfred-cli/)
  [![Python](https://img.shields.io/pypi/pyversions/alfred-cli.svg)](https://pypi.org/project/alfred-cli/)
  [![CI](https://github.com/FabienArcellier/alfred-cli/actions/workflows/ci.yml/badge.svg)](https://github.com/FabienArcellier/alfred-cli/actions/workflows/ci.yml) [![CI-Windows](https://github.com/FabienArcellier/alfred-cli/actions/workflows/ci-windows.yml/badge.svg)](https://github.com/FabienArcellier/alfred-cli/actions/workflows/ci-windows.yml)
  [![Documentation Status](https://readthedocs.org/projects/alfred-cli/badge/?version=latest)](https://alfred-cli.readthedocs.io/en/latest/?badge=latest)
  [![Discord](https://img.shields.io/badge/discord-alfred-5865F2?logo=discord&logoColor=white)](https://discord.gg/nMn9YPRGSY)
  [![License](https://img.shields.io/badge/license-MIT-007EC7.svg)](LICENSE)

  Alfred is an extensible automation tool designed to **streamline repository operations**. It allows you various commands as continuous integration, runner, build commands ...

  You'll craft advanced commands harnessing **the strengths of both worlds: shell and Python**.




  ![introductory video of alfred](https://media.githubusercontent.com/media/FabienArcellier/alfred-cli/master/docs/demo-1.gif)
  **introductory video**



  You will generate commands to launch of the linter and unit tests process.

  ```bash
  $ alfred --new pylint src/myapp
  ```

  ```bash
  $ alfred --new pytest tests/unit
  ```

  ```bash
  alfred
  ```

  ```text
  Usage: alfred [OPTIONS] COMMAND [ARGS]...

    alfred is an extensible automation tool designed to streamline repository
    operations.

  Options:
    -d, --debug    display debug information like command runned and working
                   directory
    -v, --version  display the version of alfred
    --new          open a wizard to generate a new command
    -c, --check    check the command integrity
    --completion   display instructions to enable completion for your shell
    --help         Show this message and exit.

  Commands:
    lint                run linter on codebase
    tests               run unit tests on codebase
  ```



  * Documentation : https://alfred-cli.readthedocs.io/en/latest
  * PyPI Release : https://pypi.org/project/alfred-cli
  * Source code: https://github.com/FabienArcellier/alfred-cli
  * Chat: https://discord.gg/nMn9YPRGSY



  ``alfred`` exists thanks to this 2 amazing open source projects.

  * [click](https://github.com/pallets/click/)
  * [plumbum](https://github.com/tomerfiliba/plumbum>)




  MIT License

  Copyright (c) 2021-2023 Fabien Arcellier

  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.


pkgId: 4575c0e5643c8ae538ea37532b5b3ffddb1be1752597a5d34cdd04108f75af84
name: python-alfred-workflow-packager
arch: src
version: 3.1.1
epoch: 0
release: 1
summary: A CLI utility for packaging and exporting Alfred workflows
url: https://pypi.org/project/alfred-workflow-packager/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alfred-workflow-packager-3.1.1-1.src.rpm
checksum_type: sha256
description:
  *Copyright 2016-2024 Caleb Evans*
  *Released under the MIT license*

  Alfred Workflow Packager is a command-line utility which makes the process of
  packaging and exporting an [Alfred](https://www.alfredapp.com/) workflow
  incredibly quick and easy. The utility supports Alfred 3 and up, on projects running Python 3 (Python 2 is no longer supported).



  You can install the utility via `pip3`, either globally or within a virtualenv:

  ```sh
  pip3 install alfred-workflow-packager
  ```





  Once you've installed AWP, you must configure it for every project where you
  wish to use it. To do so, create a `packager.json` file in the root directory of
  your project; this file configures AWP for that particular project.



  ```json
  {
    "export_files": [
      "Fruit.alfredworkflow"
    ],
    "bundle_id": "com.yourname.fruit",
    "readme": "README.txt",
    "resources": [
        "icon.png",
        "src/*.py",
        "src/data/*.json"
    ]
  }
  ```





  The paths of the exported workflows (relative to your project directory).



  The unique bundle ID of your workflow. You must have one set in the installed
  workflow, or AWP will not be able to find your workflow when packaging.



  A list of zero or more files/folder patterns representing files or folders to
  copy from your project to the installed workflow. The directory structures and
  filenames are preserved when copying.

  *Local project:*

  ```
  - icon.png
  - fruit
      - apple.py
      - banana.applescript
      - orange.php
  ```

  *Installed workflow (before running utility):*

  ```
  - info.plist
  - special_file.json
  ```

  *packager.json resources:*

  ```json
  [
      "icon.png",
      "fruit/*.json"
  ]
  ```

  *Installed workflow (after running utility):*

  ```
  - info.plist
  - icon.png
  - special_file.json
  - fruit
      - apple.py
      - banana.applescript
      - orange.php
  ```

  Note that files and folders already present in the installed workflow are *not*
  touched if they are not in the *resources* list.





  The path to the README file to use for this workflow; the *About this Workflow*
  field in your workflow is populated with the contents of this file.



  You can run the utility via the `awp` command:

  ```sh
  awp
  ```

  Running `awp` will copy those project resources listed in `packager.json` to
  the installed workflow (in their respective locations), but only if their
  contents or permissions have changed. If you ever need to ignore this equality
  check, you can force the copying of all files/directories by passing `--force`
  / `-f`.

  ```sh
  awp --force
  ```

  ```sh
  awp -f
  ```



  Passing the `--version` option (also `-v`) to `awp` allows you to set the
  version of the installed workflow directly. I highly recommend using [semantic
  versioning](http://semver.org/) to version your workflow releases.

  ```sh
  awp --version 1.2.0
  ```

  ```sh
  awp -v 1.2.0
  ```



  When you're pleased with your work and you're ready to publish a new release,
  you can export the installed workflow to your project directory by passing the
  `--export` flag (or `-e`) to `awp`.

  ```sh
  awp --export
  ```

  ```sh
  awp -e
  ```

  Note that you can set the version and export the workflow simultaneously:

  ```sh
  awp -v 1.2.0 -e
  ```

  **New in AWP v1.1.0:** If you wish to temporarily export the workflow to a
  different file (different from `export_files` in `packager.json`), you can
  pass one or more optional paths to `--export`:

  ```sh
  awp -v 1.3.0-beta.1 -e ~/Desktop/fruit-beta-alfred-5.alfredworkflow
  ```



  The last important step is to update any script objects in your workflow (*i.e.*
  objects of type **Script Filter**, **Run Script**, *etc.*) to reference the
  files copied to the installed workflow directory.

  You should set the *Language* to `/bin/bash` and use the appropriate shell
  command to call your script. Use `"$@"` if your input is passed as argv, or
  `"{query}"` if your input is passed as {query}.



  ```sh
  /usr/bin/python3 -m fruit.apple "$@"
  ```

  ```sh
  /usr/bin/python3 -m fruit.apple "{query}"
  ```



  ```sh
  /usr/bin/osascript fruit/banana.applescript "$@"
  ```

  ```sh
  /usr/bin/osascript fruit/banana.applescript "{query}"
  ```



  ```sh
  /usr/bin/php fruit/orange.php "$@"
  ```

  ```sh
  /usr/bin/php fruit/orange.php "{query}"
  ```

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


pkgId: 8b51ec5761e7568c12701e94f53cf4f11aa4a7ca742a3d03a8477585dc4ed4e3
name: python-alfred3
arch: src
version: 2.6.1
epoch: 0
release: 1
url: https://github.com/ctreffe/alfred
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alfred3-2.6.1-1.src.rpm
checksum_type: sha256
summary:
  A library for rapid development of dynamic and interactive online experiments in the social sciences.

description:
  ![GitHub](https://img.shields.io/github/license/ctreffe/alfred) [![zenodo](https://zenodo.org/badge/150700371.svg)](https://zenodo.org/badge/latestdoi/150700371) [![pytest](https://github.com/ctreffe/alfred/actions/workflows/pytest.yml/badge.svg)](https://github.com/ctreffe/alfred/actions/workflows/pytest.yml) [![pre-commit](https://github.com/ctreffe/alfred/actions/workflows/pre-commit.yml/badge.svg)](https://github.com/ctreffe/alfred/actions/workflows/pre-commit.yml)

  Alfred3 is a package for Python 3 offering an easy way to create
  computer experiments that meet the highest standards of Open Science.
  Specifically, experiments created with alfred3 are transparent,
  accessible, reproducible, and adhere to the [FAIR principles for
  research software](https://www.doi.org/10.3233/DS-190026). In its core
  version, alfred3 comes well-equipped for the creation of dynamic
  content that can be delivered online via a webserver or offline running
  on local machines. In addition, the [alfred3-interact
  plugin](https://github.com/jobrachem/alfred3-interact) enables users to
  create interactive group experiments with features such as automated
  group forming, quick access to members' experiment data, and a
  prepacked chat functionality.

  Further advantages include:

  * All alfred3 scripts are written in [Python
    3](https://www.python.org/), a very popular open source programming
    language that is easy to learn and fast to develop with, as it
    focuses on code readability. Thus, even minimal programming skills
    are sufficient to create experiments with alfred3 (see the
    requirement section for more details and suggestions on beginner
    tutorials).
  * Alfred3 uses the principle of Object-oriented programming (OOP) to
    maximize code reusability. By simply copying and pasting elements
    between scripts, users can instantly integrate content from previous
    experiments with their current project.
  * Experimenters can share experiments created with alfred3 the same way
    they share code from their data analysis. In addition to highly
    reusable code, transparency and ease of sharing are two key
    advantages of using script-based experimental software.
  * Using open source software is a core principle of Open Science and
    both Python 3 and alfred3 are published under permissive open source
    licenses. Researchers will not face the hurdles associated with
    closed source software when trying to reproduce an alfred3 experiment
    (see [The Open Science Training
    Handbook](https://open-science-training-handbook.gitbook.io/book/open-science-basics/open-research-software-and-open-source)
    for more information on the importance of using open source research
    software for your experiments and data analyses).
  * Online experiments written in alfred3 support all types of mobile
    devices through a responsive interface, making them suitable for a wide range of applications and settings (e.g., laboratory experiments where users are invited to bring their own devices, or surveying passers-py with tablets in public spaces)
  * Alfred3 is optimized for the collection of personal data in full
    compliance with both the GDPR and official German guidelines on data
    management in psychological science ([English
    version](https://www.dgps.de/fileadmin/documents/Empfehlungen/Data_Management_eng.pdf)
    | [German
    version](https://www.dgps.de/fileadmin/documents/Empfehlungen/Datenmanagement_deu.pdf)).
    The core version of alfred3 already includes data encryption and
    decryption methods as well as unlinked storage options for personal or
    sensitive data (meaning that you can store personal data separately
    without the possibility of linking it back to experimental data).



  If you have Python 3.7 or newer installed, just install alfred3 via pip

  ```
  $ pip3 install alfred3
  ```



  Documentation and tutorials for alfred3's most important features
  is available here: [Link to docs](https://alfredo3.psych.bio.uni-goettingen.de/docs/)



  We use [GitHub Discussions](https://github.com/ctreffe/alfred/discussions/categories/q-a).
  You can ask questions, share ideas, and showcase your work there. Do not
  hesitate to ask!



  Creating a hello-world experiment is as easy as writing this *script.py*
  file. You can even do it in a simple text editor. Note that the file
  must be named ``script.py``

  ```python
  import alfred3 as al
  exp = al.Experiment()
  exp += al.Page("Hello, world!", name="hello_world")
  ```

  To run the script, open a terminal and change the working directory to
  your experiment directory:

  ```
  $ cd path/to/experiment
  ```

  Next, simply execute the following command in the terminal::

  ```
  $ alfred3 run
  ```

  If you have *Google Chrome* installed on your machine, a browser window
  with the experiment opens automatically. Otherwise, open any webbrowser
  and visit ``http://127.0.0.1:5000/start`` to start the experiment.

  Of course, this "Hello, world" experiment does not contain much content:
  Only a single page with a heading. To learn how to add content to an
  experiment, visit our tutorials in the [alfred3 documentation](
  https://alfredo3.psych.bio.uni-goettingen.de/docs/).



  **If you are publishing research conducted using alfred3, the
  following citation is required:**

  >Treffenstaedt, C., Brachem, J., & Wiemann, P. (2021). Alfred3 - A
  library for rapid experiment development (Version x.x.x). Göttingen,
  Germany: https://doi.org/10.5281/zenodo.1437219

  If you want to use alfred3 and need more information, don't hesitate to
  contact us via alfred@psych.uni-goettingen.de.



  If you want to stay up to date with current developments, you can join
  our [mailing list](mailto:https://listserv.gwdg.de/mailman/listinfo/Alfred).
  We use this list to announce new releases and spread important
  information concerning the use of Alfred. You can expect to receive at
  most one mail per month.


pkgId: d8b6617ec0cdfe8ff227638ff5eaeb9e349497183ea8e9bf7097a2d7450b9a4a
name: python-alfred3-interact
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Components for interactive experiments in the alfred3 framework.
url: https://github.com/jobrachem/alfred3-interact
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alfred3-interact-0.3.1-1.src.rpm
checksum_type: sha256
description:
  ![GitHub](https://img.shields.io/github/license/jobrachem/alfred3-interact) [![DOI](https://zenodo.org/badge/340368707.svg)](https://zenodo.org/badge/latestdoi/340368707) [![pre-commit](https://github.com/jobrachem/alfred3-interact/actions/workflows/pre-commit.yml/badge.svg)](https://github.com/jobrachem/alfred3-interact/actions/workflows/pre-commit.yml) [![Run tests](https://github.com/jobrachem/alfred3-interact/actions/workflows/pytest.yml/badge.svg)](https://github.com/jobrachem/alfred3-interact/actions/workflows/pytest.yml) [![pytest-coverage](coverage.svg)](https://github.com/jobrachem/alfred3-interact/actions/workflows/pytest.yml)

  Alfred3-interact is a plugin for [alfred3](https://github.com/ctreffe/alfred).
  It allows for the creation of interactive web experiments, predominantly
  in the social sciences. As prerequisites,
  you need to have **Python 3.7** or newer and **alfred3 v2.2.0** or newer installed.



  ```
  $ pip3 install alfred3_interact
  ```



  Documentation for alfred3_interact is available here: [Link to docs](https://jobrachem.github.io/alfred3-interact/build/html/index.html)



  Below is an example `script.py` for creating an experiment with an
  asynchronous exchange of data between participants matching:

  1. Initialize a group spec and the `alfred3_interact.MatchMaker` during experiment setup
  2. Use a `alfred3_interact.WaitingPage` for matchmaking inside its `wait_for` hook method.
  3. Find a group via `MatchMaker.match` and bind it to the
     experiment plugins object.
  4. Now the group object is available in sections, pages, and elements
     through the experiment session object. You can use it to access data
     from other participants in the same group.

  ```python

  import alfred3 as al
  import alfred3_interact as ali

  exp = al.Experiment()

  @exp.setup
  def setup(exp):
      spec = ali.SequentialSpec("role1", "role2", nslots = 10, name="mygroup")
      exp.plugins.mm = ali.MatchMaker(spec, exp=exp)


  @exp.member
  class Match(ali.WaitingPage):

      def wait_for(self):
          group = self.exp.plugins.mm.match()
          self.exp.plugins.group = group
          return True


  @exp.member
  class Success(al.Page):
      title = "Match successful"

      def on_exp_access(self):
          group = self.exp.plugins.group

          txt = f"You have successfully matched to role: {group.me.role}"
          self += al.Text(txt, align="center")

  if __name__ == "__main__":
      exp.run()
  ```

  The demo experiment can be started by executing the following command
  from the experiment directory (i.e. the directory in which you placed
  the `script.py`):

  ```
  $ alfred3 run
  ```



  Alfred3-interact was developed for research at the department for
  economic and social psychology, Georg-August-University Göttingen.
  **If you are publishing research conducted using alfred3, the
  following citation is required:**

  >Brachem, J. & Treffenstädt, C. (2021). Alfred3-interact - Interactive web experiments in alfred3. (Version x.x.x). Göttingen,
  Germany: https://doi.org/10.5281/zenodo.1437219


pkgId: 629dc88a5cd07475e8bd68b486d4045660b26087bc9568bf1d418522309b50f0
name: python-alfred5
arch: src
version: 1.1.6
epoch: 0
release: 1
summary: Simple python wrapper for alfred5 workflow / snippets
url: https://github.com/yedhrab/alfred5
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alfred5-1.1.6-1.src.rpm
checksum_type: sha256
description:
  Simplest Alfred Client that I use my own projects.



  ```bash
  pip install alfred5
  ```
  - Projects dir structure
      - Put your codes and `requirements.txt` to `src` folders
      - Install `alfred5` via
          ```bash
          pip install alfred5 --target=src/libs
          ```
      - Add the top of the `main.py`
          ```python
              import sys

              sys.path.insert(0, "src/libs")
          ```
          - ![main](https://i.imgur.com/O6rYLQA.png)
      - If u want to use different `--target` for ex `.` use `WorkflowClient.run(packagedir=".")`
      - Sample of default structure:
          - ![structure](https://i.imgur.com/doLWDR4.png)
      - **If u install all of requirements, dont need to create `requirements.txt` file in `src`**
      - _If you use `vscode`, add the code that below to `.vscode/settings.json` to debug your file_
          - ![vscode](https://i.imgur.com/QeseMTr.png)
          ```json
          {
              "python.analysis.extraPaths": [
                  "./src/libs"
              ],
              "python.analysis.exclude": [
                  "./src/libs"
              ]
          }

          ```
  - Via `SnippetsClient` API create custom snippets programmaically
  - Via `WorkflowClient` API create custom alfred workflow
      - Craete `requirements.txt` file for your python project to let `alfred5` installs them if needed 🙃
      - To install `from requirements.txt` do all import packages inside `main`
              - Use `global` keyword to access imported packages globally
          - `client.query` is the query string
          - `client.page_count` is the page count for pagination results
      - Dont need to add `alfred5` to `requirements.txt`
  - Use `WorkflowClient.log` to log your message to alfred debugger
      - [debugging alfred workflow](https://www.alfredapp.com/help/workflows/utilities/debug/)
      - [why this project use stderr for all logging operation](https://www.alfredforum.com/topic/14721-get-the-python-output-back-to-alfred/?do=findComment&comment=75303)
  - Use `WorkflowClient(main, cache=True)` method to use caching system
      - Just do it for static (not timebased nor any dynamic stuff) response
      - Db path is `db/results.yml` also you can see it from workflow debug panel



  ![alt](https://i.imgur.com/tUJjVUJ.png)

  ```python
  from re import sub
  from urllib.parse import quote_plus
  import sys

  sys.path.insert(0, "src/libs")

  from alfred5 import WorkflowClient


  async def main(client: WorkflowClient):
      
      global get
      from requests import get

      query = client.query
      client.log(f"my query: {query}")  # use it to see your log in workflow debug panel

      
      
      

      char_count = str(len( query))
      word_count = str(len(query.split(" ")))
      line_count = str(len(query.split("\n")))

      encoded_string = quote_plus(query)
      remove_dublication = " ".join(dict.fromkeys(query.split(" ")))

      upper_case = query.upper()
      lower_case = query.lower()
      capitalized = query.capitalize()
      template = sub(r"[a-zA-Z0-9]", "X", query)

      client.add_result(encoded_string, "Encoded", arg=encoded_string)
      client.add_result(remove_dublication, "Remove dublication", arg=remove_dublication)
      client.add_result(upper_case, "Upper Case", arg=upper_case)
      client.add_result(lower_case, "Lower Case", arg=lower_case)
      client.add_result(capitalized, "Capitalized", arg=capitalized)
      client.add_result(template, "Template", arg=template)
      client.add_result(char_count, "Characters", arg=char_count)
      client.add_result(word_count, "Words", arg=word_count)
      client.add_result(line_count, "Lines", arg=line_count)

      
      
      

  if __name__ == "__main__":
      WorkflowClient.run(main)  # WorkflowClient.run(main, cache=True)

  ```




  ![insturaction1](https://i.imgur.com/2oDMChr.png)
  ![insturaction2](https://i.imgur.com/IMVWNDm.png)
  ![insturaction3](https://i.imgur.com/WicJKBN.png)
  ![insturaction4](https://i.imgur.com/AwPNT8Y.png)




  ```
  Copyright 2023 Yunus Emre Ak ~ YEmreAk.com

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

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

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


pkgId: 741b65641e0e14613e40c13b5f56915043cdca6b263d31b8ec7589bd6e0bb103
name: python-alfworld
arch: src
version: 0.3.5
epoch: 0
release: 1
summary: ALFWorld - Aligning Text and Embodied Environments for Interactive Learning.
url: https://pypi.org/project/alfworld/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alfworld-0.3.5-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2020 Mohit Shridhar and others  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: cfe4ee028b6e2b05648b46e3b06b90f7c5572cffde2410ed9463e7dc0087fc54
name: python-alg3dpy
arch: src
version: 0.18.1
epoch: 0
release: 1
summary: 3D Algebra in Python
url: https://github.com/saullocastro/alg3dpy
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alg3dpy-0.18.1-1.src.rpm
checksum_type: sha256
description:
  Very useful basic algebra operations with points, vectors, planes:
  - Calculate distances
  - Calculate angles
  - Intersections
  - Projections


pkgId: e8cf8e16e8fec46dec79113b061141b4c3b46924881a3572f23955d20756c9bc
name: python-algebraic-data-types
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Algebraic data types for Python
url: https://github.com/jspahrsummers/adt
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algebraic-data-types-0.2.1-1.src.rpm
checksum_type: sha256
description:
  `adt` is a library providing [algebraic data types](https://en.wikipedia.org/wiki/Algebraic_data_type) in Python, with a clean, intuitive syntax, and support for [`typing`](https://docs.python.org/3/library/typing.html) through a [mypy plugin](#mypy-plugin).

  _**NOTE:** This project is experimental, and not actively maintained by the author. Contributions and forking are more than welcome._

  **Table of contents:**

  1. [What are algebraic data types?](#what-are-algebraic-data-types)
      1. [Pattern matching](#pattern-matching)
      1. [Compared to Enums](#compared-to-enums)
      1. [Compared to inheritance](#compared-to-inheritance)
      1. [Examples in other programming languages](#examples-in-other-programming-languages)
  1. [Installation](#installation)
      1. [mypy plugin](#mypy-plugin)
  1. [Defining an ADT](#defining-an-adt)
      1. [Generated functionality](#generated-functionality)
      1. [Custom methods](#custom-methods)



  An [algebraic data type](https://en.wikipedia.org/wiki/Algebraic_data_type) (also known as an ADT) is a way to represent multiple variants of a single type, each of which can have some data associated with it. The idea is very similar to [tagged unions and sum types](https://en.wikipedia.org/wiki/Tagged_union), which in Python are represented as [Enums](#compared-to-enums).

  ADTs are useful for a variety of data structures, including binary trees:

  ```python
  @adt
  class Tree:
      EMPTY: Case
      LEAF: Case[int]
      NODE: Case["Tree", "Tree"]
  ```

  Abstract syntax trees (like you might implement as part of a parser, compiler, or interpreter):

  ```python
  @adt
  class Expression:
      LITERAL: Case[float]
      UNARY_MINUS: Case["Expression"]
      ADD: Case["Expression", "Expression"]
      MINUS: Case["Expression", "Expression"]
      MULTIPLY: Case["Expression", "Expression"]
      DIVIDE: Case["Expression", "Expression"]
  ```

  Or more generic versions of a variant type, like an `Either` type that represents a type A or a type B, but not both:

  ```python
  L = TypeVar('L')
  R = TypeVar('R')

  @adt
  class Either(Generic[L, R]):
      LEFT: Case[L]
      RIGHT: Case[R]
  ```



  Now, defining a type isn't that interesting by itself. A lot of the expressivity of ADTs arises when you [pattern match](https://en.wikipedia.org/wiki/Pattern_matching) over them (sometimes known as "destructuring").

  For example, we could use the `Either` ADT from above to implement a sort of error handling:

  ```python

  def some_operation() -> Either[Exception, int]:
      return Either.RIGHT(22)  # Example of building a constructor


  default_value = 5
  unpacked_result = some_operation().match(
      
      left=lambda ex: default_value,
      right=lambda result: result)
  ```

  _Aside: this is very similar to how error handling is implemented in languages like [Haskell](https://www.haskell.org/), because it avoids the unpredictable control flow of raising and catching exceptions, and ensures that callers need to make an explicit decision about what to do in an error case._

  One can do the same thing with the `Expression` type above (just more cases to match):

  ```python
  def handle_expression(e: Expression):
      return e.match(
          literal=lambda n: ...,
          unary_minus=lambda expr: ...,
          add=lambda lhs, rhs: ...,
          minus=lambda lhs, rhs: ...,
          multiply=lambda lhs, rhs: ...,
          divide=lambda lhs, rhs: ...)
  ```



  ADTs are somewhat similar to [`Enum`s](https://docs.python.org/3/library/enum.html) from the Python standard library (in fact, the uppercase naming convention is purposely similar).

  For example, an `Enum` version of `Expression` might look like:

  ```python
  from enum import Enum, auto
  class EnumExpression(Enum):
      LITERAL = auto()
      UNARY_MINUS = auto()
      ADD = auto()
      MINUS = auto()
      MULTIPLY = auto()
      DIVIDE = auto()
  ```

  However, this doesn't allow data to be associated with each of these enum values. A particular value of `Expression` will tell you about a _kind_ of expression that exists, but the operands to the expressions still have to be stored elsewhere.

  From this perspective, ADTs are like `Enum`s that can optionally have data associated with each case.



  Algebraic data types are a relatively recent introduction to object-oriented programming languages, for the simple reason that inheritance can replicate the same behavior.

  Continuing our examples with the `Expression` ADT, here's how one might represent it with inheritance in Python:

  ```python
  from abc import ABC
  class ABCExpression(ABC):
      pass

  class LiteralExpression(ABCExpression):
      def __init__(self, value: float):
          pass

  class UnaryMinusExpression(ABCExpression):
      def __init__(self, inner: ABCExpression):
          pass

  class AddExpression(ABCExpression):
      def __init__(self, lhs: ABCExpression, rhs: ABCExpression):
          pass

  class MinusExpression(ABCExpression):
      def __init__(self, lhs: ABCExpression, rhs: ABCExpression):
          pass

  class MultiplyExpression(ABCExpression):
      def __init__(self, lhs: ABCExpression, rhs: ABCExpression):
          pass

  class DivideExpression(ABCExpression):
      def __init__(self, lhs: ABCExpression, rhs: ABCExpression):
          pass
  ```

  This is noticeably more verbose, and the code to consume these types gets much more complex as well:

  ```python
  e: ABCExpression = UnaryMinusExpression(LiteralExpression(3))  # Example of creating an expression

  if isinstance(e, LiteralExpression):
      result = ... # do something with e.value
  elif isinstance(e, UnaryMinusExpression):
      result = ... # do something with e.inner
  elif isinstance(e, AddExpression):
      result = ... # do something with e.lhs and e.rhs
  elif isinstance(e, MinusExpression):
      result = ... # do something with e.lhs and e.rhs
  elif isinstance(e, MultiplyExpression):
      result = ... # do something with e.lhs and e.rhs
  elif isinstance(e, DivideExpression):
      result = ... # do something with e.lhs and e.rhs
  else:
      raise ValueError(f'Unexpected type of expression: {e}')
  ```

  ADTs offer a simple way to define a type which is _one of a set of possible cases_, and allowing data to be associated with each case and packed/unpacked along with it.



  Algebraic data types are very common in functional programming languages, like [Haskell](https://www.haskell.org/) or [Scala](https://www.scala-lang.org/), but they're gaining increasing acceptance in "mainstream" programming languages as well.

  Here are a few examples.



  Rust `enum`s are actually full-fledged ADTs. Here's how an `Either` ADT could be defined:

  ```rust
  enum Either<L, R> {
      Left(L),
      Right(R),
  }
  ```



  [Swift enumerations](https://docs.swift.org/swift-book/LanguageGuide/Enumerations.html) are very similar to Rust's, and behave like algebraic data types through their support of "associated values."

  ```swift
  enum Either<L, R> {
      case Left(L)
      case Right(R)
  }
  ```



  [TypeScript](https://en.wikipedia.org/wiki/Microsoft_TypeScript) offers ADTs through a language feature known as ["discriminated unions"](https://www.typescriptlang.org/docs/handbook/advanced-types.html#discriminated-unions).

  See this example from their documentation:

  ```typescript
  interface Square {
      kind: "square";
      size: number;
  }
  interface Rectangle {
      kind: "rectangle";
      width: number;
      height: number;
  }
  interface Circle {
      kind: "circle";
      radius: number;
  }

  type Shape = Square | Rectangle | Circle;
  ```



  To add `adt` as a library in your Python project, simply run `pip` (or `pip3`, as it may be named on your system):

  ```
  pip install algebraic-data-types
  ```

  This will install [the latest version from PyPI](https://pypi.org/project/algebraic-data-types/).



  The library also comes with a plugin for [mypy](http://mypy-lang.org/) that enables typechecking of `@adt` definitions. **If you are already using mypy, the plugin is required to avoid nonsensical type errors.**

  To enable the `adt` typechecking plugin, add the following to a `mypy.ini` file in your project's working directory:

  ```
  [mypy]
  plugins = adt.mypy_plugin
  ```



  To begin defining your own data type, import the `@adt` decorator and `Case[…]` annotation:

  [//]: # (README_TEST:AT_TOP)
  ```python
  from adt import adt, Case
  ```

  Then, define a new Python class, upon which you apply the `@adt` decorator:

  ```python
  @adt
  class MyADT1:
      pass
  ```

  For each case (variant) that your ADT will have, declare a field with the `Case` annotation. It's conventional to declare your fields with ALL_UPPERCASE names, but the only true restriction is that they _cannot_ be lowercase.

  ```python
  @adt
  class MyADT2:
      FIRST_CASE: Case
      SECOND_CASE: Case
  ```

  If you want to associate some data with a particular case, list the type of that data in brackets after `Case` (similar to the `Generic[…]` and `Tuple[…]` annotations from `typing`). For example, to add a case with an associated string:

  ```python
  @adt
  class MyADT3:
      FIRST_CASE: Case
      SECOND_CASE: Case
      STRING_CASE: Case[str]
  ```

  You can build cases with arbitrarily many associated pieces of data, as long as all the types are listed:

  ```python
  @adt
  class MyADT4:
      FIRST_CASE: Case
      SECOND_CASE: Case
      STRING_CASE: Case[str]
      LOTS_OF_DATA_CASE: Case[int, str, str, Dict[int, int]]
  ```

  ADTs can also be recursive—i.e., an ADT can itself be stored alongside a specific case—though the class name has to be provided in double quotes (a restriction which also applies to `typing`).

  A typical example of a recursive ADT is a linked list. Here, the list is also made generic over a type `T`:

  ```python
  T = TypeVar('T')

  @adt
  class LinkedList(Generic[T]):
      NIL: Case
      CONS: Case[T, "LinkedList[T]"]
  ```

  See the library's [tests](tests/) for more examples of complete ADT definitions.



  Given an ADT defined as follows:

  ```python
  @adt
  class MyADT5:
      EMPTY: Case
      INTEGER: Case[int]
      STRING_PAIR: Case[str, str]
  ```

  The `@adt` decorator will automatically generate accessor methods of the following form:

  ```python
      def empty(self) -> None:
          return None

      def integer(self) -> int:
          ... # unpacks int value and returns it

      def string_pair(self) -> Tuple[str, str]:
          ... # unpacks strings and returns them in a tuple
  ```

  These accessors can be used to obtain the data associated with the ADT case, but **accessors will throw an exception if the ADT was not constructed with the matching case**. This is a shorthand when you already know the case of an ADT object.

  `@adt` will also automatically generate a pattern-matching method, which can be used when you _don't_ know which case you have ahead of time:

  [//]: # (README_TEST:IGNORE)
  ```python
      Result = TypeVar('Result')

      def match(self,
                empty: Callable[[], Result],
                integer: Callable[[int], Result],
                string_pair: Callable[[str, str], Result]) -> Result:
          if ... self was constructed as EMPTY ...:
              return empty()
          elif ... self was constructed as INTEGER ...:
              return integer(self.integer())
          elif ... self was constructed as STRING_PAIR ...:
              return string_pair(*self.string_pair())

          
  ```

  See the library's [tests](tests/) for examples of using these generated methods.

  `@adt` will also generate `__repr__`, `__str__`, and `__eq__` methods (only if they are not [defined already](#custom-methods)), to make ADTs convenient to use by default.



  Arbitrary methods can be defined on ADTs by simply including them in the class definition as normal.

  For example, to build "safe" versions of the default accessors on `ExampleADT`, which return `None` instead of throwing an exception when the case is incorrect:

  ```python
  @adt
  class ExampleADT:
      EMPTY: Case
      INTEGER: Case[int]
      STRING_PAIR: Case[str, str]

      @property
      def safe_integer(self) -> Optional[int]:
          return self.match(empty=lambda: None,
                            integer=lambda n: n,
                            string_pair=lambda _a, _b: None)

      @property
      def safe_string_pair(self) -> Optional[Tuple[str, str]]:
          return self.match(empty=lambda: None,
                            integer=lambda n: None,
                            string_pair=lambda a, b: (a, b))
  ```

  However, additional fields _must not_ be added to the class, as the decorator will attempt to interpret them as ADT `Case`s (which will fail).


pkgId: 7b9b11df3050de4e474345f11e8aefa221558dcff0acb27528873b6b9bf1f9c8
name: python-alglab
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: A framework for running experiments on algorithms.
url: https://github.com/pmacg/algpy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alglab-0.1.3-1.src.rpm
checksum_type: sha256
description:
  Framework for performing experiments with algorithms in Python.

  More detailed documentation coming 'soon'.


pkgId: f031520e02aa6ddb3e95a6c610704763088c781c5656fb8226f88ffb46e87363
name: python-algmatch
arch: src
version: 1.0.0
epoch: 0
release: 1
url: https://github.com/VaradK62442/algmatch
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algmatch-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  A package containing various matching algorithms, such as stable marriage, hospital-residents, and student-project allocation.

description:
  A package containing various matching algorithms.
  - All algorithms check for blocking pairs and return a stable matching if no blocking pair is found, and None otherwise
  - All algorithms implemented have verification testing
    - Tested by producing random instances
    - File to brute force all stable matchings
    - Check algorithm is generating correct stable matchings

  The following algorithms are implemented so far:
  - SM: Stable Marriage (both man and woman optimal)
    - SMI: Stable Marriage with incomplete lists
  - HR: Hospital Residents (both residents and hospital optimal)
  - SPA-S: Student Project Allocation with lecturer preferences over students (both student and lecturer optimal)

  Requires Python 3.10 or later.


pkgId: 9f0e0d2518455a27054d4298447f0fbb8feacc8a67f235ccbb3b87832fbd53ca
name: python-algo
arch: src
version: 1.3.1
epoch: 0
release: 1
url: https://github.com/JesperBry/algo
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algo-1.3.1-1.src.rpm
checksum_type: sha256
summary:
  A package with the most common sorting algorithms. All algorithms are based on the book; Introduction to algorithms by Cormen.


pkgId: ba975f6e15a534c98bcf723a6fd6ece443b75e5490960da16fee2b7742defaf0
name: python-algo-library
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: Library for common algorithms
url: https://pypi.org/project/algo-library/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algo-library-0.0.5-1.src.rpm
checksum_type: sha256
description:
  <a href="https://pypi.org/project/algo-library/">
  <img src="https://img.shields.io/pypi/v/algo-library.svg">
  </a>
  <a href="https://github.com/TheNewThinkTank/msgspec/blob/main/LICENSE">
  <img src="https://img.shields.io/github/license/TheNewThinkTank/algo-lib.svg">
  </a>

  ![PyPI Downloads](https://img.shields.io/pypi/dm/algo-library)
  ![CI](https://github.com/TheNewThinkTank/algo-lib/actions/workflows/wf.yml/badge.svg)
  [![codecov](https://codecov.io/gh/TheNewThinkTank/algo-lib/graph/badge.svg?token=ltMgNt08rV)](https://codecov.io/gh/TheNewThinkTank/algo-lib)
  ![commit activity](https://img.shields.io/github/commit-activity/m/TheNewThinkTank/algo-lib)
  [![GitHub repo size](https://img.shields.io/github/repo-size/TheNewThinkTank/algo-lib?style=flat&logo=github&logoColor=whitesmoke&label=Repo%20Size)](https://github.com/TheNewThinkTank/algo-lib/archive/refs/heads/main.zip)



  Library for common algorithms



  ```BASH
  pip install algo-library
  ```



  ```Python
  from algo_lib.ml.linear_regression import linear_regression
  ```



  see `test/test_ml/test_linear_regression.py`

  <!--


  example:

  ```BASH
  git tag 0.0.1
  git push origin --tags
  ```

  release a patch:

  ```BASH
  poetry version patch
  ```

  then `git commit`, `git push` and

  ```BASH
  git tag 0.0.2
  git push origin --tags
  ```
  -->


pkgId: 73fbe7c925b1df4518f44c8c64aaa5344030175c997a3044b0d3ed34349ffb02
name: python-algo-trade
arch: src
version: 0.2.13
epoch: 0
release: 1
summary: Small package to test and implement portfolio trading algorithms
url: https://github.com/vtamprateep/algo-trade
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algo-trade-0.2.13-1.src.rpm
checksum_type: sha256
description:
  **DISCLAIMER: This is a personal project of mine to create a library that facilitates portfolio management using the TDAmeritrade platform. I am not a professional software engineer and cannot attest to robust testing of this library. Additionally, stock trading is an inherently risky practice and is subject to substantial losses. I am not responsible for any losses incurred through use of this library nor any edge cases/bugs that may occur. You have been warned.**



  `algo_trade` is designed to facilitate the creation and implementation of a portfolio management strategy. There exists free Python packages that either facilitate getting financial data, backtesting trading strategies, or connecting to trading accounts to place trades. This package is specifically created with the intent to combine those features of other financial Python tools. `algo_trade` utilizes other financial Python packages and serves as a wrapper to provide an end-to-end trading experience.



  Install the package via `pip install [INSERT PACKAGE NAME HERE]`

  As `algo_trade` is designed to integrate features of existing Python packages, usage of the package to define and implement trading strategies requires subclassing as well as knowledge of integrated Python packages. The two main classes used are `AccountClient` and `Portfolio`.

  `AccountClient` serves as a connection to trading accounts - currently, the only supported client is TDAmeritrade due to their public API and leverages the [`tda-api`](https://github.com/alexgolec/tda-api) Python package. A sample instantiation of the `AccountClient` class can be seen below:

  ```python
  from tda import auth, client
  from algo_trade.account import AccountClient


  tda_client = auth.easy_client(
          api_key = API_KEY,
          redirect_uri = REDIRECT_URI,
          token_path = TOKEN_PATH,
      )

  account = AccountClient(client=tda_client, ACC_ID=ACC_ID)
  ```

  `Portfolio` is the container for algorithmic strategies and can be considered where all the logic, documentation, and indicators the user wants to establish should be placed. A sample definition and instantiation of the `Portfolio` class can be seen below, implementing a dollar-cost-averaging of SPY and IWM using a 75:25 weighting:

  ```python
  from algo_trade.portfolio import Portfolio
  import pandas as pd


  class SpyIwmStrategy(Portfolio):
      population = ['SPY', 'IWM']

      def strategy(self):
          return pd.DataFrame(
              data={
                  'ticker': population,
                  'weight': [0.75, 0.25]
              }
          )

  port_strat = SpyIwmStrategy()
  print(port_strat.run())
  ```

  An important but not strictly needed class (depending on how you intend to set up your strategy and whether you need data) is the `DataBuilder` class, also present in the `portfolio.py` module. `DataBuilder` allows you to get data, using either `yfinance` or `tda-api`, to perform necessary calculations in your strategy. A sample instantiation of `DataBuilder` to get data via TDAmeritrade can be seen below:

  ```python
  from tda import auth, client
  from algo_trade.portfolio import DataBuilder


  data_builder = DataBuilder(client=tda_client) # tda_client created in above code sample
  data_builder.TDAmeritrade(
      port_strat,
      port_strat.population,
  )
  print(port_strat.holdings)
  ```

  Stock level data are all added to the `Portfolio` object as `Stock` objects which contain their symbol as well as historical price data stored as a dataframe.

  Trade orders are created by the `AccountClient` by comparing the current account portfolio weights against target portfolio weights, selling and buying stocks as necessary to get as close to the target portfolio weights as possible. Below is an example of a `Portfolio` strategy returning target portfolio weights to the `AccountClient` which calculates the difference, creates the orders, and submits the order onto the TDAmeritrade platform:

  ```python
  target_weights = port_strat.run()
  account.buildOrder(target_weights)
  account.placeOrderTDAmeritrade()
  ```

  Lastly, the `indicator.py` module contains a series of pre-defined calculations that a use can use within a strategy to calculate metrics such as volatility, sharpe ratio, mean, geometric mean, etc. This module provides a toolset that users can leverage but is not strictly necessary. Most calculations are done on dataframes, so it is relatively simple to create a personal library of indicators if desired.



  ***Is there a built in way to designate frequency of the strategy trades?***

  No, though it was considered for a time. A workaround would be to set up a cron job to run the strategy at the appropriate frequency.

  ***Can this library be used for day-trading or high-frequency trading?***

  Similar to the above answer, you could use the package for day-trading by setting up a strategy and a related cron job to run every minute or half-hour, though if you have a day-trading account there would be other platforms that provide the tool to do so already. Additionally, this package leverages the `tda-api` library specifically for HTTP clients - there is an additionally feature in that library used for streaming data that would be better suited for day-trading, but that is out of the scope of this project

  For high-frequency trading, and depending on the trading strategy, some would argue that Python would not be the best language to do this and that a faster programming language (such as C++ or Golang) is better. Again, this too is out of the scope of the project, but even if it were in-scope, Python would probably not be the best approach.

  ***Will there be additional APIs/clients incorporated into this project besides TDAmeritrade?***

  Perhaps if other clients that both the API and account administration fees are free, I would consider it. However, there are also other features generally that I would like to implement, so this library will probably be limited to TDAmeritrade for the time being.


pkgId: d91e8c6a380f9c674afef46ceef7be095d5480adbd40e9990760c9b2aedf9922
name: python-algo-trading-utils
arch: src
version: 0.0.14
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/algo-trading-utils/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algo-trading-utils-0.0.14-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/Algo-Trading-Tools/algo-trading-utils/actions/workflows/ci.yaml/badge.svg)](https://github.com/Algo-Trading-Tools/algo-trading-utils/actions/workflows/ci.yaml)


  A library full of utilities for algorithmic trading and data analysis.


pkgId: a1957b308fb89406a16da3e5de4eeb2742b5df31e70fe1767d5ed0923cdc3cc9
name: python-algoai
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: A collection of AI algorithms
url: https://pypi.org/project/algoai/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algoai-0.2.5-1.src.rpm
checksum_type: sha256
description:
  `algoai` is a Python package designed to implement and demonstrate various Artificial Intelligence algorithms. It includes solutions for search problems, optimization, game theory, and constraint satisfaction, among others. This package can be useful for students, enthusiasts, and developers interested in learning and experimenting with AI algorithms.





  To install `algoai`, you can use `pip`:

  ```bash
  pip install algoai
  ```


pkgId: 87db00835bd662ecd35a3ef74f95d322805ed6649f40188dbe8b3777982da5c1
name: python-algobowl
arch: src
version: 2024.10.7.0
epoch: 0
release: 1
summary: Competition-based group project for Algorithms courses
url: https://github.com/jackrosenthal/algobowl
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algobowl-2024.10.7.0-1.src.rpm
checksum_type: sha256
description:
  AlgoBOWL is a group project for algorithms courses.  Students compete to create
  heuristics to an NP-hard problem.  For more information, see the paper in
  [ITiCSE 2019](https://doi.org/10.1145/3304221.3319761).

  This is the AlgoBOWL web application, as well as associated tools (e.g., command
  line interface).



  The rest of this `README` assumes you're interested in hacking on the AlgoBOWL
  code, and want to install the web app locally.  For other topics of interest,
  check out the `docs/` directory.

  You'll need a system running Linux and Python 3.8+.

  Create and activate a virtual environment to install in:

  ```shellsession
  $ python3 -m venv venv
  $ . venv/bin/activate
  ```

  Next, install the app in editable mode::

  ```shellsession
  $ pip install -e ".[dev]"
  ```

  Next, copy the sample development config and setup the application::

  ```shellsession
  $ cp development.ini.sample development.ini
  $ gearbox setup-app
  ```

  Finally, you can serve the app::

  ```shellsession
  $ gearbox serve --reload --debug
  ```

  Have fun!


pkgId: 44708fa7dfecaf84e480641f4aca7d3e5af7dc0fc90b1fd9671f9097eaebff48
name: python-algocraft
arch: src
version: 0.2.6
epoch: 0
release: 1
summary: A collection of classic algorithms in Python
url: https://pypi.org/project/algocraft/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algocraft-0.2.6-1.src.rpm
checksum_type: sha256
description:
  Here's the updated `README.md` content in markdown format:




  **Algocraft** is a Python package that provides efficient and easy-to-use implementations of classic algorithms, including searching, sorting, dynamic programming, graph algorithms, and more. Designed to be a comprehensive library, **Algocraft** offers a wide range of fundamental algorithms commonly used in computer science, making it a go-to toolkit for both learning and practical applications.




  - Bubble Sort
  - Merge Sort
  - Quick Sort
  - Heap Sort
  - Strassen's Matrix Multiplication


  - Binary Search
  - Linear Search


  - Fibonacci Sequence
  - Knapsack Problem


  - Dijkstra's Algorithm
  - Floyd-Warshall Algorithm


  - Topological Sort
  - Tower of Hanoi
  - 8-Queens Problem
  - Simplex Method



  You can install the `algocraft` package via `pip` from the Python Package Index (PyPI):

  ```bash
  pip install algocraft
  ```



  Once installed, you can start using the algorithms directly by importing them. For example:

  ```python
  from algocraft import binary_search, fibonacci, merge_sort


  arr = [1, 2, 3, 4, 5]
  index = binary_search(arr, 3)
  print(f'Index of 3: {index}')  # Output: 2


  fib_number = fibonacci(10)
  print(f'10th Fibonacci number: {fib_number}')  # Output: 34


  arr_to_sort = [3, 1, 4, 1, 5, 9]
  sorted_arr = merge_sort(arr_to_sort)
  print(f'Sorted array: {sorted_arr}')  # Output: [1, 1, 3, 4, 5, 9]
  ```


pkgId: 72c5e8d529eb2182a54f6349becc16c786dfcdb10bc1f5e9427bda30dd336b14
name: python-algodojo
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: A automatic trading application of package
url: https://pypi.org/project/algodojo/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algodojo-0.3.4-1.src.rpm
checksum_type: sha256
description:
  Algo Dojo is a Python library for program traders are convenient to use our lib for program trading



  Use the package manager [pip]() to install algodojo.

  ```bash
  pip install algodojo
  ```



  ```python
  import algodojo


  ```


  Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

  Please make sure to update tests as appropriate.

rpm_license:
  By using AlgoDojo (we, us, our) services (website, product, forums) you agree to the following terms of use. Introduction The website located at https://www.algodojo.com/ (the “Site”) is a copyrighted work belonging to Dojo Technologies Limited (“Company”, “us”, “our”, and “we”). Certain features of the Site may be subject to additional guidelines, terms, or rules, which will be posted on the Site in connection with such features, including, without limitation the Company’s Privacy Policy, the Platform Services Agreement, and the Subscription and Sublicense Agreement, all of which are incorporated by reference to these Terms. All such additional terms, guidelines, and rules are incorporated by reference into these Terms. THESE TERMS OF USE (THESE “TERMS”) SET FORTH THE LEGALLY BINDING TERMS AND CONDITIONS THAT GOVERN YOUR USE OF THE SITE. BY ACCESSING OR USING THE SITE, YOU ARE ACCEPTING THESE TERMS (ON BEHALF OF YOURSELF OR THE ENTITY THAT YOU REPRESENT), AND YOU REPRESENT AND WARRANT THAT YOU HAVE THE RIGHT, AUTHORITY, AND CAPACITY TO ENTER INTO THESE TERMS (ON BEHALF OF YOURSELF OR THE ENTITY THAT YOU REPRESENT). YOU MAY NOT ACCESS OR USE THE SITE OR ACCEPT THE TERMS IF YOU ARE NOT AT LEAST 18 YEARS OLD. IF YOU DO NOT AGREE WITH ALL OF THE PROVISIONS OF THESE TERMS, DO NOT ACCESS AND/OR USE THE SITE. THESE TERMS REQUIRE THE USE OF ARBITRATION (SECTION 10.2) ON AN INDIVIDUAL BASIS TO RESOLVE DISPUTES, RATHER THAN JURY TRIALS OR CLASS ACTIONS, AND ALSO LIMIT THE REMEDIES AVAILABLE TO YOU IN THE EVENT OF A DISPUTE. 1.0 Accounts 1.1 Account Creation In order to use certain features of the Site, you must register for an account (“Account”) and provide certain information about yourself as prompted by the account registration form. You represent and warrant that: (a) all required registration information you submit is truthful and accurate; (b) you will maintain the accuracy of such information. You may delete your Account at any time, for any reason, by following the instructions on the Site. Company may suspend or terminate your Account in accordance with Section 8. 1.2 Account Responsibilities You are responsible for maintaining the confidentiality of your Account login information and are fully responsible for all activities that occur under your Account. You agree to immediately notify Company of any unauthorized use, or suspected unauthorized use of your Account or any other breach of security. Company cannot and will not be liable for any loss or damage arising from your failure to comply with the above requirements. 1.3 Non-Solicitation You are prohibited from soliciting or recruit any other users or members of the Site, including Alpha Stream Authors, for any reason, unless you have requested and received permission to solicit or recruit in writing from the Company. . This prohibition includes a prohibition against soliciting or recruiting users of the Site, including Alpha Stream Authors, to become members of competitive sites and services. IThis includes (but is not limited to) soliciting Alpha Stream Authors to make their methods, devices, models, algorithms or other automated processes available at services or sites outside of the Site. If you violate this policy, the Company reserves the right to terminate your Account without notice and to take legal action to recover lost revenues you have stolen from us, plus applicable damages. By using the Site, you specifically acknowledge that you agree to this prohibition. 2.0 Access to the Site 2.1 License. Subject to these Terms, Company grants you a non-transferable, non-exclusive, revocable, limited license to use and access the Site solely for your own personal use. 2.2 Certain Restrictions. The rights granted to you in these Terms are subject to the following restrictions: (a) you shall not license, sell, rent, lease, transfer, assign, distribute, host, or otherwise commercially exploit the Site, whether in whole or in part, or any content displayed on the Site; (b) you shall not share with others, resell or redistribute any of the Site’s dataset (“Data”). The Data is only for internal use. You may not publish, disseminate, re-distribute or share the Data, or any part thereof, or any derivative data that allows reverse engineering of part or all of the Data, with anyone else. You may not offer the Data, or any part thereof, for sale, rent, license or commercial redistribution. Any sharing or distribution by you of your access privileges or of the Data may result in cancellation of your use of the Data without refund. Data can only be used within the AlgoDojo software. You are prohibited from downloading or exporting the data outside the AlgoDojo software; (cb) you shall not modify, make derivative works of, disassemble, reverse compile or reverse engineer any part of the Site; (dc) you shall not access the Site in order to build a similar or competitive website, product, or service; and (ed) except as expressly stated herein, no part of the Site may be copied, reproduced, distributed, republished, downloaded, displayed, posted or transmitted in any form or by any means. Unless otherwise indicated, any future release, update, or other addition to functionality of the Site shall be subject to these Terms. All copyright and other proprietary notices on the Site (or on any content displayed on the Site) must be retained on all copies thereof.   2.3 Modification. Company reserves the right, at any time, to modify, suspend, or discontinue the Site (in whole or in part) with or without notice to you. You agree that Company will not be liable to you or to any third party for any modification, suspension, or discontinuation of the Site or any part thereof. 2.4 No Support or Maintenance. You acknowledge and agree that Company will have no obligation to provide you with any support or maintenance in connection with the Site, but the Company reserves the right, on a case by case basis, to provide support or maintenance as the need arises. 2.5 Ownership. Subject to the terms hereof, and excluding any Non-Public User Content that you may provide (defined below in Section 3.0), you acknowledge that all the intellectual property rights, including copyrights, patents, trademarks, and trade secrets, in the Site and its content, whether provided by you, the Company, or Company’s suppliers, are owned by Company or Company’s suppliers. Neither these Terms (nor your access to the Site) transfers to you or any third party any rights, title or interest in or to such intellectual property rights, except for the limited access rights expressly set forth in Section 2.1. Company and its suppliers reserve all rights not granted in these Terms. There are no implied licenses granted under these Terms. 3.0 User Content 3.1 User Content and Alpha Stream Content. “User Content” means any and all information submitted to or communicated through the Site. You are solely responsible for your User Content. You assume all risks associated with use of your User Content, including any reliance on its accuracy, completeness or usefulness by others, or any disclosure of your User Content that personally identifies you or any third party. You hereby represent and warrant that your User Content do not violate our Acceptable Use Policy (defined in Section 3.3). You may not represent or imply to others that your User Content is in any way provided, sponsored or endorsed by Company. Because you alone are responsible for your User Content, you may expose yourself to liability if, for example, your User Content violates the Acceptable Use Policy. Company is not obligated to backup any User Content, and your User Content a may be deleted at any time without prior notice. You are solely responsible for creating and maintaining your own backup copies of your User Content if you desire. 3.2 Non-Public User Content User Content includes Non-Public User Content and Public User Content. Non-Public User Content is User Content that you communicate directly to one or more other users of the Site or that is not accessible without being logged into your account. Public User Content is all other User Content. When you submit Public User Content, you agree that all rights in such Public User Content are owned by the Company per Section 2.5 above and agree to take reasonable steps, if any, necessary to effectuate such ownership. 3.3 Acceptable Use Policy. The following terms constitute our “Acceptable Use Policy”: (a) You agree not to use the Site to collect, upload, transmit, display, or distribute any User Content (i) that violates any third-party right, including any copyright, trademark, patent, trade secret, moral right, privacy right, right of publicity, or any other intellectual property or proprietary right; (ii) that is unlawful, harassing, abusive, tortious, threatening, harmful, invasive of another’s privacy, vulgar, defamatory, false, intentionally misleading, trade libelous, pornographic, obscene, patently offensive, promotes racism, bigotry, hatred, or physical harm of any kind against any group or individual or is otherwise objectionable; (iii) that is harmful to minors in any way; or (iv) that is in violation of any law, regulation, or obligations or restrictions imposed by any third party. (b) In addition, you agree not to: (i) upload, transmit, or distribute to or through the Site any computer viruses, worms, or any software intended to damage or alter a computer system or data; (ii ) share with others, resell or redistribute any of the Site’s historical market trading data; (iii) send through the Site unsolicited or unauthorized advertising, promotional materials, junk mail, spam, chain letters, pyramid schemes, or any other form of duplicative or unsolicited messages, whether commercial or otherwise; (ivii) use the Site to harvest, collect, gather or assemble information or data regarding other users, including e-mail addresses, without their consent; (iv) interfere with, disrupt, or create an undue burden on servers or networks connected to the Site, or violate the regulations, policies or procedures of such networks; (vi) attempt to gain unauthorized access to the Site (or to other computer systems or networks connected to or used together with the Site), whether through password mining or any other means; (vii) harass or interfere with any other user’s use and enjoyment of the Site; or (viii) use software or automated agents or scripts to produce multiple accounts on the Site, or to generate automated searches, requests, or queries to (or to strip, scrape, or mine data from) the Site (provided, however, that we conditionally grant to the operators of public search engines revocable permission to use spiders to copy materials from the Site for the sole purpose of and solely to the extent necessary for creating publicly available searchable indices of the materials, but not caches or archives of such materials, subject to the parameters set forth in our robots.txt file). (c) In addition, you agree not to disparage any other user of the Site to any third party based on interactions through the Site. 3.4 Enforcement. We reserve the right (but have no obligation except in rare circumstances) to review any User Content, and to investigate and/or take appropriate action against you in our sole discretion if you violate the Acceptable Use Policy or any other provision of these Terms or otherwise create liability for us or any other person. Such action may include removing or modifying your User Content, terminating your Account in accordance with Section 8, and/or reporting you to law enforcement authorities. 3.5 Feedback. If you provide Company with any feedback or suggestions regarding the Site (“Feedback”), you hereby assign to Company all rights in such Feedback and agree that Company shall have the right to use and fully exploit such Feedback and related information in any manner it deems appropriate. Company will treat any Feedback you provide to Company as non-confidential and non-proprietary. You agree that you will not submit to Company any information or ideas that you consider to be confidential or proprietary. 3.6 No Investment Advice; Not an Investment Advisor; Not a Broker-Dealer. The Company is not an investment advisory service, nor is it a registered investment advisor or broker-dealer and does not purport to tell or suggest the value of any securities or which securities customers should buy or sell for themselves. The users of the Site may hold positions in the stocks or industries discussed here. You understand and acknowledge that there is a very high degree of risk involved in trading securities. The Company, the users, the authors, the publisher, and all affiliates of the Site assume no responsibility or liability for your trading and investment results. Factual statements or publications on the Site are made as of the date stated and are subject to change without notice. It should not be assumed that the methods, techniques, or indicators presented in these products will be profitable or that they will not result in losses. Past results of any individual trader or trading system published by on the Site are not indicative of future returns by that trader or system, and are not indicative of future returns which be realized by you. In addition, the indicators, strategies, columns, articles and all other features of the Site are provided for informational and educational purposes only and should not be construed as investment advice. Examples presented on the site are for educational purposes only. Such set-ups are not solicitations of any order to buy or sell. Accordingly, you should not rely solely on the Information in making any investment. You should always check with your licensed financial advisor and tax advisor to determine the suitability of any investment. 3.7 Live Trading Risks. By using the Site, you acknowledge and agree that live algorithmic trading has various risks and the Company shall not have any liability for any losses incurred through using the Site, such risks included, without limitation: (a) Design risks; errors in data, incorrect assumptions, logical program errors. Even if you designed a perfect strategy, past performance is no guarantee of future results. (b) Data risk; Your use of, or inability to use, the Data is at your sole risk. AlgoDojo make no warranty about the accuracy or quality of the Data and do not guarantee, represent, or warrant that your use of the data will be uninterrupted, timely, secure, reliable, complete, accurate, or error-free. Data may be delayed, inaccurate, or contain errors or omissions, and AlgoDojo will have no liability with respect thereto. AlgoDojo is not responsible for the Data. All data is provided “as is” and neither party makes any other warranties, express or implied, including any implied warranty of non-infringement, accuracy, merchantability, durability, or fitness for a particular purpose.  (cb) Loss of internet connectivity; resulting in disconnections from brokerage, trades not placed, not seeing the results of algorithm, orders failing to be placed. (dc) Poor design of algorithm; resulting in runaway strategies, machine gun orders, run-time errors halting program operation, failure to trade when expected, termination of the algorithm. (ed) Unexpected market conditions; resulting in poor fill prices, rapid losses (flash crashes), late exchange openings. (fe) Live Ddata feed issues; broken, dirty, delayed or intermittent data connections causing algorithm errors. This includes data inaccuracies (exchanges sometimes publish bad/fictional trades). (gf) Execution issues; orders submissions, updates and cancellations could be rejected or delayed. Trades could be disallowed by authorities without warning. (hg) Malicious activities; criminal activity could cause your algorithm to fail or your brokerage account to become compromised, leaking personal information, intellectual property or theft of your funds. (ih) These events can cause the loss of all funds and holdings in your brokerage account. Algorithmic trading losses can occur faster than in manual trading and you should consult an investment professional to discuss these risks. You should continually monitor the operation of a live trading algorithm to ensure it is running properly. EVERY TIME YOU USE THE SITE YOU AGREE THAT IN ALL CASES THE COMPANY BEARS NO RESPONSIBILITY FOR LOSSES INCURRED, AND OFFERS NO GUARANTEES OR EXPECTATIONS ON YOUR ALGORITHM PERFORMANCE OR STABILITY. 4.0 Indemification You agree to indemnify and hold Company (and its officers, employees, and agents) harmless, including costs and attorneys’ fees, from any claim or demand made by any third party due to or arising out of (a) your use of the Site, (b) your violation of these Terms, (c) your violation of applicable laws or regulations or (d) your User Content. Company reserves the right, at your expense, to assume the exclusive defense and control of any matter for which you are required to indemnify us, and you agree to cooperate with our defense of these claims. You agree not to settle any matter without the prior written consent of Company. Company will use reasonable efforts to notify you of any such claim, action or proceeding upon becoming aware of it. 5.0 Third Party Links & Ads; Other Users 5.1 Third-Party Links & Ads. The Site may contain links to third-party websites and services, and/or display advertisements for third parties (collectively, “Third-Party Links & Ads”). Such Third-Party Links & Ads are not under the control of Company, and Company is not responsible for any Third-Party Links & Ads. Company provides access to these Third-Party Links & Ads only as a convenience to you, and does not review, approve, monitor, endorse, warrant, or make any representations with respect to Third-Party Links & Ads. You use all Third-Party Links & Ads at your own risk, and should apply a suitable level of caution and discretion in doing so. When you click on any of the Third-Party Links & Ads, the applicable third party’s terms and policies apply, including the third party’s privacy and data gathering practices. You should make whatever investigation you feel necessary or appropriate before proceeding with any transaction in connection with such Third-Party Links & Ads. 5.2 Other Users. Each Site user is solely responsible for any and all of its own User Content. Because we do not control User Content, you acknowledge and agree that we are not responsible for any User Content, whether provided by you or by others. We make no guarantees regarding the accuracy, currency, suitability, or quality of any User Content. Your interactions with other Site users are solely between you and such users. You agree that Company will not be responsible for any loss or damage incurred as the result of any such interactions. If there is a dispute between you and any Site user, we are under no obligation to become involved. 5.3 Release. You hereby release and forever discharge the Company (and our officers, employees, agents, successors, and assigns) from, and hereby waive and relinquish, each and every past, present and future dispute, claim, controversy, demand, right, obligation, liability, action and cause of action of every kind and nature (including personal injuries, death, and property damage), that has arisen or arises directly or indirectly out of, or that relates directly or indirectly to, the Site (including any interactions with, or act or omission of, other Site users or any Third-Party Links & Ads). IF YOU ARE A CALIFORNIA RESIDENT, YOU HEREBY WAIVE CALIFORNIA CIVIL CODE SECTION 1542 IN CONNECTION WITH THE FOREGOING, WHICH STATES: “A GENERAL RELEASE DOES NOT EXTEND TO CLAIMS WHICH THE CREDITOR DOES NOT KNOW OR SUSPECT TO EXIST IN HIS OR HER FAVOR AT THE TIME OF EXECUTING THE RELEASE, WHICH IF KNOWN BY HIM OR HER MUST HAVE MATERIALLY AFFECTED HIS OR HER SETTLEMENT WITH THE DEBTOR.”. 6.0 Disclaimers. THE SITE IS PROVIDED ON AN “AS-IS” AND “AS AVAILABLE” BASIS, AND COMPANY (AND OUR SUPPLIERS) EXPRESSLY DISCLAIM ANY AND ALL WARRANTIES AND CONDITIONS OF ANY KIND, WHETHER EXPRESS, IMPLIED, OR STATUTORY, INCLUDING ALL WARRANTIES OR CONDITIONS OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE, QUIET ENJOYMENT, ACCURACY, OR NON-INFRINGEMENT. WE (AND OUR SUPPLIERS) MAKE NO WARRANTY THAT THE SITE WILL MEET YOUR REQUIREMENTS, WILL BE AVAILABLE ON AN UNINTERRUPTED, TIMELY, SECURE, OR ERROR-FREE BASIS, OR WILL BE ACCURATE, RELIABLE, FREE OF VIRUSES OR OTHER HARMFUL CODE, COMPLETE, LEGAL, OR SAFE. IF APPLICABLE LAW REQUIRES ANY WARRANTIES WITH RESPECT TO THE SITE, ALL SUCH WARRANTIES ARE LIMITED IN DURATION TO NINETY (90) DAYS FROM THE DATE OF FIRST USE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO THE ABOVE EXCLUSION MAY NOT APPLY TO YOU. SOME JURISDICTIONS DO NOT ALLOW LIMITATIONS ON HOW LONG AN IMPLIED WARRANTY LASTS, SO THE ABOVE LIMITATION MAY NOT APPLY TO YOU. THE COMPANY PROVIDES THE CONTENT OF THE SITE FOR INFORMATIONAL, EDUCATIONAL AND NONCOMMERCIAL PURPOSES ONLY. SINCE EACH INDIVIDUAL'S SITUATION IS UNIQUE, A QUALIFIED PROFESSIONAL SHOULD BE CONSULTED BEFORE MAKING FINANCIAL DECISIONS. ALTHOUGH WE MAY PROVIDE DATA, INFORMATION AND CONTENT RELATING TO INVESTMENT APPROACHES AND OPPORTUNITIES TO BUY OR SELL SECURITIES, INCLUDING MUTUAL FUNDS AND EXCHANGE-TRADED FUNDS, YOU SHOULD NOT CONSTRUE ANY SUCH INFORMATION AS INVESTMENT, FINANCIAL, TAX, LEGAL OR OTHER ADVICE. YOU ALONE WILL BEAR THE SOLE RESPONSIBILITY OF EVALUATING THE MERITS AND RISKS ASSOCIATED WITH THE USE OF ANY DATA, INFORMATION OR CONTENT ON THE SITE BEFORE MAKING ANY DECISIONS BASED ON SUCH DATA, INFORMATION OR CONTENT. IN EXCHANGE FOR USING SUCH DATA, INFORMATION OR CONTENT, YOU AGREE NOT TO HOLD THE COMPANY OR ITS THIRD-PARTY CONTENT PROVIDERS LIABLE FOR ANY POSSIBLE CLAIM FOR DAMAGES ARISING FROM ANY DECISION YOU MAKE BASED ON INFORMATION MADE AVAILABLE TO YOU THROUGH THE SITE. WE DO NOT PROVIDE TAX, ACCOUNTING, LEGAL, INVESTMENT, OR FINANCIAL SERVICES. THE INFORMATION AVAILABLE THROUGH THE SITE IS PROVIDED BY THIRD PARTIES AND SOLELY FOR INFORMATIONAL PURPOSES ON AN “AS IS” BASIS AT YOUR SOLE RISK. THE INFORMATION IS NOT MEANT TO BE, AND SHOULD NOT BE CONSTRUED AS ADVICE OR USED FOR INVESTMENT, LEGAL, ACCOUNTING, OR TAX PURPOSES. THE COMPANY MAKES NO GUARANTEES AS TO THE ACCURATENESS, QUALITY, OR COMPLETENESS OF THE INFORMATION AND QUANTCONNECT SHALL NOT BE RESPONSIBLE OR LIABLE FOR ANY ERRORS, OMISSIONS, INACCURACIES IN THE INFORMATION OR FOR ANY USER’S RELIANCE ON THE INFORMATION. YOU ARE SOLELY AND COMPLETELY RESPONSIBLE FOR VERIFYING THE INFORMATION AS BEING APPROPRIATE FOR YOUR PERSONAL USE, INCLUDING WITHOUT LIMITATION, SEEKING THE ADVICE OF A QUALIFIED PROFESSIONAL REGARDING ANY SPECIFIC FINANCIAL, LEGAL, ACCOUNTING, OR TAX QUESTIONS A USER MAY HAVE. THE COMPANY DOES NOT ENDORSE ANY PARTICULAR FINANCIAL, LEGAL, ACCOUNTING, OR TAX PROFESSIONALS PROVIDING CONTENT ON THE SITE, AND IS NOT RESPONSIBLE FOR ANY CLAIMS MADE BY ANY FINANCIAL, LEGAL, ACCOUNTING OR TAX PROFESSIONALS. THE COMPANY IS NOT ENDORSED BY OR AFFILIATED WITH ANY STATE BAR ASSOCIATION OR OTHER LEGAL OR ACCOUNTING MEMBERSHIP ORGANIZATION OR ASSOCIATION, TAX AUTHORITIES, OR AGENCIES OR ASSOCIATIONS, OR FINRA OR ANY OTHER FINANCIAL REGULATORY AUTHORITY, AGENCY, OR ASSOCIATION. 7.0 Limitation On Liability TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL COMPANY (OR OUR SUPPLIERS) BE LIABLE TO YOU OR ANY THIRD PARTY FOR ANY LOST PROFITS, LOST DATA, COSTS OF PROCUREMENT OF SUBSTITUTE PRODUCTS, OR ANY INDIRECT, CONSEQUENTIAL, EXEMPLARY, INCIDENTAL, SPECIAL OR PUNITIVE DAMAGES ARISING FROM OR RELATING TO THESE TERMS OR YOUR USE OF, OR INABILITY TO USE, THE SITE, EVEN IF COMPANY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. ACCESS TO, AND USE OF, THE SITE IS AT YOUR OWN DISCRETION AND RISK, AND YOU WILL BE SOLELY RESPONSIBLE FOR ANY DAMAGE TO YOUR DEVICE OR COMPUTER SYSTEM, OR LOSS OF DATA RESULTING THEREFROM. TO THE MAXIMUM EXTENT PERMITTED BY LAW, NOTWITHSTANDING ANYTHING TO THE CONTRARY CONTAINED HEREIN, OUR LIABILITY TO YOU FOR ANY DAMAGES ARISING FROM OR RELATED TO THIS AGREEMENT (FOR ANY CAUSE WHATSOEVER AND REGARDLESS OF THE FORM OF THE ACTION), WILL AT ALL TIMES BE LIMITED TO A MAXIMUM OF FIFTY US DOLLARS (U.S. $50). THE EXISTENCE OF MORE THAN ONE CLAIM WILL NOT ENLARGE THIS LIMIT. YOU AGREE THAT OUR SUPPLIERS WILL HAVE NO LIABILITY OF ANY KIND ARISING FROM OR RELATING TO THIS AGREEMENT. SOME JURISDICTIONS DO NOT ALLOW THE LIMITATION OR EXCLUSION OF LIABILITY FOR INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THE ABOVE LIMITATION OR EXCLUSION MAY NOT APPLY TO YOU. 8.0 Term and Termination Subject to this Section, these Terms will remain in full force and effect while you use the Site. We may suspend or terminate your rights to use the Site (including your Account) at any time for any reason at our sole discretion, including for any use of the Site in violation of these Terms. Upon termination of your rights under these Terms, your Account and right to access and use the Site will terminate immediately. Even after your rights under these Terms are terminated, the following provisions of these Terms will remain in effect: Sections 2.2 through 2.5, Section 3 and Sections 4 through 10. 9.0 Copyright Policy. Company respects the intellectual property of others and asks that users of our Site do the same. In connection with our Site, we have adopted and implemented a policy respecting copyright law that provides for the removal of any infringing materials and for the termination, in appropriate circumstances, of users of our online Site who are repeat infringers of intellectual property rights, including copyrights. If you believe that one of our users is, through the use of our Site, unlawfully infringing the copyright(s) in a work, and wish to have the allegedly infringing material removed, the following information in the form of a written notification (pursuant to 17 U.S.C. § 512(c)) must be provided to our designated Copyright Agenus tvia email to support@algodojo.com: 1.	Your physical or electronic signature; 2.	Identification of the copyrighted work(s) that you claim to have been infringed; 3.	Identification of the material on our services that you claim is infringing and that you request us to remove; 4.	Sufficient information to permit us to locate such material; 5.	Your address, telephone number, and e-mail address; 6.	A statement that you have a good faith belief that use of the objectionable material is not authorized by the copyright owner, its agent, or under the law; and 7.	A statement that the information in the notification is accurate, and under penalty of perjury, that you are either the owner of the copyright that has allegedly been infringed or that you are authorized to act on behalf of the copyright owner. Please note that, pursuant to 17 U.S.C. § 512(f), any misrepresentation of material fact (falsities) in a written notification automatically subjects the complaining party to liability for any damages, costs and attorney’s fees incurred by us in connection with the written notification and allegation of copyright infringement. The designated Copyright Agent for Company is: Katten Muchin Rosenman LLP Designated Agent: Sean S. Wooden, Esq. Address of Agent: 2900 K Street, NW, North Tower - Suite 200, Washington, DC 20007-5118 Telephone: 202-625-3664, Email: sean.wooden@kattenlaw.com 10.0 General 10.1 Changes. These Terms are subject to occasional revision, and if we make any substantial changes, we may notify you by sending you an e-mail to the last e-mail address you provided to us (if any), and/or by prominently posting notice of the changes on our Site. You are responsible for providing us with your most current e-mail address. In the event that the last e-mail address that you have provided us is not valid, or for any reason is not capable of delivering to you the notice described above, our dispatch of the e-mail containing such notice will nonetheless constitute effective notice of the changes described in the notice. Any changes to these Terms will be effective upon the earlier of thirty (30) calendar days following our dispatch of an e-mail notice to you (if applicable) or thirty (30) calendar days following our posting of notice of the changes on our Site. These changes will be effective immediately for new users of our Site. Continued use of our Site following notice of such changes shall indicate your acknowledgement of such changes and agreement to be bound by the terms and conditions of such changes. 10.2 Dispute Resolution. Please read this Arbitration Agreement carefully. It is part of your contract with Company and affects your rights. It contains procedures for MANDATORY BINDING ARBITRATION AND A CLASS ACTION WAIVER. (a) Applicability of Arbitration Agreement. All claims and disputes (excluding claims for injunctive or other equitable relief as set forth below) in connection with the Terms or the use of any product or service provided by the Company that cannot be resolved informally or in small claims court shall be resolved by binding arbitration on an individual basis under the terms of this Arbitration Agreement. Unless otherwise agreed to, all arbitration proceedings shall be held in English. This Arbitration Agreement applies to you and the Company, and to any subsidiaries, affiliates, agents, employees, predecessors in interest, successors, and assigns, as well as all authorized or unauthorized users or beneficiaries of services or goods provided under the Terms. (b) Notice Requirement and Informal Dispute Resolution. Before either party may seek arbitration, the party must first send to the other party a written Notice of Dispute (“Notice”) describing the nature and basis of the claim or dispute, and the requested relief. A Notice to the Company should be sent to: 1917 1st Ave, Suite 200, Seattle, 98101, Washington(insert address of our company). After the Notice is received, you and the Company may attempt to resolve the claim or dispute informally. If you and the Company do not resolve the claim or dispute within thirty (30) days after the Notice is received, either party may begin an arbitration proceeding. The amount of any settlement offer made by any party may not be disclosed to the arbitrator until after the arbitrator has determined the amount of the award, if any, to which either party is entitled. (c) Arbitration Rules. Arbitration shall be initiated through the American Arbitration Association (“AAA”), an established alternative dispute resolution provider (“ADR Provider”) that offers arbitration as set forth in this section. If AAA is not available to arbitrate, the parties shall agree to select an alternative ADR Provider. The rules of the ADR Provider shall govern all aspects of the arbitration, including but not limited to the method of initiating and/or demanding arbitration, except to the extent such rules are in conflict with the Terms. The AAA Consumer Arbitration Rules (“Arbitration Rules”) governing the arbitration are available online at www.adr.org or by calling the AAA at 1-800-778-7879. The arbitration shall be conducted by a single, neutral arbitrator. Any claims or disputes where the total amount of the award sought is less than Ten Thousand U.S. Dollars (US $10,000.00) may be resolved through binding non-appearance-based arbitration, at the option of the party seeking relief. For claims or disputes where the total amount of the award sought is Ten Thousand U.S. Dollars (US $10,000.00) or more, the right to a hearing will be determined by the Arbitration Rules. Any hearing will be held in a location within 21050 miles of the Company’s principal place of businessCosta Mesa, CA, U.S.A., unless the parties agree otherwise. If you reside outside of the U.S., the arbitrator shall give the parties reasonable notice of the date, time and place of any oral hearings. Any judgment on the award rendered by the arbitrator may be entered in any court of competent jurisdiction. If the arbitrator grants you an award that is greater than the last settlement offer that the Company made to you prior to the initiation of arbitration, the Company will pay you the greater of the award or $2,500.00. Each party shall bear its own costs (including attorney’s fees) and disbursements arising out of the arbitration and shall pay an equal share of the fees and costs of the ADR Provider. (d) Additional Rules for Non-Appearance Based Arbitration. If non-appearance based arbitration is elected, the arbitration shall be conducted by telephone, online and/or based solely on written submissions; the specific manner shall be chosen by the party initiating the arbitration. The arbitration shall not involve any personal appearance by the parties or witnesses unless otherwise agreed by the parties. (e) Time Limits. If you or the Company pursue arbitration, the arbitration action must be initiated and/or demanded within the statute of limitations (i.e., the legal deadline for filing a claim) and within any deadline imposed under the AAA Rules for the pertinent claim. (f) Authority of Arbitrator. If arbitration is initiated, the arbitrator will decide the rights and liabilities, if any, of you and the Company, and the dispute will not be consolidated with any other matters or joined with any other cases or parties. The arbitrator shall have the authority to grant motions dispositive of all or part of any claim. The arbitrator shall have the authority to award monetary damages, and to grant any non-monetary remedy or relief available to an individual under applicable law, the AAA Rules, and the Terms. The arbitrator shall issue a written award and statement of decision describing the essential findings and conclusions on which the award is based, including the calculation of any damages awarded. The arbitrator has the same authority to award relief on an individual basis that a judge in a court of law would have. The award of the arbitrator is final and binding upon you and the Company. (g) Waiver of Jury Trial. THE PARTIES HEREBY WAIVE THEIR CONSTITUTIONAL AND STATUTORY RIGHTS TO GO TO COURT AND HAVE A TRIAL IN FRONT OF A JUDGE OR A JURY, instead electing that all claims and disputes shall be resolved by arbitration under this Arbitration Agreement. Arbitration procedures are typically more limited, more efficient and less costly than rules applicable in a court and are subject to very limited review by a court. In the event any litigation should arise between you and the Company in any state or federal court in a suit to vacate or enforce an arbitration award or otherwise, YOU AND THE COMPANY WAIVE ALL RIGHTS TO A JURY TRIAL, instead electing that the dispute be resolved by a judge. (h) Waiver of Class or Consolidated Actions. ALL CLAIMS AND DISPUTES WITHIN THE SCOPE OF THIS ARBITRATION AGREEMENT MUST BE ARBITRATED OR LITIGATED ON AN INDIVIDUAL BASIS AND NOT ON A CLASS BASIS, AND CLAIMS OF MORE THAN ONE CUSTOMER OR USER CANNOT BE ARBITRATED OR LITIGATED JOINTLY OR CONSOLIDATED WITH THOSE OF ANY OTHER CUSTOMER OR USER. (i) Confidentiality. All aspects of the arbitration proceeding, including but not limited to the award of the arbitrator and compliance therewith, shall be strictly confidential. The parties agree to maintain confidentiality unless otherwise required by law. This paragraph shall not prevent a party from submitting to a court of law any information necessary to enforce this Agreement, to enforce an arbitration award, or to seek injunctive or equitable relief. (j) Severability. If any part or parts of this Arbitration Agreement are found under the law to be invalid or unenforceable by a court of competent jurisdiction, then such specific part or parts shall be of no force and effect and shall be severed and the remainder of the Agreement shall continue in full force and effect. (k) Right to Waive. Any or all of the rights and limitations set forth in this Arbitration Agreement may be waived by the party against whom the claim is asserted. Such waiver shall not waive or affect any other portion of this Arbitration Agreement. (l) Survival of Agreement. This Arbitration Agreement will survive the termination of your relationship with Company. (m) Small Claims Court. Notwithstanding the foregoing, either you or the Company may bring an individual action in small claims court. (n) Emergency Equitable Relief. Notwithstanding the foregoing, either party may seek emergency equitable relief before a state or federal court in order to maintain the status quo pending arbitration. A request for interim measures shall not be deemed a waiver of any other rights or obligations under this Arbitration Agreement. (o) Claims Not Subject to Arbitration. Notwithstanding the foregoing, claims of defamation, violation of the Computer Fraud and Abuse Act, and infringement or misappropriation of the other party’s patent, copyright, trademark or trade secrets shall not be subject to this Arbitration Agreement. (p) Courts. In any circumstances where the foregoing Arbitration Agreement permits the parties to litigate in court, the parties hereby agree to submit to the personal jurisdiction of the courts located within Kings County, New York, for such purpose. 10.3 Export. The Site may be subject to U.S. export control laws and may be subject to export or import regulations in other countries. You agree not to export, reexport, or transfer, directly or indirectly, any U.S. technical data acquired from Company, or any products utilizing such data, in violation of the United States export laws or regulations. 10.4 Disclosures. Company is located at the address in Section 10.9. If you are a California resident, you may report complaints to the Complaint Assistance Unit of the Division of Consumer Product of the California Department of Consumer Affairs by contacting them in writing at 400 R Street, Sacramento, CA 95814, or by telephone at (800) 952-5210. 10.45 Electronic Communications. The communications between you and Company use electronic means, whether you use the Site or send us emails, or whether Company posts notices on the Site or communicates with you via email. For contractual purposes, you (a) consent to receive communications from Company in an electronic form; and (b) agree that all terms and conditions, agreements, notices, disclosures, and other communications that Company provides to you electronically satisfy any legal requirement that such communications would satisfy if it were be in a hardcopy writing. The foregoing does not affect your non-waivable rights. 10.56 Entire Terms. These Terms constitute the entire agreement between you and us regarding the use of the Site. Our failure to exercise or enforce any right or provision of these Terms shall not operate as a waiver of such right or provision. The section titles in these Terms are for convenience only and have no legal or contractual effect. The word “including” means “including without limitation”. If any provision of these Terms is, for any reason, held to be invalid or unenforceable, the other provisions of these Terms will be unimpaired and the invalid or unenforceable provision will be deemed modified so that it is valid and enforceable to the maximum extent permitted by law. Your relationship to Company is that of an independent contractor, and neither party is an agent or partner of the other. These Terms, and your rights and obligations herein, may not be assigned, subcontracted, delegated, or otherwise transferred by you without Company’s prior written consent, and any attempted assignment, subcontract, delegation, or transfer in violation of the foregoing will be null and void. Company may freely assign these Terms. The terms and conditions set forth in these Terms shall be binding upon assignees. 10.67 Copyright/Trademark Information. Copyright © 202217 QuantConnect Dojo Technologies Limited Corporation. All rights reserved. All trademarks, logos and service marks ("Marks") displayed on the Site are our property or the property of other third parties. You are not permitted to use these Marks without our prior written consent or the consent of such third party which may own the Marks. 10.8 Contact Information


pkgId: 31b82ad74e985d2059db51a06de69390cdc7cd3535e5c382238ea03b123b4041
name: python-algoesup
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Algorithmic essay support library
url: https://github.com/dsa-ou/algoesup/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algoesup-0.3.1-1.src.rpm
checksum_type: sha256
description:
  This small library was written to support the writing of
  [algorithmic essays](https://dsa-ou.github.io/algoesup),
  but can be used independently of that purpose.
  The library provides auxiliary functions that make it easier to:
   - write unit tests for functions
   - measure and plot run-times for best, average and worst case inputs
   - use linters and type checkers within Jupyter Notebook environments.

  Guidance on how to use the library is [here](https://dsa-ou.github.io/algoesup/coding/).

  To install in the global Python environment, open a terminal or PowerShell, and enter
  ```bash
  pip install algoesup
  ```
  To install in a virtual environment, activate it before entering the command above.

  The library supports the [ruff](https://docs.astral.sh/ruff) and
  [allowed](https://dsa-ou.github.io/allowed) linters, and the
  [pytype](https://google.github.io/pytype) type checker.
  You have to install them explicitly if you want to use them from within a notebook:
  ```bash
  pip install ruff allowed pytype
  ```
  Note that `pytype` is not available for Windows.



  `algoesup` is Copyright © 2023–2024 by The Open University, UK.
  The code is licensed under a
  [BSD 3-clause licence](https://github.com/dsa-ou/algoesup/blob/main/LICENSE).
  The documentation is licensed under a
  [Creative Commons Attribution 4.0 International Licence](https://creativecommons.org/licenses/by/4.0/)


pkgId: c7161350583fd477417ea208faa7e9d7f3466164ff6d4e452783a4b63b240fc7
name: python-algol-bayer
arch: src
version: 2024.12.1
epoch: 0
release: 1
summary: bayer-masked spectroscopic image reduction package
url: https://pypi.org/project/algol-bayer/
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algol-bayer-2024.12.1-1.src.rpm
checksum_type: sha256
description:
  This package was developed for astro-spectroscopic student projects
  at the Dresden Gönnsdorf observatory.

  There are method to
  * [Capture DSLR raw images](#capture-dslr-raw-images)
  * [Display raw DSLR images and spectra](#display-raw-dslr-images-and-spectra)
  * [Display fits images and spectra](#display-fits-images-and-spectra)
  * [Dark and flat correction](#dark-and-flat-correction)
  * [Debayer a 2d into a 3d fits file](#debayer-a-2d-into-a-3d-fits-file)



      apt-get install gphoto2
      pip install algol-bayer





  Capture a sequence of DSLR raw images using increasing exposure times
  and [display the images as histogram](#display-raw-dslr-image-as-histogram).

      bayer_capture_histograms.sh



  Capture a sequence of DSLR raw images and try to
  [display them as spectra](#display-raw-dslr-image-as-spectrum).

      bayer_capture_sequence.sh





  ![alt text](./docs/article/img/alpori_hist.png)

      bayer_display_histogram --help



  There is a published paper explaining how this works.
  It can be found online or in the `docs/article` folder.

  ![alt text](./docs/article/img/alpori_spec.png)

      bayer_display_spectrum --help





  ![alt text](./docs/article/img/alpleo_hist.png)

      fits_display_histogram --help



  ![alt text](./docs/article/img/alpleo_spec.png)

  There is a published paper explaining how this works.
  It can be found online or in the `docs/article` folder.

      fits_display_spectrum --help



  An example of how to do this can be found in `tests/test_darkflat.py`



  ... or a master-flat-dark from a set of dark images.

      fits_create_master_dark --help



  ... from a master-flat-dark and a set of flat images.

      fits_create_master_flat --help



      fits_apply_darks_and_flats --help





      fits_debayer --help




   * https://github.com/christianwbrock/algol-bayer
   * http://gphoto.org/
   * https://pypi.org/project/rawpy/


pkgId: b7590d3b8ed629fd8f7b08b73084139bf47fe81cf1faa85cf3c050cb8f861a2d
name: python-algoliaqb
arch: src
version: 0.0.9
epoch: 0
release: 1
summary: Algolia Query Builder
url: http://github.com/ryanb58/algoliaqb
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algoliaqb-0.0.9-1.src.rpm
checksum_type: sha256
description:
  A library to help build queries for searching Algolia.
  This package is meant to be used with the `algoliasearch <https://github.com/algolia/algoliasearch-client-python>`_ library.
  Problem:
  ^^^^^^^^
  An app I have been working on has a few points of code duplication and increased complexity. This package is a way for me to fix those issues and increase readability.
  Installation
  ^^^^^^^^^^^^
     pip install algoliaqb
  Filter Strings
  ^^^^^^^^^^^^^^
  By default ``filter_map`` considers all input as strings. This is pretty straight forward. Lets say for example you have the following filter map:
     filter_map = {
         "group_id": "tenant_id",
     }
  with the following ``flask.args``\ :
     {
         "group_id": 1
     }
  AlgoliaQB will look for ``group_id`` within ``flask.args``\ , grab the value, then remap the key and value for you.
     tenant_id:1
  Now lets try an example with a few more filters.
     filter_map = {
         "group_id": "tenant_id",
         "is_reported": "is_reported"
     }
  with the following ``flask.args``\ :
     {
         "group_id": 1,
         "is_reported": "true
     }
  The returned filter_string is as follows.
     tenant_id:1 AND is_reported:true
  Library Usage Example:
  ^^^^^^^^^^^^^^^^^^^^^^
     from algoliasearch.search_client import SearchClient
     from algoliaqb import AlgoliaQueryBuilder
     from flask import request
     aqb = AlgoliaQueryBuilder(
         search_param="search",
         filter_map={
             "group_id": "tenant_id",
             "is_reported": "is_reported"
         }
     )
     
     search_query = aqb.get_search_query(request.args)
     
     filter_query = aqb.get_filter_query(request.args)
     
     search_client = SearchClient()
     index = search_client.init_index("contacts")
     results = index.search(search_query, {"filters": filter_query})


pkgId: 6dc843f1e60cfa47addf791f270ba7c46c245b12bff4c06d06bd2fb824ce2b58
name: python-algoliasearch
arch: src
version: 4.6.0
epoch: 0
release: 1
summary: A fully-featured and blazing-fast Python API client to interact with Algolia.
url: https://www.algolia.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algoliasearch-4.6.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://www.algolia.com">
      <img alt="Algolia for Python" src="https://raw.githubusercontent.com/algolia/algoliasearch-client-common/master/banners/python.png" >
    </a>

    <h4 align="center">The perfect starting point to integrate <a href="https://algolia.com" target="_blank">Algolia</a> within your Python project</h4>

    <p align="center">
      <a href="https://pypi.org/project/algoliasearch"><img src="https://img.shields.io/pypi/v/algoliasearch.svg" alt="PyPI"></img></a>
      <a href="https://pypi.org/project/algoliasearch"><img src="https://img.shields.io/pypi/pyversions/ansicolortags.svg" alt="Python versions"></img></a>
      <a href="https://pypi.org/project/algoliasearch"><img src="https://img.shields.io/pypi/l/ansicolortags.svg" alt="License"></a>
    </p>
  </p>

  <p align="center">
    <a href="https://www.algolia.com/doc/libraries/python/" target="_blank">Documentation</a>  •
    <a href="https://github.com/algolia/algoliasearch-django" target="_blank">Django</a>  •
    <a href="https://discourse.algolia.com" target="_blank">Community Forum</a>  •
    <a href="http://stackoverflow.com/questions/tagged/algolia" target="_blank">Stack Overflow</a>  •
    <a href="https://github.com/algolia/algoliasearch-client-python/issues" target="_blank">Report a bug</a>  •
    <a href="https://www.algolia.com/doc/api-client/troubleshooting/faq/python/" target="_blank">FAQ</a>  •
    <a href="https://alg.li/support" target="_blank">Support</a>
  </p>



  - Thin & minimal low-level HTTP client to interact with Algolia's API
  - Supports Python from `3.8`



  First, install Algolia Python API Client via the [pip](https://pip.pypa.io/en/stable/installing) package manager:

  ```bash
  pip install --upgrade 'algoliasearch>=4.0,<5.0'
  ```

  You can now import the Algolia API client in your project and play with it.

  ```py
  from algoliasearch.search.client import SearchClient

  _client = SearchClient("YOUR_APP_ID", "YOUR_API_KEY")


  response = await _client.save_object(
      index_name="<YOUR_INDEX_NAME>",
      body={
          "objectID": "id",
          "test": "val",
      },
  )


  print(response)


  print(response.to_json())


  await client.wait_for_task(index_name="<YOUR_INDEX_NAME>", task_id=response.task_id)


  response = await _client.search(
      search_method_params={
          "requests": [
              {
                  "indexName": "<YOUR_INDEX_NAME>",
                  "query": "<YOUR_QUERY>",
                  "hitsPerPage": 50,
              },
          ],
      },
  )


  print(response)


  print(response.to_json())
  ```

  For full documentation, visit the **[Algolia Python API Client](https://www.algolia.com/doc/libraries/python/)**.



  Encountering an issue? Before reaching out to support, we recommend heading to our [FAQ](https://www.algolia.com/doc/api-client/troubleshooting/faq/python/) where you will find answers for the most common issues and gotchas with the client. You can also open [a GitHub issue](https://github.com/algolia/api-clients-automation/issues/new?assignees=&labels=&projects=&template=Bug_report.md)



  This repository hosts the code of the generated Algolia API client for Python, if you'd like to contribute, head over to the [main repository](https://github.com/algolia/api-clients-automation). You can also find contributing guides on [our documentation website](https://api-clients-automation.netlify.app/docs/introduction).



  The Algolia Python API Client is an open-sourced software licensed under the [MIT license](LICENSE).


pkgId: 282a1c10f05fc20da1f5d98ff77fdca0361cabb7397bda6bc809d8199596b365
name: python-algoliasearch-django
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Algolia Search integration for Django
url: https://github.com/algolia/algoliasearch-django
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algoliasearch-django-3.0.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://www.algolia.com">
      <img alt="Algolia for Django" src="https://raw.githubusercontent.com/algolia/algoliasearch-client-common/master/banners/django.png" >
    </a>

    <h4 align="center">The perfect starting point to integrate <a href="https://algolia.com" target="_blank">Algolia</a> within your Django project</h4>

    <p align="center">
      <a href="https://travis-ci.org/algolia/algoliasearch-django"><img src="https://travis-ci.org/algolia/algoliasearch-django.svg?branch=master" alt="Build Status"></img></a>
      <a href="https://coveralls.io/r/algolia/algoliasearch-django"><img src="https://coveralls.io/repos/algolia/algoliasearch-django/badge.svg?branch=master" alt="Coverage Status"></img></a>
      <a href="http://badge.fury.io/py/algoliasearch-django"><img src="https://badge.fury.io/py/algoliasearch-django.svg?branch=master" alt="PyPi Version"></img></a>
    </p>
  </p>


  <p align="center">
    <a href="https://www.algolia.com/doc/framework-integration/django/options/?language=python" target="_blank">Documentation</a>  •
    <a href="https://discourse.algolia.com" target="_blank">Community Forum</a>  •
    <a href="http://stackoverflow.com/questions/tagged/algolia" target="_blank">Stack Overflow</a>  •
    <a href="https://github.com/algolia/algoliasearch-django/issues" target="_blank">Report a bug</a>  •
    <a href="https://www.algolia.com/doc/framework-integration/django/faq/" target="_blank">FAQ</a>  •
    <a href="https://www.algolia.com/support" target="_blank">Support</a>
  </p>



  You can find the full reference on [Algolia's website](https://www.algolia.com/doc/framework-integration/django/).



  1. **[Setup](#setup)**
      * [Introduction](#introduction)
      * [Install](#install)
      * [Setup](#setup)
      * [Quick Start](#quick-start)

  1. **[Commands](#commands)**
      * [Commands](#commands)

  1. **[Search](#search)**
      * [Search](#search)

  1. **[Geo-Search](#geo-search)**
      * [Geo-Search](#geo-search)

  1. **[Tags](#tags)**
      * [Tags](#tags)

  1. **[Options](#options)**
      * [Custom <code>objectID</code>](#custom-codeobjectidcode)
      * [Custom index name](#custom-index-name)
      * [Field Preprocessing and Related objects](#field-preprocessing-and-related-objects)
      * [Index settings](#index-settings)
      * [Restrict indexing to a subset of your data](#restrict-indexing-to-a-subset-of-your-data)
      * [Multiple indices per model](#multiple-indices-per-model)
      * [Temporarily disable the auto-indexing](#temporarily-disable-the-auto-indexing)

  1. **[Tests](#tests)**
      * [Run Tests](#run-tests)

  1. **[Troubleshooting](#troubleshooting)**
      * [Frequently asked questions](#frequently-asked-questions)









  This package lets you easily integrate the Algolia Search API to your [Django](https://www.djangoproject.com/) project. It's based on the [algoliasearch-client-python](https://github.com/algolia/algoliasearch-client-python) package.

  You might be interested in this sample Django application providing a typeahead.js based auto-completion and Google-like instant search: [algoliasearch-django-example](https://github.com/algolia/algoliasearch-django-example).

  - Compatible with **Python 2.7** and **Python 3.4+**.
  - Supports **Django 1.7+**, **2.x** and **3.x**.



  ```sh
  pip install algoliasearch-django
  ```



  In your Django settings, add `algoliasearch_django` to `INSTALLED_APPS` and add these two settings:

  ```python
  ALGOLIA = {
      'APPLICATION_ID': 'MyAppID',
      'API_KEY': 'MyApiKey'
  }
  ```

  There are several optional settings:

  * `INDEX_PREFIX`: prefix all indices. Use it to separate different applications, like `site1_Products` and `site2_Products`.
  * `INDEX_SUFFIX`: suffix all indices. Use it to differentiate development and production environments, like `Location_dev` and `Location_prod`.
  * `AUTO_INDEXING`: automatically synchronize the models with Algolia (default to **True**).
  * `RAISE_EXCEPTIONS`: raise exceptions on network errors instead of logging them (default to **settings.DEBUG**).



  Create an `index.py` inside each application that contains the models you want to index.
  Inside this file, call `algoliasearch.register()` for each of the models you want to index:

  ```python


  import algoliasearch_django as algoliasearch

  from .models import YourModel

  algoliasearch.register(YourModel)
  ```

  By default, all the fields of your model will be used. You can configure the index by creating a subclass of `AlgoliaIndex` and using the `register` decorator:

  ```python


  from algoliasearch_django import AlgoliaIndex
  from algoliasearch_django.decorators import register

  from .models import YourModel

  @register(YourModel)
  class YourModelIndex(AlgoliaIndex):
      fields = ('name', 'date')
      geo_field = 'location'
      settings = {'searchableAttributes': ['name']}
      index_name = 'my_index'

  ```









  * `python manage.py algolia_reindex`: reindex all the registered models. This command will first send all the record to a temporary index and then moves it.
      * you can pass ``--model`` parameter to reindex a given model
  * `python manage.py algolia_applysettings`: (re)apply the index settings.
  * `python manage.py algolia_clearindex`: clear the index









  We recommend using our [InstantSearch.js library](https://www.algolia.com/doc/guides/building-search-ui/what-is-instantsearch/js/) to build your search
  interface and perform search queries directly from the end-user browser without going through your server.

  However, if you want to search from your backend you can use the `raw_search(YourModel, 'yourQuery', params)` method.
  It retrieves the raw JSON answer from the API, and accepts in `param` any
  [search parameters](https://www.algolia.com/doc/api-reference/search-api-parameters/).

  ```python
  from algoliasearch_django import raw_search

  params = { "hitsPerPage": 5 }
  response = raw_search(Contact, "jim", params)
  ```









  Use the `geo_field` attribute to localize your record. `geo_field` should be a callable that returns a tuple (latitude, longitude).

  ```python
  class Contact(models.model):
      name = models.CharField(max_length=20)
      lat = models.FloatField()
      lng = models.FloatField()

      def location(self):
          return (self.lat, self.lng)

  class ContactIndex(AlgoliaIndex):
      fields = 'name'
      geo_field = 'location'

  algoliasearch.register(Contact, ContactIndex)
  ```









  Use the `tags` attributes to add tags to your record. It can be a field or a callable.

  ```python
  class ArticleIndex(AlgoliaIndex):
      tags = 'category'
  ```

  At query time, specify `{ tagFilters: 'tagvalue' }` or `{ tagFilters: ['tagvalue1', 'tagvalue2'] }` as search parameters to restrict the result set to specific tags.









  You can choose which field will be used as the `objectID `. The field should be unique and can
      be a string or integer. By default, we use the `pk` field of the model.

  ```python
  class ArticleIndex(AlgoliaIndex):
      custom_objectID = 'post_id'
  ```



  You can customize the index name. By default, the index name will be the name of the model class.

  ```python
  class ContactIndex(algoliaindex):
      index_name = 'Enterprise'
  ```



  If you want to process a field before indexing it (e.g. capitalizing a `Contact`'s `name`),
  or if you want to index a [related object](https://docs.djangoproject.com/en/1.11/ref/models/relations/)'s
  attribute, you need to define **proxy methods** for these fields.



  ```python
  class Account(models.Model):
      username = models.CharField(max_length=40)
      service = models.CharField(max_length=40)

  class Contact(models.Model):
      name = models.CharField(max_length=40)
      email = models.EmailField(max_length=60)
      //...
      accounts = models.ManyToManyField(Account)

      def account_names(self):
          return [str(account) for account in self.accounts.all()]

      def account_ids(self):
          return [account.id for account in self.accounts.all()]
  ```



  ```python
  from algoliasearch_django import AlgoliaIndex

  class ContactIndex(AlgoliaIndex):
      fields = ('name', 'email', 'company', 'address', 'city', 'county',
                'state', 'zip_code', 'phone', 'fax', 'web', 'followers', 'account_names', 'account_ids')

      settings = {
          'searchableAttributes': ['name', 'email', 'company', 'city', 'county', 'account_names',
          }
  ```

  - With this configuration, you can search for a `Contact` using its `Account` names
  - You can use the associated `account_ids` at search-time to fetch more data from your
  model (you should **only proxy the fields relevant for search** to keep your records' size
  as small as possible)



  We provide many ways to configure your index allowing you to tune your overall index relevancy.
  All the configuration is explained on [our doc](https://www.algolia.com/doc/api-reference/api-parameters/).

  ```python
  class ArticleIndex(AlgoliaIndex):
      settings = {
          'searchableAttributes': ['name', 'description', 'url'],
          'customRanking': ['desc(vote_count)', 'asc(name)']
      }
  ```



  You can add constraints controlling if a record must be indexed or not. `should_index` should be a
  callable that returns a boolean.

  ```python
  class Contact(models.model):
      name = models.CharField(max_length=20)
      age = models.IntegerField()

      def is_adult(self):
          return (self.age >= 18)

  class ContactIndex(AlgoliaIndex):
      should_index = 'is_adult'
  ```



  It is possible to have several indices for a single model.

  - First, define all your indices that you want for a model:

  ```python
  from algoliasearch_django import AlgoliaIndex

  class MyModelIndex1(AlgoliaIndex):
      name = 'MyModelIndex1'
      ...

  class MyModelIndex2(AlgoliaIndex):
      name = 'MyModelIndex2'
      ...
  ```

  - Then, define a meta model which will aggregate those indices:

  ```python
  class MyModelMetaIndex(AlgoliaIndex):
      def __init__(self, model, client, settings):
          self.indices = [
              MyModelIndex1(model, client, settings),
              MyModelIndex2(model, client, settings),
          ]

      def raw_search(self, query='', params=None):
          res = {}
          for index in self.indices:
              res[index.name] = index.raw_search(query, params)
          return res

      def update_records(self, qs, batch_size=1000, **kwargs):
          for index in self.indices:
              index.update_records(qs, batch_size, **kwargs)

      def reindex_all(self, batch_size=1000):
          for index in self.indices:
              index.reindex_all(batch_size)

      def set_settings(self):
          for index in self.indices:
              index.set_settings()

      def clear_index(self):
          for index in self.indices:
              index.clear_index()

      def save_record(self, instance, update_fields=None, **kwargs):
          for index in self.indices:
              index.save_record(instance, update_fields, **kwargs)

      def delete_record(self, instance):
          for index in self.indices:
              index.delete_record(instance)
  ```

  - Finally, register this `AlgoliaIndex` with your `Model`:

  ```python
  import algoliasearch_django as algoliasearch
  algoliasearch.register(MyModel, MyModelMetaIndex)
  ```



  It is possible to temporarily disable the auto-indexing feature using the `disable_auto_indexing` context decorator:

  ```python
  from algoliasearch_django.decorators import disable_auto_indexing


  with disable_auto_indexing():
      MyModel.save()


  @disable_auto_indexing():
  my_method()


  with disable_auto_indexing(MyModel):
      MyModel.save()
      MyOtherModel.save()

  ```









  To run the tests, first find your Algolia application id and Admin API key (found on the Credentials page).

  ```shell
  ALGOLIA_APPLICATION_ID={APPLICATION_ID} ALGOLIA_API_KEY={ADMIN_API_KEY} tox
  ```


  To override settings for some tests, use the [settings method](https://docs.djangoproject.com/en/1.11/topics/testing/tools/#django.test.SimpleTestCase.settings):
  ```python
  class OverrideSettingsTestCase(TestCase):
      def setUp(self):
          with self.settings(ALGOLIA={
              'APPLICATION_ID': 'foo',
              'API_KEY': 'bar',
              'AUTO_INDEXING': False
          }):
              algolia_engine.reset(settings.ALGOLIA)

      def tearDown(self):
          algolia_engine.reset(settings.ALGOLIA)

      def test_foo():
          
  ```






  If you want to contribute to this project without installing all its dependencies, you can use our Docker image. Please check our [dedicated guide](DOCKER_README.md) to learn more.



  Encountering an issue? Before reaching out to support, we recommend heading to our [FAQ](https://www.algolia.com/doc/framework-integration/django/faq/) where you will find answers for the most common issues and gotchas with the package.


pkgId: dbb201c81b87eca6344a61c96acc468fd9bbf0d6c2af675b376ea5965625fbc4
name: python-algoliasearchasync
arch: src
version: 1.3.2
epoch: 0
release: 1
summary: Algolia Search Asyncronous API Client for Python
url: https://github.com/algolia/algoliasearch-client-python-async
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algoliasearchasync-1.3.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/algolia/algoliasearch-client-python-async.svg?token=NAo1YMSYUe1rsBFvhGmF&branch=master)](https://travis-ci.com/algolia/algoliasearch-client-python-async)
  [![PyPI version](https://badge.fury.io/py/algoliasearchasync.svg)](https://badge.fury.io/py/algoliasearchasync)
  [![Coverage Status](https://coveralls.io/repos/github/algolia/algoliasearch-client-python-async/badge.svg?branch=master)](https://coveralls.io/github/algolia/algoliasearch-client-python-async?branch=master)



  This package is designed to replace the
  [`algoliasearch`](https://github.com/algolia/algoliasearch-client-python)
  package in asynchronous environments.

  This package is only compatible with python 3.4 and onward.



  - Is compatible with python `asyncio`.

  - Provide asynchronous alternatives to most of the client methods.
    All those methods are just suffixed by `_async` (`search_async`,
    `add_object_async`, etc.)

  - Still provide synchronous versions of the methods.

  - Uses `aiohttp` as the HTTP underlying library.

  - Uses `__aexit__` to avoid manually closing `aiohttp` sessions with
    python >= 3.5.1.



  - Implement the `search_disjunctive_faceting` method.

  - Support task canceling (yet).



  Most of the logic of the synchronous client is being used here, so this
  client depends on the synchronous one. It also depends on `aiohttp`.

  To install this package: `pip install algoliasearchasync`.



  All the asynchronous functions have the same names as the synchronous ones
  with `_async` appended. Synchronous methods keep the same name.

  Arguments taken by the asynchronous functions are the same as the synchronous
  one, for documentation on the behavior of each function please see:

  - [Synchronous python client](https://github.com/algolia/algoliasearch-client-python)

  - [Algolia documentation](https://www.algolia.com/doc)



  With python >= 3.4

  ```python
  import asyncio
  from algoliasearchasync import ClientAsync


  @asyncio.coroutine
  def main(terms):
      client = ClientAsync('<APP_ID>', '<API_KEY>')
      index = client.init_index('<INDEX_NAME>')
      
      searches = [index.search_async(term) for term in terms]
      
      s = yield from asyncio.gather(*searches)
      
      yield from client.close()
      
      return s


  terms = ['<TERM2>', '<TERM2>']
  loop = asyncio.get_event_loop()

  complete = loop.run_until_complete(asyncio.gather(*searches))
  for term, search in zip(terms, complete):
      print('Results for: {}'.format(term))
      
      print('\n'.join([h['<FIELD>'] for h in search['hits']]))
  ```

  With python >= 3.5.1

  ```python
  import asyncio
  from algoliasearchasync import ClientAsync



  async def main(terms):
      
      async with ClientAsync('<APP_ID>', '<API_KEY>') as client:
          index = client.init_index('<INDEX_NAME>')
          
          searches = [index.search_async(term) for term in terms]
          
          return await asyncio.gather(*searches)


  terms = ['<TERM1>', '<TERM2>']
  loop = asyncio.get_event_loop()

  complete = loop.run_until_complete(main(terms))
  for term, search in zip(terms, complete):
      print('Results for {}'.format(term))
      
      print('\n'.join([h['<FIELD>'] for h in search['hits']]))
  ```


pkgId: 1143d0ed4f1af042378d9446b0ccbbb5272d966149e9ca522186949a358f5eba
name: python-algomock
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: A flexible input generator for algorithm testing
url: https://github.com/getCurrentThread/algomock
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algomock-0.2.0-1.src.rpm
checksum_type: sha256
description:
  AlgoMock is a flexible and powerful input generator for algorithm testing and competitive programming. It allows you to easily create mock input data for various algorithm problems, helping you test your solutions more efficiently.



  - Generate various types of input: integers, strings, arrays, and 2D arrays
  - Define input specifications using a simple and intuitive format
  - Reference previously generated values in your specifications
  - Customizable output format
  - Support for loops and repetition in input generation



  You can install AlgoMock using pip:

  ```
  pip install algomock
  ```



  Here's a simple example of how to use AlgoMock:

  ```python
  from algomock import generate_input

  spec = [
      {'type': 'int', 'limit': [1, 10], 'save_as': '$N'},  # N
      {'type': 'space'},
      {'type': 'int', 'limit': [1, 10], 'save_as': '$M'},  # M
      {'type': 'newline'},
      {'type': 'array', 'size': '$N', 'element_type': 'int', 'limit': [1, 100]},  # Array of size N
      {'type': 'newline'},
      {'type': '2d_array', 'rows': '$M', 'cols': '$N', 'element_type': 'int', 'limit': [0, 100]},  # 2D array of size M x N
  ]

  input_data = generate_input(spec)
  print(input_data)
  ```

  This will generate input data according to the specification and print it in a format suitable for most algorithm problems.



  AlgoMock uses a list of dictionaries to specify the input format. Each dictionary represents one element of the input. Below is a detailed explanation of each input type and how to use them.



  Generates a random integer within a specified range.

  **Parameters:**
  - `type`: Set to `'int'`
  - `limit`: A list of two integers `[min, max]` specifying the range (inclusive)
  - `save_as` (optional): A variable name to save the generated value for later reference

  **Example:**
  ```python
  {'type': 'int', 'limit': [1, 100], 'save_as': '$N'}
  ```
  This will generate a random integer between 1 and 100 (inclusive) and save it as `$N` for later reference.



  Generates an array of random integers.

  **Parameters:**
  - `type`: Set to `'array'`
  - `size`: The size of the array (can be a fixed number or a reference to a previously saved variable)
  - `element_type`: Currently only supports `'int'`
  - `limit`: A list of two integers `[min, max]` specifying the range for each element (inclusive)
  - `save_as` (optional): A variable name to save the generated array for later reference

  **Example:**
  ```python
  {'type': 'array', 'size': '$N', 'element_type': 'int', 'limit': [1, 1000], 'save_as': '$arr'}
  ```
  This will generate an array of `$N` integers, each between 1 and 1000, and save it as `$arr`.



  Generates a 2D array (matrix) of random integers.

  **Parameters:**
  - `type`: Set to `'2d_array'`
  - `rows`: The number of rows in the 2D array
  - `cols`: The number of columns in the 2D array
  - `element_type`: Currently only supports `'int'`
  - `limit`: A list of two integers `[min, max]` specifying the range for each element (inclusive)
  - `save_as` (optional): A variable name to save the generated 2D array for later reference

  **Example:**
  ```python
  {'type': '2d_array', 'rows': '$M', 'cols': '$N', 'element_type': 'int', 'limit': [0, 100], 'save_as': '$matrix'}
  ```
  This will generate a 2D array with `$M` rows and `$N` columns, filled with integers between 0 and 100, and save it as `$matrix`.



  Generates a random string of lowercase letters.

  **Parameters:**
  - `type`: Set to `'string'`
  - `length`: The length of the string (can be a fixed number or a reference to a previously saved variable)
  - `save_as` (optional): A variable name to save the generated string for later reference

  **Example:**
  ```python
  {'type': 'string', 'length': 10, 'save_as': '$str'}
  ```
  This will generate a random string of 10 lowercase letters and save it as `$str`.



  Inserts a newline character.

  **Parameters:**
  - `type`: Set to `'newline'`

  **Example:**
  ```python
  {'type': 'newline'}
  ```
  This will insert a newline character in the output.



  Inserts a single space character.

  **Parameters:**
  - `type`: Set to `'space'`

  **Example:**
  ```python
  {'type': 'space'}
  ```
  This will insert a single space character in the output.



  Repeats a specified character a given number of times.

  **Parameters:**
  - `type`: Set to `'repeat_char'`
  - `char`: The character to repeat
  - `count`: The number of times to repeat the character
  - `save_as` (optional): A variable name to save the generated string for later reference

  **Example:**
  ```python
  {'type': 'repeat_char', 'char': '*', 'count': '$N', 'save_as': '$stars'}
  ```
  This will repeat the `*` character `$N` times and save the result as `$stars`.



  Repeats a specified input type generation a given number of times.

  **Parameters:**
  - `type`: Set to `'repeat_type'`
  - `count`: The number of times to repeat the specified input type
  - `spec`: The specification of the input type to repeat
  - `save_as` (optional): A variable name to save the generated values for later reference

  **Example:**
  ```python
  {'type': 'repeat_type', 'count': '$M', 'spec': {'type': 'int', 'limit': [0, 9]}, 'save_as': '$digits'}
  ```
  This will generate `$M` random digits (0-9) and save them as `$digits`.



  Repeats a set of input specifications a specified number of times.

  **Parameters:**
  - `type`: Set to `'loop'`
  - `count`: The number of times to repeat the loop
  - `spec`: A list of input specifications to repeat
  - `save_as` (optional): A variable name to save the current loop index for use within the loop

  **Example:**
  ```python
  {'type': 'loop', 'count': '$T', 'save_as': '$test_case', 'spec': [
      {'type': 'int', 'limit': [1, 100], 'save_as': '$N'},
      {'type': 'space'},
      {'type': 'array', 'size': '$N', 'element_type': 'int', 'limit': [1, 1000]},
      {'type': 'newline'}
  ]}
  ```
  This will repeat the generation of an integer `$N`, a space, and an array of size `$N` for `$T` times, representing `$T` test cases.



  Here's a comprehensive example that demonstrates the use of various input types:

  ```python
  from algomock import InputGenerator

  spec = [
      {'type': 'int', 'limit': [1, 5], 'save_as': '$T'},  # Number of test cases
      {'type': 'newline'},
      {'type': 'loop', 'count': '$T', 'save_as': '$test_case', 'spec': [
          {'type': 'int', 'limit': [1, 10], 'save_as': '$N'},  # N
          {'type': 'space'},
          {'type': 'int', 'limit': [1, '$N'], 'save_as': '$M'},  # M, upper limit depends on N
          {'type': 'newline'},
          {'type': 'repeat_char', 'char': '*', 'count': '$N', 'save_as': '$stars'},  # Repeat '*' N times
          {'type': 'newline'},
          {'type': 'repeat_type', 'count': '$M', 'spec': {  # Repeat a random digit M times
              'type': 'int',
              'limit': [0, 9]
          }, 'save_as': '$digits'},
          {'type': 'newline'},
          {'type': 'array', 'size': '$N', 'limit': [1, 100], 'save_as': '$array'},  # Array of size N
          {'type': 'newline'},
          {'type': '2d_array', 'rows': '$M', 'cols': '$N', 'limit': [0, 100], 'save_as': '$matrix'},  # 2D array of size M x N
          {'type': 'newline'},
          {'type': 'string', 'length': '$M', 'save_as': '$str'},  # String of length M
          {'type': 'newline'},
          {'type': 'int', 'limit': [0, '$test_case'], 'save_as': '$index'},  # An integer between 0 and the current loop index
          {'type': 'newline'}
      ]}
  ]

  generator = InputGenerator()
  input_data = generator.generate_input(spec)
  print(input_data)
  ```

  This example generates multiple test cases, each with various types of input data, demonstrating the flexibility of AlgoMock.



  Contributions are welcome! Please feel free to submit a Pull Request.



  This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.


pkgId: b8a7c5e9e04a7258ad9a3dbdb6f1bb1f857aa2caa2e5754d4691c507c2f718d0
name: python-algomodule
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: CryptoCurrency Hashing Library
url: https://github.com/electrum-altcoin/AlgoLib
rpm_license: Proprietary
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algomodule-2.0.0-1.src.rpm
checksum_type: sha256
description:
  - Bcrypt (algomdule._bcrypt_hash)
  - BitBlock (algomodule._bitblock_hash)
  - Blake (algomodule._blake_hash)
  - Dcrypt (algomodule._dcrypt_hash)
  - Fresh (algomodule._fresh_hash)
  - Groestl (algomodule._groestl_hash)
  - Hefty1 (algomodule._hefty1_hash)
  - Jackpot (algomodule._jackpot_hash)
  - Keccak (algomodule._keccak_hash)
  - Scrypt (algomodule._ltc_scrypt)
  - Myriad Groestl (algomodule._mgroestl_hash)
  - NeoScrypt (algomodule._neoscrypt_hash)
  - Nist5 (algomodule._nist5_hash)
  - Quark (algomodule._quark_hash)
  - Qubit (algomodule._qubit_hash)
  - Sha1 (algomodule._sha1_hash)
  - Shavite3 (algomodule._shavite3_hash)
  - Skein (algomodule._skein_hash)
  - 3S (algomodule._threes_hash)
  - TWE (algomodule._twe_hash)
  - x11 (algomodule._x11_hash)
  - x13 (algomodule._x13_hash)
  - x14 (algomodule._x14_hash)
  - x15 (algomodule._x15_hash)
  - x17 (algomodule._x17_hash)
  - X16RV2 (algomodule._x16rv2_hash)


  Ahmed Bodiwala


  All hashing algorithms welcome either by requests or PR's


  - DGB: DQVEK4NVRMeLafP3whnUX7vM2ieedhu6T
  - LTC: LN128KQcBq545EEjmyWGCGDrQQkuAt4b6W
  - DOGE: DFAytXbSZ6HsMi1prKR1QRvC9rgS83zPqJ
  - BTC: 19Ckhmd7gKLXgwZfqgErkPgipzmuxVd3c9
  - BCH: qz0t72sr7mvewxc7t78chysaz0sj4drj2qjhl5xef6
  - NMC: NBUmzUR6Wz7B9FoHojjNkxv6iW7vpurbau
  - USDT(BEP-20): 0xce304642773c80793a46b9b13256e919f9653e12
  - ETH: 0xf1fd985F91a1E84B9285f446057BA9DDf92176c3
  - HMS: HHFXHfh6LaSYJchBzSCi1o1xD4EkhqrpyG
  - CAT: 9bTygmcJFJrNNTViV2RJSvPW2tdF99jCw1
  - FBX: fcC24C9mjz3SLqxdQe86gU2ism9gatT1gT
  - TLS: TweUAsEwfZTGyo4GA8tdEbC2pvxVqCYCX5


pkgId: 22bb67b5c496a5bc1ceaa28732c043922667ff4d4a80a0ca2ef1229fc36176c3
name: python-algophon
arch: src
version: 0.1.5
epoch: 0
release: 1
url: https://github.com/cbelth/algophon
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algophon-0.1.5-1.src.rpm
checksum_type: sha256
summary:
  Tools for an algorithmic approach to phonology (some useful to computational phonology and morphology more broadly)

description:
  **Code for working on computational phonology and morphology in Python.**

  This package is based on code developed by [Caleb Belth](https://cbelth.github.io/) during the course of his PhD; the title of his [dissertation](https://cbelth.github.io/public/assets/documents/belth_dissertation.pdf), *Towards an Algorithmic Account of Phonological Rules and Representations*, serves as the origin for the repository's name *algophon*.

  The package is under active development! The PyPI distribution and documentation are updated as the project progresses. The package includes:
  1. Handy tools for working with strings of phonological segments.
  2. Implementations of computational learning models.

  **Suggestions are welcome!**



  ```bash
  pip install algophon
  ```



  The code at the top level of the package provides some nice functionality for easily working with strings of phonological segments.

  The following examples assume you have imported the appropriate classes:

  ```pycon
  >>> from algophon import Seg, SegInv, SegStr, NatClass
  ```



  **A class to represent a phonological segment.**

  You are unlikely to be creating `Seg` objects yourself very often. They will usually be constructed internally by other parts of the package (in particular, see `SegInv` and `SegStr`). However, if you ever need to, creating a `Seg` object requires the following arguments:
  - `ipa`: a `str` IPA symbol
  - `features` (optional): a `dict` of features mapping to their corresponding values

  ```pycon
  >>> seg = Seg(ipa='i', features={'syl': '+', 'voi': '+', 'stri': '0'})
  ```

  What is important to know is how `Seg` objects behave, and why they are handy.

  <span style="color:green">**First**</span>, in the important respects `Seg` behaves like the `str` IPA segment used to create it.

  If you `print` a `Seg` object, it will print its IPA:

  ```pycon
  >>> print(seg)
  i
  ```

  If you compare a `Seg` object to a `str`, it will behave like it is the IPA symbol:

  ```pycon
  >>> print(seg == 'i')
  True
  >>> print(seg == 'e')
  False
  ```

  A `Seg` object hashes to the same value as its IPA symbol:

  ```pycon
  >>> print(len({seg, 'i'}))
  1
  >>> print('i' in {seg}, seg in {'i'})
  True True
  ```

  <span style="color:green">**Second**</span>, in the important respects `Seg` behaves like a feature bundle (see also the other classes, where other benefits will become clear).

  ```pycon
  >>> print(seg.features['syl'])
  +
  ```

  <span style="color:green">**Third**</span>, `Seg` handles IPA symbols that are longer than one Unicode char.

  ```pycon
  >>> tsh = Seg(ipa='t͡ʃ')
  >>> print(tsh)
  t͡ʃ
  >>> print(len(tsh))
  1
  >>> from algophon.symbols import LONG # see description of symbols below
  >>> long_i = Seg(ipa=f'i{LONG}')
  >>> print(long_i)
  iː
  >>> print(len(long_i))
  1
  ```



  **A class to represent an inventory of phonological segments (Seg objects).**

  A `SegInv` object is a collection of `Seg` objects. A `SegInv` requires no arguments to construct, though it provides two optional arguments:
  - `ipa_file_path`: a `str` pointing to a file of segment-feature mappings.
  - `sep`: a `str` specifying the column separator of the `ipa_file_path` file.

  By default, `SegInv` uses [Panphon](https://github.com/dmort27/panphon) (Mortensen et. al., 2016) features. The optional parameters allow you to use your own features. The file at `ipa_file_path` must be formatted like this:
  - The first row must be a header of feature names, separated by the `sep` (by default, `\t`)
  - The first column must contain the segment IPAs (the header row can have anything, e.g., `SEG`)
  - The remaining columns (non-first row) must contain the feature values.

  When a `SegInv` object is created, it is empty:

  ```pycon
  >>> seginv = SegInv()
  >>> seginv
  SegInv of size 0
  ```

  You can add segments by the `add`, `add_segments`, and `add_segments_by_str` methods:

  ```pycon
  >>> seginv.add('i')
  >>> print(seginv.segs)
  {i}
  >>> seginv.add_segs({'p', 'b', 't', 'd'})
  >>> print(seginv.segs)
  {b, t, d, i, p}
  >>> seginv.add_segs_by_str('eː n t j ə') # segments in str must be space-separated
  >>> print(seginv.segs)
  {b, t, d, i, j, n, p, ə, eː}
  ```

  The reason that `add_segs_by_str` requires the segments to be space-separated is because not all IPA symbols are only one char (e.g., `'eː'`). Moreover, this is consistent with the [Sigmorphon](https://github.com/sigmorphon) challenges data format commonly used in morphophonology tasks.

  These `add*` methods automatically create `Seg` objects and assign them `features` based on either Panphon (default) or the `ipa_file_path` file.

  ```pycon
  >>> print(seginv['eː'].features)
  {'syl': '+', 'son': '+', 'cons': '-', 'cont': '+', 'delrel': '-', 'lat': '-', 'nas': '-', 'strid': '0', 'voi': '+', 'sg': '-', 'cg': '-', 'ant': '0', 'cor': '-', 'distr': '0', 'lab': '-', 'hi': '-', 'lo': '-', 'back': '-', 'round': '-', 'velaric': '-', 'tense': '+', 'long': '+', 'hitone': '0', 'hireg': '0'}
  ```

  This also demonstrates that `seginv` operates like a dictionary in that you can retrieve and check the existence of segments by their IPA.

  ```pycon
  >>> 'eː' in seginv
  True
  ```



  **A class to represent a sequence of phonological segments (Seg objects).**

  The class `SegStr` allows for handling several tricky aspects of IPA sequences. It is common practice to represent strings of IPA sequences in a space-separated fashion such that, for example, [eːntjə] is represented `'eː n t j ə'`.

  Creating a `SegStr` object requires the following arguments:
    - `segs`: a collection of segments, which can be in any of the following formats:
      - str of IPA symbols, where each symbol is separated by a space ' ' (**most common**)
      - list of IPA symbols
      - list of Seg objects
    - `seginv`: a `SegInv` object

  ```pycon
  >>> seginv = SegInv() # init SegInv
  >>> seq = SegStr('eː n t j ə', seginv)
  >>> print(seq)
  eːntjə
  ```

  Creating the `SegStr` object automatically adds the segments in the object to the `SegInv` object.

  ```pycon
  >>> print(seginv.segs)
  {ə, t, n, j, eː}
  ```

  For clean visualization, `SegStr` displays the sequence of segments without spaces, as `print(seq)` shows above. But internally a `SegStr` object knows what the segments are:

  ```pycon
  >>> print(len(seq))
  5
  >>> seq[0]
  eː
  >>> type(seq[0]) # indexing returns a Seg object
  <class 'algophon.seg.Seg'>
  >>> seq[-2:]
  jə
  >>> type(seq[-2:]) # slicing returns a new SegStr object
  <class 'algophon.segstr.SegStr'>
  >>> seq[-2:] == 'j ə' # comparison to str objects works as expected
  True
  >>> seq[-2:] == 'ə n'
  False
  ```

  `SegStr` also implements equivalents of useful `str` methods.

  ```pycon
  >>> seq.endswith('j ə')
  True
  >>> dim_sufx = seq[-2:]
  >>> seq.endswith(dim_sufx)
  True
  >>> seq.startswith(seq[:-2])
  True
  ```

  A `SegStr` object hashes to the value of its (space-separated) string:

  ```pycon
  >>> len({seq, 'eː n t j ə'})
  1
  >>> seq in {'eː n t j ə'}
  True
  ```



  **A class to represent a Natural class, in the sense of sets of segments represented intensionally as conjunctions of features.**

  ```pycon
  >>> son = NatClass(feats={'+son'}, seginv=seginv)
  >>> son
  [+son]
  >>> 'ə' in son
  True
  >>> 'n' in son
  True
  >>> 't' in son
  False
  ```

  The class also allows you to get the natural class's extension and the extension's complement, relative to the `SegInv` (in our example, only `{ə, t, n, j, eː}` are in `seginv`):

  ```pycon
  >>> son.extension()
  {eː, j, ə, n}
  >>> son.extension_complement()
  {t}
  ```

  You can also retrieve an extension (complement) directly from a `SegInv` object without creating a `NatClass` obj:

  ```pycon
  >>> seginv.extension({'+syl'})
  {ə, eː}
  >>> seginv.extension_complement({'+syl'})
  {j, t, n}
  ```



  The `symbols` module (technically just a file...) contains a number of constant variables that store some useful symbols:

  ```python
  LWB = '⋊'
  RWB = '⋉'
  SYLB = '.'
  MORPHB = '-'
  BOUNDARIES = [LWB, RWB, SYLB, MORPHB]
  PRIMARY_STRESS = 'ˈ'
  SEC_STRESS = 'ˌ'
  LONG = 'ː'
  NASALIZED = '\u0303'  # ◌̃
  UNDERSPECIFIED = '0'
  UNK = '?'
  NEG = '¬'
  EMPTY = '_'
  FUNCTION_COMPOSITION = '∘'
  ```

  These can be accessed like this:

  ```pycon
  >>> from algophon.symbols import *
  >>> NASALIZED
  '̃'
  >>> f'i{LONG}'
  iː
  ```





  An implementation of the model "Distant to Local" from the following paper:

  ```bibtex
  @article{belth2024tiers,
      title={A Learning-Based Account of Phonological Tiers},
      author={Belth, Caleb},
      journal={Linguistic Inquiry},
      year={2024},
      publisher={MIT Press},
      url = {https://doi.org/10.1162/ling\_a\_00530},
  }
  ```

  Please see the models [README](https://github.com/cbelth/algophon/blob/main/algophon/models/README.md) for details.



  <span style="color:orange">[Work in Progress](https://github.com/cbelth/algophon/pull/5)</span>



  An implementation of the model "Meaning Informed Segmentation of Agglutinative Morphology" (Mɪᴀꜱᴇɢ) from the following paper:

  ```bibtex
  @inproceedings{belth2024miaseg,
    title={Meaning-Informed Low-Resource Segmentation of Agglutinative Morphology},
    author={Belth, Caleb},
    booktitle={Proceedings of the Society for Computation in Linguistics},
    year={2024}
  }
  ```

  Please see the models [README](https://github.com/cbelth/algophon/blob/main/algophon/models/README.md) for details.



  <span style="color:orange">Work in Progress</span>



  If you use this package in your research, you can use the following citation:

  ```bibtex
  @phdthesis{belth2023towards,
    title={{Towards an Algorithmic Account of Phonological Rules and Representations}},
    author={Belth, Caleb},
    year={2023},
    school={{University of Michigan}}
  }
  ```

  If you use one of the computational models, please cite the corresponding paper(s).



  - Mortensen, D. R., Littell, P., Bharadwaj, A., Goyal, K., Dyer, C., & Levin, L. (2016, December). Panphon: A resource for mapping IPA segments to articulatory feature vectors. In Proceedings of COLING 2016, the 26th International Conference on Computational Linguistics: Technical Papers (pp. 3475-3484).


pkgId: 4146003f17652d4a98ce4b9b3e68ac0b55e129e4d101ac82f835027cad750db1
name: python-algopy
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: ALGOPY: Taylor Arithmetic Computation and Algorithmic Differentiation
url: https://www.github.com/b45ch1/algopy
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algopy-0.7.2-1.src.rpm
checksum_type: sha256
description:
  Description:
      AlgoPy allows you to differentiate functions implemented as computer programs
      by using Algorithmic Differentiation (AD) techniques in the forward and
      reverse mode.
      The forward mode propagates univariate Taylor polynomials of arbitrary order.
      Hence it is also possible to use AlgoPy to evaluate higher-order derivative tensors.
      The reverse mode is also known as backpropagation and can be found in similar form in tools like PyTorch.
      Speciality of AlgoPy is the possibility to differentiate functions that contain
      matrix functions as +,-,*,/, dot, solve, qr, eigh, cholesky.
  Rationale:
      Many programs for scientific computing make use of numerical linear algebra.
      The defacto standard for array manipulations in Python is NumPy.
      AlgoPy allows you to write code that can either be evaluated by NumPy, or with
      AlgoPy with little or no modifications to your code.
      Note that this does not mean that any code you wrote can be differentiated with AlgoPy,
      but rather that you can write code that can be evaluated with or without AlgoPy.
  Documentation:
      Available at http://packages.python.org/algopy/
      For more documentation have a look at:
          1) the talks in the ./documentation folder
          2) the examples in the ./documentation/examples folder
          3) sphinx documenation ./documentation/sphinx and run `make`
  Example:
      Compute directional derivatives of the function f(J)::
          import numpy
          from algopy import UTPM, qr, solve, dot, eigh
          def f(x):
              N,M = x.shape
              Q,R = qr(x)
              Id = numpy.eye(M)
              Rinv = solve(R,Id)
              C = dot(Rinv,Rinv.T)
              l,U = eigh(C)
              return l[0]
          x = UTPM.init_jacobian(numpy.random.random((50,10)))
          y = f(x)
          J = UTPM.extract_jacobian(y)
          print 'Jacobian dy/dx =', J
  Installation:
      see http://packages.python.org/algopy/
  Features:
      Univariate Taylor Propagation:
          * Univariate Taylor Propagation on Matrices (UTPM)
            Implementation in: `algopy.utpm`
          * Exact Interpolation of Higher Order Derivative Tensors:
            (Hessians, etc.)
      Reverse Mode:
          ALGOPY also features functionality for convenient differentiation of a given
          algorithm. For that, the sequence of operation is recorded by tracing the
          evaluation of the algorithm. Implementation in: `./algopy/tracer.py`
  Testing:
      Uses numpy testing facilities. Simply run::
          $ python -c "import algopy; algopy.test()"
  Alternatives:
      There are nowadays many alternatives like `PYTORCH`_ which provide a more efficient way for backpropagation on CPU/GPUs.
      For AD in Python you can also have a look at
          * `PYADOLC`_ a Python wrapper for ADOL-C (C++)
          * `PYCPPAD`_ a Python wrapper for  CppAD (C++)
      However, their support for differentiation of Numerical Linear Algebra (NLA)
      functions is only very limited.
  Email:
      sebastian.walter@gmail.com
  How to cite AlgoPy::
      @article{Walter2011,
      title = "Algorithmic differentiation in Python with AlgoPy",
      journal = "Journal of Computational Science",
      volume = "",
      number = "0",
      pages = " - ",
      year = "2011",
      note = "",
      issn = "1877-7503",
      doi = "10.1016/j.jocs.2011.10.007",
      url = "http://www.sciencedirect.com/science/article/pii/S1877750311001013",
      author = "Sebastian F. Walter and Lutz Lehmann",
      keywords = "Automatic differentiation",
      keywords = "Cholesky decomposition",
      keywords = "Hierarchical approach",
      keywords = "Higher-order derivatives",
      keywords = "Numerical linear algebra",
      keywords = "NumPy",
      keywords = "Taylor arithmetic"


pkgId: 6517e36d35c775e91919be53c41936d7433f01bc11a0eb2558b2f8a7816de487
name: python-algorand-python
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: API for writing Algorand Python Smart contracts
url: https://pypi.org/project/algorand-python/
rpm_license: AGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algorand-python-2.3.0-1.src.rpm
checksum_type: sha256
description:
  The minimum supported Python version for writing Algorand Python smart contracts is 3.12.

  You can install the Algorand Python framework from PyPI into your project virtualenv:
  ```shell
  pip install algorand-python
  ```
  If you're using poetry for dependency and virutalenv management, you can add it that way with
  `poetry add algorand-python`.

  Once you have installed the Algorand Python framework, you can access the type definitions from the `algopy` module, e.g.
  ```python
  from algopy import Contract
  ```

  For more details on using this API and the puyapy compiler see https://algorandfoundation.github.io/puya/



  The Algorand Python API follows [semver](https://semver.org/) principles, however since the compiler is very closely
  coupled with the stubs definition, it's worth noting the interplay.


  An increase in the major version should only occur if existing contracts would fail to type-check
  after the update.

  Some examples of situations that might cause this:
  - Breaking changes to the signature of an existing function, such as a new parameter being added
    to an existing
    method and no default value is provided.
  - Something has been renamed, or moved such that the import path has changed (excluding moving
    between private modules, indicated with a leading underscore).
  - Something has been removed.

  The first two examples would necessitate changes in the compiler itself as well, which should
  also be considered breaking changes, thus there would be a coinciding new major version of the
  compiler.

  The third example may not necessitate a change to the compiler, although it probably would be
  likely there is one to remove the supporting code, but either way, since it will also change
  the behaviour in terms of what version range of the stubs is supported, should also result in a
  new major version of the compiler.

  However, vice versa is not necessarily true: a new major version of the compiler may not require
  a new major version of the stubs. For example:
  - Any breaking change to the compiler that has no changes in the stubs.
  - The default value of a parameter has changed. This changes the meaning of existing code that
    does not supply a default, thus requiring a major version bump of the compiler, but no
    existing contracts will fail to compile.


  When new functionality is added, the minor version should be bumped.

  Example situations:
  - A new high level API has been added.
  - A new parameter has been added to an existing method but a default value has been provided.
  - A new TEAL/AVM version has been released with new low-level op-codes that should be exposed.

  In each of these cases, there should be zero impact on whether existing contracts will compile
  or not. They all would also require a new compiler version to be released. Although the existing
  compiler version could continue to work with new stubs version, provided none of the new
  functionality is used, for simplicity the compiler should be updated to require the new stubs
  version as a minimum.


  When a bug in the stubs themselves is fixed, or a non-functional change is made (such as
  changes to docstrings / documentation), the patch version should be bumped.

  Examples:
  - Docstrings added/removed/updated.
  - Type parameters that were incorrectly specified are fixed
    ([concrete example](https://github.com/algorandfoundation/puya/issues/191)).
  - Adding something that was unintentionally omitted from the stubs, but is otherwise supported by
    the current compiler.
    Generally in these cases, the code would compile if a `# type: ignore[<error-code>]` was added
    ([concrete example](https://github.com/algorandfoundation/puya/issues/200)).

  In each of these cases, the new stubs should functional correctly when paired with the current
  release of the compiler.

  The second example is a slight break from semver principles, since this is not backwards
  compatible, as existing contracts may fail to compile. However, those contracts should not have
  compiled in the first place. The minimum version of stubs supported by the compiler should be
  increased to this new patch release, however this will only take effect on the next release of the
  compiler itself. The current compiler release would detect the new stubs version as supported
  though, and so users can update to that new version of the stubs once it is released.


pkgId: 4556fb4dd8dea0852136826471f9c0316378e2b892d118aa4c94acbdbcaf2e45
name: python-algorithmia-adk
arch: src
version: 1.2.4
epoch: 0
release: 1
summary: Algorithmia Python ADK client
url: http://github.com/algorithmiaio/algorithmia-adk-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algorithmia-adk-1.2.4-1.src.rpm
checksum_type: sha256
description:
  Algorithm Development Kit code used for creating Python algorithms on Algorithmia. Used by the Algorithmia client


pkgId: e58b7131536a794231c268a665336663e88f5387f7e08f3e847dd83c18546eaf
name: python-algorithms
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Pythonic Data Structures and Algorithms
url: https://github.com/keon/algorithms
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algorithms-0.1.4-1.src.rpm
checksum_type: sha256
description:
  Minimal and clean example implementations of data structures and algorithms in Python 3.

  Thanks for your interest in contributing! There are many ways to contribute to this project. [Get started here](CONTRIBUTING.md)


  For running all tests write down:
      $ python3 -m unittest discover tests
  For running some specific tests you can do this as following (Ex: sort):
      $ python3 -m unittest tests.test_sort

  For running all tests write down:
      $ python3 -m pytest tests

  If you want to use the API algorithms in your code, it is as simple as:
      $ pip3 install algorithms
  You can test by creating a python file: (Ex: use `merge_sort` in `sort`)
  ```python3
  from algorithms.sort import merge_sort
  if __name__ == "__main__":
      my_list = [1, 8, 3, 5, 6]
      my_list = merge_sort(my_list)
      print(my_list)
  ```

  If you want to uninstall algorithms, it is as simple as:
      $ pip3 uninstall -y algorithms

  - [arrays](algorithms/arrays)
      - [delete_nth](algorithms/arrays/delete_nth.py)
      - [flatten](algorithms/arrays/flatten.py)
      - [garage](algorithms/arrays/garage.py)
      - [josephus_problem](algorithms/arrays/josephus.py)
      - [limit](algorithms/arrays/limit.py)
      - [longest_non_repeat](algorithms/arrays/longest_non_repeat.py/)
      - [max_ones_index](algorithms/arrays/max_ones_index.py)
      - [merge_intervals](algorithms/arrays/merge_intervals.py)
      - [missing_ranges](algorithms/arrays/missing_ranges.py)
      - [plus_one](algorithms/arrays/plus_one.py)
      - [rotate](algorithms/arrays/rotate.py)
      - [summarize_ranges](algorithms/arrays/summarize_ranges.py)
      - [three_sum](algorithms/arrays/three_sum.py)
      - [trimmean](algorithms/arrays/trimmean.py)
      - [top_1](algorithms/arrays/top_1.py)
      - [two_sum](algorithms/arrays/two_sum.py)
      - [move_zeros](algorithms/arrays/move_zeros.py)
      - [n_sum](algorithms/arrays/n_sum.py)
  - [automata](algorithms/automata)
      - [DFA](algorithms/automata/dfa.py)
  - [backtrack](algorithms/backtrack)
      - [general_solution.md](algorithms/backtrack/)
      - [add_operators](algorithms/backtrack/add_operators.py)
      - [anagram](algorithms/backtrack/anagram.py)
      - [array_sum_combinations](algorithms/backtrack/array_sum_combinations.py)
      - [combination_sum](algorithms/backtrack/combination_sum.py)
      - [factor_combinations](algorithms/backtrack/factor_combinations.py)
      - [generate_abbreviations](algorithms/backtrack/generate_abbreviations.py)
      - [generate_parenthesis](algorithms/backtrack/generate_parenthesis.py)
      - [letter_combination](algorithms/backtrack/letter_combination.py)
      - [palindrome_partitioning](algorithms/backtrack/palindrome_partitioning.py)
      - [pattern_match](algorithms/backtrack/pattern_match.py)
      - [permute](algorithms/backtrack/permute.py)
      - [permute_unique](algorithms/backtrack/permute_unique.py)
      - [subsets](algorithms/backtrack/subsets.py)
      - [subsets_unique](algorithms/backtrack/subsets_unique.py)
  - [bfs](algorithms/bfs)
      - [maze_search](algorithms/bfs/maze_search.py)
      - [shortest_distance_from_all_buildings](algorithms/bfs/shortest_distance_from_all_buildings.py)
      - [word_ladder](algorithms/bfs/word_ladder.py)
  - [bit](algorithms/bit)
      - [add_bitwise_operator](algorithms/bit/add_bitwise_operator.py)
      - [bit_operation](algorithms/bit/bit_operation.py)
      - [bytes_int_conversion](algorithms/bit/bytes_int_conversion.py)
      - [count_flips_to_convert](algorithms/bit/count_flips_to_convert.py)
      - [count_ones](algorithms/bit/count_ones.py)
      - [find_difference](algorithms/bit/find_difference.py)
      - [find_missing_number](algorithms/bit/find_missing_number.py)
      - [flip_bit_longest_sequence](algorithms/bit/flip_bit_longest_sequence.py)
      - [power_of_two](algorithms/bit/power_of_two.py)
      - [reverse_bits](algorithms/bit/reverse_bits.py)
      - [single_number](algorithms/bit/single_number.py)
      - [single_number2](algorithms/bit/single_number2.py)
      - [single_number3](algorithms/bit/single_number3.py)
      - [subsets](algorithms/bit/subsets.py)
      - [swap_pair](algorithms/bit/swap_pair.py)
      - [has_alternative_bit](algorithms/bit/has_alternative_bit.py)
      - [insert_bit](algorithms/bit/insert_bit.py)
      - [remove_bit](algorithms/bit/remove_bit.py)
      - [binary_gap](algorithms/bit/binary_gap.py)
  - [compression](algorithms/compression)
      - [huffman_coding](algorithms/compression/huffman_coding.py)
      - [rle_compression](algorithms/compression/rle_compression.py)
      - [elias](algorithms/compression/elias.py)
  - [dfs](algorithms/dfs)
      - [all_factors](algorithms/dfs/all_factors.py)
      - [count_islands](algorithms/dfs/count_islands.py)
      - [pacific_atlantic](algorithms/dfs/pacific_atlantic.py)
      - [sudoku_solver](algorithms/dfs/sudoku_solver.py)
      - [walls_and_gates](algorithms/dfs/walls_and_gates.py)
  - [distribution](algorithms/distribution)
      - [histogram](algorithms/distribution/histogram.py)
  - [dp](algorithms/dp)
      - [buy_sell_stock](algorithms/dp/buy_sell_stock.py)
      - [climbing_stairs](algorithms/dp/climbing_stairs.py)
      - [coin_change](algorithms/dp/coin_change.py)
      - [combination_sum](algorithms/dp/combination_sum.py)
      - [egg_drop](algorithms/dp/egg_drop.py)
      - [house_robber](algorithms/dp/house_robber.py)
      - [int_divide](algorithms/dp/int_divide.py)
      - [job_scheduling](algorithms/dp/job_scheduling.py)
      - [knapsack](algorithms/dp/knapsack.py)
      - [longest_increasing](algorithms/dp/longest_increasing.py)
      - [matrix_chain_order](algorithms/dp/matrix_chain_order.py)
      - [max_product_subarray](algorithms/dp/max_product_subarray.py)
      - [max_subarray](algorithms/dp/max_subarray.py)
      - [min_cost_path](algorithms/dp/min_cost_path.py)
      - [num_decodings](algorithms/dp/num_decodings.py)
      - [regex_matching](algorithms/dp/regex_matching.py)
      - [rod_cut](algorithms/dp/rod_cut.py)
      - [word_break](algorithms/dp/word_break.py)
      - [fibonacci](algorithms/dp/fib.py)
  	- [hosoya triangle](algorithms/dp/hosoya_triangle.py)
  - [graph](algorithms/graph)
      - [check_bipartite](algorithms/graph/check_bipartite.py)
      - [strongly_connected](algorithms/graph/check_digraph_strongly_connected.py)
      - [clone_graph](algorithms/graph/clone_graph.py)
      - [cycle_detection](algorithms/graph/cycle_detection.py)
      - [find_all_cliques](algorithms/graph/find_all_cliques.py)
      - [find_path](algorithms/graph/find_path.py)
      - [graph](algorithms/graph/graph.py)
      - [dijkstra](algorithms/graph/dijkstra.py)
      - [markov_chain](algorithms/graph/markov_chain.py)
      - [minimum_spanning_tree](algorithms/graph/minimum_spanning_tree.py)
      - [satisfiability](algorithms/graph/satisfiability.py)
      - [minimum_spanning_tree_prims](algorithms/graph/prims_minimum_spanning.py)
      - [tarjan](algorithms/graph/tarjan.py)
      - [traversal](algorithms/graph/traversal.py)
  	  - [maximum_flow](algorithms/graph/maximum_flow.py)
      - [maximum_flow_bfs](algorithms/graph/maximum_flow_bfs.py)
      - [maximum_flow_dfs](algorithms/graph/maximum_flow_dfs.py)
      - [all_pairs_shortest_path](algorithms/graph/all_pairs_shortest_path.py)
      - [bellman_ford](algorithms/graph/bellman_ford.py)
      - [Count Connected Components](algorithms/graph/count_connected_number_of_component.py)
  - [heap](algorithms/heap)
      - [merge_sorted_k_lists](algorithms/heap/merge_sorted_k_lists.py)
      - [skyline](algorithms/heap/skyline.py)
      - [sliding_window_max](algorithms/heap/sliding_window_max.py)
      - [binary_heap](algorithms/heap/binary_heap.py)
      - [k_closest_points](algorithms/heap/k_closest_points.py)
  - [linkedlist](algorithms/linkedlist)
      - [add_two_numbers](algorithms/linkedlist/add_two_numbers.py)
      - [copy_random_pointer](algorithms/linkedlist/copy_random_pointer.py)
      - [delete_node](algorithms/linkedlist/delete_node.py)
      - [first_cyclic_node](algorithms/linkedlist/first_cyclic_node.py)
      - [is_cyclic](algorithms/linkedlist/is_cyclic.py)
      - [is_palindrome](algorithms/linkedlist/is_palindrome.py)
      - [kth_to_last](algorithms/linkedlist/kth_to_last.py)
      - [linkedlist](algorithms/linkedlist/linkedlist.py)
      - [remove_duplicates](algorithms/linkedlist/remove_duplicates.py)
      - [reverse](algorithms/linkedlist/reverse.py)
      - [rotate_list](algorithms/linkedlist/rotate_list.py)
      - [swap_in_pairs](algorithms/linkedlist/swap_in_pairs.py)
      - [is_sorted](algorithms/linkedlist/is_sorted.py)
      - [remove_range](algorithms/linkedlist/remove_range.py)
  - [map](algorithms/map)
      - [hashtable](algorithms/map/hashtable.py)
      - [separate_chaining_hashtable](algorithms/map/separate_chaining_hashtable.py)
      - [longest_common_subsequence](algorithms/map/longest_common_subsequence.py)
      - [randomized_set](algorithms/map/randomized_set.py)
      - [valid_sudoku](algorithms/map/valid_sudoku.py)
      - [word_pattern](algorithms/map/word_pattern.py)
      - [is_isomorphic](algorithms/map/is_isomorphic.py)
      - [is_anagram](algorithms/map/is_anagram.py)
  - [maths](algorithms/maths)
      - [power](algorithms/maths/power.py)
      - [base_conversion](algorithms/maths/base_conversion.py)
      - [combination](algorithms/maths/combination.py)
      - [cosine_similarity](algorithms/maths/cosine_similarity.py)
      - [decimal_to_binary_ip](algorithms/maths/decimal_to_binary_ip.py)
      - [euler_totient](algorithms/maths/euler_totient.py)
      - [extended_gcd](algorithms/maths/extended_gcd.py)
      - [factorial](algorithms/maths/factorial.py)
      - [gcd/lcm](algorithms/maths/gcd.py)
      - [generate_strobogrammtic](algorithms/maths/generate_strobogrammtic.py)
      - [is_strobogrammatic](algorithms/maths/is_strobogrammatic.py)
      - [modular_exponential](algorithms/maths/modular_exponential.py)
      - [next_bigger](algorithms/maths/next_bigger.py)
      - [next_perfect_square](algorithms/maths/next_perfect_square.py)
      - [nth_digit](algorithms/maths/nth_digit.py)
      - [prime_check](algorithms/maths/prime_check.py)
      - [primes_sieve_of_eratosthenes](algorithms/maths/primes_sieve_of_eratosthenes.py)
      - [pythagoras](algorithms/maths/pythagoras.py)
      - [rabin_miller](algorithms/maths/rabin_miller.py)
      - [rsa](algorithms/maths/rsa.py)
      - [sqrt_precision_factor](algorithms/maths/sqrt_precision_factor.py)
      - [summing_digits](algorithms/maths/summing_digits.py)
      - [hailstone](algorithms/maths/hailstone.py)
      - [recursive_binomial_coefficient](algorithms/maths/recursive_binomial_coefficient.py)
      - [find_order](algorithms/maths/find_order_simple.py)
  	- [find_primitive_root](algorithms/maths/find_primitive_root_simple.py)
  	- [diffie_hellman_key_exchange](algorithms/maths/diffie_hellman_key_exchange.py)
  - [matrix](algorithms/matrix)
      - [sudoku_validator](algorithms/matrix/sudoku_validator.py)
      - [bomb_enemy](algorithms/matrix/bomb_enemy.py)
      - [copy_transform](algorithms/matrix/copy_transform.py)
      - [count_paths](algorithms/matrix/count_paths.py)
      - [matrix_exponentiation](algorithms/matrix/matrix_exponentiation.py)
      - [matrix_inversion](algorithms/matrix/matrix_inversion.py)
      - [matrix_multiplication](algorithms/matrix/multiply.py)
      - [rotate_image](algorithms/matrix/rotate_image.py)
      - [search_in_sorted_matrix](algorithms/matrix/search_in_sorted_matrix.py)
      - [sparse_dot_vector](algorithms/matrix/sparse_dot_vector.py)
      - [sparse_mul](algorithms/matrix/sparse_mul.py)
      - [spiral_traversal](algorithms/matrix/spiral_traversal.py)
  	- [crout_matrix_decomposition](algorithms/matrix/crout_matrix_decomposition.py)
  	- [cholesky_matrix_decomposition](algorithms/matrix/cholesky_matrix_decomposition.py)
      - [sum_sub_squares](algorithms/matrix/sum_sub_squares.py)
  - [queues](algorithms/queues)
      - [max_sliding_window](algorithms/queues/max_sliding_window.py)
      - [moving_average](algorithms/queues/moving_average.py)
      - [queue](algorithms/queues/queue.py)
      - [reconstruct_queue](algorithms/queues/reconstruct_queue.py)
      - [zigzagiterator](algorithms/queues/zigzagiterator.py)
  - [search](algorithms/search)
      - [binary_search](algorithms/search/binary_search.py)
      - [first_occurrence](algorithms/search/first_occurrence.py)
      - [last_occurrence](algorithms/search/last_occurrence.py)
      - [linear_search](algorithms/search/linear_search.py)
      - [search_insert](algorithms/search/search_insert.py)
      - [two_sum](algorithms/search/two_sum.py)
      - [search_range](algorithms/search/search_range.py)
      - [find_min_rotate](algorithms/search/find_min_rotate.py)
      - [search_rotate](algorithms/search/search_rotate.py)
      - [jump_search](algorithms/search/jump_search.py)
      - [next_greatest_letter](algorithms/search/next_greatest_letter.py)
      - [interpolation_search](algorithms/search/interpolation_search.py)
  - [set](algorithms/set)
      - [randomized_set](algorithms/set/randomized_set.py)
      - [set_covering](algorithms/set/set_covering.py)
      - [find_keyboard_row](algorithms/set/find_keyboard_row.py)
  - [sort](algorithms/sort)
      - [bitonic_sort](algorithms/sort/bitonic_sort.py)
      - [bogo_sort](algorithms/sort/bogo_sort.py)
      - [bubble_sort](algorithms/sort/bubble_sort.py)
      - [bucket_sort](algorithms/sort/bucket_sort.py)
      - [cocktail_shaker_sort](algorithms/sort/cocktail_shaker_sort.py)
      - [comb_sort](algorithms/sort/comb_sort.py)
      - [counting_sort](algorithms/sort/counting_sort.py)
      - [cycle_sort](algorithms/sort/cycle_sort.py)
      - [gnome_sort](algorithms/sort/gnome_sort.py)
      - [heap_sort](algorithms/sort/heap_sort.py)
      - [insertion_sort](algorithms/sort/insertion_sort.py)
      - [meeting_rooms](algorithms/sort/meeting_rooms.py)
      - [merge_sort](algorithms/sort/merge_sort.py)
      - [pancake_sort](algorithms/sort/pancake_sort.py)
      - [pigeonhole_sort](algorithms/sort/pigeonhole_sort.py)
      - [quick_sort](algorithms/sort/quick_sort.py)
      - [radix_sort](algorithms/sort/radix_sort.py)
      - [selection_sort](algorithms/sort/selection_sort.py)
      - [shell_sort](algorithms/sort/shell_sort.py)
      - [sort_colors](algorithms/sort/sort_colors.py)
      - [stooge_sort](algorithms/sort/stooge_sort.py)
      - [top_sort](algorithms/sort/top_sort.py)
      - [wiggle_sort](algorithms/sort/wiggle_sort.py)
  - [stack](algorithms/stack)
      - [longest_abs_path](algorithms/stack/longest_abs_path.py)
      - [simplify_path](algorithms/stack/simplify_path.py)
      - [stack](algorithms/stack/stack.py)
      - [valid_parenthesis](algorithms/stack/valid_parenthesis.py)
      - [stutter](algorithms/stack/stutter.py)
      - [switch_pairs](algorithms/stack/switch_pairs.py)
      - [is_consecutive](algorithms/stack/is_consecutive.py)
      - [remove_min](algorithms/stack/remove_min.py)
      - [is_sorted](algorithms/stack/is_sorted.py)
  - [strings](algorithms/strings)
      - [fizzbuzz](algorithms/strings/fizzbuzz.py)
      - [delete_reoccurring](algorithms/strings/delete_reoccurring.py)
      - [strip_url_params](algorithms/strings/strip_url_params.py)
      - [validate_coordinates](algorithms/strings/validate_coordinates.py)
      - [domain_extractor](algorithms/strings/domain_extractor.py)
      - [merge_string_checker](algorithms/strings/merge_string_checker.py)
      - [add_binary](algorithms/strings/add_binary.py)
      - [breaking_bad](algorithms/strings/breaking_bad.py)
      - [decode_string](algorithms/strings/decode_string.py)
      - [encode_decode](algorithms/strings/encode_decode.py)
      - [group_anagrams](algorithms/strings/group_anagrams.py)
      - [int_to_roman](algorithms/strings/int_to_roman.py)
      - [is_palindrome](algorithms/strings/is_palindrome.py)
      - [license_number](algorithms/strings/license_number.py)
      - [make_sentence](algorithms/strings/make_sentence.py)
      - [multiply_strings](algorithms/strings/multiply_strings.py)
      - [one_edit_distance](algorithms/strings/one_edit_distance.py)
      - [rabin_karp](algorithms/strings/rabin_karp.py)
      - [reverse_string](algorithms/strings/reverse_string.py)
      - [reverse_vowel](algorithms/strings/reverse_vowel.py)
      - [reverse_words](algorithms/strings/reverse_words.py)
      - [roman_to_int](algorithms/strings/roman_to_int.py)
      - [word_squares](algorithms/strings/word_squares.py)
      - [unique_morse](algorithms/strings/unique_morse.py)
      - [judge_circle](algorithms/strings/judge_circle.py)
      - [strong_password](algorithms/strings/strong_password.py)
      - [caesar_cipher](algorithms/strings/caesar_cipher.py)
      - [check_pangram](algorithms/strings/check_pangram.py)
      - [contain_string](algorithms/strings/contain_string.py)
      - [count_binary_substring](algorithms/strings/count_binary_substring.py)
      - [repeat_string](algorithms/strings/repeat_string.py)
      - [min_distance](algorithms/strings/min_distance.py)
      - [longest_common_prefix](algorithms/strings/longest_common_prefix.py)
      - [rotate](algorithms/strings/rotate.py)
      - [first_unique_char](algorithms/strings/first_unique_char.py)
      - [repeat_substring](algorithms/strings/repeat_substring.py)
  	  - [atbash_cipher](algorithms/strings/atbash_cipher.py)
      - [longest_palindromic_substring](algorithms/strings/longest_palindromic_substring.py)
    	- [knuth_morris_pratt](algorithms/strings/knuth_morris_pratt.py)
  - [tree](algorithms/tree)
      - [bst](algorithms/tree/bst)
          - [array_to_bst](algorithms/tree/bst/array_to_bst.py)
          - [bst_closest_value](algorithms/tree/bst/bst_closest_value.py)
          - [BSTIterator](algorithms/tree/bst/BSTIterator.py)
          - [delete_node](algorithms/tree/bst/delete_node.py)
          - [is_bst](algorithms/tree/bst/is_bst.py)
          - [kth_smallest](algorithms/tree/bst/kth_smallest.py)
          - [lowest_common_ancestor](algorithms/tree/bst/lowest_common_ancestor.py)
          - [predecessor](algorithms/tree/bst/predecessor.py)
          - [serialize_deserialize](algorithms/tree/bst/serialize_deserialize.py)
          - [successor](algorithms/tree/bst/successor.py)
          - [unique_bst](algorithms/tree/bst/unique_bst.py)
          - [depth_sum](algorithms/tree/bst/depth_sum.py)
          - [count_left_node](algorithms/tree/bst/count_left_node.py)
          - [num_empty](algorithms/tree/bst/num_empty.py)
          - [height](algorithms/tree/bst/height.py)
      - [red_black_tree](algorithms/tree/red_black_tree)
          - [red_black_tree](algorithms/tree/red_black_tree/red_black_tree.py)
      - [segment_tree](algorithms/tree/segment_tree)
          - [segment_tree](algorithms/tree/segment_tree/segment_tree.py)
          - [iterative_segment_tree](algorithms/tree/segment_tree/iterative_segment_tree.py)
      - [traversal](algorithms/tree/traversal)
          - [inorder](algorithms/tree/traversal/inorder.py)
          - [level_order](algorithms/tree/traversal/level_order.py)
          - [postorder](algorithms/tree/traversal/postorder.py)
          - [preorder](algorithms/tree/traversal/preorder.py)
          - [zigzag](algorithms/tree/traversal/zigzag.py)
      - [trie](algorithms/tree/trie)
          - [add_and_search](algorithms/tree/trie/add_and_search.py)
          - [trie](algorithms/tree/trie/trie.py)
      - [b_tree](algorithms/tree/b_tree.py)
      - [binary_tree_paths](algorithms/tree/binary_tree_paths.py)
      - [bin_tree_to_list](algorithms/tree/bin_tree_to_list.py)
      - [deepest_left](algorithms/tree/deepest_left.py)
      - [invert_tree](algorithms/tree/invert_tree.py)
      - [is_balanced](algorithms/tree/is_balanced.py)
      - [is_subtree](algorithms/tree/is_subtree.py)
      - [is_symmetric](algorithms/tree/is_symmetric.py)
      - [longest_consecutive](algorithms/tree/longest_consecutive.py)
      - [lowest_common_ancestor](algorithms/tree/lowest_common_ancestor.py)
      - [max_height](algorithms/tree/max_height.py)
      - [max_path_sum](algorithms/tree/max_path_sum.py)
      - [min_height](algorithms/tree/min_height.py)
      - [path_sum](algorithms/tree/path_sum.py)
      - [path_sum2](algorithms/tree/path_sum2.py)
      - [pretty_print](algorithms/tree/pretty_print.py)
      - [same_tree](algorithms/tree/same_tree.py)
      - [tree](algorithms/tree/tree.py)
  - [unix](algorithms/unix)
      - [path](algorithms/unix/path/)
          - [join_with_slash](algorithms/unix/path/join_with_slash.py)
          - [full_path](algorithms/unix/path/full_path.py)
          - [split](algorithms/unix/path/split.py)
          - [simplify_path](algorithms/unix/path/simplify_path.py)
  - [unionfind](algorithms/unionfind)
      - [count_islands](algorithms/unionfind/count_islands.py)

  Thanks to [all the contributors](https://github.com/keon/algorithms/graphs/contributors)
  who helped in building the repo.


pkgId: 77e30133677736053071ba4cfcf1edf5bb65a24e7c34135b9440c852ad5ccaa0
name: python-algospace
arch: src
version: 0.4.13
epoch: 0
release: 1
summary: AlgoSpace: A platform for displaying and using algorithm achievements
url: https://algospace.top
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algospace-0.4.13-1.src.rpm
checksum_type: sha256
description:
  > 最保密、最快速的发布方式

  > ⚡️⚡️⚡️ 一分钟极速发布 ⚡️⚡️⚡️



  👉 任何可以上网的计算机

  👉 可以跑通的算法

  👉 `Python>=3.7`



  例如：

  ```Python
  def landmark_detection(image_path):
      '''
      人脸关键点标注
      args:
          image_path: 本地图片路径
      '''
      
      return {
          'output_image_path': output_image_path,  # 带关键点标注的本地图片路径
          'dets': dets,                            # 目标图像检测的人脸坐标点
      }
  ```



  在算法所用 Python 环境的命令行执行：

  ```Bash
  pip install algospace -i https://pypi.python.org/simple
  ```



  进入算法根目录，命令行执行：

  ```Bash
  algospace init
  ```

  > `algospace` 命令也可以简写为 `asc`

  执行后在当前目录下生成 `algospace-config.py` 配置文件。



  根据 `algospace-config.py` 中的注释信息，填写第一步准备完成的预测函数的信息。

  例如第一步预测函数的配置信息应当填写为：

  ```Python
  service_filepath = './main.py'
  service_function = 'landmark_detection'
  service_input = {
      'image_path': {
          'type': 'image_path',
          'describe': '人脸图片',
      }
  }
  service_output = {
      'output_image_path': {
          'type': 'image_path',
          'describe': '带标注点的人脸图片'
      },
      'dets': {
          'type': 'str',
          'describe': '目标图像检测的人脸坐标点'
      }
  }
  ```



  进入算法根目录，命令行执行：

  ```Bash
  algospace start
  ```

  也可以挂在后台运行：

  ```Bash
  nohup algospace start > ./algospace.log 2>&1 &
  ```



  **🎉 算法将会自动注册、运行、发布。**

  **🎉 稍等片刻后即可在「我的算法」页面中查看新增的算法。**


pkgId: dd182ab7913fc7ca22b2f62a6ba0385011cde7a402b15bdd29354477c1e0ed4b
name: python-algosto
arch: src
version: 0.0.15
epoch: 0
release: 1
summary: Algosto implements stochastic algorithms.
url: https://github.com/Melvin-klein/algosto
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algosto-0.0.15-1.src.rpm
checksum_type: sha256
description:
  Algosto, from the concatenation of french words *Algorithmes Stochastiques (/al.ɡo.ʁitm stɔ.kas.tik/)*,
  is a Python package built on top of *NumPy* that provides implementations of various stochastic algorithms.

  The full documentation is available [here](https://www.algosto.dev).



  You can install Algosto with:

      pip install algosto



  This section shows an example on how Algosto works by applying the
  stochastic gradient descent algorithm (SGD) to a quadratic function.



  The basic workflow needs four elements :

  **An objective function :** This is the function we want to minimize.
      It is a Python function that takes a numpy matrix `(n, d)`,
      where `n` is the number of points to handle and `d` is the dimension of points,
      and returns a result vector of length `n`.

  **A constraint :** It is an object that defines the space in which the solver will optimize the function.
      Obviously, the objective function needs to be defined on this space.

  **A solver :** In Algosto, solvers are always classes that need an objective function and a constraint to be instanciated.
      Simply call the `fit` method to minimize the objective on the constraint.

  **A plot :** Algosto provides some functions to plot most used graph.
      You can build your own graph using *Matplotlib* or *Plotly*.



  Based on the workflow given just before, we start by defining the quadratic objective function
  and its gradient in order to use the SGD.

      import numpy as np

      def objective(x: np.array) -> float :
          return np.sum(x**2, axis=1)

      def grad(x: np.array) -> float :
          return 2*x

  > [!WARNING]
  > As said before, objective functions and gradients need to be able to process multiple points simultaneously to work with Algosto.
  > Specifically, if the function operates on points of dimension `d`, it should accept a numpy array with shape `(n, d)`
  > and returns a numpy array of length `n`, where `n` is the number of points provided to the objective function or gradient.

  Algosto provides some toy objective functions, of which the quadratic function is a part, that you can import like this :

      from algosto.utils.functions import quadratic

      objective, grad = quadratic()

  > [!NOTE]
  > You can find a list of all available functions in the [references](https://www.algosto.dev/references/utils/functions/index.html)
  > section of the documentation.



  Now, we need to specify the definition space.
  To do that, Algosto provides object called *constraints* that you can import from the module ``algosto.constraints`` as follow :

      import numpy as np
      from algosto.constraints import RdBallConstraint

      ct = RdBallConstraint(2, np.zeros(2), 5)

  We define a two-dimensional ball in $\mathbb{R}^d$, centered at the origin.
  Constraints provide the solver with information about the space within which it can optimize the objective function.

  > [!NOTE]
  > You can find a list of all available constraints in the [references](https://www.algosto.dev/references/constraints/index.html)
  > section of the documentation.

  > [!NOTE]
  > If your constraint is not yet implemented, you can define your own.
  > Refer to the constraint chapter in the cookbook to learn how.



  It's time to speak about the solver itself.
  Solvers are avaible from the `algosto.solvers` module where you can find all the solvers implemented in Algosto.
  In this example, we are going to use the stochastic gradient descent (SGD) to minimize the objective.

      from algosto.solvers import SGDSolver

      solver = SGDSolver(ct, objective)

  > [!NOTE]
  > You can find a list of all available solvers in the [references](https://www.algosto.dev/references/solvers/index.html)
  > section of the documentation.

  Finally, we can minimize the objective function with the help of the `fit` method :

      from algosto.utils import plot

      solver.fit()

      plot(solver)



  The full Python code is avaible just below

      import numpy as np
      from algosto.utils.functions import quadratic
      from algosto.constraints import RdBallConstraint
      from algosto.solvers import SGDSolver
      from algosto.utils import plot

      objective, grad = quadratic()

      ct = RdBallConstraint(2, np.zeros(2), 5)

      solver = SGDSolver(ct, objective, grad)

      solver.fit()

      plot(solver)


pkgId: 174bc71420e966bee0120eb62c0707f2f419c8629d0d174e739cbe5ce6972f75
name: python-algviz
arch: src
version: 0.3.1
epoch: 0
release: 1
url: https://algviz.com/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-algviz-0.3.1-1.src.rpm
checksum_type: sha256
summary:
  An algorithm visualization tool for jupyter notebook to show animation for vector, table, linked list, tree and graph data structures.

description:
  [<img src="https://cdn.jsdelivr.net/gh/zjl9959/algviz@main/docs/images/logo_v1.svg"/>](https://algviz.com)

  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/algviz)
  ![PyPI](https://img.shields.io/pypi/v/algviz)
  ![Conda-forge](https://img.shields.io/conda/vn/conda-forge/algviz)
  ![License](https://img.shields.io/github/license/zjl9959/algviz)

  [中文介绍文档](README_CN.md)



  [Algviz](https://algviz.com) is an algorithm animation engine for your Python code in [Jupyter](https://jupyter.org/), which supports multiple data structures such as `vector`, `table`, `linked_list`, `tree` and `graph`.

  | Vector | Table | Tree | Graph |
  |:---:|:---:|:---:|:---:|
  |  ![vector.svg] |   ![table.svg]  |  ![tree.svg]   |  ![graph.svg]   |

  You can get live algorithm animation after bringing some algviz interfaces to your algorithm.
  For example, this code below shows the bubble sort algorithm:

  <details>

  <summary>Click to show the code example</summary>

  ```python
  import algviz

  def bubble_sort(data):
      viz = algviz.Visualizer(0.5)
      vector = viz.createVector(data, cell_size=(40, 160), histogram=True)
      for i in range(len(vector)):
          for j in range(len(vector)-i-1):
              if vector[j] > vector[j+1]:
                  vector.mark(algviz.cRed, j)
                  vector.mark(algviz.cGreen, j+1)
                  viz.display()
                  vector.swap(j, j+1)
              else:
                  vector.mark(algviz.cRed, j+1)
                  vector.mark(algviz.cGreen, j)
              viz.display()
          vector.mark(algviz.cGray, len(vector)-i-1, hold=True)
      vector.removeMark(algviz.cGray)
      viz.display()

  bubble_sort([5, 4, -2, 1, -1, 3])
  ```

  </details>

  <br>

  The rendered animation looks like this:

  ![bubble_sort_animation](https://cdn.jsdelivr.net/gh/zjl9959/algviz-launch@master/svgs/BubbleSort.svg)

  *If you are interested in this project, please give me a star⭐, thanks!*



  Ready to see the magic? Click this button to try more algorithms on Gitpod!

  [![Open algviz examples in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/zjl9959/algviz-launch) *Need to login with your github account.*



  Please follow this [installation guide](https://algviz.com/en/installation.html) to setup algviz.



  This [tutorial](https://algviz.com/en/examples.html) gives you a quick start on using algviz.

  All the API references can be found at [algviz API reference](https://algviz.readthedocs.io/en/latest/api.html#).



  Algviz uses GNU general public [LICENSE](https://github.com/zjl9959/algviz/blob/main/LICENSE). You can use it freely for learning and communication. For the commercial usage, please contact the author.



  Any form of contribution is welcomed! Please feel free to report a [bug](https://github.com/zjl9959/algviz/issues) or create a [pull request](https://github.com/zjl9959/algviz/pulls).

  If you want to share your algorithms using algviz, you can create a [PR](https://github.com/zjl9959/algviz-launch/pulls) from this repo: 👉 [algviz-launch](https://github.com/zjl9959/algviz-launch).

  [bubble sort algorithm]: https://en.wikipedia.org/wiki/Bubble_sort
  [vector.svg]: https://cdn.jsdelivr.net/gh/zjl9959/algviz.com@master/assets/img/data_vector.svg
  [table.svg]: https://cdn.jsdelivr.net/gh/zjl9959/algviz.com@master/assets/img/data_table.svg
  [tree.svg]: https://cdn.jsdelivr.net/gh/zjl9959/algviz.com@master/assets/img/data_tree.svg
  [graph.svg]: https://cdn.jsdelivr.net/gh/zjl9959/algviz.com@master/assets/img/data_graph.svg




  **QQ group**: [334605370](http://qm.qq.com/cgi-bin/qm/qr?_wv=1027&k=NYzoqZd6B8sryXf0S8o1uv72b_p2M5ai&authKey=qTbFUbVoI%2F8RWZVmlabPkuBHnuY2RzywEnKeNZlV8dOhcdcKY%2BoiYnPklmdfpwlE&noverify=0&group_code=334605370)

  **Telegram**: https://t.me/+mvF8Sivxr3thZWY1


pkgId: 22147b30d865ec7243d404c7d845092fb1ee1e33984c16802584d26c6d2bbbd6
name: python-alianator
arch: src
version: 4.0.2
epoch: 0
release: 1
summary: A Discord permission name resolver for Pycord
url: https://github.com/celsiusnarhwal/alianator
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alianator-4.0.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/alianator?logo=python&logoColor=white&style=for-the-badge)](https://pypi.org/project/alianator)
  [![PyPI](https://img.shields.io/pypi/v/alianator?logo=pypi&color=green&logoColor=white&style=for-the-badge)](https://pypi.org/project/alianator)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/celsiusnarhwal/alianator?logo=github&color=orange&logoColor=white&style=for-the-badge)](https://github.com/celsiusnarhwal/alianator/releases)
  [![PyPI - License](https://img.shields.io/pypi/l/alianator?color=03cb98&style=for-the-badge)](https://github.com/celsiusnarhwal/alianator/blob/master/LICENSE)
  [![Black](https://aegis.celsiusnarhwal.dev/badge/black?style=for-the-badge)](https://github.com/psf/black)

  alianator is a Discord permission name resolver for [Pycord](https://github.com/Pycord-Development/pycord).
  It takes Discord's API permission flags (e.g. `manage_guild`) and resolves them to their user-facing aliases (
  e.g. `Manage Server`).



  ```bash
  $ pip install alianator
  ```



  alianator can resolve aliases from `discord.Permissions` objects, integers, strings, tuples, lists of strings, and lists
  of tuples.

  ```python
  import alianator

  alianator.resolve(arg, mode=mode)
  ```

  The optional `mode` flag can be used to specify which permissions should be resolved. If `mode` is `True`, only granted
  permissions will be resolved; if `mode` is `False`, only denied permissions will be resolved; if `mode` is `None`, all
  permissions will be resolved. If `mode` is not explicitly specified, it will default to `True`.

  ```python
  import alianator
  import discord


  perms = discord.Permissions.general()
  aliases = alianator.resolve(perms)
  print(aliases)




  perms = 3072
  aliases = alianator.resolve(perms)
  print(aliases)




  perms = "send_tts_messages"
  aliases = alianator.resolve(perms)
  print(aliases)




  perms = ("moderate_members", True)
  aliases = alianator.resolve(perms)
  print(aliases)




  perms = ["manage_guild", "manage_emojis"]
  aliases = alianator.resolve(perms)
  print(aliases)




  perms = [("use_slash_commands", True), ("use_voice_activation", True)]
  aliases = alianator.resolve(perms)
  print(aliases)

  ```

  That's about all there is to it. alianator does one thing and does it well.



  alianator is released under the [MIT License](https://github.com/celsiusnarhwal/alianator/blob/master/LICENSE.md).


pkgId: 224c99c01eb5f1a8497acb68bf7b2c083f5fc7ac51248ffb6439e9e1883936b3
name: python-alias-free-torch
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: alias free torch
url: https://github.com/junjun3518/alias-free-torch
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alias-free-torch-0.0.6-1.src.rpm
checksum_type: sha256
description:
  Simple *torch* module implementation of [Alias-Free GAN](https://nvlabs.github.io/alias-free-gan/).

  This repository including
  - Alias-Free GAN style lowpass sinc filter @[filter.py](/src/alias_free_torch/filter.py)

  - Alias-Free GAN style up/downsample @[resample.py](/src/alias_free_torch/resample.py)

  - Alias-Free activation @[act.py](/src/alias_free_torch/act.py)

  - and test codes @[./test](/src/alias_free_torch/test)

  **Note: Since this repository is unofficial, filter and upsample could be different with [official implementation](https://github.com/NVlabs/stylegan3).**

  **Still working! If you notice some error or typo, please open new issue!**
  **v0.0.8 is TESTED**

  **UPDATE: You can download alias-free-torch from [pip](https://pypi.org/project/alias-free-torch/)**
  ```shell
  python -m pip install alias-free-torch
  ```



  Due to `torch.kaiser_window` and `torch.i0` are implemeted after `1.7.0`, our repository need `torch>=1.7.0`.
  - Pytorch>=1.7.0

  For custom torch users, `pip` will not check torch version.


  - [x] 2d sinc filter
  - [x] 2d resample
  - [x] devide 1d and 2d modules
  - [x] pip packaging
  - [x] rewrite upsample
  - [x] Upsample pad size issue
  - [x] \(Upsample\) support calculation for \[B,C,T/(H,W)\] (now only supports \[B,T/(H,W)\] or \[B,1,T/(H,W)\])
  - [x] set filter as register buffer
  - [x] \(Downsample & Filter\) support calculation for \[B,C,T/(H,W)\] (now only supports \[B,T/(H,W)\] or \[B,1,T/(H,W)\])
  - [ ] provide loadable ckpt for lower version of torch
  - [ ] documentation


  | Filter sine              | Filter noise                  |
  | --------------------- | --------------------------- |
  | ![filtersin](asset/filtersin.png) | ![filternoise](asset/filternoise.png) |

  | upsample              | downsample                  |
  | --------------------- | --------------------------- |
  | ![up2](asset/up2.png) | ![down10](asset/down10.png) |
  | ![up256](asset/up256.png) | ![down100](asset/down100.png) |


  | Filter L1 norm sine   | Filter noise                  |
  | --------------------- | --------------------------- |
  | ![filter2dsin](asset/filter2dsin.png) | ![filter2dnoise](asset/filter2dnoise.png) |

  | upsample              | downsample                  |
  | --------------------- | --------------------------- |
  | ![up2d2](asset/up2d2.png) | ![downsample2d2](asset/downsample2d2.png) |
  | ![up2d8](asset/up2d8.png) | ![downsample2d4](asset/downsample2d4.png) |



  - [Alias-Free GAN](https://nvlabs-fi-cdn.nvidia.com/alias-free-gan/alias-free-gan-paper.pdf)
  - [adefossez](https://github.com/adefossez)/[julius](https://github.com/adefossez/julius)
  - A. V. Oppenheim and R. W. Schafer. *Discrete-Time Signal Processing*. Pearson, International Edition, 3rd edition, 2010



  This work is done at [MINDsLab Inc](https://github.com/mindslab-ai).

  Thanks to teammates at MINDsLab Inc.
  - [Hyoungkyu Song](https://github.com/deepkyu)
  - [Kang-wook Kim](https://github.com/wookladin)
  - [Dongho Choi](https://github.com/dhchoi99)
  - [Sang Hoon Woo](https://github.com/tonyswoo)


pkgId: 4ad7e7da5580fc0751f745ecb53b0dac49cbc2a35e641a5cce86d8819fa35e14
name: python-alibabacloud-adb20190315
arch: src
version: 4.2.1
epoch: 0
release: 1
summary: Alibaba Cloud adb (20190315) SDK Library for Python
url: https://github.com/aliyun/alibabacloud-python-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-adb20190315-4.2.1-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 3.7



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_adb20190315
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/adb-20190315/ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: 5d631d6d15c83f856f2bb157da51158424a42630e798eaacb670488dd107eb07
name: python-alibabacloud-adb20190315-py2
arch: src
version: 3.1.3
epoch: 0
release: 1
summary: Alibaba Cloud adb (20190315) SDK Library for Python2
url: https://github.com/aliyun/alibabacloud-python2-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-adb20190315-py2-3.1.3-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 2.6



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_adb20190315_py2
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python2-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](./ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: 0dad7f72f1e8fc72db08fdd874b21e52a8896ead7585a255db20ecfb41efacef
name: python-alibabacloud-adb20211201
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Alibaba Cloud adb (20211201) SDK Library for Python
url: https://github.com/aliyun/alibabacloud-python-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-adb20211201-2.0.0-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 3.6



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_adb20211201
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/adb-20211201/ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: d2dee0817ce0485e684d60ea1e75a3bddd172f982997ec0c17183224f40bae87
name: python-alibabacloud-adcp20220101
arch: src
version: 3.1.1
epoch: 0
release: 1
summary: Alibaba Cloud adcp (20220101) SDK Library for Python
url: https://github.com/aliyun/alibabacloud-python-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-adcp20220101-3.1.1-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 3.6



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_adcp20220101
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/adcp-20220101/ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: acc8dfcc85470b7f5613e9c232c6cd166b50488159a4db2637a1594d88fbfcbb
name: python-alibabacloud-adcp20220101-py2
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: Alibaba Cloud adcp (20220101) SDK Library for Python2
url: https://github.com/aliyun/alibabacloud-python2-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-adcp20220101-py2-3.1.0-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 2.6



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_adcp20220101_py2
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python2-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](./ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: 7d63de522d48a3802658f61df3be038582ea071b18452d60a61a9806070a8907
name: python-alibabacloud-agency20221216
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: Alibaba Cloud Agency (20221216) SDK Library for Python
url: https://github.com/aliyun/alibabacloud-python-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-agency20221216-1.6.0-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 3.7



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_agency20221216
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/agency-20221216/ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: f8be1f3e9f6d7cd7c5e6a5d7afbcf974a8fb8844872e60cab432e376ddbe90df
name: python-alibabacloud-aimath20241114
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Alibaba Cloud AIMath (20241114) SDK Library for Python
url: https://github.com/aliyun/alibabacloud-python-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-aimath20241114-1.0.0-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 3.7



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_aimath20241114
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/aimath-20241114/ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: e95e8483d68e97141372dd39a5339d017f77f3ca97b5357fc784fed14f4473ed
name: python-alibabacloud-aimiaobi20230801
arch: src
version: 1.10.0
epoch: 0
release: 1
summary: Alibaba Cloud AiMiaoBi (20230801) SDK Library for Python
url: https://github.com/aliyun/alibabacloud-python-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-aimiaobi20230801-1.10.0-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 3.7



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_aimiaobi20230801
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/aimiaobi-20230801/ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: b9b0b2c6c232b3e68af32909e986f6eaac8a4baa1246fb2a40f1beba8ff6f26a
name: python-alibabacloud-airticketopen20230117
arch: src
version: 3.5.0
epoch: 0
release: 1
summary: Alibaba Cloud airticketOpen (20230117) SDK Library for Python
url: https://github.com/aliyun/alibabacloud-python-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-airticketopen20230117-3.5.0-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 3.7



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_airticketopen20230117
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/airticketopen-20230117/ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: 4f4ebb581217ab9ae125f86ff2b509d21653c90eb5ca8320d5639f19a10c6197
name: python-alibabacloud-aiworkspace20210204
arch: src
version: 5.1.0
epoch: 0
release: 1
summary: Alibaba Cloud AIWorkSpace (20210204) SDK Library for Python
url: https://github.com/aliyun/alibabacloud-python-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-aiworkspace20210204-5.1.0-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 3.7



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_aiworkspace20210204
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/aiworkspace-20210204/ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: 7ee2ee49db82718d02ddb27f885ed7ef42e66a4863297352f255ea491d059c08
name: python-alibabacloud-alb20200616
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: Alibaba Cloud Alb (20200616) SDK Library for Python
url: https://github.com/aliyun/alibabacloud-python-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-alb20200616-1.2.1-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 3.6



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_alb20200616
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/alb-20200616/ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: b02547a5895847f9ce6cc642297ec00d0bb3e96fd66788b121e163b08fad84df
name: python-alibabacloud-alb20200616
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: Alibaba Cloud Alb (20200616) SDK Library for Python
url: https://github.com/aliyun/alibabacloud-python-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-alb20200616-1.2.3-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 3.7



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_alb20200616
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/alb-20200616/ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: b52dfe8f4206ab9f8cc5b622da9f06066b0141d420cd8977ad55904da6289e6a
name: python-alibabacloud-aliding20230426
arch: src
version: 2.26.1
epoch: 0
release: 1
summary: Alibaba Cloud aliding (20230426) SDK Library for Python
url: https://github.com/aliyun/alibabacloud-python-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-aliding20230426-2.26.1-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 3.7



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_aliding20230426
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/aliding-20230426/ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: 246dd8cd461003309beaca703328599f24f894af21d2eb17ce2e5e57e056d7cf
name: python-alibabacloud-aliding20230426-py2
arch: src
version: 1.14.0
epoch: 0
release: 1
summary: Alibaba Cloud aliding (20230426) SDK Library for Python2
url: https://github.com/aliyun/alibabacloud-python2-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-aliding20230426-py2-1.14.0-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 2.6



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_aliding20230426_py2
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python2-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](./ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: 8ad2427602c4ce160dee5443201bccc62f345f1efd1907c3863b1417dc9efeaa
name: python-alibabacloud-alidns20150109
arch: src
version: 3.5.6
epoch: 0
release: 1
summary: Alibaba Cloud Alidns (20150109) SDK Library for Python
url: https://github.com/aliyun/alibabacloud-python-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-alidns20150109-3.5.6-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 3.7



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_alidns20150109
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/alidns-20150109/ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: 16d6b3e921eb6b719cf8cd1d69dfd15e54707a891061094c27ec1d8f535cf61c
name: python-alibabacloud-alidns20150109-py2
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Alibaba Cloud Alidns (20150109) SDK Library for Python2
url: https://github.com/aliyun/alibabacloud-python2-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-alidns20150109-py2-1.2.0-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 2.6



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_alidns20150109_py2
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python2-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](./ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: f7ff0254ed3213ab512f35029e3647ce3f5adb7575d914c7811557f18e8b3ef0
name: python-alibabacloud-aligenieiap-1-0
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: Alibaba Cloud AliGenie (iap_1_0) SDK Library for Python
url: https://github.com/aliyun/alibabacloud-python-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-aligenieiap-1-0-1.2.2-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 3.6



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_aligenieiap_1_0
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/aligenie-iap_1_0/ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: ec2580cc1165a2e7eacc0c58796db83ac4cc1449a5ad00a43a00859898aa126b
name: python-alibabacloud-aligenieip-1-0
arch: src
version: 2.7.0
epoch: 0
release: 1
summary: Alibaba Cloud AliGenie (ip_1_0) SDK Library for Python
url: https://github.com/aliyun/alibabacloud-python-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-aligenieip-1-0-2.7.0-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 3.6



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_aligenieip_1_0
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/aligenie-ip_1_0/ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: 2566ff77b153c8410bab4e5ea18e3731df579a7e2d1d09f71f06a744f60f01fb
name: python-alibabacloud-aligeniessp-1-0
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Alibaba Cloud AliGenie (ssp_1_0) SDK Library for Python
url: https://github.com/aliyun/alibabacloud-python-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-aligeniessp-1-0-2.1.0-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 3.6



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_aligeniessp_1_0
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](./ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: 2c4e0d9f1220e57ad9bda98e8cfad52d6621a44bad1dd32f073a152d1d85e7be
name: python-alibabacloud-alikafka20190916
arch: src
version: 2.8.0
epoch: 0
release: 1
summary: Alibaba Cloud MQ for Kafka (20190916) SDK Library for Python
url: https://github.com/aliyun/alibabacloud-python-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-alikafka20190916-2.8.0-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 3.7



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_alikafka20190916
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/alikafka-20190916/ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: 49ae1823518f83d08ec2e6e9575c88cf5d85883f0b6521857d99223895ca9b3d
name: python-alibabacloud-alimt20181012
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Alibaba Cloud Machine Translation (20181012) SDK Library for Python
url: https://github.com/aliyun/alibabacloud-python-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-alimt20181012-1.3.0-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 3.6



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_alimt20181012
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/alimt-20181012/ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: 36e6bea185a485fbf09c9656bb14b3916f66d7fac1d6bee2e75e07d5f06028e5
name: python-alibabacloud-alinlp20200629
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: Alibaba Cloud alinlp (20200629) SDK Library for Python
url: https://github.com/aliyun/alibabacloud-python-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-alinlp20200629-3.1.0-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 3.6



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_alinlp20200629
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/alinlp-20200629/ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: 151d860c867a94cdbe3c55441876f12871657f3ff193940a14c5f884839939fc
name: python-alibabacloud-alinlp20200629-py2
arch: src
version: 1.5.2
epoch: 0
release: 1
summary: Alibaba Cloud alinlp (20200629) SDK Library for Python2
url: https://github.com/aliyun/alibabacloud-python2-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-alinlp20200629-py2-1.5.2-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 2.6



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_alinlp20200629_py2
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python2-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](./ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: b6864bd8a470777c92a1a360f8132d7e15b9be20c05f80290e01ddbd5db9bef7
name: python-alibabacloud-aliyunape20210908
arch: src
version: 1.0.96
epoch: 0
release: 1
summary: Alibaba Cloud aliyunape (20210908) SDK Library for Python
url: https://github.com/aliyun/alibabacloud-python-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-aliyunape20210908-1.0.96-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 3.6



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_aliyunape20210908
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/aliyunape-20210908/ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: 53ea6c8c0fdf10fd4d99b11451cec531707c5e621e8c847fb71c850e817ffc7a
name: python-alibabacloud-aliyunape20210908-py2
arch: src
version: 1.0.96
epoch: 0
release: 1
summary: Alibaba Cloud aliyunape (20210908) SDK Library for Python2
url: https://github.com/aliyun/alibabacloud-python2-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-aliyunape20210908-py2-1.0.96-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 2.6



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_aliyunape20210908_py2
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python2-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](./ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: 1863aea8832b786ae41b7b815e055e0ecd0b8a158a9db41ec8927e29fca8ab9d
name: python-alibabacloud-amqp-open20191212
arch: src
version: 1.3.3
epoch: 0
release: 1
summary: Alibaba Cloud amqp-open (20191212) SDK Library for Python
url: https://github.com/aliyun/alibabacloud-python-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alibabacloud-amqp-open20191212-1.3.3-1.src.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)
  ![](https://aliyunsdk-pages.alicdn.com/icons/AlibabaCloud.svg)





  - Python >= 3.6



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install alibabacloud_amqp_open20191212
  ```



  [Opening an Issue](https://github.com/aliyun/alibabacloud-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/docs/0-Usage-EN.md#quick-examples)



  Detailed changes for each release are documented in the [release notes](https://github.com/aliyun/alibabacloud-python-sdk/blob/master/amqp-open-20191212/ChangeLog.md).



  - [Latest Release](https://github.com/aliyun/alibabacloud-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


