# packages

pkgId: 0173c282e0c77216d2d04e5b2da9070b66b021b447f749d4fda1283838cd92b9
name: python-art-dl
arch: src
version: 0.2.7
epoch: 0
release: 1
summary: Artworks downloader
url: https://github.com/istudyatuni/artworks-downloader
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-art-dl-0.2.7-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/art-dl)](https://pypi.org/project/art-dl)



  - artstation.com [#usage](#sites-with-simple-usage)
  - deviantart.com [#usage](#deviantart)
  - imgur.com [#usage](#sites-with-simple-usage)
  - pixiv.net [#usage](#sites-with-simple-usage) [#notes](#pixiv)
    - zettai.moe
  - reddit.com [#usage](#sites-with-simple-usage)
  - twitter.com [#usage](#sites-with-simple-usage) [#notes](#twitter)
  - wallhaven.cc [#usage](#sites-with-simple-usage) [#notes](#wallhaven)

  [Supported URL types](#supported-url-types)





  ```sh
  pip install -U art-dl
  ```

  Then run as `art-dl`: [#usage](#usage)



  You need poetry, [install](https://python-poetry.org/docs/#installation) it, then run from inside the project

  ```sh
  poetry install --no-dev


  poetry run python -m art_dl


  poetry shell

  python -m art_dl

  art-dl


  poetry install --no-dev
  art-dl
  ```

  Alternatively, build binary with [nuitka](https://github.com/Nuitka/Nuitka):

  ```sh
  poetry install
  poetry shell
  python -m nuitka art_dl
  ```

  After that you will have binary in the root directory.



  ```
  usage: art-dl [-h] [-u URL] [-l LIST] [--folder FOLDER] [--action ACTION] [-q] [-v] [--version]

  Artworks downloader

  options:
    -h, --help            show this help message and exit
    -u URL, --url URL     URL to download
    -l LIST, --list LIST  File with list of URLs to download, one URL per line
    --folder FOLDER       Folder to save artworks. Default folder - data
    --action ACTION
    -q, --quiet           Do not show logs
    -v, --verbose         Show more logs
    --version             Show version
  ```



  Just run

  ```sh

  art-dl -u [URL]

  art-dl -l [file with list of urls]
  ```



  You should have deviantart.com account, login to it, then

  - register an application
    - go to https://www.deviantart.com/developers/apps
    - click "Register Application"
    - in field "OAuth2 Redirect URI Whitelist (Required)" under "Application Settings" block paste `http://localhost:23445`
    - scroll to bottom and check "I have read and agree to the API License Agreement."
    - click "Save"
    - in the block with newly created application click "Publish"

  - save `client_id` and `client_secret` in this application
    - run

    ```sh
    art-dl --action deviantart:register
    ```

    - paste needed values

  - authorize application
    - open suggested link
    - click "Authorize"

  After that you can use it as other sites: [#usage](#sites-with-simple-usage)



  Run

  ```sh
  art-dl --action config:proxy
  ```

  Enter proxy, for example, `socks5://localhost:1080`





  If the artwork has more one image, you can specify which images should be downloaded, for example, if the artwork has 10 images and you want to download 1, 3, 4, 5 and 7 image, you can add `#1,3-5,7` to the link for that: `https://www.pixiv.net/<lang>/artworks/<id>#1,3-5,7`.



  Here we use an alternative frontend for Twitter: https://nitter.net ([Github](https://github.com/zedeus/nitter))



  NSFW images supported only with API key, to use it, get it from [account settings](https://wallhaven.cc/settings/account), then run

  ```sh
  art-dl --action wallhaven:key
  ```



  - **artstation.com**
    - `https://www.artstation.com/artwork/<hash>`
    - `https://www.artstation.com/<artist>`
  - **deviantart.com**
    - All deviations
      - `https://www.deviantart.com/<artist>`
      - `https://www.deviantart.com/<artist>/gallery/all`
    - "Featured" collection
      - `https://www.deviantart.com/<artist>/gallery`
    - `https://www.deviantart.com/<artist>/gallery/<some number>/<gallery name>`
    - `https://www.deviantart.com/<artist>/art/<name>`
  - **imgur.com**
    - `https://imgur.com/a/<id>`
    - `https://imgur.com/gallery/<id>`
    - `https://imgur.com/t/<tag>/<id>`
  - **pixiv.net**
    - `https://www.pixiv.net/artworks/<id>`
    - `https://www.pixiv.net/<lang>/artworks/<id>`

    - Other sites with the same content as pixiv:
      - `https://zettai.moe/detail?id=<id>`
  - **reddit.com**
    - `https://redd.it/<id>`
    - `https://www.reddit.com/comments/<id>`
    - `https://www.reddit.com/gallery/<id>`
    - `https://www.reddit.com/r/<subreddit>/comments/<id>/<any name>`
  - **twitter.com**
    - `https://(mobile.)twitter.com/<account>/status/<id>`
    - `https://nitter.net/<account>/status/<id>`
  - **wallhaven.cc**
    - `https://wallhaven.cc/w/<id>`
    - `https://whvn.cc/<id>`


pkgId: 1436edf6ebbfe1d95c54e9d507c1989b602652b63724726a61837ab5c387d44d
name: python-artbox
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: ArtBox is a tool set for handling multimedia files.
url: https://pypi.org/project/artbox/
rpm_license: Other
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artbox-0.8.0-1.src.rpm
checksum_type: sha256
description:
  ArtBox is a tool set for handling multimedia files.

  - Documentation: https://ggpedia.games
  - License: BSD-3 Clause



  TBD



  ArtBox uses some dependencies that maybe would not work well in your machine. In
  order to have everything well installed, create a conda/mamba environment and
  install `artbox` there.

  ```bash
  $ mamba create --name artbox "python>=3.8.1,<3.12" pygobject pip
  $ conda activate artbox
  $ pip install artbox
  ```



  For the following examples, create the a temporary folder for artbox:

  ```bash
  $ mkdir /tmp/artbox
  ```



  By default, the `artbox speech` uses
  [`edge-tts`](https://pypi.org/project/edge-tts/) engine, but if you can also
  specify [`gtts`](https://github.com/pndurette/gTTS) with the flag
  `--engine gtts`.

  ```bash
  $ echo "Are you ready to join Link and Zelda in fighting off this unprecedented threat to Hyrule?" > /tmp/artbox/text.md
  $ artbox speech text-to-speech \
      --title artbox \
      --input-path /tmp/artbox/text.md \
      --output-path /tmp/artbox/speech.mp3 \
      --engine edge-tts
  ```

  If you need to generate the audio for different language, you can use the flag
  `--lang`:

  ```bash
  $ echo "Bom dia, mundo!" > /tmp/artbox/text.md
  $ artbox speech text-to-speech \
      --title artbox \
      --input-path /tmp/artbox/text.md \
      --output-path /tmp/artbox/speech.mp3 \
      --lang pt
  ```

  If you are using `edge-tts` engine (the default one), you can also specify the
  locale for that language, for example:

  ```bash
  $ echo "Are you ready to join Link and Zelda in fighting off this unprecedented threat to Hyrule?" > /tmp/artbox/text.md
  $ artbox speech text-to-speech \
      --title artbox \
      --input-path /tmp/artbox/text.md \
      --output-path /tmp/artbox/speech.mp3 \
      --engine edge-tts \
      --lang en-IN
  ```

  Additionally, if you are using edge-tts, you can specify `--rate`, `--volume`,
  and `--pitch`, for example:

  ```bash
  $ echo "Do you want some coffee?" > /tmp/artbox/text.md
  $ artbox speech text-to-speech \
      --title artbox \
      --input-path /tmp/artbox/text.md \
      --output-path /tmp/artbox/speech.mp3 \
      --engine edge-tts \
      --lang en \
      --rate +10% \
      --volume -10% \
      --pitch -5Hz
  ```



  If you want to download videos from the youtube, you can use the following
  command:

  ```bash
  $ artbox youtube download \
      --url https://www.youtube.com/watch?v=zw47_q9wbBE \
      --output-path /tmp/artbox/
  ```

  The command above downloads using a random resolution. If you want a specific
  resolution, use the flat `--resolution`:

  ```bash
  $ artbox youtube download \
      --url https://www.youtube.com/watch?v=zw47_q9wbBE \
      --output-path /tmp/artbox/ \
      --resolution 360p
  ```



  ```bash

  echo '["E", "D#", "E", "D#", "E", "B", "D", "C", "A"]' > /tmp/artbox/notes.txt
  $ artbox sound notes-to-audio \
    --input-path /tmp/artbox/notes.txt \
    --output-path /tmp/artbox/music.mp3 \
    --duration 2
  ```



  First, download the youtube video `https://www.youtube.com/watch?v=zw47_q9wbBE`
  as explained before.

  Next, run the following command:

  ```bash
  $ artbox video remove-audio \
    --input-path "/tmp/artbox/The Legend of Zelda Breath of the Wild - Nintendo Switch Presentation 2017 Trailer.mp4" \
    --output-path /tmp/artbox/botw.mp4
  ```



  First, download the youtube video `https://www.youtube.com/watch?v=zw47_q9wbBE`
  as explained before.

  Next, run the following command:

  ```bash
  $ artbox video extract-audio \
    --input-path "/tmp/artbox/The Legend of Zelda Breath of the Wild - Nintendo Switch Presentation 2017 Trailer.mp4" \
    --output-path /tmp/artbox/botw-audio.mp3
  ```



  First, execute the previous steps:

  - Download a youtube video
  - Remove the audio from a video
  - Extract the audio from a video

  Next, run the following command:

  ```bash
  $ artbox video combine-video-and-audio \
    --video-path /tmp/artbox/botw.mp4 \
    --audio-path /tmp/artbox/botw-audio.mp3 \
    --output-path /tmp/artbox/botw-combined.mp4
  ```



  If you want to use Python to play your audio files, you can install `playsound`:

  ```bash
  $ pip wheel --use-pep517 "playsound (==1.3.0)"
  ```



  After installing with `poetry install`:

  - Patch `pytube` (ref: https://github.com/pytube/pytube/issues/1773):
    `sed -i 's/(r"^$\\w+\\W")/(r"^\\w+\\W")/' $CONDA_PREFIX/lib/python3.*/site-packages/pytube/cipher.py`


pkgId: 3240d822aae6cf1fea72fa38ab683c613814555d6f66130cd982a6fce6930a69
name: python-artd-alliance
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: ArtD Alliance.
url: https://www.artd.com.co/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artd-alliance-1.0.3-1.src.rpm
checksum_type: sha256
description:
  The ArtD Alliance module allows different parties to partner to create promotional strategies such as percentage or fixed discounts and discount coupons of different types.



  1. Install The package
  ```bash
  pip install artd-alliance
  ```

  2. Add the required on settings.py as follows
  ```python
  INSTALLED_APPS = [
      "django_json_widget",
      "artd_customer",
      "artd_location",
      "artd_modules",
      "artd_partner",
      "artd_product",
      "artd_service",
      "artd_urls",
      "artd_promotion",
      "artd_alliance",
  ]

  ```
  3. Run the migrations command
  ```bash
  python manage.py migrate
  ```

  4. Run the base commands
  ```bash
  python manage.py create_countries
  python manage.py create_colombian_regions
  python manage.py create_colombian_cities
  python manage.py create_apps
  python manage.py create_services
  python manage.py create_base_customer_groups
  python manage.py create_tax_segments
  python manage.py create_vat_data
  python manage.py create_taxes
  python manage.py insert_installed_apps_and_permissions
  ```

  5. Create a superuser
  ```bash
  python manage.py createsuperuser
  ```
  6. Add the context processor

  ```bash
   TEMPLATES = [
      {
          'OPTIONS': {
              'context_processors': [
                  'artd_alliance.context_processors.user_context_processor',

              ],
          }
      },
  ]
  ```

  6. Log in to your Django instance manager

  7. Create a partner

  8. Configure your partners and alliances


pkgId: 3f605206c04fb8606f1b07141366e4a1a8844bd6c8554b5cb09055e892c2bc0e
name: python-artd-promotion
arch: src
version: 1.0.16
epoch: 0
release: 1
summary: ArtD Promotion.
url: https://www.artd.com.co/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artd-promotion-1.0.16-1.src.rpm
checksum_type: sha256
description:
  Art Promotion is a package that manage coupon codes.



  1. Install The package
  ```bash
  pip install artd-alliance
  ```

  2. Add the required on settings.py as follows

  ```python
  INSTALLED_APPS = [
      "django-json-widget",
      "artd-customer",
      "artd-location",
      "artd-modules",
      "artd-partner",
      "artd-product",
      "artd-service",
      "artd-urls",
  ]
  ```

  3. Run the migrations command
  ```bash
  python manage.py migrate
  ```

  4. Run the base commands
  ```bash
  python manage.py create_countries
  python manage.py create_colombian_regions
  python manage.py create_colombian_cities
  python manage.py create_apps
  python manage.py create_services
  python manage.py create_base_customer_groups
  python manage.py create_tax_segments
  python manage.py create_vat_data
  python manage.py create_taxes
  python manage.py insert_installed_apps_and_permissions
  ```


pkgId: 9e75706e3cf6503bc88bbe039ade16f03a3c272dc3dc11caacd6c25f3dba2380
name: python-artefacts
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Deserialization for dbt artifacts
url: https://pypi.org/project/artefacts/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artefacts-1.2.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/artefacts.svg)](https://badge.fury.io/py/artefacts) ![badge](https://img.shields.io/badge/dbt-%3E%3D1.0-orange?style=flat&logo=dbt) ![badge](https://img.shields.io/pypi/pyversions/artefacts?logo=python)

  ![badge](https://img.shields.io/github/workflow/status/tjwaterman99/artefacts/CI/main?label=CI) [![Coverage Status](https://coveralls.io/repos/github/tjwaterman99/artefacts/badge.svg?branch=main)](https://coveralls.io/github/tjwaterman99/artefacts?branch=main)

  _A deserialization library for dbt artifacts._

  ```
  pip install artefacts
  ```

  The `artefacts.api` module aims to provide simple, easy to use python objects for interacting with your dbt project. Here's an example that identifies models in your project that are missing tests or descriptions.

  ```py
  >>> import artefacts.api
  >>> for model in artefacts.api.models():
  ...     if model.description is None or len(model.tests) == 0:
  ...         print(f"Incomplete model: {model.name}")

  ```



  After installing artefacts, you first need to _compile_ your dbt project.

  ```
  dbt compile
  ```

  You can then start using the api.

  ```py
  >>> import artefacts.api
  ```



  Documentation for the project is available on the Github Pages site.

  > https://tjwaterman99.github.io/artefacts/

  All methods exposed by the api are documented with usage examples in the API section.

  > https://tjwaterman99.github.io/artefacts/api.html

  References for the objects returned by the api are available in the References section.

  > https://tjwaterman99.github.io/artefacts/reference.html



  Open this repository in a Github Codespace. (Click the green `Code` button in the repository's [Github page](https://github.com/tjwaterman99/artefacts) and select `New Codespace`).



  ```
  poetry run pytest
  ```

  By default, pytest will test against the dbt project located at `ARTEFACTS_DBT_PROJECT_DIR`. To test against a different dbt project, update that environment variable and build the project.

  ```
  export ARTEFACTS_DBT_PROJECT_DIR=$PWD/dbt_projects/dbt-starter-project
  poetry run dbt build --project-dir $ARTEFACTS_DBT_PROJECT_DIR
  poetry run pytest
  ```

  To run the doctests use the `--doctest-modules` flag. Note that the doctests are intended to pass only when using the [`poffertjes_shop`](https://github.com/tjwaterman99/poffertjes_shop) project.

  ```
  poetry run pytest --doctest-modules
  ```



  Use `sphinx-livereload` to run the docs site on port `8000`.

  ```
  poetry run sphinx-autobuild docs/ docs/_build --watch artefacts
  ```


pkgId: 69e2856d4c87fd2b9e67794b0f31a24a8a60e3ab0d986ace2b1e47dc5c430eb5
name: python-artefacts-cli
arch: src
version: 0.6.16
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/art-e-fact/artefacts-client
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artefacts-cli-0.6.16-1.src.rpm
checksum_type: sha256
description:
  CLI to the Artefacts platform.

  [![Documentation](https://img.shields.io/badge/documentation-blue.svg?style=flat-square)](https://docs.artefacts.com/)
  [![Code style: Black-compatible with Ruff](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)



  * Currently working partially where Python can run.
  * Fully working on ROS-compatible and ready environments. Notably need for packages like `ros-<dist>-rclpy` and `ros-<dist>-rosidl-runtime-py`.




  To install:
  ```
  pip install artefacts-cli
  ```

  Check configuration: After creating `project-name` from the web UI and getting an API key, try:

  ```
  artefacts config add [project-name]
  ```

  and enter you `API_KEY` for the project when prompted.

  You can then do

  ```
  artefacts hello [project-name]
  ```

  alternatively, you can specify you API KEY via environment variable

  ```
  ARTEFACTS_KEY=[your-key] artefacts hello [project-name]
  ```

  To run a job locally, for example the turtlesim example (need ros2 installed).
  First edit `artefacts.yaml` to change the project name, then:

  ```
  cd examples/turtlesim
  artefacts run basic_tests
  ```




  See [the configuration syntax documentation](docs/configuration-syntax.md)




  You can serve docs locally using mkdocs:

  ```
  mkdocs serve -a 127.0.0.1:7000
  ```

  The docs are automatically deployed by the documentation workflow.


pkgId: b54c6e247d89a70913e4677a162f74daa6e9ce24fc073637b17cd0ef7b5b6650
name: python-artemis-model
arch: src
version: 0.1.80
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/artemis-model/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artemis-model-0.1.80-1.src.rpm
checksum_type: sha256
description:
  Welcome to `artemis-model`, the backbone repository that contains all the essential models used in both the `artemis-api` and the `prophet` project. This project includes asynchronous models used by `artemis-api`, such as `Artist`, and synchronous models like `ArtistSync` for other implementations.



  To set up your development environment for `artemis-model`, follow these initial setup steps:

  1. **Environment Setup**

  ```shell
  cp ./alembic/.env.example ./alembic/.env
  ```

  After copying the example environment file, make sure to fill in the `.env` file with your specific configurations.

  2. **Install Dependencies**

  ```shell
  poetry install --all-extras
  ```

  This will install all necessary dependencies to get you started with `artemis-models` and `alembic`.



  To introduce a new model in the project, you should start by creating a mixin and then define two different model classes that inherit from this mixin.



  1. **Define the Mixin**
  This mixin will include all the common attributes of your model.

  ```python
  class LoginHistoryMixin:
      """
      Stores the login history of users.
      """

      id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True, nullable=False)
      account_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("user_account.id"), nullable=False, index=True)
      ip_address: Mapped[str] = mapped_column(nullable=True)
      created_at = mapped_column(DateTime, default=datetime.utcnow)

      @declared_attr
      def account(cls) -> Mapped["UserAccount"]:
          return relationship("UserAccount", back_populates="login_histories")
  ```

  2. **Inherit from Base Classes**
  Create two classes that inherit from CustomBase and CustomSyncBase respectively, using the mixin for shared attributes.

  ```python
  class LoginHistorySync(CustomSyncBase, LoginHistoryMixin):
      pass

  class LoginHistory(CustomBase, LoginHistoryMixin):
      pass
  ```



  1. **Update the Project Version**

  Open pyproject.toml and increment the minor version number.

  2. **Build the Project**

  ```shell
  poetry build
  ```

  3. **Update Dependency in artemis-api/prophet**

  If the build succeeds, remember to also bump the version number in the pyproject.toml of artemis-api and prophet to match the new version of artemis-model.



  If modifications are necessary for any model:

  1. **Modify the Model**
  2. **Create an Alembic Revision**

  ```shell
  alembic revision --autogenerate -m "Description of changes"
  ```

  3. **Upgrade Database Schema**

  ```shell
  alembic upgrade head
  ```

  Ensure that the new Alembic script in the versions directory is committed to your git repository.
  Repeat the build and version update steps as necessary after making changes.


pkgId: 83e1ccf23ed8a6e30317de4afa627496b8a1359a3f051ea329491a44272bbfd3
name: python-artemis-utils
arch: src
version: 1.0.17
epoch: 0
release: 1
summary: ARTEMIS utility modules
url: https://github.com/FORTH-ICS-INSPIRE/artemis
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artemis-utils-1.0.17-1.src.rpm
checksum_type: sha256
description:
  ARTEMIS is an open-source tool, that implements a defense approach against BGP prefix hijacking attacks.

  This package holds all the utility functions that are shared between the different modules.

  Read more at [bgpartemis.org](http://bgpartemis.org/) and the [docs](https://bgpartemis.readthedocs.io/en/latest/).

  Instructions on publishing a package update:

  ```

  https://docs.gitlab.com/ee/user/packages/pypi_repository/

  https://pypi.org/manage/account/token/

  python3 setup.py sdist bdist_wheel
  twine upload dist/*
  ```


pkgId: 54508e11f2776b65bf52e4d6fcc87c82fa7bc79bad069e7a98d9058729773755
name: python-artesian-sdk
arch: src
version: 4.0.2
epoch: 0
release: 1
summary: Library provides read access to the Artesian API
url: https://www.artesian.cloud/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artesian-sdk-4.0.2-1.src.rpm
checksum_type: sha256
description:
  This Library provides read access to the Artesian API





  You can install the package directly from [pip](https://pypi.org/project/artesian-sdk/).

  ```Python
  pip install artesian-sdk
  ```

  Alternatively, to install this package go to the [release page](https://github.com/ARKlab/Artesian.SDK-Python/releases) .



  The Artesian.SDK instance can be configured using API-Key authentication

  ```Python
  from Artesian import ArtesianConfig

  cfg = ArtesianConfig("https://arkive.artesian.cloud/{tenantName}/", "{api-key}")
  ```



  The following breaking changes has been introduced in v3 respect to v2.



  Python >=3.8 is **required**.
  Python 3.7 is not supported due missing 'typing' features.



  With Artesian-SDK v3 we introduced SubPkg to split the different part of the library. The new SubPkg are:

  - Artesian.Query: contains all classes for querying Artesian data.
  - Artesian.GMEPublicOffers: contains all classes for querying GME Public Offers
  - **(NEW)** Artesian.MarketData: contains all classes to interact with the MarketData registry of Artesian. Register a new MarketData, change its Tags, etc. See documentation below.

  To upgrade is enough to prefix the QueryService with 'Query.' or import it from Artesian.Query.

  Were was used:

  ```Python
  from Artesian import *

  cfg = ArtesianConfig("https://arkive.artesian.cloud/{tenantName}/", "{api-key}")
  qs = QueryService(cfg)
  ```

  now you have to:

  ```Python
  from Artesian import ArtesianConfig
  from Artesian.Query import QueryService

  cfg = ArtesianConfig("https://arkive.artesian.cloud/{tenantName}/", "{api-key}")
  qs = QueryService(cfg)
  ```



  To align the casing of the entries of the Enum, we adopted PascalCase to align it with the Artesian API.

  Where before was used

  ```Python
    .inGranularity(Granularity.HOUR) \
  ```

  now is

  ```Python
    .inGranularity(Granularity.Hour) \
  ```



  Using the ArtesianConfig `cfg` we create an instance of the QueryService which is used to create Actual, Versioned and Market Assessment time series queries



  ```Python
  from Artesian import ArtesianConfig, Granularity
  from Artesian.Query import QueryService, RelativeInterval

  cfg = ArtesianConfig("https://arkive.artesian.cloud/{tenantName}/", "{api-key}")

  qs = QueryService(cfg)
  data = qs.createActual() \
      .forMarketData([100011484,100011472,100011477,100011490,100011468,100011462,100011453]) \
      .inAbsoluteDateRange("2018-01-01","2018-01-02") \
      .inTimeZone("UTC") \
      .inGranularity(Granularity.Hour) \
      .execute()

  print(data)

  ```

  To construct an Actual Time Series Extraction the following must be provided.

  <table>
    <tr><th>Actual Query</th><th>Description</th></tr>
    <tr><td>Market Data ID</td><td>Provide a market data id or set of market data id's to query</td></tr>
    <tr><td>Time Granularity</td><td>Specify the granularity type</td></tr>
    <tr><td>Time Extraction Window</td><td>An extraction time window for data to be queried</td></tr>
  </table>

  [Go to Time Extraction window section](#artesian-sdk-extraction-windows)



  ```Python
  from Artesian import ArtesianConfig, Granularity
  from Artesian.Query import QueryService, RelativeInterval

  qs = QueryService(cfg)
  q = qs.createVersioned() \
      .forMarketData([100042422,100042283,100042285,100042281,100042287,100042291,100042289]) \
      .inAbsoluteDateRange("2018-01-01","2018-01-02") \
      .inTimeZone("UTC") \
      .inGranularity(Granularity.Hour)

  print(q)

  ret = q.forMUV().execute()
  print(ret)
  ret = q.forLastNVersions(2).execute()
  print(ret)
  ret = q.forLastOfDays("2019-03-12","2019-03-16").execute()
  print(ret)
  ret = q.forLastOfDays("P0Y0M-2D","P0Y0M2D").execute()
  print(ret)
  ret = q.forLastOfDays("P0Y0M-2D").execute()
  print(ret)
  ret = q.forLastOfMonths("2019-03-12","2019-03-16").execute()
  print(ret)
  ret = q.forLastOfMonths("P0Y-1M0D","P0Y1M0D").execute()
  print(ret)
  ret = q.forLastOfMonths("P0Y-1M0D").execute()
  print(ret)
  ret = q.forVersion("2019-03-12T14:30:00").execute()
  print(ret)
  ret = q.forMostRecent("2019-03-12","2019-03-16").execute()
  print(ret)
  ret = q.forMostRecent("2019-03-12T12:30:05","2019-03-16T18:42:30").execute()
  print(ret)
  ret = q.forMostRecent("P0Y0M-2D","P0Y0M2D").execute()
  print(ret)
  ret = q.forMostRecent("P0Y0M-2D").execute()
  print(ret)
  ret = q.forMostRecent("2019-03-12","2019-03-16").execute()
  print(ret)
  ret = q.forMostRecent("P0Y-1M0D","P0Y1M0D").execute()
  print(ret)
  ret = q.forMostRecent("P0Y-1M0D").execute()
  print(ret)
  ```

  To construct a Versioned Time Series Extraction the following must be provided.

  <table>
    <tr><th>Versioned Query</th><th>Description</th></tr>
    <tr><td>Market Data ID</td><td>Provide a market data id or set of market data id's to query</td></tr>
    <tr><td>Time Granularity</td><td>Specify the granularity type</td></tr>
    <tr><td>Versioned Time Extraction Window</td><td>Versioned extraction time window</td></tr>
    <tr><td>Time Extraction Window</td><td>An extraction time window for data to be queried</td></tr>
  </table>

  [Go to Time Extraction window section](#artesian-sdk-extraction-windows)



  ```Python
  from Artesian import ArtesianConfig
  from Artesian.Query import QueryService, RelativeInterval

  qs = QueryService(cfg)
  data = qs.createMarketAssessment() \
      .forMarketData([100000032,100000043]) \
      .forProducts(["D+1","Feb-18"]) \
      .inAbsoluteDateRange("2018-01-01","2018-01-02") \
      .execute()

  print(data)
  ```

  To construct a Market Assessment Time Series Extraction the following must be provided.

  <table>
    <tr><th>Mas Query</th><th>Description</th></tr>
    <tr><td>Market Data ID</td><td>Provide a market data id or set of market data id's to query</td></tr>
    <tr><td>Product</td><td>Provide a product or set of products</td></tr>
    <tr><td>Time Extraction Window</td><td>An extraction time window for data to be queried </td></tr>
  </table>

  [Go to Time Extraction window section](#artesian-sdk-extraction-windows)



  ```Python
  from Artesian import ArtesianConfig
  from Artesian.Query import QueryService, RelativeInterval

  qs = QueryService(cfg)
  data = qs.createBidAsk() \
      .forMarketData([100000032,100000043]) \
      .forProducts(["D+1","Feb-18"]) \
      .inAbsoluteDateRange("2018-01-01","2018-01-02") \
      .execute()

  print(data)
  ```

  To construct a Bid Ask Time Series Extraction the following must be provided.

  <table>
    <tr><th>Mas Query</th><th>Description</th></tr>
    <tr><td>Market Data ID</td><td>Provide a market data id or set of market data id's to query</td></tr>
    <tr><td>Product</td><td>Provide a product or set of products</td></tr>
    <tr><td>Time Extraction Window</td><td>An extraction time window for data to be queried </td></tr>
  </table>

  [Go to Time Extraction window section](#artesian-sdk-extraction-windows)



  ```Python
  from Artesian import ArtesianConfig
  from Artesian.Query import QueryService, RelativeInterval

  qs = QueryService(cfg)
  data = qs.createAuction() \
      .forMarketData([100011484,100011472,100011477,100011490,100011468,100011462,100011453]) \
      .inAbsoluteDateRange("2018-01-01","2018-01-02") \
      .inTimeZone("UTC") \
      .execute()

  print(data)
  ```

  To construct an Auction Time Series Extraction the following must be provided.

  <table>
    <tr><th>Auction Query</th><th>Description</th></tr>
    <tr><td>Market Data ID</td><td>Provide a market data id or set of market data id's to query</td></tr>
    <tr><td>Time Extraction Window</td><td>An extraction time window for data to be queried</td></tr>
  </table>

  [Go to Time Extraction window section](#artesian-sdk-extraction-windows)



  Extraction window types for queries.

  Date Range

  ```Python
   .inAbsoluteDateRange("2018-08-01", "2018-08-10")
  ```

  Relative Interval

  ```Python
   .inRelativeInterval(RelativeInterval.RollingWeek)
  ```

  Period

  ```Python
   .inRelativePeriod("P5D")
  ```

  Period Range

  ```Python
   .inRelativePeriodRange("P-3D", "P10D")
  ```



  All extraction types (Actual,Versioned, Market Assessment and BidAsk) have an optional filler strategy.

  ```python
  var versionedSeries = qs
    .createVersioned() \
    .forMarketData([100000001]) \
    .forLastNVersions(1) \
    .inGranularity(Granularity.Day) \
    .inAbsoluteDateRange(new Date("2018-1-1"), new Date("2018-1-10")) \
    .withFillLatestValue("P5D") \
    .execute()
  ```

  Use 'Null' to fill the missing timepoint with 'None' values.

  ```python
   .withFillNull()
  ```

  Use 'None' to not fill at all: timepoints are not returned if not present.

  ```python
   .withFillNone()
  ```

  Custom Value can be provided for each MarketDataType.

  Custom Value for Actual extraction type.

  ```python
  .withFillCustomValue(123)
  ```

  Custom Value for BidAsk extraction type.

  ```python
  .withFillCustomValue(
    bestBidPrice = 15.0,
    bestAskPrice = 20.0,
    bestBidQuantity = 30.0,
    bestAskQuantity = 40.0,
    lastPrice = 50.0,
    lastQuantity = 60.0)
  ```

  Custom Value for Market Assessment extraction type.

  ```python
  .withFillCustomValue(
  settlement = 10.0,
  open = 20.0,
  close = 30.0,
  high = 40.0,
  low = 50.0,
  volumePaid = 60.0,
  volueGiven = 70.0,
  volume = 80.0)
  ```

  Custom Value for Versioned extraction type.

  ```python
  .withFillCustomValue(123)
  ```

  Latest Value to propagate the latest value, not older than a certain threshold only if there is a value at the end of the period.

  ```python
   .withFillLatestValue("P5D")
  ```

  ```python
   .withFillLatestValue("P5D", "False")
  ```

  Latest Value to propagate the latest value, not older than a certain threshold even if there's no value at the end.

  ```python
   .withFillLatestValue("P5D", "True")
  ```



  Using MarketDataService is possible to query all the Versions and all the Products curves which has been written in a MarketData.

  ```Python
  from Artesian.MarketData import MarketDataService

  mds = MarketDataService(cfg)

  ```

  To list MarketData curves

  ```Python
  page = 1
  pageSize = 100
  res = mds.readCurveRange(100042422, page, pageSize, versionFrom="2016-12-20" , versionTo="2019-03-12")
  ```



  Using MarketDataService is possible to query and search the MarketData collection with faceted results. Supports paging, filtering and free text.

  ```Python
  from Artesian.MarketData import MarketDataService

  mds = MarketDataService(cfg)

  ```

  To list MarketData curves

  ```Python
  page = 1
  pageSize = 100
  searchText = "Riconsegnato_"
  filters = {"ProviderName": ["SNAM", "France"]}
  sorts=["MarketDataId asc"]
  doNotLoadAdditionalInfo=True
  res = mds.searchFacet(page, pageSize, searchText, filters, sorts, doNotLoadAdditionalInfo)
  ```



  Artesian support Query over GME Public Offers which comes in a custom and dedicated format.



  ```Python
  from Artesian.GMEPublicOffers import GMEPublicOfferService, Market, Purpose, Status, Zone, Scope, UnitType, GenerationType, BAType

  qs = GMEPublicOfferService(cfg)

  data = qs.createQuery() \
      .forDate("2020-04-01") \
      .forMarket([Market.MGP]) \
      .forStatus(Status.ACC) \
      .forPurpose(Purpose.BID) \
      .forZone([Zone.NORD]) \
      .withPagination(1,100) \
      .execute()

  print(data)
  ```

  To construct a GME Public Offer Extraction the following must be provided.

  <table>
    <tr><th>GME Public Offer Query</th><th>Description</th></tr>
    <tr><td>Time Extraction Window</td><td>An extraction time window for data to be queried</td></tr>
    <tr><td>Market</td><td>Provide a market or set of markets to query</td></tr>
     <tr><td>Status</td><td>Provide a status or set of statuses to query</td></tr>
      <tr><td>Purpose</td><td>Provide a purpose or set of purposes to query</td></tr>
       <tr><td>Zone</td><td>Provide a zone to query</td></tr>

  </table>



  Extraction options for GME Public Offer queries.



  ```Python
   .forDate("2020-04-01")
  ```



  ```Python
   .forPurpose(Purpose.BID)
  ```



  ```Python
   .forStatus(Status.ACC)
  ```



  ```Python
   .forOperator(["Operator_1", "Operator_2"])
  ```



  ```Python
   .forUnit(["UP_1", "UP_2"])
  ```



  ```Python
   .forMarket([Market.MGP])
  ```



  ```Python
   .forScope([Scope.ACC, Scope.RS])
  ```



  ```Python
   .forBAType([BAType.NETT, BAType.NERV])
  ```



  ```Python
   .forZone([Zone.NORD])
  ```



  ```Python
   .forUnitType([UnitType.UCV, UnitType.UPV])
  ```



  ```Python
   .forGenerationType(GenerationType.GAS)
  ```



  ```Python
   .withPagination(1,10)
  ```



  Using the MarketDataService is possible to register MarketData and write curves into it using the UpsertData method.

  Depending on the Type of the MarketData, the UpsertData should be composed as per example below.



  ```Python
  from Artesian import ArtesianConfig, Granularity, MarketData
  from Artesian.MarketData import AggregationRule
  from datetime import datetime
  from dateutil import tz

  cfg = ArtesianConfg()

  mkservice = MarketData.MarketDataService(cfg)

  mkdid = MarketData.MarketDataIdentifier('PROVIDER', 'MARKETDATANAME')
  mkd = MarketData.MarketDataEntityInput(
        providerName = mkdid.provider,
        marketDataName = mkdid.name,
        originalGranularity=Granularity.Day,
        type=MarketData.MarketDataType.ActualTimeSerie,
        originalTimezone="CET",
        aggregationRule=AggregationRule.AverageAndReplicate,
        tags={
          'TestSDKPython': ['PythonValue2']
        }
    )

  registered = mkservice.readMarketDataRegistryByName(mkdid.provider, mkdid.name)
  if (registered is None):
    registered = mkservice.registerMarketData(mkd)

  data = MarketData.UpsertData(mkdid, 'CET',
    rows=
    {
        datetime(2020,1,1): 42.0,
        datetime(2020,1,2): 43.0,
    },
    downloadedAt=datetime(2020,1,3).replace(tzinfo=tz.UTC)
    )

  mkservice.upsertData(data)

  ```

  In case we want to write an hourly (or lower) time series the timezone for the upsert data must be UTC:

  ```Python
  mkservice = MarketData.MarketDataService(cfg)

  mkdid = MarketData.MarketDataIdentifier('PROVIDER', 'MARKETDATANAME')
  mkd = MarketData.MarketDataEntityInput(
        providerName = mkdid.provider,
        marketDataName = mkdid.name,
        originalGranularity=Granularity.Hour,
        type=MarketData.MarketDataType.ActualTimeSerie,
        originalTimezone="CET",
        aggregationRule=AggregationRule.AverageAndReplicate,
        tags={
          'TestSDKPython': ['PythonValue2']
        }
    )

  registered = mkservice.readMarketDataRegistryByName(mkdid.provider, mkdid.name)
  if (registered is None):
    registered = mkservice.registerMarketData(mkd)

  data = MarketData.UpsertData(mkdid, 'UTC',
    rows=
    {
        datetime(2020,1,1,5,0,0): 42.0,
        datetime(2020,1,2,6,0,0): 43.0,
        datetime(2020,1,2,7,0,0): 44.0,
        datetime(2020,1,2,8,0,0): 45.0,
        datetime(2020,1,2,9,0,0): 46.0,
    },
    downloadedAt=datetime(2020,1,3).replace(tzinfo=tz.UTC)
    )

  mkservice.upsertData(data)

  ```



  ```Python
  from Artesian import ArtesianConfig, Granularity, MarketData
  from Artesian.MarketData import AggregationRule
  from datetime import datetime
  from dateutil import tz

  cfg = ArtesianConfg()

  mkservice = MarketData.MarketDataService(cfg)

  mkdid = MarketData.MarketDataIdentifier('PROVIDER', 'MARKETDATANAME')
  mkd = MarketData.MarketDataEntityInput(
        providerName = mkdid.provider,
        marketDataName = mkdid.name,
        originalGranularity=Granularity.Day,
        type=MarketData.MarketDataType.VersionedTimeSerie,
        originalTimezone="CET",
        aggregationRule=AggregationRule.AverageAndReplicate,
        tags={
          'TestSDKPython': ['PythonValue2']
        }
    )

  registered = mkservice.readMarketDataRegistryByName(mkdid.provider, mkdid.name)
  if (registered is None):
    registered = mkservice.registerMarketData(mkd)

  data = MarketData.UpsertData(mkdid, 'CET',
    rows=
    {
        datetime(2020,1,1): 42.0,
        datetime(2020,1,2): 43.0,
    },
    version= datetime(2020,1,3,12,0),
    downloadedAt=datetime(2020,1,3).replace(tzinfo=tz.UTC)
    )

  mkservice.upsertData(data)

  ```



  ```Python
  from Artesian import ArtesianConfig, Granularity, MarketData
  from datetime import datetime
  from dateutil import tz

  cfg = ArtesianConfg()
  mkservice = MarketData.MarketDataService(cfg)

  mkdid = MarketData.MarketDataIdentifier('PROVIDER', 'MARKETDATANAME')
  mkd = MarketData.MarketDataEntityInput(
        providerName = mkdid.provider,
        marketDataName = mkdid.name,
        originalGranularity=Granularity.Day,
        type=MarketData.MarketDataType.MarketAssessment,
        originalTimezone="CET",
        tags={
          'TestSDKPython': ['PythonValue2']
        }
    )

  registered = mkservice.readMarketDataRegistryByName(mkdid.provider, mkdid.name)
  if (registered is None):
    registered = mkservice.registerMarketData(mkd)

  marketAssessment = MarketData.UpsertData(MarketData.MarketDataIdentifier('PROVIDER', 'MARKETDATANAME'), 'CET',
    marketAssessment=
    {
        datetime(2020,1,1):
        {
           "Feb-20": MarketData.MarketAssessmentValue(open=10.0, close=11.0),
           "Mar-20": MarketData.MarketAssessmentValue(open=20.0, close=21.0)
        },
            datetime(2020,1,2):
            {
                "Feb-20": MarketData.MarketAssessmentValue(open=11.0, close=12.0),
                "Mar-20": MarketData.MarketAssessmentValue(open=21.0, close=22.0)
            }
    },
    downloadedAt=datetime(2020,1,3).replace(tzinfo=tz.UTC)
    )

  mkservice.upsertData(marketAssessment)

  ```



  ```Python
  from Artesian import ArtesianConfig,Granularity,MarketData
  from datetime import datetime
  from dateutil import tz

  cfg = ArtesianConfg()
  mkservice = MarketData.MarketDataService(cfg)

  mkdid = MarketData.MarketDataIdentifier('PROVIDER', 'MARKETDATANAME')
  mkd = MarketData.MarketDataEntityInput(
        providerName = mkdid.provider,
        marketDataName = mkdid.name,
        originalGranularity=Granularity.Day,
        type=MarketData.MarketDataType.BidAsk,
        originalTimezone="CET",
        tags={
          'TestSDKPython': ['PythonValue2']
        }
    )

  registered = mkservice.readMarketDataRegistryByName(mkdid.provider, mkdid.name)
  if (registered is None):
    registered = mkservice.registerMarketData(mkd)

  bidAsk = MarketData.UpsertData(MarketData.MarketDataIdentifier('PROVIDER', 'MARKETDATANAME'), 'CET',
    bidAsk={
        datetime(2020,1,1):
        {
            "Feb-20":MarketData.BidAskValue(bestBidPrice=15.0, lastQuantity=14.0),
            "Mar-20":MarketData.BidAskValue(bestBidPrice=25.0, lastQuantity=24.0)
        },
        datetime(2020,1,2):
        {
            "Feb-20":MarketData.BidAskValue(bestBidPrice=15.0, lastQuantity=14.0),
            "Mar-20":MarketData.BidAskValue(bestBidPrice=25.0, lastQuantity=24.0)
        }

    },
    downloadedAt=datetime(2020,1,3).replace(tzinfo=tz.UTC)
    )

  mkservice.upsertData(bidAsk)
  ```



  ```Python
  from Artesian import ArtesianConfig,Granularity,MarketData
  from datetime import datetime
  from dateutil import tz

  cfg = ArtesianConfg()
  mkservice = MarketData.MarketDataService(cfg)

  mkdid = MarketData.MarketDataIdentifier('PROVIDER', 'MARKETDATANAME')
  mkd = MarketData.MarketDataEntityInput(
        providerName = mkdid.provider,
        marketDataName = mkdid.name,
        originalGranularity=Granularity.Day,
        type=MarketData.MarketDataType.Auction,
        originalTimezone="CET",
        tags={
          'TestSDKPython': ['PythonValue2']
        }
    )

  registered = mkservice.readMarketDataRegistryByName(mkdid.provider, mkdid.name)
  if (registered is None):
    registered = mkservice.registerMarketData(mkd)

  auctionRows = MarketData.UpsertData(MarketData.MarketDataIdentifier('PROVIDER', 'MARKETDATANAME'), 'CET',
    auctionRows={
        datetime(2020,1,1): MarketData.AuctionBids(datetime(2020,1,1),
            bid=[
                MarketData.AuctionBidValue(11.0, 12.0),
                MarketData.AuctionBidValue(13.0, 14.0),
            ],
            offer=[
                MarketData.AuctionBidValue(21.0, 22.0),
                MarketData.AuctionBidValue(23.0, 24.0),
            ]
        )
    },
    downloadedAt=datetime(2020,1,3).replace(tzinfo=tz.UTC)
    )

    mkservice.upsertData(auctionRows)


  ```



  Using the MarketDataService is possible to delete MarketData and its curves.



  Using the MarketDataService is possible to delete MarketData and its curves.

  ```Python

  from Artesian import ArtesianConfig
  from Artesian.MarketData import MarketDataService

  cfg = ArtesianConfg()
  mkservice = MarketDataService(cfg)

  mkservice.deleteMarketData(100042422)

  ```

  Depending on the Type of the MarketData, the DeletData should be composed as per example below. The timezone is optional: for DateSeries if provided must be equal to MarketData OriginalTimezone Default:MarketData OriginalTimezone. For TimeSeries Default:CET



  ```Python
  from Artesian import ArtesianConfig, Granularity, MarketData
  from Artesian.MarketData import AggregationRule
  from datetime import datetime
  from dateutil import tz

  cfg = ArtesianConfg()

  mkservice = MarketData.MarketDataService(cfg)

  mkdid = MarketData.MarketDataIdentifier('PROVIDER', 'MARKETDATANAME')
  deleteData = MarketData.DeleteData(
      ID=mkdid,
      timezone='CET',
      rangeStart=datetime(2020, 1, 1, 6),
      rangeEnd=datetime(2020, 1, 1, 18),
  )

  mkdservice.deleteData(deleteData)
  ```



  ```Python
  from Artesian import ArtesianConfig, Granularity, MarketData
  from Artesian.MarketData import AggregationRule
  from datetime import datetime
  from dateutil import tz

  cfg = ArtesianConfg()

  mkservice = MarketData.MarketDataService(cfg)

  mkdid = MarketData.MarketDataIdentifier('PROVIDER', 'MARKETDATANAME')
  deleteData = MarketData.DeleteData(
      ID=mkdid,
      timezone='CET',
      rangeStart=datetime(2020, 1, 1, 0),
      rangeEnd=datetime(2020, 1, 7, 0),
      version=datetime(2020, 1, 1, 0)
  )

  mkdservice.deleteData(deleteData)
  ```



  ```Python
  from Artesian import ArtesianConfig, Granularity, MarketData
  from datetime import datetime
  from dateutil import tz

  cfg = ArtesianConfg()
  mkservice = MarketData.MarketDataService(cfg)

  mkdid = MarketData.MarketDataIdentifier('PROVIDER', 'MARKETDATANAME')
  deleteData = MarketData.DeleteData(
      ID= mkdid,
      timezone='CET',
      rangeStart=datetime(2020, 1, 1, 0),
      rangeEnd=datetime(2020, 1, 3, 0),
      product=["Feb-20"]
  )

  mkdservice.deleteData(deleteData)
  ```



  ```Python
  from Artesian import ArtesianConfig, Granularity, MarketData
  from datetime import datetime
  from dateutil import tz

  cfg = ArtesianConfg()
  mkservice = MarketData.MarketDataService(cfg)

  mkdid = MarketData.MarketDataIdentifier('PROVIDER', 'MARKETDATANAME')
  deleteData = MarketData.DeleteData(
      ID= mkdid,
      timezone='CET',
      rangeStart=datetime(2020, 1, 1, 0),
      rangeEnd=datetime(2020, 1, 3, 0),
      product=["Feb-20"]
  )

  mkdservice.deleteData(deleteData)
  ```



  ```Python
  from Artesian import ArtesianConfig, Granularity, MarketData
  from Artesian.MarketData import AggregationRule
  from datetime import datetime
  from dateutil import tz

  cfg = ArtesianConfg()

  mkservice = MarketData.MarketDataService(cfg)

  mkdid = MarketData.MarketDataIdentifier('PROVIDER', 'MARKETDATANAME')
  deleteData = MarketData.DeleteData(
      ID=mkdid,
      timezone='CET',
      rangeStart=datetime(2020, 1, 1, 6),
      rangeEnd=datetime(2020, 1, 1, 18),
  )

  mkdservice.deleteData(deleteData)
  ```



  Artesian SDK uses asyncio internally, this causes a conflict with Jupyter. You can work around this issue by add the following at the beginning of the notebook.

  ```python

  !pip install nest_asyncio

  import nest_asyncio
  nest_asyncio.apply()


  ```

  [Issue #3397 with workaround](https://github.com/jupyter/notebook/issues/3397#issuecomment-419386811)



  - [Github](https://github.com/ARKlab/Artesian.SDK-Python)
  - [Ark Energy](http://www.ark-energy.eu/)
  - [Artesian Portal](https://portal.artesian.cloud)

rpm_license:
  MIT License  Copyright (c) 2022 Ark Energy S.r.l.  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: cb4f09f98c6bade2b241abea28b2c2602811ff2c518fbb3386a654d5f415005b
name: python-arthub-api
arch: src
version: 1.9.5
epoch: 0
release: 1
summary: ArHhub Python SDK
url: https://pypi.org/project/arthub-api/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arthub-api-1.9.5-1.src.rpm
checksum_type: sha256
description:
  This python project provides a series of API interfaces to access the ArtHub server



  You can install via pip.

  ```
  pip install arthub_api
  ```

  or build from source

  ```
  git clone https://git.woa.com/arthub/arthub-python-sdk.git
  cd arthub-python-sdk
  python setup.py install
  ```



  We provide unit tests in ./test, you can use them with pytest

  ```
  pytest ./tests
  ```
  You can test under different domain by passing the parameter 'env'
  ```
  pytest ./tests --env=oa_test
  pytest ./tests --env=qq_test
  pytest ./tests --env=oa
  pytest ./tests --env=qq
  ```



  * Please refer to the SDK usage guide:
    [Usage Guide](./docs/usage_guide.md)
  * If you have any questions, please contact joeyding on WeChat Work



  * [Developer](./docs/developer_guide.md)


pkgId: 9940edf07d9c12d0bae29de3fa8e54e31d3852fff5cf723495f6572589615463
name: python-arthub-api
arch: src
version: 1.9.6
epoch: 0
release: 1
summary: ArHhub Python SDK
url: https://pypi.org/project/arthub-api/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arthub-api-1.9.6-1.src.rpm
checksum_type: sha256
description:
  This python project provides a series of API interfaces to access the ArtHub server







  You can install via pip.



  ```

  pip install arthub_api

  ```



  or build from source



  ```

  git clone https://git.woa.com/arthub/arthub-python-sdk.git

  cd arthub-python-sdk

  python setup.py install

  ```







  We provide unit tests in ./test, you can use them with pytest



  ```

  pytest ./tests

  ```

  You can test under different domain by passing the parameter 'env'

  ```

  pytest ./tests --env=oa_test

  pytest ./tests --env=qq_test

  pytest ./tests --env=oa

  pytest ./tests --env=qq

  ```







  * Please refer to the SDK usage guide:

    [Usage Guide](./docs/usage_guide.md)

  * If you have any questions, please contact joeyding on WeChat Work







  * [Developer](./docs/developer_guide.md)


pkgId: 988c168d8af98415f028cac1cb60fd15806858196a1732a9b6173db6eda0f76b
name: python-articat
arch: src
version: 0.1.16
epoch: 0
release: 1
summary: articat: data artifact catalog
url: https://github.com/related-sciences/articat
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-articat-0.1.16-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/related-sciences/articat/actions/workflows/build.yml/badge.svg?branch=main)](https://github.com/related-sciences/articat/actions/workflows/build.yml)
  [![PYPI](https://img.shields.io/pypi/v/articat.svg)](https://pypi.org/project/articat/)

  Minimal metadata catalog to store and retrieve metadata about data artifacts.



  At a high level, *articat* is simply a key-value store. Value being the Artifact metadata.
  Key a.k.a. "Artifact Spec" being:
   * globally unique `id`
   * optional timestamp: `partition`
   * optional arbitrary string: `version`

  To publish a file system Artifact (`FSArtifact`):

  ```python
  from articat import FSArtifact
  from pathlib import Path
  from datetime import date




  with FSArtifact.partitioned("foo", partition=date(1643, 1, 4)) as fsa:
      
      
      
      

      
      
      data_path = Path("/tmp/data")
      data_path.write_text("42")

      
      
      fsa.stage(data_path)

      
      
      fsa.metadata.description = "Answer to the Ultimate Question of Life, the Universe, and Everything"
  ```

  To retrieve the metadata about the Artifact above:

  ```python
  from articat.fs_artifact import FSArtifact
  from datetime import date
  from pathlib import Path


  fsa = FSArtifact.partitioned("foo", partition=date(1643, 1, 4)).fetch()

  fsa.id # "foo"
  fsa.created # <CREATION-TIMESTAMP>
  fsa.partition # <CREATION-TIMESTAMP>
  fsa.metadata.description # "Answer to the Ultimate Question of Life, the Universe, and Everything"
  fsa.main_dir # Data directory, this is where the data was stored after staging
  Path(fsa.joinpath("data")).read_text() # 42
  ```



   * store and retrieve metadata about your data artifacts
   * no long running services (low maintenance)
   * data publishing utils builtin
   * IO/data format agnostic
   * immutable metadata
   * development mode



  Currently available Artifact flavours:
   * `FSArtifact`: metadata/utils for files or objects (supports: local FS, GCS, S3 and more)
   * `BQArtifact`: metadata/utils for BigQuery tables
   * `NotebookArtifact`: metadata/utils for Jupyter Notebooks



  To ease development of Artifacts, *articat* supports development/dev mode.
  Development Artifact can be indicated by `dev` parameter (preferred), or
  `_dev` prefix in the Artifact `id`. Dev mode supports:
   * overwriting Artifact metadata
   * configure separate locations (e.g. `dev_prefix` for `FSArtifact`), with
     potentially different retention periods etc



   * `local`: mostly for testing/demo, metadata is stored locally (configurable, default: `~/.config/articat/local`)
   * `gcp_datastore`: metadata is stored in the Google Cloud Datastore



  *articat* configuration can be provided in the API, or configuration files. By default configuration
  is loaded from `~/.config/articat/articat.cfg` and `articat.cfg` in current working directory. You
  can also point at the configuration file via environment variable `ARTICAT_CONFIG`.

  You use `local` mode without configuration file. Available options:

   ```toml
  [main]






  [fs]







  [gcp]



  [bq]




  ```



  Below you can see a diagram of our setup, Articat is just one piece of our system, and solves a specific problem. This should give you an idea where it might fit into your environment:

  <p align="center">
    <img src="https://docs.google.com/drawings/d/1wll4Q_PlKGHVu-C2IN8jUIxzFTD8jwFWnvwgFrvq2ls/export/png" alt="Our setup diagram"/>
  </p>


pkgId: eecb1483af12afec0c020d8ef3124b9fd769e5aadbcddaffecdccc4de6f9dfd1
name: python-article-parser
arch: src
version: 1.8.0
epoch: 0
release: 1
summary: A parser that parses articles from any url or html
url: https://github.com/myifeng/article-parser
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-article-parser-1.8.0-1.src.rpm
checksum_type: sha256
description:
  ![](http://img2.chinadaily.com.cn/images/202009/22/5f6962b2a31024adbd959228.jpeg)
  Serbia's Novak Djokovic kisses the trophy after winning the final against
  Argentina's Diego Schwartzman at Italian Open, Foro Italico, Rome, Italy, Sept
  21, 2020. [Photo/Agencies]
  ROME - Novak Djokovic won a record 36th Masters crown as he beat Diego
  Schwartzman in the men's final of the ATP Italian Open on Monday.
  Djokovic, the world number one and the top seed at the tournament, won 7-5,
  6-3 against Argentine Schwartzman to lift his 36th Masters title, one more
  than Rafael Nadal.
  The Serb said he did not play his best tennis this time in Rome, but could
  find it when needed.
  Simona Halep, top seed of the women's draw, won her first title in Rome after
  defending champion Karolina Pliskova of the Czech Republic retired while
  trailing 6-0, 2-1 in the final.
  ```
  * HTML
  ```python
  >>> import article_parser
  >>> title, content = article_parser.parse(url="http://www.chinadaily.com.cn/a/202009/22/WS5f6962b2a31024ad0ba7afcb.html", timeout=5)
  >>> print(title)
  >>> print('----------------')
  >>> print(content)


pkgId: 996b13c1d550721c461e00c85e94e96dfb6d11c2489c48338c0a4b5433b00b20
name: python-articulo
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/articulo/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-articulo-0.5.1-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/mrmegatelo/articulo/graph/badge.svg?token=4UDVH5KHWP)](https://codecov.io/gh/mrmegatelo/articulo)
  [![Python Versions](https://img.shields.io/pypi/pyversions/articulo)](PyPI)
  [![PyPI - Version](https://img.shields.io/pypi/v/articulo)](Version)
  ![GitHub](https://img.shields.io/github/license/mrmegatelo/articulo)



  Tiny library for extraction articles from html.
  It can extract the content of an article, both in text and HTML, and it's title.



  This library is designed to be as simple as possible.
  To start using it just import it and instantiate with link you want to parse as a parameter.

  Also the library designed to work in lazy manner.
  So, until you make a request for some property, it does not send any requests.

  ```python
  from articulo import Articulo


  article = Articulo('https://info.cern.ch/')


  print(article.title) # article title as a string
  print(article.text) # article content as a string
  print(article.markup) # article content as an html markup string
  print(article.icon) # link to article icon
  print(article.description) # article meta description
  print(article.preview) # link to article meta preview image
  print(article.keywords) # article meta keywords list
  ```


  In case you want to see the whole procees just provide parameter `verbose=True` to the instance. It can be helpful for debugging.


  ```python
  from articulo import Articulo


  article = Articulo('https://info.cern.ch/', verbose=True)
  ```


  The whole idea of parsing article content is to define the part of the document that has the highest information density. To find that part there is the so-called `information loss coefficient`. This coefficient determines the decrease in the text density of the document during parsing.

  The default value is `0.7` which stands for `70%` information density decrease. In most cases, this works fine.
  Nevertheless, you can change it in case you have insufficient parsing results. Just provide `theshold` parameter to the `articulo` instance, it might help.

  ```python
  from articulo import Articulo


  article = Articulo('https://info.cern.ch/', threshold=0.3)
  ```


  In some cases  you need to provide additional headers to get an article html from url.
  For that case you can provide headers with `http_headers` parameter when
  you create new instance of `articulo`.

  ```python
  from articulo import Articulo


  headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36' }
  article = Articulo('https://info.cern.ch/', http_headers=headers)
  ```


  Articulo uses `requests` library to get html from url. This library tries to guess the encoding of the response based on the HTTP headers.
  Although it works fine most of the time, in some cases this might not work as expected, and you'll get a mess instead of text. For that case you can provide custom charset with `def_charset` parameter when you create new instance of `articulo`.

  ```python
  from articulo import Articulo


  article = Articulo('https://info.cern.ch/', def_charset='cp1251')
  ```


pkgId: 0d5069646a86ce65d2306dcc33d77b45113696b20f7f04f921063390d4972a09
name: python-artifact-client
arch: src
version: 2.4.5
epoch: 0
release: 1
summary: Python client for the Artifact API
url: https://github.com/Ozone-App/artifact-python-client
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artifact-client-2.4.5-1.src.rpm
checksum_type: sha256
description:
  *DefaultApi* | [**create_graph**](docs/DefaultApi.md#create_graph) | **POST** /graphs | Create a new graph
  *DefaultApi* | [**delete_all_graphs**](docs/DefaultApi.md#delete_all_graphs) | **POST** /graphs/delete_all | Deletes all graphs
  *DefaultApi* | [**delete_graph**](docs/DefaultApi.md#delete_graph) | **POST** /graphs/{graphId}/delete | Delete a graph
  *DefaultApi* | [**get_graph_documents_meta**](docs/DefaultApi.md#get_graph_documents_meta) | **POST** /graphs/{graphId}/documents_meta | Get graph documents meta
  *DefaultApi* | [**get_graph_stats**](docs/DefaultApi.md#get_graph_stats) | **POST** /graphs/{graphId}/stats | Get graph statistics
  *DefaultApi* | [**ingest_document**](docs/DefaultApi.md#ingest_document) | **POST** /graphs/{graphId}/ingest | Ingest a document into a graph
  *DefaultApi* | [**list_graphs**](docs/DefaultApi.md#list_graphs) | **GET** /graphs | List all graphs
  *DefaultApi* | [**query_graph**](docs/DefaultApi.md#query_graph) | **POST** /graphs/{graphId}/query | Query a graph

   - [CreateGraphRequest](docs/CreateGraphRequest.md)
   - [DocumentMeta](docs/DocumentMeta.md)
   - [Graph](docs/Graph.md)
   - [GraphStats](docs/GraphStats.md)
   - [IngestDocumentRequest](docs/IngestDocumentRequest.md)
   - [QueryRequest](docs/QueryRequest.md)
   - [QueryResult](docs/QueryResult.md)
  <a id="documentation-for-authorization"></a>

  Authentication schemes defined for the API:
  <a id="ApiKeyAuth"></a>

  - **Type**: API key
  - **API key parameter name**: Authorization
  - **Location**: HTTP header


pkgId: 3528f4df9b20df6fd2b0ff7d651680112ac3f845fef8a5c96d1039c56ebeb5af
name: python-artifactory
arch: src
version: 0.1.17
epoch: 0
release: 1
summary: A Python to Artifactory interface
url: http://github.com/parallels/artifactory
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artifactory-0.1.17-1.src.rpm
checksum_type: sha256
description:
  |Build Status|
  This module is intended to serve as a logical descendant of
  `pathlib <https://docs.python.org/3/library/pathlib.html>`__, a Python 3
  module for object-oriented path manipulations. As such, it implements
  everything as closely as possible to the origin with few exceptions,
  such as stat().


pkgId: fb0550c2bfc58101ec8bcfb1d0bc36ab138726d4af20ae207438d25ba2c78324
name: python-artifactory-cleanup
arch: src
version: 1.0.12
epoch: 0
release: 1
summary: Rules and cleanup policies for Artifactory
url: https://github.com/devopshq/artifactory-cleanup
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artifactory-cleanup-1.0.12-1.src.rpm
checksum_type: sha256
description:
  `artifactory-cleanup` is an extended and flexible cleanup tool for JFrog Artifactory.

  The tool has simple YAML-defined cleanup configuration and can be extended with your own rules on Python.
  Everything must be as a code, even cleanup policies!



  <!-- toc -->

  - [Artifactory cleanup](#artifactory-cleanup)
  - [Tables of Contents](#tables-of-contents)
  - [Installation](#installation)
  - [Usage](#usage)
    - [Notes](#notes)
    - [Commands](#commands)
  - [Rules](#rules)
    - [Common](#common)
    - [Delete](#delete)
    - [Keep](#keep)
    - [Docker](#docker)
    - [Filters](#filters)
    - [Create your own rule](#create-your-own-rule)
  - [How to](#how-to)
    - [How to connect self-signed certificates for docker?](#how-to-connect-self-signed-certificates-for-docker)
    - [How to clean up Conan repository?](#how-to-clean-up-conan-repository)
    - [How to keep latest N docker images?](#how-to-keep-latest-n-docker-images)
  - [Release](#release)

  <!-- tocstop -->



  As simple as one command!

  ```bash

  docker pull devopshq/artifactory-cleanup
  docker run --rm devopshq/artifactory-cleanup artifactory-cleanup --help


  python3 -mpip install artifactory-cleanup
  artifactory-cleanup --help
  ```



  Suppose you want to remove **all artifacts older than N days** from **reponame** repository.
  You should take the following steps:

  1. Install `artifactory-cleanup` (see above)
  2. Create a configuration file `artifactory-cleanup.yaml`. variables.

  ```yaml

  artifactory-cleanup:
    server: https://repo.example.com/artifactory
    
    user: $ARTIFACTORY_USERNAME
    password: $ARTIFACTORY_PASSWORD

    policies:
      - name: Remove all files from repo-name-here older than 7 days
        rules:
          - rule: Repo
            name: "reponame"
          - rule: DeleteOlderThan
            days: 7
  ```

  3. Run the command **TO SHOW** (not remove) artifacts that will be deleted. By default `artifactory-cleanup` uses "dry
     mode".

  ```bash

  export ARTIFACTORY_USERNAME=usernamehere
  export ARTIFACTORY_PASSWORD=password


  docker run --rm -v "$(pwd)":/app -e ARTIFACTORY_USERNAME -e ARTIFACTORY_PASSWORD devopshq/artifactory-cleanup artifactory-cleanup


  artifactory-cleanup
  ```

  4. Verify that right artifacts will be removed and add `--destroy` flag **TO REMOVE** artifacts:

  ```bash

  docker run --rm -v "$(pwd)":/app -e ARTIFACTORY_USERNAME -e ARTIFACTORY_PASSWORD devopshq/artifactory-cleanup artifactory-cleanup --destroy


  artifactory-cleanup --destroy
  ```

  Looking for more examples? Check [examples](./examples) folder!



  - **Always** specify version of `artifactory-cleanup` when using it in the production. `1.0.0` is just an example, find the latest version in pypi: https://pypi.org/project/artifactory-cleanup/

  ```bash

  docker pull devopshq/artifactory-cleanup:1.0.0
  docker run --rm devopshq/artifactory-cleanup:1.0.0 artifactory-cleanup --version


  python3 -mpip install artifactory-cleanup==1.0.0
  artifactory-cleanup --help
  ```

  - Use CI servers or cron-like utilities to run `artifactory-cleanup` every day (or every hour). TeamCity and GitHub have
    built-in support and show additional logs format
  - Do not save credentials in the configuration file, use environment variables.
  - Use `--ignore-not-found` flag to ignore errors when the repository is not found. It's useful when you have a
    configuration for multiple repositories and some of them are not found.
  - Use `--worker-count=<WORKER_NUM>` to increase the number of workers. By default, it's 1. It's useful when you have a lot of
    artifacts and you want to speed up the process.



  ```bash


  artifactory-cleanup


  artifactory-cleanup --policy-name policytestname



  artifactory-cleanup --destroy


  export ARTIFACTORY_CLEANUP_DESTROY=True
  artifactory-cleanup


  artifactory-cleanup --config artifactory-cleanup.yaml


  export ARTIFACTORY_CLEANUP_CONFIG_FILE=artifactory-cleanup.yaml
  artifactory-cleanup --config artifactory-cleanup.yaml


  artifactory-cleanup --days-in-future=10


  artifactory-cleanup --load-rules=myrule.py
  docker run -v "$(pwd)":/app devopshq/artifactory-cleanup artifactory-cleanup --load-rules=myrule.py


  artifactory-cleanup --output=myfile.txt


  artifactory-cleanup --output=myfile.txt --output-format=json


  artifactory-cleanup --output=myfile.json --output-format json --output-artifacts
  ```





  - `Repo` - Apply the rule to one repository. If no name is specified, it is taken from the rule name (in `CleanupPolicy`
    definition)

  ```yaml
  - rule: Repo
    name: reponame
  ```

  ```yaml


  policies:
    - name: reponame
      rules:
        - rule: Repo
  ```

  - `RepoList` - Apply the policy to list of repositories.

  ```yaml
  - rule: RepoList
    repos:
      - repo1
      - repo2
      - repo3
  ```

  - `RepoByMask` - Apply rule to repositories matching by mask

  ```yaml
  - rule: RepoByMask
    mask: "*.banned"
  ```

  - `PropertyEq`- Delete repository artifacts only with a specific property value (property_key is the name of the
    parameter, property_value is the value)

  ```yaml
  - rule: PropertyEq
    property_key: key-name
    property_value: 1
  ```

  - `PropertyNeq`- Delete repository artifacts only if the value != specified. If there is no value, delete it anyway.
    Allows you to specify the deletion flag `do_not_delete = 1`

  ```yaml
  - rule: PropertyNeq
    property_key: key-name
    property_value: 1
  ```



  - `DeleteOlderThan` - deletes artifacts that are older than N days

  ```yaml
  - rule: DeleteOlderThan
    days: 1
  ```

  - `DeleteWithoutDownloads`  - deletes artifacts that have never been downloaded (DownloadCount=0). Better to use
    with `DeleteOlderThan` rule

  ```yaml
  - rule: DeleteWithoutDownloads
  ```

  - `DeleteOlderThanNDaysWithoutDownloads` - deletes artifacts that are older than N days and have not been
    downloaded

  ```yaml
  - rule: DeleteOlderThanNDaysWithoutDownloads
    days: 1
  ```

  - `DeleteNotUsedSince` - delete artifacts that were downloaded, but for a long time. N days passed. Or not
    downloaded at all from the moment of creation and it's been N days

  ```yaml
  - rule: DeleteNotUsedSince
    days: 1
  ```

  - `DeleteEmptyFolders` - Clean up empty folders in given repository list

  ```yaml
  - rule: DeleteEmptyFolders
  ```

  - `DeleteByRegexpName` - delete artifacts whose name matches the specified regexp

  ```yaml
  - rule: DeleteByRegexpName
    regex_pattern: "\d"
  ```



  - `KeepLatestNFiles` - Leaves the last (by creation time) files in the amount of N pieces. WITHOUT accounting
    subfolders

  ```yaml
  - rule: KeepLatestNFiles
    count: 1
  ```

  - `KeepLatestNFilesInFolder` - Leaves the last (by creation time) files in the number of N pieces in each
    folder

  ```yaml
  - rule: KeepLatestNFilesInFolder
    count: 1
  ```

  - `KeepLatestVersionNFilesInFolder` - Leaves the latest N (by version) files in each
    folder. The definition of the version is using regexp. By default it parses [semver](https://semver.org/) using the regex - `([\d]+\.[\d]+\.[\d]+)")`

  ```yaml
  - rule: KeepLatestVersionNFilesInFolder
    count: 1
    custom_regexp: "[^\\d][\\._]((\\d+\\.)+\\d+)"
  ```

  - `KeepLatestNupkgNVersions` - Leaves N nupkg (adds `*.nupkg` filter) in release feature builds

  ```yaml
  - rule: KeepLatestNupkgNVersions
    count: 1
  ```



  - `DeleteDockerImagesOlderThan` - Delete docker images that are older than N days

  ```yaml
  - rule: DeleteDockerImagesOlderThan
    days: 1
  ```

  - `DeleteDockerImagesOlderThanNDaysWithoutDownloads` - Deletes docker images that are older than N days and have
    not been downloaded

  ```yaml
  - rule: DeleteDockerImagesOlderThanNDaysWithoutDownloads
    days: 1
  ```

  - `DeleteDockerImagesNotUsed` - Removes Docker image not downloaded since N days

  ```yaml
  - rule: DeleteDockerImagesNotUsed
    days: 1
  ```

  - `IncludeDockerImages` - Apply to docker images with the specified names and tags

  ```yaml
  - rule: IncludeDockerImages
    masks: "*singlemask*"
  - rule: IncludeDockerImages
    masks:
      - "*production*"
      - "*release*"
  ```

  - `ExcludeDockerImages` - Exclude Docker images by name and tags.

  ```yaml
  - rule: ExcludeDockerImages
    masks:
      - "*production*"
      - "*release*"
  ```

  - `KeepLatestNVersionImagesByProperty(count=N, custom_regexp='some-regexp', number_of_digits_in_version=X)` - Leaves N
    Docker images with the same major. `(^\d+\.\d+\.\d+$)` is the default regexp how to determine version which matches semver `1.1.1`. If you
    need to add minor then set `number_of_digits_in_version` to 2 or if patch then set to 3 (by default we match major, which 1). Semver tags
    prefixed with `v` are supported by updating the regexp to include (an optional) `v` in the expression (e.g., `(^v?\d+\.\d+\.\d+$)`).

  ```yaml
  - rule: KeepLatestNVersionImagesByProperty
    count: 1
    custom_regexp: "[^\\d][\\._]((\\d+\\.)+\\d+)"
  ```

  - `DeleteDockerImageIfNotContainedInProperties(docker_repo='docker-local', properties_prefix='my-prop', image_prefix=None, full_docker_repo_name=None)`
    \- Remove Docker image, if it is not found in the properties of the artifact repository.

  - `DeleteDockerImageIfNotContainedInPropertiesValue(docker_repo='docker-local', properties_prefix='my-prop', image_prefix=None, full_docker_repo_name=None)`
    \- Remove Docker image, if it is not found in the properties of the artifact repository.



  - `IncludePath` - Apply to artifacts by path / mask.

  ```yaml
  - rule: IncludePath
    masks: "*production*"
  - rule: IncludePath
    masks:
     - "*production*"
     - "*develop*"
  ```

  - `IncludeFilename` - Apply to artifacts by name/mask

  ```yaml
  - rule: IncludeFilename
    masks:
     - "*production*"
     - "*develop*"
  ```

  - `ExcludePath` - Exclude artifacts by path/mask

  ```yaml
  - rule: ExcludePath
    masks:
     - "*production*"
     - "*develop*"
  ```

  - `ExcludeFilename` - Exclude artifacts by name/mask

  ```yaml
  - rule: ExcludeFilename
    masks:
      - "*.tag.gz"
      - "*.zip"
  ```



  If you want to create your own rule, you can do it!

  The basic flow how the tool calls Rules:

  1. `Rule.check(*args, **kwargs)` - verify that the Rule configured right. Call other services to get more information.
  2. `Rule.aql_add_filter(filters)` - add Artifactory Query Language expressions
  3. `Rule.aql_add_text(aql)` - add text to the result aql query
  4. `artifactory-cleanup` calls Artifactory with AQL and pass the result to the next step
  5. `Rule.filter(artifacts)` - filter out artifacts. The method returns **artifacts that will be removed!**.
      - To keep artifacts use `artifacts.keep(artifact)` method

  Create `myrule.py` file at the same folder as `artifactory-cleanup.yaml`:

  ```python

  from typing import List

  from artifactory_cleanup import register
  from artifactory_cleanup.rules import Rule, ArtifactsList


  class MySimpleRule(Rule):
      """
      This doc string is used as rule title

      For more methods look at Rule source code
      """

      def __init__(self, my_param: str, value: int):
          self.my_param = my_param
          self.value = value

      def aql_add_filter(self, filters: List) -> List:
          print(f"Today is {self.today}")
          print(self.my_param)
          print(self.value)
          return filters

      def filter(self, artifacts: ArtifactsList) -> ArtifactsList:
          """I'm here just to print the list"""
          print(self.my_param)
          print(self.value)
          
          
          
          
          return artifacts



  register(MySimpleRule)
  ```

  Use `rule: MySimpleRule` in configuration:

  ```yaml

  - rule: MySimpleRule
    my_param: "Hello, world!"
    value: 42
  ```

  Specify `--load-rules` to the command:

  ```bash

  docker run -v "$(pwd)":/app devopshq/artifactory-cleanup artifactory-cleanup --load-rules=myrule.py


  artifactory-cleanup --load-rules=myrule.py
  ```





  In case you have set up your Artifactory self-signed certificates, place all certificates of the chain of trust into
  the `certificates` folder and add additional argument to the command:

  ```bash
  docker run -v "$(pwd)":/app -v "$(pwd)/certificates":/mnt/self-signed-certs/ devopshq/artifactory-cleanup artifactory-cleanup
  ```



  We can handle conan's metadata by creating two policies:

  1. First one removes files but keep all metadata.
  2. Second one look at folders and if it contains only medata files - removes it (because there's no associated with
     metadata files)

  The idea came from https://github.com/devopshq/artifactory-cleanup/issues/47

  ```yaml

  artifactory-cleanup:
    server: https://repo.example.com/artifactory
    user: $ARTIFACTORY_USERNAME
    password: $ARTIFACTORY_PASSWORD

    policies:
      - name: Conan - delete files older than 60 days
        rules:
          - rule: Repo
            name: "conan-testing"
          - rule: DeleteNotUsedSince
            days: 60
          - rule: ExcludeFilename
            masks:
              - ".timestamp"
              - "index.json"
      - name: Conan - delete empty folders (to fix the index)
        rules:
          - rule: Repo
            name: "conan-testing"
          - rule: DeleteEmptyFolders
          - rule: ExcludeFilename
            masks:
              - ".timestamp"
              - "index.json"
  ```



  We can combine docker rules with usual "files" rules!

  The idea came from https://github.com/devopshq/artifactory-cleanup/issues/61

  ```yaml

  artifactory-cleanup:
    server: https://repo.example.com/artifactory
    user: $ARTIFACTORY_USERNAME
    password: $ARTIFACTORY_PASSWORD

    policies:
      - name: Remove docker images, but keep last 3
        rules:
          
          - rule: Repo
            name: docker-demo
          
          - rule: DeleteDockerImagesOlderThan
            days: 30
          
          - rule: ExcludeDockerImages
            masks:
              - "*:latest"
              - "*:release*"
          
          - rule: ExcludePath
            masks: "*base-tools*"
          
          - rule: KeepLatestNFilesInFolder
            count: 3
  ```



  In order to provide a new release of `artifactory-cleanup`, there are two steps involved.

  1. Bump the version in the [setup.py](setup.py)
  2. Bump the version in the [__init__.py](./artifactory_cleanup/__init__.py)
  3. Create a Git release tag (in format `1.0.1`) by creating a release on GitHub


pkgId: 690dfff7fecec10e123613b708b94becf49fdd1d3ce684ffb8054d7f09a644d7
name: python-artifactory-vk
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/artifactory-vk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artifactory-vk-0.1.2-1.src.rpm
checksum_type: sha256
description:
  Artifactory — a service for managing blob resources with no sweat.

  [PyPI package](https://pypi.org/project/artifactory-vk/)



  ```bash
  pip install artifactory-vk
  ```



  ```python
  import artifactory as art
  from artifactory.shortcuts import upload_resource, download_resource


  config = art.ClientConfig(
      artifactory_endpoint = 'https://artifactory.domain',
  )
  client = art.Client(config)

  resource_id = upload_resource(
      client,
      'Hello, World!',
      hard_ttl_s=30,
  )
  ```



  * See [examples](examples) folder


pkgId: 9d50c57dc610e05b3e5ffbc1a8c1fddda2501367b0189f0f43bfa41d840fb316
name: python-artifacts
arch: src
version: 20240518
epoch: 0
release: 1
summary: ForensicArtifacts.com Artifact Repository.
url: https://github.com/ForensicArtifacts/artifacts
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artifacts-20240518-1.src.rpm
checksum_type: sha256
description:
  A free, community-sourced, machine-readable knowledge base of forensic artifacts that the world can use both as an information source and within other tools.


pkgId: 373348ab910d42272eae796ddfe8bb903412b61b6e710e4fda4d8b4a0bb655b4
name: python-artifacts-keyring
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: "Automatically retrieve credentials for Azure Artifacts."
url: https://github.com/Microsoft/artifacts-keyring
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artifacts-keyring-0.4.0-1.src.rpm
checksum_type: sha256
description:
  'artifacts-keyring' is a relatively thin wrapper around [artifacts-credprovider](https://github.com/microsoft/artifacts-credprovider).  Make sure to also look at that repository for more information about different scenarios. For example:

  * [Environment variable to explicitly override tokens](https://github.com/microsoft/artifacts-credprovider)
  * [Safely using credentials in docker](https://github.com/dotnet/dotnet-docker/blob/master/documentation/scenarios/nuget-credentials.md#using-the-azure-artifact-credential-provider)



  The `artifacts-keyring` package provides authentication for publishing or consuming Python packages to or from Azure Artifacts feeds within [Azure DevOps](https://azure.com/devops).

  This package is an extension to [keyring](https://pypi.org/project/keyring), which will automatically find and use it once installed.

  Both [pip](https://pypi.org/project/pip) and [twine](https://pypi.org/project/twine) will use `keyring` to
  find credentials.



  To install this package, run the following `pip` command:

  ```
  pip install artifacts-keyring
  ```





  To use `artifacts-keyring` to set up authentication between `pip`/`twine` and Azure Artifacts, the following requirements must be met:

  * pip version **19.2** or higher
  * twine version **1.13.0** or higher
  * python version **3.0** or higher
  * .Net runtime 6.0.X or later is installed. Refer to [here](https://learn.microsoft.com/dotnet/core/install/) for installation guideline.


  Once `artifacts-keyring` is installed, to publish a package, use the following `twine` command, replacing **<org_name>** and **<feed_name>** with your own:

  ```
  twine upload --repository-url https://pkgs.dev.azure.com/<org_name>/_packaging/<feed_name>/pypi/upload <package_wheel_or_other_dist_format>
  ```


  Once `artifacts-keyring` is installed, to consume a package, use the following `pip` command, replacing **<org_name>** and **<feed_name>** with your own, and **<package_name>** with the package you want to install:

  ```
  pip install <package_name> --index-url https://pkgs.dev.azure.com/<org_name>/_packaging/<feed_name>/pypi/simple
  ```


  The `artifacts-keyring` package is layered on top of our [Azure Artifacts Credential Provider](https://github.com/microsoft/artifacts-credprovider). Check out that link to the GitHub repo for more information on configuration options.



  - `ARTIFACTS_KEYRING_NONINTERACTIVE_MODE`: Controls whether the underlying credential provider can issue interactive prompts.



  This project welcomes contributions and suggestions.  Most contributions require you to agree to a
  Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
  the rights to use your contribution. For details, visit https://cla.microsoft.com.

  When you submit a pull request, a CLA-bot will automatically determine whether you need to provide
  a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions
  provided by the bot. You will only need to do this once across all repos using our CLA.

  This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
  For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or
  contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.


pkgId: 9a265d70c8215aa7e278a816fd239fa6e8cf87fb5a3edf7b7e13df14778cc121
name: python-artifactsmmo-wrapper
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: A Python API Wrapper for ArtifactsMMO
url: https://github.com/Veillax/ArtifactsMMO-Wrapper
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artifactsmmo-wrapper-1.1.0-1.src.rpm
checksum_type: sha256
description:
  This wrapper is a third-party tool and is not officially affiliated with Artifacts MMO. Use it responsibly and at your own risk. Be aware of the game's terms of service and avoid any actions that could violate them.


  This is a Python wrapper for interacting with the Artifacts MMO API, providing an easy way to interact with the game's data, perform in-game actions, and manage character and account information. This library simplifies API requests and provides a range of features to integrate with Artifacts MMO's online functionalities.


  - **Character Management**: Create, delete, and manage character data.
  - **In-Game Actions**: Move, gather, craft, fight, and other interactive commands.
  - **Task Management**: Accept, complete, and exchange tasks from the taskmaster.
  - **Grand Exchange**: Manage buy and sell orders, view order history.
  - **Inventory and Equipment Management**: View, equip, and manage items.
  - **Bank and Gold Management**: Deposit and withdraw gold or items.
  - **Leaderboard and Events**: View event and leaderboard data.


  Some of the following text is taken from the ArtifactsMMO Website to ensure it is accurate and well put for newcommers to be able to understand. It is adapted to

  Artifacts is an asynchronous MMORPG in which you can control up to 5 characters at the same time. Your characters can fight monsters, gather resources, craft items and much more.

  Unlike a traditional game, you'll have to write your own scripts in your preferred programming language to control your characters via an API.

  This wrapper is an easy way to get started with playing ArtifactsMMO Season 3. It allows you to access the API without writing too much complex code.

  For another quick start, you can write your first Javascript scripts directly in the client's code editor, otherwise you can use any language you like on your own IDE. You can see examples in other programming languages in the [Reference API](https://api.artifactsmmo.com/docs/#/).


  The first step is to [create your account](https://artifactsmmo.com/account/create) and your first character [by logging in](https://artifactsmmo.com/account/characters). After that you'll need your token, which you can find [on your account](https://artifactsmmo.com/account/).

  ![API Token Box](https://artifactsmmo.com/images/docs/token.png)

  **⚠️ The token is used by the server to identify you when you make requests. It is important to keep it secret.**

  You can now open the game client by [clicking here](https://artifactsmmo.com/client).

  **Ready to start?**

  Visit [Not available right now](#) to view the python package


  [ArtifactsMMO Website](https://artifactsmmo.com/)
  [ArtifactsMMO Discord](https://discord.com/invite/prEBQ8a6Vs)
  [ArtifactsMMO Docs](https://docs.artifactsmmo.com/)
  [ArtifactsMMO Encyclopidea](https://artifactsmmo.com/encyclopedia)
  [ArtifactsMMO API Docs](https://api.artifactsmmo.com/docs/#/)


pkgId: 0c154b7cb8a3d1bffaf1e2528860b2550f8938afbc5c1a7f21a3b967927b789c
name: python-artifactsmmo-wrapper
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: A Python API Wrapper for ArtifactsMMO
url: https://github.com/Veillax/ArtifactsMMO-Wrapper
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artifactsmmo-wrapper-1.2.3-1.src.rpm
checksum_type: sha256
description:
  [![Upload Python Package](https://github.com/Veillax/ArtifactsMMO-Wrapper/actions/workflows/python-publish.yml/badge.svg)](https://github.com/Veillax/ArtifactsMMO-Wrapper/actions/workflows/python-publish.yml)


  This wrapper is a third-party tool and is not officially affiliated with Artifacts MMO. Use it responsibly and at your own risk. Be aware of the game's terms of service and avoid any actions that could violate them.


  This is a Python wrapper for interacting with the Artifacts MMO API, providing an easy way to interact with the game's data, perform in-game actions, and manage character and account information. This library simplifies API requests and provides a range of features to integrate with Artifacts MMO's online functionalities.


  - **Character Management**: Create, delete, and manage character data.
  - **In-Game Actions**: Move, gather, craft, fight, and other interactive commands.
  - **Task Management**: Accept, complete, and exchange tasks from the taskmaster.
  - **Grand Exchange**: Manage buy and sell orders, view order history.
  - **Inventory and Equipment Management**: View, equip, and manage items.
  - **Bank and Gold Management**: Deposit and withdraw gold or items.
  - **Leaderboard and Events**: View event and leaderboard data.



  `pip install artifactsmmo-wrapper`


  `conda install artifactsmmo-wrapper`


  ```bash
  mkdir artifactsmmo-wrapper
  cd artifactsmmo-wrapper

  git clone https://github.com/veillax/ArtifactsMMO-Wrapper.git
  cd ArtifactsMMO-Wrapper


  pip install .




  ```


  Some of the following text is taken from the ArtifactsMMO Website to ensure it is accurate and well put for newcommers to be able to understand. It is adapted to

  Artifacts is an asynchronous MMORPG in which you can control up to 5 characters at the same time. Your characters can fight monsters, gather resources, craft items and much more.

  This wrapper however is thus far a synchronous wrapper, so you have to use the threading module to control more than one character at once

  Unlike a traditional game, you'll have to write your own scripts in your preferred programming language to control your characters via an API.

  This wrapper is an easy way to get started with playing ArtifactsMMO Season 3. It allows you to access the API without writing too much complex code.

  For another quick start, you can write your own Javascript scripts directly in the client's code editor, otherwise you can use any language you like on your own IDE. You can see examples in other programming languages in the [Reference API](https://api.artifactsmmo.com/docs/#/).


  The first step is to [create your account](https://artifactsmmo.com/account/create) and your first character [by logging in](https://artifactsmmo.com/account/characters). After that you'll need your token, which you can find [on your account](https://artifactsmmo.com/account/).

  ![API Token Box](https://artifactsmmo.com/images/docs/token.png)

  **⚠️ The token is used by the server to identify you when you make requests. It is important to keep it secret.**

  You can now open the game client by [clicking here](https://artifactsmmo.com/client).

  **Ready to start?**

  Visit [ArtifactsMMO Wrapper on PyPi](https://pypi.org/project/artifactsmmo-wrapper/) to view the python package


  [ArtifactsMMO Website](https://artifactsmmo.com/)
  [ArtifactsMMO Discord](https://discord.com/invite/prEBQ8a6Vs)
  [ArtifactsMMO Docs](https://docs.artifactsmmo.com/)
  [ArtifactsMMO Encyclopidea](https://artifactsmmo.com/encyclopedia)
  [ArtifactsMMO API Docs](https://api.artifactsmmo.com/docs/#/)


pkgId: 08f9b48320146b8dc5b7951c938513029723efff1f9913578771c82e17d296d6
name: python-artifax
arch: src
version: 0.5
epoch: 0
release: 1
summary: python package for building artifacts from a computational graph
url: https://github.com/brunolange/artifax
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artifax-0.5-1.src.rpm
checksum_type: sha256
description:
  ![Tests](https://github.com/brunolange/artifax/actions/workflows/pythonpackage.yml/badge.svg)
  ![Coverage](https://img.shields.io/codecov/c/github/brunolange/artifax?color=%2334D058)

  artifax is a Python package to evaluate nodes in a computation graph where
  the dependencies associated with each node are extracted directly from their
  function signatures. Here's an example of `artifax` in action:

  ```python
  >>> from artifax import build
  >>> import math
  >>> build({
  ...     'x': math.pi/3,
  ...     'sin': lambda x: math.sin(x),
  ...     'cos': lambda x: math.cos(x),
  ...     'y': lambda sin, cos: 2*sin - 1.2*cos
  ... })
  {'x': 1.0471975511965976, 'sin': 0.8660254037844386, 'cos': 0.5000000000000001, 'y': 1.132050807568877}
  ```

  Install with pip:

  ```bash
  $ python3 -m pip install artifax
  ```

  A computation graph can be entirely encoded in a standard python dictionary.
  Each key represents a node or an artifact, that will eventually be computed
  once all of its dependencies have been calculated. The value associated with
  each key can be either a constant - a string, a number or an instance of a class,
  or a function. In the latter case, the function arguments map to other nodes
  in the computation graph to establish a direct dependency between the nodes.

  For example, the following dictionary:

  ```python
  artifacts = {
      'A': 42,
      'B': 7,
      'C': lambda: 10,
      'AB': lambda A, B: A*B,
      'C-B': lambda B, C: C - B,
      'greeting': 'Hello',
      'message': lambda greeting, A: '{} World! The answer is {}.'.format(greeting, A)
  }
  ```
  yields the following computation graph:

  ![Screenshot](sample-dag.png)
  <div style="font-style:italic">Figure 1. Example of a computation graph.</div>

  The `build` function evalutes the entire computation graph and returns a new dictionary
  with the same keys as the original one and with the calculated values for each of the nodes
  in the computation graph.

  ```python
  from artifax import build

  artifacts = {
      'A': 42,
      'B': 7,
      'C': lambda: 10,
      'AB': lambda A, B: A*B,
      'C-B': lambda B, C: C - B,
      'greeting': 'Hello',
      'message': lambda greeting, A: '{} World! The answer is {}.'.format(greeting, A)
  }
  result = build(artifacts)

  for k, v in result.items():
      print(f"{k:<10}: {v}")
  ```
  outputs
  ```shell
  A         : 42
  B         : 7
  C         : 10
  AB        : 294
  C-B       : 3
  greeting  : Hello
  message   : Hello World! The answer is 42.
  ```



  The `build` function represents the core transformation that yields artifacts.
  It is entirely stateless and has no side-effects. Given the same input graph, it will always
  evaluate every single node and generate the same results.

  Whilst these features are highly desirable from any core component, the stateful `Artifax`
  class can be employed to interface with the build function and provide some additional features
  and performance enhancements.

  ```python
  from artifax import Artifax, At

  def double(x):
      return x*2

  afx = Artifax()
  afx.set('a', 42)
  afx.set('b', At('a', double))

  afx.set(c=lambda b: -b)

  assert len(afx) == 3
  assert 'b' in afx

  results = afx.build()
  for k, v in results.items():
      print(k, v)




  ```



  Artifax instances optimize sequential builds by only re-evaluating nodes that
  have become stale due to an update. For example, given the graph illustrated in
  Figure 1, if node `B` is updated, e.g, `afx.set('B', -5))`, nodes `B`, `AB` and
  `C-B` get re-evaluated when the build method is invoked, but not any other
  nodes.

  In the example below, the second call to the `build` method triggers a
  re-evaluation of node `p1` and all the nodes that depend on it. Nodes `v2` and
  `m2`, on the other hand, do not require re-evaluation since they do not depend
  on the updated node.

  ```python
  import artifax
  import math

  class Vector:
      def __init__(self, u, v):
          self.u = u
          self.v = v
      def magnitude(self):
          print('Calculating magnitude of vector {}...'.format(self))
          return math.sqrt(self.u**2 + self.v**2)
      def __repr__(self):
          return '({}, {})'.format(self.u, self.v)

  afx = artifax.Artifax(
      p1=(3, 4),
      v1=lambda p1: Vector(*p1),
      m1=lambda v1: v1.magnitude(),
      v2=Vector(5, 12),
      m2=lambda v2: v2.magnitude()
  )
  _ = afx.build()
  print('Updating p1...')
  afx.set(p1=(1, 1))
  _ = afx.build()
  ```

  ```
  Calculating magnitude of vector (3, 4)...
  Calculating magnitude of vector (5, 12)...
  Updating p1...
  Calculating magnitude of vector (1, 1)...
  ```


  The `build` method accepts an optional argument that specifies which node in
  your computation graph should be built. Instead of returning the usual dictionary,
  targeted builds return a tuple containing the value associated with each of the
  target nodes.

  ```python
  terminal_node_value = afx.build(targets='terminal_node')
  some_node, another_node = afx.build(targets=('node1', 'node2'))

  ```

  Targeted builds only evaluate dependencies for the target node and the target node itself.
  Any other nodes in the computation graph do not get evaluated.

  ```python
  from artifax import Artifax
  afx = Artifax({
      'name': 'World',
      'punctuation': '?',
      'greeting': lambda name, punctuation: 'Hello, {}{}'.format(name, punctuation),
  })
  greeting = afx.build(targets='greeting')
  print(greeting) # prints "Hello, World?"
  afx.set('punctuation', '!')
  greeting, punctuation = afx.build(targets=('greeting', 'punctuation'))
  print(greeting) # prints "Hello, World!"
  print('Cool beans{}'.format(punctuation)) # prints "Cool beans!"
  ```

  Targeted builds are an efficient way of retrieving certain nodes without
  evaluating the entire computation graph.



  Depending on the use case, different solvers can be employed to increase performance.
  The `build` function and methods accept an optional `solver` parameter which defaults to
  `linear`.



  The linear solver topologically sorts the computation graph to define a sequence
  of nodes to be calculated in an order such that for any node, all of its dependencies appear
  before in the sequence.



  The `parallel` solver consumes the computation graph starting from the nodes that have
  no dependencies and processes them all in parallel. When this initial set of nodes is resolved,
  their immediate neighbors make up the new frontier which also gets processed in parallel.
  This procedure continues until there are no more nodes to be calculated. At any step, the
  solver spawns one new process for each node at the frontier without exceeding the number of
  available cores minus 1.



  The `async` solver takes the parallelism of the `parallel` solver one step further. It is triggered
  each time a node evaluation is completed, looking for new nodes that can be started and evaluating
  them in a new process immediately.



  If the computation graph represented by the artifacts dictionary is not a DAG
  (Direct Acyclic Graph), a `CircularDependencyError` exception is thrown.

  ```python
  import artifax
  try:
      _ = artifax.build({'x': lambda x: x+1})
  except artifax.CircularDependencyError as err:
      print('Cannot build artifacts: {}'.format(err))
  ```
  ```
  Cannot build artifacts: artifact graph is not a DAG
  ```

  If a particular node is represented by a function for which any of its arguments isn't part
  of the computation graph, an `UnresolvedDependencyError` exception is thrown.

  ```python
  _ = artifax.build({
      'x': 42,
      'p': lambda x, y: x + y
  }) # raises UnresolvedDependencyError due to missing 'y' node
  ```

  However, sometimes this behavior might be desirable if we want nodes to resolve to partially
  applied functions that can be used elsewhere. If that's the case, the exception can be suppressed
  by setting the `allow_partial_functions` optional parameter to `build` to `True`.

  ```python
  results = artifax.build({
      'x': 42,
      'p': lambda x, y: x + y
  }, allow_partial_functions=True)
  print(results['p'](100)) # prints 142
  ```


pkgId: 33742ef222c3e35257c78cdeb9a479b0c45f39833c69db480c5857de78981511
name: python-artify
arch: src
version: 1.10.9
epoch: 0
release: 1
url: https://github.com/stewiejnr
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artify-1.10.9-1.src.rpm
checksum_type: sha256
summary:
  Upload to Nexus, Upload files to hooks, Modify version number, Sync to GitLab type repository, Extract command from Git commit message, Create SonarQube project, Generate template files and Create archives

description:
  You can download and install the latest version of this software from the Python package index (PyPI) as follows::
      pip install --upgrade artify


pkgId: 426f969fe2423624319213dc66f0778d1207c9dad3abb10f48298fce38f6ece2
name: python-artigen
arch: src
version: 0.0.88
epoch: 0
release: 1
summary: A small example package
url: https://github.com/pypa/sampleproject
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artigen-0.0.88-1.src.rpm
checksum_type: sha256
description:
  Here , you can give a description of your project.



  You can install the package using pip:
  pip install -i https://test.pypi.org/simple/


pkgId: fda8a1d6aed02c8e62d673e45ca0b95b8517f04cb17073ee85b39a8b54f57d29
name: python-artist-getter
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: Getty ULAN and WikiData scraping utilities for artists
url: https://github.com/fangyizhu/artist-getter
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artist-getter-0.4.3-1.src.rpm
checksum_type: sha256
description:
  Building on top of [sfmoma/getty-getter](https://github.com/sfmoma/getty-getter) to retrieve artist information from
  both Getty ULAN and WikiData.



  `pip install artist-getter`

  Getty Getter was built on Django 1.8 and Python 3.12.



  [Getty Getter](https://github.com/sfmoma/getty-getter) was a script developed by SFMOMA for associating artists with the
  Getty ULAN vocabulary and gathering additional metadata
  based on an artist's ULAN.

  The ULAN vocabulary is a wealth of information regarding people and organizations involved in art and culture. More
  about ULAN can be found [here](http://www.getty.edu/research/tools/vocabularies/ulan/about.html).

  Wikidata is later added as a supplement on top of ULAN, in case there are entries missing from one of the two artist
  databases. Together they constitute Artist Getter.

  This script is a work in progress.



  Right now there are four basic functions.



  `get_getty_ulan` which consumes and artist's name (formatted    `u'Last, First'`) and does a best guess match against
  similar names in the Getty ULAN vocabulary. The returned data will include the name of the artist or organization, the
  ULAN, the "type" og thing returned (e.g. person, organization etc) and a scope note, which is a brief summary of the
  artist's career.

  `get_getty_ulan(u"Stieglitz, Alfred")`

  ```
  {'scopenote': u'Renowned photographer Stieglitz first studied photochemistry with Hermann Wilhelm Vogel at the Technische Hochschule in Berlin, from 1882-1886, and took his first photographs in 1883. He continued to travel and photograph in Germany, Austria, and Switzerland until 1890, when he returned to New York City. From 1890 to 1895 he was a partner in a photogravure firm. During this time he concentrated on photographing the streets of New York City. In 1894, Stieglitz travelled to Europe and was elected a member of the Linked Ring, a pictorialist society in London. In 1902, Stieglitz founded the Photo-Secession Movement which attempted to prove that pictorialist photography was a fine art form. From 1903 to 1917, Stieglitz was publisher and director of Camera Work magazine. The graphic section was run by Edward Steichen (1879-1973). In 1905, Stieglitz opened the Little Galleries of the Photo-Secession "291" on Fifth Avenue in New York City with Steichen. The galleries operated until 1917. In 1907, Stieglitz exhibited his autochrome photographs. Stieglitz stopped photographing in 1937. During his lifetime, Stieglitz was also a close friend and collaborator of Joseph T. Keiley. Together they invented the glycerine process which permitted partial development of platinum papers. Also, they produced joint research on the history of photography. Keiley also acted as the associate editor of Stieglitz\'\'s publications "Camera Notes" and "Camera Works". American photographer.', 'ulan': u'500024301', 'type': u'Persons, Artists', 'term': u'Stieglitz, Alfred'}
  ```



  `get_getty_relationship` which consumes an artist's ULAN and returns a list of the relationships that artist had with
  other artists in the ULAN vocabulary. The `object_ulan` being the ULAN of the related person or organization.
  `get_getty_relationship("500024301")`

  ```
  {'relationship_type': u'student of', 'object_ulan': u'500063166'}{'relationship_type': u'influenced', 'object_ulan': u'500007426'}{'relationship_type': u'colleague of', 'object_ulan': u'500004441'}{'relationship_type': u'collaborated with', 'object_ulan': u'500001336'}{'relationship_type': u'collaborated with', 'object_ulan': u'500000431'}{'relationship_type': u'spouse of', 'object_ulan': u'500018666'}{'relationship_type': u'friend of', 'object_ulan': u'500070483'}
  ```



  `get_getty_artist_name` which consumes an ULAN and returns just the artist's name formatted `Last, First`.
  `get_getty_artist_name("500024301")`
  ```Stieglitz, Alfred```



  `get_getty_artist_data` which consumes an ULAN and returns entire set of data from given ulan as a dictionary.
  `get_getty_artist_data("500024301")`

  ```
  {
  '@context': 'https://linked.art/ns/v1/linked-art.json',
  '_label': 'Stieglitz, Alfred',
  'born': { 'id': 'http://vocab.getty.edu/ulan/activity/birth/4000062133',
  'timespan': { 'begin_of_the_begin': '1864-01-01T00:00:00',
      'end_of_the_end': '1864-12-31T23:59:59',
      'id': 'http://vocab.getty.edu/ulan/time/birth/4000062133',
      'type': 'TimeSpan' },
  'took_place_at': [ { '_label': 'Hoboken',
      'id': 'http://vocab.getty.edu/tgn/7013711-place',
      'type': 'Place' } ],
  ...
  ```

  The dictionary is parsed from [this json file on ULAN](http://vocab.getty.edu/ulan/500024301.json)



  `get_getty_artist_name` which consumes an ULAN and returns just the artist's sex as a string, available sexes are '
  male', 'female' and None if unknown.
  `get_getty_artist_sex("500024301")`

  `male`



  `get_wiki_artist_data` consumes a WikiData ID like `Q948598` and returns the entire data set from WikiData.


  `get_wiki_artist_data` consumes a WikiData ID and returns the artist name in 'First Last' format, as seen on WikiData.

  `get_wiki_artist_name("Q948598")`

  `Albert Pinkham Ryder`


  `get_wiki_artist_sex` which consumes a WikiData ID and returns just the artist's gender and sex as a string, available sexes are '
  male', 'female' and None if unknown.

  `get_wiki_artist_sex("Q948598")`

  `male`



  ```python
  from django.views.generic.base import View
  from django.http import HttpResponse
  from artist_getter import *
  import json


  class GetUlanView(View):
      def get(self, request):
          artist_ulan = json.dumps(get_getty_ulan(u"Stieglitz, Alfred"))

          return HttpResponse(artist_ulan, content_type="application/json")
  ```



  For maintainers of this package only.

  Download setuptools:
  `pip install --upgrade setuptools`

  First, bump up the release version in setup.py.

  Run this command to build package:
  `python -m build`

  Run checks before releasing to PyPI:
  `twine check --strict dist/*`

  Release to PYPI by:
  `twine upload --skip-existing dist/*`

  Push everything and create a release on GitHub.


pkgId: 856a509a582f860030e2ba859c0657bf020da4be1ca1be9992e165f1ed9d0429
name: python-artist-getter
arch: src
version: 0.4.4
epoch: 0
release: 1
summary: Getty ULAN and WikiData scraping utilities for artists
url: https://github.com/fangyizhu/artist-getter
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artist-getter-0.4.4-1.src.rpm
checksum_type: sha256
description:
  Building on top of [sfmoma/getty-getter](https://github.com/sfmoma/getty-getter) to retrieve artist information from
  both Getty ULAN and WikiData.



  `pip install artist-getter`

  Getty Getter was built on Django 1.8 and Python 3.12.



  [Getty Getter](https://github.com/sfmoma/getty-getter) was a script developed by SFMOMA for associating artists with the
  Getty ULAN vocabulary and gathering additional metadata
  based on an artist's ULAN.

  The ULAN vocabulary is a wealth of information regarding people and organizations involved in art and culture. More
  about ULAN can be found [here](http://www.getty.edu/research/tools/vocabularies/ulan/about.html).

  Wikidata is later added as a supplement on top of ULAN, in case there are entries missing from one of the two artist
  databases. Together they constitute Artist Getter.

  This script is a work in progress.



  Right now there are four basic functions.



  `get_getty_ulan` consumes and artist's name (formatted    `u'Last, First'`) and does a best guess match against
  similar names in the Getty ULAN vocabulary. The returned data will include the name of the artist or organization, the
  ULAN, the "type" og thing returned (e.g. person, organization etc) and a scope note, which is a brief summary of the
  artist's career.

  `get_getty_ulan(u"Stieglitz, Alfred")`

  ```
  {'scopenote': u'Renowned photographer Stieglitz first studied photochemistry with Hermann Wilhelm Vogel at the Technische Hochschule in Berlin, from 1882-1886, and took his first photographs in 1883. He continued to travel and photograph in Germany, Austria, and Switzerland until 1890, when he returned to New York City. From 1890 to 1895 he was a partner in a photogravure firm. During this time he concentrated on photographing the streets of New York City. In 1894, Stieglitz travelled to Europe and was elected a member of the Linked Ring, a pictorialist society in London. In 1902, Stieglitz founded the Photo-Secession Movement which attempted to prove that pictorialist photography was a fine art form. From 1903 to 1917, Stieglitz was publisher and director of Camera Work magazine. The graphic section was run by Edward Steichen (1879-1973). In 1905, Stieglitz opened the Little Galleries of the Photo-Secession "291" on Fifth Avenue in New York City with Steichen. The galleries operated until 1917. In 1907, Stieglitz exhibited his autochrome photographs. Stieglitz stopped photographing in 1937. During his lifetime, Stieglitz was also a close friend and collaborator of Joseph T. Keiley. Together they invented the glycerine process which permitted partial development of platinum papers. Also, they produced joint research on the history of photography. Keiley also acted as the associate editor of Stieglitz\'\'s publications "Camera Notes" and "Camera Works". American photographer.', 'ulan': u'500024301', 'type': u'Persons, Artists', 'term': u'Stieglitz, Alfred'}
  ```



  `get_getty_relationship` consumes an artist's ULAN and returns a list of the relationships that artist had with
  other artists in the ULAN vocabulary. The `object_ulan` being the ULAN of the related person or organization.
  `get_getty_relationship("500024301")`

  ```
  {'relationship_type': u'student of', 'object_ulan': u'500063166'}{'relationship_type': u'influenced', 'object_ulan': u'500007426'}{'relationship_type': u'colleague of', 'object_ulan': u'500004441'}{'relationship_type': u'collaborated with', 'object_ulan': u'500001336'}{'relationship_type': u'collaborated with', 'object_ulan': u'500000431'}{'relationship_type': u'spouse of', 'object_ulan': u'500018666'}{'relationship_type': u'friend of', 'object_ulan': u'500070483'}
  ```



  `get_getty_artist_name` consumes an ULAN and returns just the artist's name formatted `Last, First`.
  `get_getty_artist_name("500024301")`
  ```Stieglitz, Alfred```



  `get_getty_artist_data` consumes an ULAN and returns entire set of data from given ulan as a dictionary.
  `get_getty_artist_data("500024301")`

  ```
  {
  '@context': 'https://linked.art/ns/v1/linked-art.json',
  '_label': 'Stieglitz, Alfred',
  'born': { 'id': 'http://vocab.getty.edu/ulan/activity/birth/4000062133',
  'timespan': { 'begin_of_the_begin': '1864-01-01T00:00:00',
      'end_of_the_end': '1864-12-31T23:59:59',
      'id': 'http://vocab.getty.edu/ulan/time/birth/4000062133',
      'type': 'TimeSpan' },
  'took_place_at': [ { '_label': 'Hoboken',
      'id': 'http://vocab.getty.edu/tgn/7013711-place',
      'type': 'Place' } ],
  ...
  ```

  The dictionary is parsed from [this json file on ULAN](http://vocab.getty.edu/ulan/500024301.json)



  `get_getty_artist_name` consumes an ULAN and returns just the artist's sex as a string, available sexes are '
  male', 'female' and None if unknown.
  `get_getty_artist_sex("500024301")`

  `male`



  `get_getty_artist_birth_year` consumes an ULAN and returns artist birth year as an integer

  `get_getty_artist_birth_year("500024301")`

  `1864`




  `get_wiki_artist_data` consumes a WikiData ID like `Q948598` and returns the entire data set from WikiData.


  `get_wiki_artist_data` consumes a WikiData ID and returns the artist name in 'First Last' format, as seen on WikiData.

  `get_wiki_artist_name("Q948598")`

  `Albert Pinkham Ryder`


  `get_wiki_artist_sex` consumes a WikiData ID and returns just the artist's gender and sex as a string, available sexes are '
  male', 'female' and None if unknown.

  `get_wiki_artist_sex("Q948598")`

  `male`


  `get_wiki_artist_birth_year` consumes a WikiData ID and returns just the artist's birth year as an integer.

  `get_wiki_artist_birth_year("Q948598")`

  `1864`



  ```python
  from django.views.generic.base import View
  from django.http import HttpResponse
  from artist_getter import *
  import json


  class GetUlanView(View):
      def get(self, request):
          artist_ulan = json.dumps(get_getty_ulan(u"Stieglitz, Alfred"))

          return HttpResponse(artist_ulan, content_type="application/json")
  ```



  For maintainers of this package only.

  Download setuptools:
  `pip install --upgrade setuptools`

  First, bump up the release version in setup.py.

  Run this command to build package:
  `python -m build`

  Run checks before releasing to PyPI:
  `twine check --strict dist/*`

  Release to PYPI by:
  `twine upload --skip-existing dist/*`

  Push everything and create a release on GitHub.


  `pip uninstall artist-getter`

  Change to the dist directory and install the newest distribution by calling:
  `pip install artist_getter-$NEWEST_EDITION`


pkgId: 9026d3815f4242a5b428f251d8b432096dac00a21a0b05e4705d7556adbf7739
name: python-artistools
arch: src
version: 2024.10.28
epoch: 0
release: 1
summary: Plotting and analysis tools for the ARTIS 3D radiative transfer code for supernovae and kilonovae.
url: https://pypi.org/project/artistools/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artistools-2024.10.28-1.src.rpm
checksum_type: sha256
description:
  > Artistools is collection of plotting, analysis, and file format conversion tools for the [ARTIS](https://github.com/artis-mcrt/artis) radiative transfer code.

  [![DOI](https://zenodo.org/badge/53433932.svg)](https://zenodo.org/badge/latestdoi/53433932)
  [![Installation and pytest](https://github.com/artis-mcrt/artistools/actions/workflows/pytest.yml/badge.svg)](https://github.com/artis-mcrt/artistools/actions/workflows/pytest.yml)
  [![codecov](https://codecov.io/gh/artis-mcrt/artistools/branch/main/graph/badge.svg?token=XFlarJqeZd)](https://codecov.io/gh/artis-mcrt/artistools)
  ![PyPI - Version](https://img.shields.io/pypi/v/artistools)


  Requires Python >= 3.10

  artistools can be installed from PyPI using `pip install artistools'. For development, clone the repository and make an editable install:
  ```sh
  git clone https://github.com/artis-mcrt/artistools.git
  cd artistools
  python3 -m pip install -e .
  pre-commit install
  ```


  Type "artistools" at the command-line to get a full list of commands. The most frequently used commands are:
  - artistools plotspectra
  - artistools plotlightcurve
  - artistools plotestimators
  - artistools plotnltepops
  - artistools describeinputmodel

  Use the -h option to get a list of command-line arguments for each command. Most of these commands would usually be run from within an ARTIS simulation folder.



  ![Emission plot](https://github.com/artis-mcrt/artistools/raw/main/images/fig-emission.png)
  ![NLTE plot](https://github.com/artis-mcrt/artistools/raw/main/images/fig-nlte-Ni.png)
  ![Estimator plot](https://github.com/artis-mcrt/artistools/raw/main/images/fig-estimators.png)


  Distributed under the MIT license. See [LICENSE](https://github.com/artis-mcrt/artistools/blob/main/LICENSE.txt) for more information.

  [https://github.com/artis-mcrt/artistools](https://github.com/artis-mcrt/artistools)




  If you artistools for a paper or presentation, please cite it. For details, see [https://zenodo.org/badge/latestdoi/53433932](https://zenodo.org/badge/latestdoi/53433932).


pkgId: 78094f0e33cc5a59a461a0b1f601133d60210c2c8b0945eafbc48b3219efc663
name: python-artlib
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: A Python library for Adaptive Resonance Theory (ART) algorithms.
url: https://github.com/NiklasMelton/AdaptiveResonanceLib
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artlib-0.1.3-1.src.rpm
checksum_type: sha256
description:
  Welcome to AdaptiveResonanceLib, a comprehensive and modular Python library for Adaptive Resonance Theory (ART) algorithms. Based on scikit-learn, our library offers a wide range of ART models designed for both researchers and practitioners in the field of machine learning and neural networks. Whether you're working on classification, clustering, or pattern recognition, AdaptiveResonanceLib provides the tools you need to implement ART algorithms efficiently and effectively.

  <!-- START available_models -->


  AdaptiveResonanceLib includes implementations for the following ART models:

  - #### Elementary Clustering
      - [ART1](https://adaptiveresonancelib.readthedocs.io/en/latest/artlib.html#artlib.ART1)
      - [ART2](https://adaptiveresonancelib.readthedocs.io/en/latest/artlib.html#artlib.ART2A)
      - [Bayesian ART](https://adaptiveresonancelib.readthedocs.io/en/latest/artlib.html#artlib.BayesianART)
      - [Gaussian ART](https://adaptiveresonancelib.readthedocs.io/en/latest/artlib.html#artlib.GaussianART)
      - [Hypersphere ART](https://adaptiveresonancelib.readthedocs.io/en/latest/artlib.html#artlib.HypersphereART)
      - [Ellipsoid ART](https://adaptiveresonancelib.readthedocs.io/en/latest/artlib.html#artlib.EllipsoidART)
      - [Fuzzy ART](https://adaptiveresonancelib.readthedocs.io/en/latest/artlib.html#artlib.FuzzyART)
      - [Quadratic Neuron ART](https://adaptiveresonancelib.readthedocs.io/en/latest/artlib.html#artlib.QuadraticNeuronART)
  - #### Metric Informed
      - [CVI ART](https://adaptiveresonancelib.readthedocs.io/en/latest/artlib.html#artlib.CVIART)
      - [iCVI Fuzzy ART](https://adaptiveresonancelib.readthedocs.io/en/latest/artlib.html#artlib.iCVIFuzzyART)
  - #### Topological
      - [Topo ART](https://adaptiveresonancelib.readthedocs.io/en/latest/artlib.html#artlib.TopoART)
      - [Dual Vigilance ART](https://adaptiveresonancelib.readthedocs.io/en/latest/artlib.html#artlib.DualVigilanceART)
  - #### Classification
      - [Simple ARTMAP](https://adaptiveresonancelib.readthedocs.io/en/latest/artlib.html#artlib.SimpleARTMAP)
  - #### Regression
      - [ARTMAP](https://adaptiveresonancelib.readthedocs.io/en/latest/artlib.html#artlib.ARTMAP)
      - [Fusion ART](https://adaptiveresonancelib.readthedocs.io/en/latest/artlib.html#artlib.FusionART)
  - #### Hierarchical
      - [DeepARTMAP](https://adaptiveresonancelib.readthedocs.io/en/latest/artlib.html#artlib.DeepARTMAP)
      - [SMART](https://adaptiveresonancelib.readthedocs.io/en/latest/artlib.html#artlib.SMART)
  - #### Data Fusion
      - [Fusion ART](https://adaptiveresonancelib.readthedocs.io/en/latest/artlib.html#artlib.FusionART)
  - #### Reinforcement Learning
      - [FALCON](https://adaptiveresonancelib.readthedocs.io/en/latest/artlib.html#artlib.FALCON)
      - [TD-FALCON](https://adaptiveresonancelib.readthedocs.io/en/latest/artlib.html#artlib.TD_FALCON)
  - #### Biclustering
      - [Biclustering ARTMAP](https://adaptiveresonancelib.readthedocs.io/en/latest/artlib.biclustering.html#artlib.biclustering.BARTMAP.BARTMAP)

  <!-- END available_models -->

  <!-- START comparison_of_elementary_models -->


  [comment]: <> (![Comparison of Elementary Images]&#40;https://github.com/NiklasMelton/AdaptiveResonanceLib/raw/main/docs/_static/comparison_of_elementary_methods.jpg?raw=true"&#41;)
  ![Comparison of Elementary Images](https://github.com/NiklasMelton/AdaptiveResonanceLib/raw/main/img/comparison_of_elementary_methods.jpg?raw=true")
  <!-- END comparison_of_elementary_models -->

  <!-- START installation -->


  To install AdaptiveResonanceLib, simply use pip:

  ```bash
  pip install artlib
  ```

  Or to install directly from the most recent source:

  ```bash
  pip install git+https://github.com/NiklasMelton/AdaptiveResonanceLib.git@develop
  ```

  Ensure you have Python 3.9 or newer installed.
  <!-- END installation -->

  <!-- START quick-start -->


  Here are some quick examples to get you started with AdaptiveResonanceLib:



  ```python
  from artlib import FuzzyART
  import numpy as np


  train_X = np.array([...]) # shape (n_samples, n_features)
  test_X = np.array([...])


  model = FuzzyART(rho=0.7, alpha = 0.0, beta=1.0)


  train_X_prep = model.prepare_data(train_X)
  test_X_prep = model.prepare_data(test_X)


  model.fit(train_X_prep)


  predictions = model.predict(test_X_prep)
  ```



  ```python
  from artlib import GaussianART, SimpleARTMAP
  import numpy as np


  train_X = np.array([...]) # shape (n_samples, n_features)
  train_y = np.array([...]) # shape (n_samples, ), must be integers
  test_X = np.array([...])


  sigma_init = np.array([0.5]*train_X.shape[1]) # variance estimate for each feature
  module_a = GaussianART(rho=0.0, sigma_init=sigma_init)


  model = SimpleARTMAP(module_a=module_a)


  train_X_prep = model.prepare_data(train_X)
  test_X_prep = model.prepare_data(test_X)


  model.fit(train_X_prep, train_y)


  predictions = model.predict(test_X_prep)
  ```



  ```python
  from artlib import FuzzyART, HypersphereART, FusionART
  import numpy as np


  train_X = np.array([...]) # shape (n_samples, n_features_X)
  train_y = np.array([...]) # shape (n_samples, n_features_y)
  test_X = np.array([...])


  module_x = FuzzyART(rho=0.0, alpha = 0.0, beta=1.0)


  r_hat = 0.5*np.sqrt(train_X.shape[1]) # no restriction on hyperpshere size
  module_y = HypersphereART(rho=0.0, alpha = 0.0, beta=1.0, r_hat=r_hat)


  gamma_values = [0.5, 0.5] # eqaul weight to both channels
  channel_dims = [
    2*train_X.shape[1], # fuzzy ART complement codes data so channel dim is 2*n_features
    train_y.shape[1]
  ]
  model = FusionART(
    modules=[module_x, module_y],
    gamma_values=gamma_values,
    channel_dims=channel_dims
  )


  train_Xy = model.join_channel_data(channel_data=[train_X, train_y])
  train_Xy_prep = model.prepare_data(train_Xy)
  test_Xy = model.join_channel_data(channel_data=[train_X], skip_channels=[1])
  test_Xy_prep = model.prepare_data(test_Xy)


  model.fit(train_X_prep, train_y)


  pred_y = model.predict_regression(test_Xy_prep, target_channels=[1])
  ```

  <!-- END quick-start -->

  <!-- START documentation -->


  For more detailed documentation, including the full list of parameters for each model, visit our [Read the Docs page](https://adaptiveresonancelib.readthedocs.io/en/latest/index.html).
  <!-- END documentation -->

  <!-- START examples -->


  For examples of how to use each model in AdaptiveResonanceLib, check out the [`/examples`](https://github.com/NiklasMelton/AdaptiveResonanceLib/tree/develop/examples) directory in our repository.
  <!-- END examples -->

  <!-- START contributing -->


  We welcome contributions to AdaptiveResonanceLib! If you have suggestions for improvements, or if you'd like to add more ART models, please see our `CONTRIBUTING.md` file for guidelines on how to contribute.

  You can also join our [Discord server](https://discord.gg/E465HBwEuN) and participate directly in the discussion.
  <!-- END contributing -->

  <!-- START license -->


  AdaptiveResonanceLib is open source and available under the MIT license. See the [`LICENSE`](https://github.com/NiklasMelton/AdaptiveResonanceLib/blob/develop/LICENSE) file for more info.
  <!-- END license -->

  <!-- START contact -->


  For questions and support, please open an issue in the GitHub issue tracker or message us on our [Discord server](https://discord.gg/E465HBwEuN). We'll do our best to assist you.

  Happy Modeling with AdaptiveResonanceLib!
  <!-- END contact -->

  <!-- START citation -->

  If you use this project in your research, please cite it as:

  Melton, N. (2024). AdaptiveResonanceLib (Version 0.1.3)
  <!-- END citation -->


pkgId: bc4273797e43f33c0101d5e9a60fae5c7ee602d25b48f5191203428ced2a7c3b
name: python-artur-tancredo-alvarenga-puc-csv-converter
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Trabalho da PUC - converter arquivo(s) de csv para json e json para csv
url: https://pypi.org/project/artur-tancredo-alvarenga-puc-csv-converter/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artur-tancredo-alvarenga-puc-csv-converter-1.1.1-1.src.rpm
checksum_type: sha256
description:
  .CSV para JSON

  .JSON para CSV.



  Esse é um trabalho proposta na disciplina de Python da Pós Graduação da PUC-MG, cujo objetivo é usar o PATH para a conversão de arquivos de CSV para JSON e/ou JSON para CSV.



  Ler um arquivo de **CSV** ou **JSON** e até mesmo, ler uma pasta com arquivos de **CSV** ou **JSON** , cujo objetivo é converter **CSV-JSON** ou **JSON-CSV**. Este projeto é um programa de execução no terminal, de preferÊncia instalado com **pipx**:

  ```bash
  pipx install artur_tancredo_alvarenga_puc_csv_converter
  ```

  Para usar, basta digitar:



  ```bash
  converter_CSV_JSON --help
  ```



  ```bash
  converter_JSON_CSV --help
  ```


pkgId: 33c8b9d6ae25f85274be718e580644bc15f98ab992422eaf7164b9591051cf15
name: python-artypy
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: Lightweight library for artistic filters
url: https://github.com/artypy/arty
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-artypy-0.10.0-1.src.rpm
checksum_type: sha256
description:
  ```bash
  pip install artypy
  ```

  If you want to use cuda for nn module, you should install pytorch with cuda, or simply:
  ```bash
  pip install artypy[cuda]
  ```

  You can see usage examples in the _demo folder of the github repository:

  https://github.com/artypy/arty


pkgId: 4aa7463dca7f985a68b4d46b1c28142bd78892a0eae77ea4a87b90bb6e2250ca
name: python-arus
arch: src
version: 1.1.22
epoch: 0
release: 1
summary: Activity Recognition with Ubiquitous Sensing
url: https://github.com/qutang/arus
rpm_license: GNU
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arus-1.1.22-1.src.rpm
checksum_type: sha256
description:
  __ARUS__ python package provides a computational and experimental framework to manage and process sensory data or wireless devices, to develop and run activity recognition algorithms on the data, and to create interactive programs using the algorithms and wireless devices.

  This package is licensed under [GPL version 3](https://qutang.github.io/arus/LICENSE/).

  [![PyPI version](https://badge.fury.io/py/arus.svg)](https://badge.fury.io/py/arus)
  [![Downloads](https://pepy.tech/badge/arus)](https://pepy.tech/project/arus)
  [![deployment build](https://github.com/qutang/arus/workflows/deploy/badge.svg)](https://github.com/qutang/arus/actions?query=workflow%3Adeploy)
  [![unittest and build test](https://github.com/qutang/arus/workflows/unittest%20and%20build%20test/badge.svg)](https://github.com/qutang/arus/actions?query=workflow%3A%22unittest+and+build+test%22)
  [![codecov](https://codecov.io/gh/qutang/arus/branch/master/graph/badge.svg)](https://codecov.io/gh/qutang/arus)



  ```bash
  python >= 3.7.0
  ```

  ```bash

  Visual Studio C++ SDK (v14.1)
  Windows SDK (10.0.16299.0)
  Windows SDK (10.0.17763.0)


  libbluetooth-dev
  libboost-all-dev
  bluez
  ```



  ```bash
  > pip install arus

  > pip install arus[metawear]
  > pip install arus[demo]
  > pip install arus[dev]
  > pip install arus[nn]
  ```



  `arus[metawear]`: This optional component installs dependency supports for streaming data from Bluetooth metawear sensors.

  `arus[demo]`: This optional component installs dependency supports for running the demo app that demonstrates a real-time interactive activity recognition training and testing program.

  `arus[dev]`: These optional component installs dependency supports for running some package and version management functions in the `arus.dev` module.

  `arus[nn]`: The optional component installs dependency supports for PyTorch and Tensorboard, which are required by `arus.models.report` module. Note that for Windows, you should install the `torch` package manually using `pip` following the `pytorch.org` instruction.



  ```bash
  > git clone https://github.com/qutang/arus.git
  > cd arus
  > # Install poetry python package management tool https://python-poetry.org/docs/
  > # On Linux
  > curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python
  > # On windows powershell
  > (Invoke-WebRequest -Uri https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py -UseBasicParsing).Content | python
  > # Install package dependencies
  > poetry install
  > # Install optional component dependencies
  > poetry install --extras "metawear demo dev nn"
  > # Run unit tests
  > poetry run python -m pytest
  ```



  1. Use Google's python coding guidance: http://google.github.io/styleguide/pyguide.html.
  2. Use `arus package release VERSION --release` to bump and tag versions. `VERSION` can be manual version code following semantic versioning, `path`, `minor`, or `major`.
  3. Changelogs are automatically generated when building the documentation website, do not create it manually.
  4. Pypi release will be handled by github action `deploy.yml`, which will be triggered whenever a new tag is pushed. Therefore, developers should only tag release versions.
  5. After commits, even not bumping and releasing the package, you may run `arus package docs --release` to update the documentation website, where the developer version changelogs will be updated immediately.


pkgId: 830799e5e49fde41936048a217acb32410067136a6e1b0f2215fa92b547006a2
name: python-arvados-cwl-runner
arch: src
version: 2.7.4
epoch: 0
release: 1
summary: Arvados Common Workflow Language runner
url: https://arvados.org
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arvados-cwl-runner-2.7.4-1.src.rpm
checksum_type: sha256
description:
  .. Copyright (C) The Arvados Authors. All rights reserved.
  ..
  .. SPDX-License-Identifier: Apache-2.0

  Arvados Common Workflow Language (CWL) runner.


pkgId: ae9934daefbd35b4549310a2cf333f43ffffbae01b8a4c8616cfa102b501b713
name: python-arvi
arch: src
version: 0.1.24
epoch: 0
release: 1
summary: The Automated RV Inspector
url: https://pypi.org/project/arvi/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arvi-0.1.24-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img width = "140" src="https://github.com/j-faria/arvi/blob/main/docs/logo/logo.png?raw=true"/>
  </p>

  This package sits alongside [DACE](https://dace.unige.ch/) to help with the
  analysis of radial velocity datasets.
  It has been used within the ESPRESSO GTO program, and may be useful for other
  surveys and instruments.




  Install `arvi` using pip

  ```sh
  pip install arvi


  pip install arvi -U # to update
  ```


  Then either directly import a given target

  ```py
  from arvi import HD1234
  ```

  or create an instance of the `RV` class

  ```py
  from arvi import RV
  s = RV('HD1234', instrument='ESPRESSO')
  ```



  ![PyPI - Version](https://img.shields.io/pypi/v/arvi)



  [![Deploy docs](https://github.com/j-faria/arvi/actions/workflows/docs-gh-pages.yml/badge.svg)](https://github.com/j-faria/arvi/actions/workflows/docs-gh-pages.yml)
  [![Install-Test](https://github.com/j-faria/arvi/actions/workflows/install.yml/badge.svg)](https://github.com/j-faria/arvi/actions/workflows/install.yml)
  [![Upload Python Package](https://github.com/j-faria/arvi/actions/workflows/python-publish.yml/badge.svg)](https://github.com/j-faria/arvi/actions/workflows/python-publish.yml)


pkgId: a4d40e227c66a9490e52446644a38efbb34966b6407bf177f45a624ffe7f3273
name: python-arviz
arch: src
version: 0.19.0
epoch: 0
release: 1
summary: Exploratory analysis of Bayesian models
url: http://github.com/arviz-devs/arviz
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arviz-0.19.0-1.src.rpm
checksum_type: sha256
description:
  <p>
  <table>
  <tr>
    <td>
    <a href= "https://python.arviz.org/en/latest/examples/plot_forest_ridge.html">
    <img alt="Ridge plot"
    src="https://python.arviz.org/en/latest/_images/mpl_plot_forest_ridge.png" width="300" height="auto" />
    </a>
    </td>
    <td>
    <a href="https://python.arviz.org/en/latest/examples/plot_forest.html">
    <img alt="Forest Plot"
    src="https://python.arviz.org/en/latest/_images/mpl_plot_forest.png" width="300" height="auto" />
    </a>
    </td>
    <td>
    <a href="https://python.arviz.org/en/latest/examples/plot_violin.html">
    <img alt="Violin Plot"
    src="https://python.arviz.org/en/latest/_images/mpl_plot_violin.png" width="300" height="auto" />
    </a>
    </td>
  </tr>
  <tr>
    <td>
    <a href="https://python.arviz.org/en/latest/examples/plot_ppc.html">
    <img alt="Posterior predictive plot"
    src="https://python.arviz.org/en/latest/_images/mpl_plot_ppc.png" width="300" height="auto" />
    </a>
    </td>
    <td>
    <a href="https://python.arviz.org/en/latest/examples/plot_dot.html">
    <img alt="Joint plot"
    src="https://python.arviz.org/en/latest/_images/mpl_plot_dot.png" width="300" height="auto" />
    </a>
    </td>
    <td>
    <a href="https://python.arviz.org/en/latest/examples/plot_posterior.html">
    <img alt="Posterior plot"
    src="https://python.arviz.org/en/latest/_images/mpl_plot_posterior.png" width="300" height="auto" />
    </a>
    </td>
  </tr>
  <tr>
    <td>
    <a href="https://python.arviz.org/en/latest/examples/plot_density.html">
    <img alt="Density plot"
    src="https://python.arviz.org/en/latest/_images/mpl_plot_density.png" width="300" height="auto" />
    </a>
    </td>
    <td>
    <a href="https://python.arviz.org/en/latest/examples/plot_pair.html">
    <img alt="Pair plot"
    src="https://python.arviz.org/en/latest/_images/mpl_plot_pair.png" width="300" height="auto" />
    </a>
    </td>
    <td>
    <a href="https://python.arviz.org/en/latest/examples/plot_pair_hex.html">
    <img alt="Hexbin Pair plot"
    src="https://python.arviz.org/en/latest/_images/mpl_plot_pair_hex.png" width="300" height="auto" />
    </a>
    </td>
  </tr>
  <tr>
    <td>
    <a href="https://python.arviz.org/en/latest/examples/plot_trace.html">
    <img alt="Trace plot"
    src="https://python.arviz.org/en/latest/_images/mpl_plot_trace.png" width="300" height="auto" />
    </a>
    </td>
    <td>
    <a href="https://python.arviz.org/en/latest/examples/plot_energy.html">
    <img alt="Energy Plot"
    src="https://python.arviz.org/en/latest/_images/mpl_plot_energy.png" width="300" height="auto" />
    </a>
    </td>
    <td>
    <a href="https://python.arviz.org/en/latest/examples/plot_rank.html">
    <img alt="Rank Plot"
    src="https://python.arviz.org/en/latest/_images/mpl_plot_rank.png" width="300" height="auto" />
    </a>
    </td>
  </tr>
  </table>
  <div>
    <a href="https://python.arviz.org/en/latest/examples/index.html">And more...</a>
  </div>

  ArviZ is tested on Python 3.10, 3.11 and 3.12, and depends on NumPy, SciPy, xarray, and Matplotlib.

  If you use ArviZ and want to cite it please use [![DOI](http://joss.theoj.org/papers/10.21105/joss.01143/status.svg)](https://doi.org/10.21105/joss.01143)
  Here is the citation in BibTeX format
  ```
  @article{arviz_2019,
    doi = {10.21105/joss.01143},
    url = {https://doi.org/10.21105/joss.01143},
    year = {2019},
    publisher = {The Open Journal},
    volume = {4},
    number = {33},
    pages = {1143},
    author = {Ravin Kumar and Colin Carroll and Ari Hartikainen and Osvaldo Martin},
    title = {ArviZ a unified library for exploratory analysis of Bayesian models in Python},
    journal = {Journal of Open Source Software}
  }
  ```

  ArviZ is a community project and welcomes contributions.
  Additional information can be found in the [Contributing Readme](https://github.com/arviz-devs/arviz/blob/main/CONTRIBUTING.md)

  ArviZ wishes to maintain a positive community. Additional details
  can be found in the [Code of Conduct](https://github.com/arviz-devs/arviz/blob/main/CODE_OF_CONDUCT.md)

  ArviZ is a non-profit project under NumFOCUS umbrella. If you want to support ArviZ financially, you can donate [here](https://numfocus.org/donate-to-arviz).

  [![NumFOCUS](https://www.numfocus.org/wp-content/uploads/2017/07/NumFocus_LRG.png)](https://numfocus.org)


pkgId: 6cf6aade73867ee45e2f39be35d5e061cb3d7962952aa876378c793a09d431f2
name: python-arxette
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: autoregressive fit
url: https://pypi.org/project/arxette/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arxette-0.2.0-1.src.rpm
checksum_type: sha256
description:
  autoregressive model with exogeneous variables



  ```sh
  $ pip install arxette
  ```



  ```python
  import numpy as np
  from arxette import ARX, GARCH
  ```

  ```python
  y = np.random.randn(20)
  x = np.random.randn(20,5)
  mod = ARX()
  mod.fit(y,x)
  ```

  The `fit` method minimize the nll. Alternative one could use the OLS estimator with

  ```python
  mod.fit_ols(y,x)
  ```

  Once the model is fit, one can inspect the fitted parameters

  ```python
  mod.params # nll
  mod.params_ols # ols
  ```



  To run the tests, install `pytest` and run

  ```sh
  pytest
  ```

  which tests that the params fit by both methods are pretty close.


pkgId: b6b402c9660ae7d0fe06b2ace0607872d4b11c0650c0bfc7a95e4558eb239cbe
name: python-arxiv-client
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Python3 client for the arXiv API
url: https://pypi.org/project/arxiv-client/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arxiv-client-0.3.2-1.src.rpm
checksum_type: sha256
description:
  Python3 client for the [arXiv API](https://info.arxiv.org/help/api/user-manual.html).
  Install package [`arxiv_client`](https://pypi.org/project/arxiv-client/) from PyPI.

  This differs from the pre-existing [arxiv.py](https://github.com/lukasschwab/arxiv.py) project
  in that it further abstracts away the arXiv API so you do not need to learn to construct
  query strings. The overall goal is to enable users to skip reading the API docs entirely.



  - Simple structured queries
  - Comprehensive entity models, with documentation
    - For example, see the [Category](src/arxiv_client/category.py) enum for arXiv's category taxonomy
  - Fully type annotated





  ```py
  import arxiv_client as arx


  client = arx.Client()
  articles = client.rss_by_subject(arx.Subject.COMPUTER_SCIENCE)
  ```



  ```py
  import arxiv_client as arx


  categories = [arx.Category.CS_AI, arx.Category.CS_CL, arx.Category.CS_IR]
  client = arx.Client()
  articles = client.search(arx.Query(keywords=["llm"], categories=categories, max_results=10))
  for article in articles:
      print(article)
  ```



  When using the structured `Query` fields, multiple values within a single field are combined using `OR`,
  and multiple fields are combined using `AND`.



  The `Query` object accepts the following field filters:

  - `keywords`: terms across all fields
  - `title_keywords`: terms in the article title
  - `author_names`: names in the author list
  - `categories`: arXiv subject categories
  - `abstract_keywords`: terms in the article abstract
  - `comment_keywords`: terms in the author provided comment
  - `article_ids`: arXiv article IDs
  - `custom_params`: custom query string



  ```py
  Query(keywords=["llm"], categories=[Category.CS_AI, Category.CS_IR], max_results=5)













  ```

  Results in the following query logic:

  ```
  ("llm") in any field AND (cs.AI OR cs.IR) in the categories
  ```

  See the [Query](src/arxiv_client/query.py) class for more information.



  If the provided simple query logic is insufficient, the `Query` object takes a self-built query string through the `custom_params` attribute. You do not need to URL encode this value.

  See [arXiv Query Construction](https://info.arxiv.org/help/api/user-manual.html#51-details-of-query-construction) for more information on building your own queries.



  ```py
  custom = f"cat:{Category.CS_AI.value} ANDNOT cat:{Category.CS_RO.value}"
  Query(keywords=["paged attention", "attention window"], custom_params=custom)













  ```

  Results in the following query logic:

  ```
  ("paged attention" OR "attention window") in any field AND (cs.AI AND NOT cs.RO) in the categories
  ```

  Equivalent query string:

  ```
  (all:"paged attention" OR all:"attention window") AND (cat:cs.AI ANDNOT cat:cs.RO)
  ```



  The arXiv search API is unreliable, especially for large queries.

  The API will sometimes return incomplete results or return no entries,
  although the response is valid. See this [GitHub issue](https://github.com/lukasschwab/arxiv.py/issues/43)
  for discussion on the topic.

  If you are encountering this problem, some things that may help include:

  - Reduce the page size; `100` seems to have a relatively high success rate
  - Increase paging retry and delay parameters
  - Break up large queries into smaller queries

  Retries often help with the issue, but are sometimes insufficient.
  If you need more reliable access to large query results, consider looking into
  the [arXiv Bulk Data Access](https://info.arxiv.org/help/bulk_data.html) options.



  This uses [hatch](https://hatch.pypa.io/latest/) for project management.

rpm_license:
  MIT License  Copyright (c) 2024 Jerry Lin  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: f1a92ffb6d2f8086a3447d88288eea7e9cc312dee8a5e655578e1b5b555781b5
name: python-arxiv-dl
arch: src
version: 1.1.5
epoch: 0
release: 1
summary: Command-line arXiv Papers Downloader. Citation extraction and PDF naming automation.
url: https://github.com/MarkHershey/arxiv-dl
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arxiv-dl-1.1.5-1.src.rpm
checksum_type: sha256
description:
  Command-line [ArXiv](https://arxiv.org/) & [CVF Open Access](https://openaccess.thecvf.com/menu) Paper Downloader.
  [[PyPI]](https://pypi.org/project/arxiv-dl/)
  [[Source]](https://github.com/MarkHershey/arxiv-dl)

  [![](https://img.shields.io/pypi/v/arxiv-dl)](https://pypi.org/project/arxiv-dl/)
  [![](https://img.shields.io/pypi/pyversions/arxiv-dl)](https://pypi.org/project/arxiv-dl/)
  [![](https://img.shields.io/pypi/wheel/arxiv-dl)](https://github.com/MarkHershey/arxiv-dl/releases)
  [![](https://img.shields.io/pypi/dm/Arxiv-dl)](https://pypistats.org/packages/arxiv-dl)
  [![](https://img.shields.io/badge/license-MIT-blue)](https://github.com/MarkHershey/arxiv-dl/blob/master/LICENSE)
  [![](https://img.shields.io/badge/code%20style-black-black)](https://github.com/psf/black)

  _Disclaimer: This is a highly-opinionated CLI tool for downloading papers. It priorities ease of use for researchers. Obviously, this is not an official project._



  -   Support downloading papers from [ArXiv](https://arxiv.org/), [CVPR, ICCV, WACV](https://openaccess.thecvf.com/menu) via simple CLI.
  -   Support downloading speedup by using [aria2c](https://aria2.github.io/).
  -   Retrieve the paper's metadata such as:
      -   Title, Abstract, Year
      -   Authors
      -   Comments (Conference acceptance info)
      -   Repository URLs
      -   `BibTeX` Citation
  -   Automatically maintain a list of local papers and their metadata in a JSON file.
  -   Configure the desired download destination via an environment variable or a command-line argument.
  -   All downloaded papers will have standardized filename for easy browsing.



  -   Save time and effort to download and organize papers on your machine.
  -   Speedup downloading process by using multiple parallel connections.
  -   Local paper list would be handy for quick local lookup, making notes, and doing citations.



  This is a command-line tool, simply use `pip` to install the package globally, then you are good to go!

  -   Pre-requisite: `Python 3.x`

  ```bash
  python3 -m pip install --upgrade arxiv-dl
  ```

  NOTE: After installation, you need to ensure the installation path is included in your PATH variable. If you encounter any difficulty finding / setting the PATH, there is this recommended way of [installing stand alone command line tools](https://packaging.python.org/en/latest/guides/installing-stand-alone-command-line-tools/), kindly follow its instruction when installing `arxiv-dl`.

  Optionally, install [aria2c](https://aria2.github.io/) for download speedup.

  -   MacOS: `brew install aria2`
  -   Linux: `sudo snap install aria2c`



  After installation, you may use the command `paper` in your shell to download papers. (You may also use the `getpaper` or `arxiv-dl` command, they are all equivalent.)

  ```bash
  $ paper [-h] [-v] [-p] [-d DOWNLOAD_DIR] [-n N_THREADS] urls [urls ...]
  ```

  Options:

  -   `-v`, `--verbose` (optional): Print paper metadata.
  -   `-p`, `--pdf_only` (optional): Download PDF only without creating Markdown notes
  -   `-d`, `--download_dir` (optional): Specify one-time download directory. This option will override the default download directory or the one specified in the environment variable `ARXIV_DOWNLOAD_FOLDER`.
  -   `-n`, `--n_threads` (optional): Specify the number of parallel connections to be used by `aria2`.



  ```bash

  $ paper 1512.03385


  $ paper 1512.03385 2103.15538 2304.04415


  $ paper https://arxiv.org/abs/2103.15538


  $ paper https://arxiv.org/pdf/1512.03385.pdf


  $ paper "https://openaccess.thecvf.com/content/CVPR2021/html/Lin_Real-Time_High-Resolution_Background_Matting_CVPR_2021_paper.html"
  ```

  ![](imgs/demo.png)





  -   Without any configurations, all paper will be downloaded to `$HOME/Downloads/ArXiv_Papers`.



  You may configure your preferred download destination once and for all via an environment variable. This will override the default download destination. To do that, include the following line in your `.bashrc` or `.zshrc` file:

  ```bash
  export ARXIV_DOWNLOAD_FOLDER="YOUR/PATH/TO/ANY/FOLDER"
  ```

  -   Every time you use the `paper` command, the download destination will be set to the following order of priority:
      1.  Command-line option `-d`
      2.  Environment variable `ARXIV_DOWNLOAD_FOLDER`
      3.  Default download destination



  -   You can always set your own preferred alias to rename the command or add more options.
  -   Include the following line(s) in your `.bashrc` or `.zshrc` file to set your preferred alias:
      ```bash
      alias dp="paper"
      alias dpv="paper -v -d '~/Documents/Papers'"
      ```





  ```bash
  python3 -m venv venv && \
  source venv/bin/activate && \
  pip install -e ".[dev]"
  ```



  ```bash
  pytest
  ```



  ```bash
  make
  ```



  ```bash
  make clean
  ```



  -   [x] Add support for ara2c.
  -   [x] Add support for papers on CVF Open Access.
  -   [ ] Add support for papers on OpenReview.



  [MIT License](https://github.com/MarkHershey/arxiv-dl/blob/master/LICENSE) - Copyright (c) 2021-2023 Mark Huang


pkgId: 54ccff1d06f0148112e11a1ffd3270f23658d670d8b7aea8734fb8f45fa700ec
name: python-arxiv-latex-cleaner
arch: src
version: 1.0.8
epoch: 0
release: 1
summary: Cleans the LaTeX code of your paper to submit to arXiv.
url: https://github.com/google-research/arxiv-latex-cleaner
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arxiv-latex-cleaner-1.0.8-1.src.rpm
checksum_type: sha256
description:
  This tool allows you to easily clean the LaTeX code of your paper to submit to
  arXiv. From a folder containing all your code, e.g. `/path/to/latex/`, it
  creates a new folder `/path/to/latex_arXiv/`, that is ready to ZIP and upload to
  arXiv.



  ```bash
  arxiv_latex_cleaner /path/to/latex --resize_images --im_size 500 --images_allowlist='{"images/im.png":2000}'
  ```

  Or simply from a config file

  ```bash
  arxiv_latex_cleaner /path/to/latex --config cleaner_config.yaml
  ```



  ```bash
  pip install arxiv-latex-cleaner
  ```

  | :exclamation: arxiv_latex_cleaner is only compatible with Python >=3.9 :exclamation: |
  | ---------------------------------------------------------------------------------- |

  If using MacOS, you can install using [Homebrew](https://brew.sh/):

  ```bash
  brew install arxiv_latex_cleaner
  ```

  Alternatively, you can download the source code:

  ```bash
  git clone https://github.com/google-research/arxiv-latex-cleaner
  cd arxiv-latex-cleaner/
  python -m arxiv_latex_cleaner --help
  ```

  And install as a command-line program directly from the source code:

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





  *   Removes all auxiliary files (`.aux`, `.log`, `.out`, etc.).
  *   Removes all comments from your code (yes, those are visible on arXiv and you
      do not want them to be). These also include `\begin{comment}\end{comment}`,
      `\iffalse\fi`, and `\if0\fi` environments.
  *   Optionally removes user-defined commands entered with `commands_to_delete`
      (such as `\todo{}` that you redefine as the empty string at the end).
  *   Optionally allows you to define custom regex replacement rules through a
      `cleaner_config.yaml` file.



  There is a 50MB limit on arXiv submissions, so to make it fit:

  *   Removes all unused `.tex` files (those that are not in the root and not
      included in any other `.tex` file).
  *   Removes all unused images that take up space (those that are not actually
      included in any used `.tex` file).
  *   Optionally resizes all images to `im_size` pixels, to reduce the size of the
      submission. You can allowlist some images to skip the global size using
      `images_allowlist`.
  *   Optionally compresses `.pdf` files using ghostscript (Linux and Mac only).
      You can allowlist some PDFs to skip the global size using
      `images_allowlist`.



  To prevent the upload of tikzpicture source code or raw simulation data, this
  feature:

  *   Replaces the tikzpicture environment `\begin{tikzpicture} ...
      \end{tikzpicture}` with the respective
      `\includegraphics{EXTERNAL_TIKZ_FOLDER/picture_name.pdf}`.
  *   Requires externally compiled TikZ pictures as `.pdf` files in folder
      `EXTERNAL_TIKZ_FOLDER`. See section 52 (Externalization Library) in the
      [PGF/TikZ manual](https://ctan.org/pkg/pgf?lang=en) on TikZ picture
      externalization.
  *   Only replaces environments with preceding
      `\tikzsetnextfilename{picture_name}` command (as in
      `\tikzsetnextfilename{picture_name}\begin{tikzpicture} ...
      \end{tikzpicture}`) where the externalized `picture_name.pdf` filename
      matches `picture_name`.



  Sometimes it is useful to work with a set of custom LaTeX commands when writing
  a paper. To get rid of them upon arXiv submission, one can simply revert them to
  plain LaTeX with a regular expression insertion.

  ```yaml
  {
      "pattern" : '(?:\\figcomp{\s*)(?P<first>.*?)\s*}\s*{\s*(?P<second>.*?)\s*}\s*{\s*(?P<third>.*?)\s*}',
      "insertion" : '\parbox[c]{{ {second} \linewidth}} {{ \includegraphics[width= {third} \linewidth]{{figures/{first} }} }}',
      "description" : "Replace figcomp"
  }
  ```

  The pattern above will find all `\figcomp{path}{w1}{w2}` commands and replace
  them with
  `\parbox[c]{w1\linewidth}{\includegraphics[width=w2\linewidth]{figures/path}}`.
  Note that the insertion template is filled with the
  [named groups captures](https://docs.python.org/3/library/re.html#regular-expression-examples)
  from the pattern. Note that the replacement is processed **before** all
  `\includegraphics` commands are processed and corresponding file paths are
  copied, making sure all figure files are copied to the cleaned version. See also
  [cleaner_config.yaml](cleaner_config.yaml) for details on how to specify the
  patterns.



  ```
  usage: arxiv_latex_cleaner@v1.0.8  [-h] [--resize_images] [--im_size IM_SIZE]
                                     [--compress_pdf]
                                     [--pdf_im_resolution PDF_IM_RESOLUTION]
                                     [--images_allowlist IMAGES_ALLOWLIST]
                                     [--keep_bib]
                                     [--commands_to_delete COMMANDS_TO_DELETE [COMMANDS_TO_DELETE ...]]
                                     [--commands_only_to_delete COMMANDS_ONLY_TO_DELETE [COMMANDS_ONLY_TO_DELETE ...]]
                                     [--environments_to_delete ENVIRONMENTS_TO_DELETE [ENVIRONMENTS_TO_DELETE ...]]
                                     [--if_exceptions IF_EXCEPTIONS [IF_EXCEPTIONS ...]]
                                     [--use_external_tikz USE_EXTERNAL_TIKZ]
                                     [--svg_inkscape [SVG_INKSCAPE]]
                                     [--config CONFIG] [--verbose]
                                     input_folder

  Clean the LaTeX code of your paper to submit to arXiv. Check the README for
  more information on the use.

  positional arguments:
    input_folder          Input folder containing the LaTeX code.

  optional arguments:
    -h, --help            show this help message and exit
    --resize_images       Resize images.
    --im_size IM_SIZE     Size of the output images (in pixels, longest side).
                          Fine tune this to get as close to 10MB as possible.
    --compress_pdf        Compress PDF images using ghostscript (Linux and Mac
                          only).
    --pdf_im_resolution PDF_IM_RESOLUTION
                          Resolution (in dpi) to which the tool resamples the
                          PDF images.
    --images_allowlist IMAGES_ALLOWLIST
                          Images (and PDFs) that won't be resized to the default
                          resolution, but the one provided here. Value is pixel
                          for images, and dpi forPDFs, as in --im_size and
                          --pdf_im_resolution, respectively. Format is a
                          dictionary as: '{"path/to/im.jpg": 1000}'
    --keep_bib            Avoid deleting the *.bib files.
    --commands_to_delete COMMANDS_TO_DELETE [COMMANDS_TO_DELETE ...]
                          LaTeX commands that will be deleted. Useful for e.g.
                          user-defined \todo commands. For example, to delete
                          all occurrences of \todo1{} and \todo2{}, run the tool
                          with `--commands_to_delete todo1 todo2`.Please note
                          that the positional argument `input_folder` cannot
                          come immediately after `commands_to_delete`, as the
                          parser does not have any way to know if it's another
                          command to delete.
    --commands_only_to_delete COMMANDS_ONLY_TO_DELETE [COMMANDS_ONLY_TO_DELETE ...]
                          LaTeX commands that will be deleted but the text
                          wrapped in the commands will be retained. Useful for
                          commands that change text formats and colors, which
                          you may want to remove but keep the text within. Usages
                          are exactly the same as commands_to_delete. Note that if
                          the commands listed here duplicate that after
                          commands_to_delete, the default action will be retaining
                          the wrapped text.
    --environments_to_delete ENVIRONMENTS_TO_DELETE [ENVIRONMENTS_TO_DELETE ...]
                          LaTeX environments that will be deleted. Useful for e.g.
                          user-defined comment environments. For example, to
                          delete all occurrences of \begin{note} ... \end{note},
                          run the tool with `--environments_to_delete note`.
                          Please note that the positional argument `input_folder`
                          cannot come immediately after
                          `environments_to_delete`, as the parser does not have
                          any way to know if it's another environment to delete.
    --if_exceptions IF_EXCEPTIONS [IF_EXCEPTIONS ...]
                          Constant TeX primitive conditionals (\iffalse, \iftrue,
                          etc.) are simplified, i.e., true branches are kept, false
                          branches deleted. To parse the conditional constructs
                          correctly, all commands starting with `\if` are assumed to
                          be TeX primitive conditionals (e.g., declared by
                          \newif\ifvar). Some known exceptions to this rule are
                          already included (e.g., \iff, \ifthenelse, etc.), but you
                          can add custom exceptions using `--if_exceptions iffalt`.
    --use_external_tikz USE_EXTERNAL_TIKZ
                          Folder (relative to input folder) containing
                          externalized tikz figures in PDF format.
    --svg_inkscape [SVG_INKSCAPE]
                          Include PDF files generated by Inkscape via the
                          `\includesvg` command from the `svg` package. This is
                          done by replacing the `\includesvg` calls with
                          `\includeinkscape` calls pointing to the generated
                          `.pdf_tex` files. By default, these files and the
                          generated PDFs are located under `./svg-inkscape`
                          (relative to the input folder), but a different path
                          (relative to the input folder) can be provided in case a
                          different `inkscapepath` was set when loading the `svg`
                          package.
    --config CONFIG       Read settings from `.yaml` config file. If command
                          line arguments are provided additionally, the config
                          file parameters are updated with the command line
                          parameters.
    --verbose             Enable detailed output.
  ```



  ```bash
  python -m unittest arxiv_latex_cleaner.tests.arxiv_latex_cleaner_test
  ```



  This is not an officially supported Google product.


pkgId: d3b4c86d6522e143bee44d3659253462c4ffca38e76cf1503fea9e0cd88ae370
name: python-arxiv-mcp-server
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A flexible arXiv search and analysis service
url: https://pypi.org/project/arxiv-mcp-server/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arxiv-mcp-server-0.1.0-1.src.rpm
checksum_type: sha256
description:
  A powerful and flexible service for searching and analyzing arXiv papers. This tool provides both a Python API and a command-line interface for easy access to arXiv's research paper repository.



  The recommended installation method uses uv:

  ```bash
  uv pip install git+https://github.com/blazickjp/arxiv-mcp-server.git
  ```

  For development installation with test dependencies:

  ```bash

  git clone https://github.com/blazickjp/arxiv-mcp-server.git
  cd arxiv-mcp-server


  uv venv
  source .venv/bin/activate


  uv pip install -e ".[test]"
  ```



  The package provides a command-line tool `arxiv-search` with two main commands:



  ```bash

  arxiv-search search "attention is all you need"


  arxiv-search search "transformer architecture" \
      --max-results 20 \
      --date-from 2023-01-01 \
      --categories cs.AI cs.LG \
      --batch-size 10
  ```



  ```bash
  arxiv-search analyze 1706.03762
  ```



  The package can also be used as a Python library:

  ```python
  import asyncio
  from arxiv_mcp_server.server import ServiceFactory, SearchParameters

  async def main():
      
      service = ServiceFactory.create_service()

      
      params = SearchParameters(
          query="attention is all you need",
          max_results=5,
          categories=["cs.AI", "cs.LG"]
      )
      result = await service.search_papers(params)
      print(result.text)

      
      analysis = await service.analyze_paper("1706.03762")
      print(analysis.text)

  if __name__ == "__main__":
      asyncio.run(main())
  ```



  To run the tests:

  ```bash

  uv pip install -e ".[test]"


  python -m pytest
  ```



  - Full-text search across arXiv papers
  - Date-based filtering
  - Category filtering
  - Batch processing for efficient retrieval
  - Detailed paper analysis
  - Asynchronous operation for better performance
  - Command-line interface for easy access
  - Python API for integration into other projects



  MIT License


pkgId: 7664269b34ff9129520e1bffdf5ef485b44ddd5daf93b152213a635986a1996e
name: python-arxiv-mcp-server
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: A flexible arXiv search and analysis service with MCP protocol support
url: https://pypi.org/project/arxiv-mcp-server/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arxiv-mcp-server-0.2.4-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
  Made with ❤️ by the ArXiv MCP Server Team
  If you find this project helpful, please consider giving it a star ⭐
  </div>


pkgId: c5bae8e1e1de36a1399503674cc65c29d9415cf64f4cb73be392af6cc4816469
name: python-arxiv-retriever
arch: src
version: 1.3.2
epoch: 0
release: 1
summary: "Automate your ArXiv paper search, retrieval, and summarization process."
url: https://github.com/MimicTester1307/arxiv_retriever
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arxiv-retriever-1.3.2-1.src.rpm
checksum_type: sha256
description:
  - [Introduction](#introduction)
  - [Features](#features)
  - [Environment Setup](#environment-setup)
  - [Installation](#installation)
  - [Usage](#usage)
  - [Contributing](#contributing)
  - [Maintenance Policy](#maintenance-policy)
  - [License](#license)


pkgId: 8c556bd76ea164015130188b5ec9800e0139a1077259e8a5368e1e0a809cfb33
name: python-arxml-parse
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: ARXML parser
url: https://github.com/zariiii9003/arxml-parse
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arxml-parse-0.1.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/arxml-parse.svg)](https://pypi.org/project/arxml-parse)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/arxml-parse.svg)](https://pypi.org/project/arxml-parse)

  The dataclasses in this library are created from xml schema files with the help
  of the [xsdata](https://github.com/tefra/xsdata/) code generator.
  As such, the library is fully compliant with `mypy --strict` type checking.

  The `arxml_parse.io` module contains functions to parse arxml files and return
  the xml root object (e.g. `arxml_parse.autosar_00042.autosar_00042.Autosar`).



  Install the library via `pip`::

  ```shell
     pip install arxml-parse
  ```




  ```python
  from pathlib import Path

  import arxml_parse.io


  arxml_path = Path("random.arxml")
  arxml_root_obj = arxml_parse.io.parse_arxml(arxml_path)


  arxml_string = arxml_parse.io.serialize_arxml(arxml_root_obj)
  ```


pkgId: a414e0134692ecdd849c154ceff614a424e450a821496bc2f8fbd71403732c94
name: python-aryaxai
arch: src
version: 0.0.73
epoch: 0
release: 1
summary: Full stack ML Observability with AryaXAI
url: https://xai.arya.ai/docs/introduction
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aryaxai-0.0.73-1.src.rpm
checksum_type: sha256
description:
  AryaXAI is a full-stack ML Observability platform that integrates with your MLOPs platform to Explain, Monitor, Audit and Improve your ML models.

  AryaXAI has multiple components to address the complex observability required for mission-critical ‘AI’.

  1. **ML Explainability:** AryaXAI offers diverse explainability options like- Bactrace(Specialized for deep learning models), SHAPE, Decision View, Observations (New way to correlate expert functioning vs model functioning) and Similar Cases (reference as explanations).
  2. **ML Monitoring:** Monitor your models for drifts, performance & bias. The tool offers diverse options for drift (data/model) like - PSI, KL Divergence, Chi-square test,
  3. **Synthetic ‘AI’:** Deploy advanced synthetic ‘AI’ techniques like GPT-2 & GANs on your tabular data to generate high-quality synthetic datasets. Test the quality and privacy of these data sets using our Anonymity tests, column tests etc.
  4. **ML Risk policies:** Define advanced risk policies on your models.
  5. **AutoML:** AryaXAI also provides fully low-code and no-code options to build ML models on your data. For advanced users, it also provides more options to fine-tune it.

  AryaXAI also acts as a common workflow and provides insights acceptable by all stakeholders - Data Science, IT, Risk, Operations and compliance teams, making the rollout and maintenance of AI/ML models seamless and clutter-free.


  Get started with AryaXAI with a few easy steps:

  1. Sign up and log in to your new AryaXAI account.
  2. After logging in, generate an Access Token for your user account.
  3. Set the environment variable **XAI_ACCESS_TOKEN** with the generated value.

  Once you've completed these steps, you're all set! Now, you can easily log in and start using the AryaXAI SDK:

  1. Log in by importing the "xai" object instance from the "arya_xai" package.
  2. Call the "login" method. This method automatically takes the access token value from the "XAI_ACCESS_TOKEN" environment variable and stores the JWT in the object instance. This means that all your future SDK operations will be authorized automatically, making it simple and hassle-free!


  ```
  from aryaxai import xai as aryaxai




  aryaxai.login()


  Enter your Arya XAI Access Token: ··········
  Authenticated successfully.
  ```


  In this section, you can review the examples of implementation of AryaXAI-SDK.

  1. [Full features overview of AryaXAI](https://colab.research.google.com/drive/1Dy5eL-FJVnFV0K5yOfGGVoAmiS_Icaz3?usp=sharing)
  2. Using AryaXAI in Loan Underwriting (Coming Soon)


  At AryaXAI, we're passionate about open source and value community contributions! Explore our contribution guide for insights into the development workflow and AryaXAI library internals. For bug reports or feature requests, head to GitHub Issues or reach out to us at [support@aryaxai.com](support@aryaxai.com).


pkgId: 58f1bf714229524382d9743dd71e4ff2d45a1e79d3909e7c67ecb7702cc77397
name: python-aryn-sdk
arch: src
version: 0.1.10
epoch: 0
release: 1
summary: The client library for Aryn services
url: https://pypi.org/project/aryn-sdk/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aryn-sdk-0.1.10-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/aryn-sdk)](https://pypi.org/project/aryn-sdk/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/aryn-sdk)](https://pypi.org/project/aryn-sdk/)
  [![Slack](https://img.shields.io/badge/slack-sycamore-brightgreen.svg?logo=slack)](https://join.slack.com/t/sycamore-ulj8912/shared_invite/zt-23sv0yhgy-MywV5dkVQ~F98Aoejo48Jg)
  [![Docs](https://readthedocs.org/projects/sycamore/badge/?version=stable)](https://sycamore.readthedocs.io/en/stable/?badge=stable)
  ![License](https://img.shields.io/github/license/aryn-ai/sycamore)

  `aryn-sdk` is a simple client library for interacting with Aryn cloud services.



  Partition pdf files with Aryn DocParse through `aryn-sdk`:

  ```python
  from aryn_sdk.partition import partition_file

  with open("partition-me.pdf", "rb") as f:
      data = partition_file(
          f,
          use_ocr=True,
          extract_table_structure=True,
          extract_images=True
      )
  elements = data['elements']
  ```

  Convert a partitioned table element to a pandas dataframe for easier use:

  ```python
  from aryn_sdk.partition import partition_file, table_elem_to_dataframe

  with open("partition-me.pdf", "rb") as f:
      data = partition_file(
          f,
          use_ocr=True,
          extract_table_structure=True,
          extract_images=True
      )


  df = None
  for element in data['elements']:
      if element['type'] == 'table':
          df = table_elem_to_dataframe(element)
          break
  ```

  Or convert all partitioned tables to pandas dataframes in one shot:

  ```python
  from aryn_sdk.partition import partition_file, tables_to_pandas

  with open("partition-me.pdf", "rb") as f:
      data = partition_file(
          f,
          use_ocr=True,
          extract_table_structure=True,
          extract_images=True
      )
  elements_and_tables = tables_to_pandas(data)
  dataframes = [table for (element, table) in elements_and_tables if table is not None]
  ```

  Visualize partitioned documents by drawing on the bounding boxes:

  ```python
  from aryn_sdk.partition import partition_file, draw_with_boxes

  with open("partition-me.pdf", "rb") as f:
      data = partition_file(
          f,
          use_ocr=True,
          extract_table_structure=True,
          extract_images=True
      )
  page_pics = draw_with_boxes("partition-me.pdf", data, draw_table_cells=True)

  from IPython.display import display
  display(page_pics[0])
  ```

  > Note: visualizing documents requires `poppler`, a pdf processing library, to be installed. Instructions for installing poppler can be found [here](https://pypi.org/project/pdf2image/)

  Convert image elements to more useful types, like PIL, or image format typed byte strings

  ```python
  from aryn_sdk.partition import partition_file, convert_image_element

  with open("my-favorite-pdf.pdf", "rb") as f:
      data = partition_file(
          f,
          extract_images=True
      )
  image_elts = [e for e in data['elements'] if e['type'] == 'Image']

  pil_img = convert_image_element(image_elts[0])
  jpg_bytes = convert_image_element(image_elts[1], format='JPEG')
  png_str = convert_image_element(image_elts[2], format="PNG", b64encode=True)
  ```


pkgId: 9daf4cb6b7a30f5d9f0a82a5f2c50f23d2964798a09e61cd2c116c5ce63e9965
name: python-aryn-sdk
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: The client library for Aryn services
url: https://pypi.org/project/aryn-sdk/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aryn-sdk-0.1.9-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/aryn-sdk)](https://pypi.org/project/aryn-sdk/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/aryn-sdk)](https://pypi.org/project/aryn-sdk/)
  [![Slack](https://img.shields.io/badge/slack-sycamore-brightgreen.svg?logo=slack)](https://join.slack.com/t/sycamore-ulj8912/shared_invite/zt-23sv0yhgy-MywV5dkVQ~F98Aoejo48Jg)
  [![Docs](https://readthedocs.org/projects/sycamore/badge/?version=stable)](https://sycamore.readthedocs.io/en/stable/?badge=stable)
  ![License](https://img.shields.io/github/license/aryn-ai/sycamore)

  `aryn-sdk` is a simple client library for interacting with Aryn cloud services.



  Partition pdf files with the Aryn Partitioning Service (APS) through `aryn-sdk`:

  ```python
  from aryn_sdk.partition import partition_file

  with open("partition-me.pdf", "rb") as f:
      data = partition_file(
          f,
          use_ocr=True,
          extract_table_structure=True,
          extract_images=True
      )
  elements = data['elements']
  ```

  Convert a partitioned table element to a pandas dataframe for easier use:

  ```python
  from aryn_sdk.partition import partition_file, table_elem_to_dataframe

  with open("partition-me.pdf", "rb") as f:
      data = partition_file(
          f,
          use_ocr=True,
          extract_table_structure=True,
          extract_images=True
      )


  df = None
  for element in data['elements']:
      if element['type'] == 'table':
          df = table_elem_to_dataframe(element)
          break
  ```

  Or convert all partitioned tables to pandas dataframes in one shot:

  ```python
  from aryn_sdk.partition import partition_file, tables_to_pandas

  with open("partition-me.pdf", "rb") as f:
      data = partition_file(
          f,
          use_ocr=True,
          extract_table_structure=True,
          extract_images=True
      )
  elements_and_tables = tables_to_pandas(data)
  dataframes = [table for (element, table) in elements_and_tables if table is not None]
  ```

  Visualize partitioned documents by drawing on the bounding boxes:

  ```python
  from aryn_sdk.partition import partition_file, draw_with_boxes

  with open("partition-me.pdf", "rb") as f:
      data = partition_file(
          f,
          use_ocr=True,
          extract_table_structure=True,
          extract_images=True
      )
  page_pics = draw_with_boxes("partition-me.pdf", data, draw_table_cells=True)

  from IPython.display import display
  display(page_pics[0])
  ```

  > Note: visualizing documents requires `poppler`, a pdf processing library, to be installed. Instructions for installing poppler can be found [here](https://pypi.org/project/pdf2image/)

  Convert image elements to more useful types, like PIL, or image format typed byte strings

  ```python
  from aryn_sdk.partition import partition_file, convert_image_element

  with open("my-favorite-pdf.pdf", "rb") as f:
      data = partition_file(
          f,
          extract_images=True
      )
  image_elts = [e for e in data['elements'] if e['type'] == 'Image']

  pil_img = convert_image_element(image_elts[0])
  jpg_bytes = convert_image_element(image_elts[1], format='JPEG')
  png_str = convert_image_element(image_elts[2], format="PNG", b64encode=True)
  ```


pkgId: f2ce2be3edcb30bc9c4ce06d153c8f50e46cb5ad3a14a59c8ab7e7ea7f8dd456
name: python-arz-api
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Модуль для взаимодействия с форумом без Xenforo ключей
url: https://github.com/TastyBread123/Arizona-API/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-arz-api-2.0.1-1.src.rpm
checksum_type: sha256
description:
  API для взаимодействия с ресурсами Arizona без необходимости в получении API ключа xenforo у администраторов форума. Вы можете просто найти ваши куки (рекомендую для этого отдельные расширения) и начинать разработку!


  API поддерживает около 35 методов, которые помогают в решении 90% задач. API легко масштабируется, а также имеет удобную [документацию](https://tastybread123.github.io/Arizona-API/arz_api.html).
  Также рекомендую ознакомиться с [примерами](https://github.com/TastyBread123/Arizona-API/tree/main/examples), дабы возникало меньше вопросов по использованию API.
  Удачи!


pkgId: 6ab7c797d136fa51d49506f85a6c39b447d806e8444ab6121731b79f8d3a4820
name: python-as-codegen
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Generate typed GraphQL client from GraphQL schema, queries and mutations!
url: https://pypi.org/project/as-codegen/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-as-codegen-0.1.1-1.src.rpm
checksum_type: sha256
description:
  - Create a virtual environment

  ```bash
  python3 -m venv .venv
  ```

  - Install the requirements

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

  - Run the tests
  - Run codegen locally

  ```bash
  python -m as_codegen
  ```


pkgId: a46ade25bad3e30c4f510d6a0f22628234ba8e888cf3a799c47c5ff558574b59
name: python-as-seg
arch: src
version: 0.1.10
epoch: 0
release: 1
url: https://gitlab.inria.fr/amarmore/autosimilarity_segmentation
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-as-seg-0.1.10-1.src.rpm
checksum_type: sha256
summary:
  Package for the segmentation of autosimilarity matrices. This version is related to a stable vesion on PyPi, for installation in MSAF.

description:
  Hello, and welcome on this repository!

  This project aims at computing autosimilarity matrices, and segmenting them, which consists of the task of structural segmentation.

  The current version contains the CBM algorithm [1], along with an implementation of Foote's novelty algorithm [2] based on the MSAF toolbox [3].

  It can be installed using pip as `pip install as-seg`.

  This is a first release, and may contain bug. Comments are welcomed!



  A tutorial notebook presenting the most important components of this toolbox is available in the folder "Notebooks".



  A Tutorial notebook is presented in the "Notebooks" folder. In older version of the code, you may find Notebooks presenting experiments associated with publications.



  Should be obtained from Zenodo: https://zenodo.org/records/10168387. DOI: 10.5281/zenodo.10168386.



  This code was developed with Python 3.8.5, and some external libraries detailed in dependencies.txt. They should be installed automatically if this project is downloaded using pip.



  You should cite the package `as_seg`, available on HAL (https://hal.archives-ouvertes.fr/hal-03797507).

  Here are two styles of citations:

  As a bibtex format, this should be cited as: @softwareversion{marmoret2022as_seg, title={as\_seg: module for computing and segmenting autosimilarity matrices}, author={Marmoret, Axel and Cohen, J{\'e}r{\'e}my and Bimbot, Fr{\'e}d{\'e}ric}, LICENSE = {BSD 3-Clause ''New'' or ''Revised'' License}, year={2022}}

  In the IEEE style, this should be cited as: A. Marmoret, J.E. Cohen, and F. Bimbot, "as_seg: module for computing and segmenting autosimilarity matrices," 2022, url: https://gitlab.inria.fr/amarmore/autosimilarity_segmentation.



  Code was created by Axel Marmoret (<axel.marmoret@imt-atlantique.fr>), and strongly supported by Jeremy E. Cohen (<jeremy.cohen@cnrs.fr>).

  The technique in itself was also developed by Frédéric Bimbot (<bimbot@irisa.fr>).


  [1] A. Marmoret, J.E. Cohen, F. Bimbot. Barwise Music Structure Analysis with the Correlation Block-Matching Segmentation Algorithm. Transactions of the International Society for Music Information Retrieval (TISMIR), 2023, 6 (1), pp.167-185. ⟨10.5334/tismir.167⟩. ⟨hal-04323556⟩, https://hal.science/hal-04323556.

  [2] J. Foote, "Automatic audio segmentation using a measure of audio novelty," in: 2000 IEEE Int. Conf. Multimedia and Expo. ICME2000. Proc. Latest Advances in the Fast Changing World of Multimedia, vol. 1, IEEE, 2000, pp. 452–455.

  [3] Nieto, O., Bello, J. P., Systematic Exploration Of Computational Music Structure Research. Proc. of the 17th International Society for Music Information Retrieval Conference (ISMIR). New York City, NY, USA, 2016.

  [4] Böck, S., Korzeniowski, F., Schlüter, J., Krebs, F., & Widmer, G. (2016, October). Madmom: A new python audio and music signal processing library. In Proceedings of the 24th ACM international conference on Multimedia (pp. 1174-1178).


pkgId: 6c3b7c7ed0386974ea7ba016b480f8cbac395442b34fcb28c1f58a595b5e145b
name: python-as4pgc
arch: src
version: 1.1.5
epoch: 0
release: 1
url: https://github.com/ClarkFieseln/as4pgc
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-as4pgc-1.1.5-1.src.rpm
checksum_type: sha256
summary:
  Audio Steganography: compress, encrypt and hide a secret file inside an audio file (MP3, WAV, OGG, FLAC, ..)

description:
  Hide files inside audio files.

  Use "Audio Steganography for Pretty Good Concealing" to compress, encrypt, and hide small files of any type inside compressed audio files (e.g. MP3, FLAC, OGG) or inside uncompressed .WAV files.


  ```sh
    pip install as4pgc

    pip install -r requirements.txt

    
    sudo apt install ffmpeg
  ```
  For Windows you can download ffmpeg from here:
  https://www.ffmpeg.org/


  Hide a file of any type inside an .mp3 file:
  ```sh
    as4pgc -w secret.zip carrier.mp3
  ```
  Use option -p to activate plots and track signal processing steps.

  Use option -v to output details.

  Then recover the hidden file:
  ```sh
    as4pgc -r stego.mp3
  ```

  Use the option -h for more information:

  ```sh
    as4pgc -h
  ```

  Configuration settings can be adapted in config.ini (detailed documentation to be provided soon).


  https://github.com/ClarkFieseln/as4pgc



  (c) 2021 Clark Fieseln

  This repository is licensed under the MIT license. See LICENSE for details.


pkgId: 00370abfc564c68e6dad3eb278a7cada3c3ae6933693bd94a711a73f2de3ffa0
name: python-asa-tools
arch: src
version: 0.1.15
epoch: 0
release: 1
summary: asa's personal toolbox
url: https://pypi.org/project/asa-tools/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asa-tools-0.1.15-1.src.rpm
checksum_type: sha256
description:
  asa自用的工具包，功能包括
  - bira 下载b站视频
      - 需要配置conf.ini，格式为
          ```ini
          [spiderbi]
          SESSDATA = "XXXX"
          ```
      - 需要环境变量中配置ASA_HOME
  - cf    copyFolder 复制所有源代码文件到asahome的文件夹下
  - cp4   mp4拷贝到asa_home的环境变量的目录中，并重命名为合法字符
  - ctt   mp4目录下文件生成要转换的txt文件
  - od    调用out_dutys 转换值班为js
  - ra    removeAnnotate 去掉注解
  - ttm4  合并mp4视频，转为h264编码mp4或海信电视可播放的mp4 equipment ： --e


pkgId: 1334f10b7a9fa144279173692838b30de898525a99bbc2c88808bb1c2ba03226
name: python-asaas-sdk
arch: src
version: 3.3.1
epoch: 0
release: 1
summary: Biblioteca não oficial de comunicação com a API de pagamento do ASAAS
url: https://github.com/GaNiziolek/asaas-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asaas-sdk-3.3.1-1.src.rpm
checksum_type: sha256
description:
  Biblioteca não oficial de comunicação com a API de pagamento do ASAAS

  Baseado na documentação especificada em https://asaasv3.docs.apiary.io/



  Instale o pacote via pip:

  ```sh
  pip install asaas-sdk
  ```



  ```py
  from asaas import Asaas

  asaas = Asaas(access_token = 'acess_token', url_production='asaas_production_url', production = False)

  ```
  A variável `acess_token` deve receber um [token válido](https://asaasv3.docs.apiary.io/#introduction/autenticacao).
  A variável `url_production` deve receber a url de produção do Asaas.



  ```py
  new_customer = asaas.customers.new(name = 'Roberto', cpfCnpj = '24971563792')

  print(new_customer)

  ```





  ```py

  from asaas.payments import CreditCard, CreditCardHolderInfo, BillingType
  from datetime import date

  credit_card = CreditCard(
              holderName = 'marcelo h almeida',
              number = '5162306219378829',
              expiryYear = '2024', expiryMonth = '05',
              ccv = '318'
          )

  credit_card_holder_info = CreditCardHolderInfo(
              name = 'Marcelo Henrique Almeida',
              email = 'marcelo.almeida@gmail.com',
              cpfCnpj = '24971563792',
              postalCode = '89223-005',
              addressNumber = '277',
              addressComplement = '',
              phone = '4738010919'
          )

  pagamento = asaas.payments.new(
          customer = new_customer,
          billingType = BillingType.CREDIT_CARD,
          value = 100,
          dueDate = date.today(),
          creditCard = credit_card.json(),
          creditCardHolderInfo = credit_card_holder_info.json()
      )

  print(pagamento)


  ```




  ```py


  pagamento = asaas.payments.new(
          customer = new_customer,
          billingType = BillingType.BOLETO,
          value = 100,
          dueDate = date.today()
      )

  print(pagamento)


  ```




  ```py

  pagamento = asaas.payments.new(
          customer = new_customer,
          billingType = BillingType.PIX,
          value = 100,
          dueDate = date.today()
      )

  print(pagamento)


  pix_info = asaas.payments.get_pix_qr(pagamento.id)

  print(pix_info)


  ```


pkgId: 4a265293aa4d723163467e775836e35f547a8b2be77c25aebc7f0c100c5f72e9
name: python-asahi
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: A small package to provide utility functions to libraries that has optional installs / extras
url: https://github.com/kalaspuff/asahi
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asahi-0.2.0-1.src.rpm
checksum_type: sha256
description:
  ![Python package](https://github.com/kalaspuff/asahi/workflows/Python%20package/badge.svg)
  [![pypi](https://badge.fury.io/py/asahi.svg)](https://pypi.python.org/pypi/asahi/)
  [![Made with Python](https://img.shields.io/pypi/pyversions/asahi)](https://www.python.org/)
  [![Type hinted - mypy validated](https://img.shields.io/badge/typehinted-yes-teal)](https://github.com/kalaspuff/asahi)
  [![MIT License](https://img.shields.io/github/license/kalaspuff/asahi.svg)](https://github.com/kalaspuff/asahi/blob/master/LICENSE)
  [![Code coverage](https://codecov.io/gh/kalaspuff/asahi/branch/master/graph/badge.svg)](https://codecov.io/gh/kalaspuff/asahi/tree/master/asahi)

  *A small package to provide utility functions to libraries that has optional installs (so called "extras").*



  Like you would install any other Python package, use `pip`, `poetry`, `pipenv` or your weapon of choice.
  ```
  $ pip install asahi
  ```





  ```
  import asahi

  ```


pkgId: 059ab3892bfa106496a1de4d5cfb81f346fced8cab689a4fe497cc1b0bad67c4
name: python-asam-qc-baselib
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Python base library for ASAM Quality Checker Framework
url: https://pypi.org/project/asam-qc-baselib/
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asam-qc-baselib-1.0.0-1.src.rpm
checksum_type: sha256
description:
  platform linux -- Python 3.11.9, pytest-8.2.1, pluggy-1.5.0
  rootdir: /home/tripel/asam/qc-baselib-py
  configfile: pyproject.toml
  collected 13 items
  tests/test_configuration.py .........                                                                                                                                               [ 69%]
  tests/test_models.py ..                                                                                                                                                             [ 84%]


pkgId: e0083cf9ca062bb337b1284abee13f196e9fe4997f1f2307bd4064c13cb3add0
name: python-asam-qc-framework
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Python ASAM Quality Checker Framework module. Executes bundles and creates result reports.
url: https://pypi.org/project/asam-qc-framework/
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asam-qc-framework-1.0.0-1.src.rpm
checksum_type: sha256
description:
  This is the Python package for the ASAM Quality Checker Framework.

  Visit the [main GitHub repository](https://github.com/asam-ev/qc-framework) for detailed documentation.


pkgId: 454273bc1b4f11ae100bc41bdc4f01019db1eea0b2fef427208e0df6865a5df1
name: python-asam-qc-opendrive
arch: src
version: 1.0.0rc1
epoch: 0
release: 1
summary: This project implements the OpenDrive Checker for the ASAM Quality Checker project.
url: https://pypi.org/project/asam-qc-opendrive/
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asam-qc-opendrive-1.0.0rc1-1.src.rpm
checksum_type: sha256
description:
  platform linux -- Python 3.11.9, pytest-8.2.2, pluggy-1.5.0 -- /home/tripel/asam/qc-opendrive/.venv/bin/python
  cachedir: .pytest_cache
  rootdir: /home/tripel/asam/qc-opendrive
  configfile: pytest.ini
  collected 4 items
  tests/test_semantic_checks.py::test_road_lane_access_no_mix_of_deny_or_allow[17_invalid] PASSED                                                                                     [ 25%]
  tests/test_semantic_checks.py::test_road_lane_access_no_mix_of_deny_or_allow[17_valid] PASSED                                                                                       [ 50%]
  tests/test_semantic_checks.py::test_road_lane_access_no_mix_of_deny_or_allow[18_invalid] PASSED                                                                                     [ 75%]


pkgId: dc89380ce0e2ac13b5e020b8b237390814ea865503e029c449e68bc70924adcc
name: python-asam-qc-openscenarioxml
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: This project implements the OpenScenario Checker for the ASAM Quality Checker project.
url: https://pypi.org/project/asam-qc-openscenarioxml/
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asam-qc-openscenarioxml-1.0.0-1.src.rpm
checksum_type: sha256
description:
  platform linux -- Python 3.11.9, pytest-8.2.2, pluggy-1.5.0
  ```
  You can check more options for pytest at its [own documentation](https://docs.pytest.org/).

  For contributing, you need to install the development requirements besides the
  test and installation requirements, for that run:
  ```bash
  poetry install --with dev
  ```
  You need to have pre-commit installed and install the hooks:
  ```
  pre-commit install
  ```
  **To implement a new checker**
  1. Create a new Python module for each checker.
  2. Specify the following global variables for the Python module
  | Variable | Meaning |
  | --- | --- |
  | `CHECKER_ID` | The ID of the checker |
  | `CHECKER_DESCRIPTION` | The description of the checker |
  | `CHECKER_PRECONDITIONS` | A set of other checkers in which if any of them raise an issue, the current checker will be skipped |
  | `RULE_UID` | The rule UID of the rule that the checker will check |
  3. Implement the checker logic in the following function:
  ```python
  def check_rule(checker_data: models.CheckerData) -> None:
      pass
  ```
  1. Register the checker module in the following function in [main.py](qc_openscenario/main.py).
  ```python
  def run_checks(config: Configuration, result: Result) -> None:
      
      execute_checker(your_checker_module, checker_data)
  ```
  All the checkers in this checker bundle are implemented in this way. Take a look at some of them before implementing your first checker.


pkgId: 983d37e9a8fb1a434dc6b6ac957a31778b88d7de5e2f694ce7803449569ddf80
name: python-asam-qc-otx
arch: src
version: 1.0.0
epoch: 0
release: 1
url: https://pypi.org/project/asam-qc-otx/
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asam-qc-otx-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  This project implements the Open Test sequence eXchange Checker for the ASAM Quality Checker project.

description:
  platform linux -- Python 3.11.9, pytest-8.2.2, pluggy-1.5.0
  ```
  You can check more options for pytest at its [own documentation](https://docs.pytest.org/).

  For contributing, you need to install the development requirements besides the
  test and installation requirements, for that run:
  ```bash
  poetry install --with dev
  ```
  You need to have pre-commit installed and install the hooks:
  ```
  pre-commit install
  ```
  **To implement a new checker:**
  1. Create a new Python module for each checker.
  2. Specify the following global variables for the Python module
  | Variable | Meaning |
  | --- | --- |
  | `CHECKER_ID` | The ID of the checker |
  | `CHECKER_DESCRIPTION` | The description of the checker |
  | `CHECKER_PRECONDITIONS` | A set of other checkers in which if any of them raise an issue, the current checker will be skipped |
  | `RULE_UID` | The rule UID of the rule that the checker will check |
  3. Implement the checker logic in the following function:
  ```python
  def check_rule(checker_data: models.CheckerData) -> None:
      pass
  ```
  4. Register the checker module in the following function in [main.py](qc_otx/main.py).
  ```python
  def run_checks(config: Configuration, result: Result) -> None:
      
      execute_checker(your_checker_module, checker_data)
  ```
  All the checkers in this checker bundle are implemented in this way. Take a look at some of them before implementing your first checker.


pkgId: bea9b8aaba715f2abdfcb3c8d3f3a3ea12c55d475e310374d01ccbedf122f130
name: python-asammdf
arch: src
version: 8.0.0
epoch: 0
release: 1
summary: ASAM MDF measurement data file parser
url: https://github.com/danielhrisca/asammdf
rpm_license: LGPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asammdf-8.0.0-1.src.rpm
checksum_type: sha256
description:
  <img align=left src="https://raw.githubusercontent.com/danielhrisca/asammdf/master/asammdf.png" width="128" height="128" />

  <p align=center>

  *asammdf* is a fast parser and editor for ASAM (Association for Standardization of Automation and Measuring Systems) MDF (Measurement Data Format) files.

  *asammdf* supports MDF versions 2 (.dat), 3 (.mdf) and 4 (.mf4).

  *asammdf* works on Python >= 3.8

  </p>

  <img align=left src="https://raw.githubusercontent.com/danielhrisca/asammdf/master/gui.png"/>



  | Continuous Integration                                                                                                                                                                      | Coveralls                                                                                                                                                            | Codacy                                                                                                                                                                                                                                                       | ReadTheDocs                                                                                                                                     |
  | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------- |
  | [![continuous integration](https://github.com/danielhrisca/asammdf/actions/workflows/main.yml/badge.svg?branch=master)](https://github.com/danielhrisca/asammdf/actions/workflows/main.yml) | [![Coverage Status](https://coveralls.io/repos/github/danielhrisca/asammdf/badge.svg?branch=master)](https://coveralls.io/github/danielhrisca/asammdf?branch=master) | [![Codacy Badge](https://api.codacy.com/project/badge/Grade/a3da21da90ca43a5b72fc24b56880c99?branch=master)](https://www.codacy.com/app/danielhrisca/asammdf?utm_source=github.com&utm_medium=referral&utm_content=danielhrisca/asammdf&utm_campaign=badger) | [![Documentation Status](http://readthedocs.org/projects/asammdf/badge/?version=master)](http://asammdf.readthedocs.io/en/master/?badge=stable) |

  | PyPI                                                                                      | conda-forge                                                                                                                     |
  | ----------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
  | [![PyPI version](https://badge.fury.io/py/asammdf.svg)](https://badge.fury.io/py/asammdf) | [![conda-forge version](https://anaconda.org/conda-forge/asammdf/badges/version.svg)](https://anaconda.org/conda-forge/asammdf) |


  The main goals for this library are:

  * to be faster than the other Python based mdf libraries
  * to have clean and easy to understand code base
  * to have minimal 3-rd party dependencies



  * create new mdf files from scratch
  * append new channels
  * read unsorted MDF v3 and v4 files
  * read CAN and LIN bus logging files
  * extract CAN and LIN signals from anonymous bus logging measurements
  * filter a subset of channels from original mdf file
  * cut measurement to specified time interval
  * convert to different mdf version
  * export to HDF5, Matlab (v7.3), CSV and parquet
  * merge multiple files sharing the same internal structure
  * read and save mdf version 4.10 files containing zipped data blocks
  * space optimizations for saved files (no duplicated blocks)
  * split large data blocks (configurable size) for mdf version 4
  * full support (read, append, save) for the following map types (multidimensional array channels):

      * mdf version 3 channels with CDBLOCK
      * mdf version 4 structure channel composition
      * mdf version 4 channel arrays with CNTemplate storage and one of the array types:

          * 0 - array
          * 1 - scaling axis
          * 2 - look-up

  * add and extract attachments for mdf version 4
  * handle large files (for example merging two fileas, each with 14000 channels and 5GB size, on a RaspberryPi)
  * extract channel data, master channel and extra channel information as *Signal* objects for unified operations with v3 and v4 files
  * time domain operation using the *Signal* class

      * Pandas data frames are good if all the channels have the same time based
      * a measurement will usually have channels from different sources at different rates
      * the *Signal* class facilitates operations with such channels

   * graphical interface to visualize channels and perform operations with the files



  * for version 3

      * functionality related to sample reduction block: the samples reduction blocks are simply ignored

  * for version 4

      * experimental support for MDF v4.20 column oriented storage
      * functionality related to sample reduction block: the samples reduction blocks are simply ignored
      * handling of channel hierarchy: channel hierarchy is ignored
      * full handling of bus logging measurements: currently only CAN and LIN bus logging are implemented with the
        ability to *get* signals defined in the attached CAN/LIN database (.arxml or .dbc). Signals can also
        be extracted from an anonymous bus logging measurement by providing a CAN or LIN database (.dbc or .arxml)
      * handling of unfinished measurements (mdf 4): finalization is attempted when the file is loaded, however the
        not all the finalization steps are supported
      * full support for remaining mdf 4 channel arrays types
      * xml schema for MDBLOCK: most metadata stored in the comment blocks will not be available
      * full handling of event blocks: events are transferred to the new files (in case of calling methods
        that return new *MDF* objects) but no new events can be created
      * channels with default X axis: the default X axis is ignored and the channel group's master channel
        is used
      * attachment encryption/decryption using user provided encryption/decryption functions; this is not
        part of the MDF v4 spec and is only supported by this library



  ```python
  from asammdf import MDF

  mdf = MDF('sample.mdf')
  speed = mdf.get('WheelSpeed')
  speed.plot()

  important_signals = ['WheelSpeed', 'VehicleSpeed', 'VehicleAcceleration']

  short = mdf.filter(important_signals).cut(start=10, stop=12)


  short.convert('4.10').save('important signals.mf4')


  efficient = MDF('huge.mf4')
  for signal in efficient.select(['Sensor1', 'Voltage3']):
     signal.plot()
  ```

  Check the *examples* folder for extended usage demo, or the documentation
  http://asammdf.readthedocs.io/en/master/examples.html

  https://canlogger.csselectronics.com/canedge-getting-started/ce3/log-file-tools/asammdf-gui/



  http://asammdf.readthedocs.io/en/master

  And a nicely written tutorial on the [CSS Electronics site](https://canlogger.csselectronics.com/canedge-getting-started/ce3/log-file-tools/asammdf-gui/)


  Please have a look over the [contributing guidelines](CONTRIBUTING.md)

  If you enjoy this library please consider making a donation to the
  [numpy project](https://numfocus.org/donate-to-numpy) or to [danielhrisca using liberapay](https://liberapay.com/danielhrisca/donate) <noscript><a href="https://liberapay.com/danielhrisca/donate"><img alt="Donate using Liberapay" src="https://liberapay.com/assets/widgets/donate.svg"></a></noscript>


  Thanks to all who contributed with commits to *asammdf*:

  <a href="https://github.com/danielhrisca/asammdf/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=danielhrisca/asammdf" />
  </a>


  *asammdf* is available on

  * github: https://github.com/danielhrisca/asammdf/
  * PyPI: https://pypi.org/project/asammdf/
  * conda-forge: https://anaconda.org/conda-forge/asammdf

  ```shell
  pip install asammdf

  pip install asammdf[gui]

  conda install -c conda-forge asammdf
  ```

  In case a wheel is not present for you OS/Python versions and you
  lack the proper compiler setup to compile the c-extension code, then
  you can simply copy-paste the package code to your site-packages. In this
  way the python fallback code will be used instead of the compiled c-extension code.


  asammdf uses the following libraries

  * numpy : the heart that makes all tick
  * numexpr : for algebraic and rational channel conversions
  * wheel : for installation in virtual environments
  * pandas : for DataFrame export
  * canmatrix : to handle CAN/LIN bus logging measurements
  * natsort
  * lxml : for canmatrix arxml support
  * lz4 : to speed up the disk IO performance
  * python-dateutil : measurement start time handling

  optional dependencies needed for exports

  * h5py : for HDF5 export
  * hdf5storage : for Matlab v7.3 .mat export
  * fastparquet : for parquet export
  * scipy: for Matlab v4 and v5 .mat export

  other optional dependencies

  * PySide6 : for GUI tool
  * pyqtgraph : for GUI tool and Signal plotting
  * matplotlib : as fallback for Signal plotting
  * faust-cchardet : to detect non-standard Unicode encodings
  * chardet : to detect non-standard Unicode encodings
  * pyqtlet2 : for the GPS window
  * isal : for faster zlib compression/decompression
  * fsspec : access files stored in the cloud



  http://asammdf.readthedocs.io/en/master/benchmarks.html


pkgId: 6d323d56cdc73551cc6221713cea2211e3d63ca81d016e721ec43ed791f6520f
name: python-asana
arch: src
version: 5.0.10
epoch: 0
release: 1
summary: Asana
url: http://github.com/asana/python-asana
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asana-5.0.10-1.src.rpm
checksum_type: sha256
description:
  *AllocationsApi* | [**create_allocation**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/AllocationsApi.md#create_allocation) | **POST** /allocations | Create an allocation
  *AllocationsApi* | [**delete_allocation**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/AllocationsApi.md#delete_allocation) | **DELETE** /allocations/{allocation_gid} | Delete an allocation
  *AllocationsApi* | [**get_allocation**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/AllocationsApi.md#get_allocation) | **GET** /allocations/{allocation_gid} | Get an allocation
  *AllocationsApi* | [**get_allocations**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/AllocationsApi.md#get_allocations) | **GET** /allocations | Get multiple allocations
  *AllocationsApi* | [**update_allocation**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/AllocationsApi.md#update_allocation) | **PUT** /allocations/{allocation_gid} | Update an allocation
  *AttachmentsApi* | [**create_attachment_for_object**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/AttachmentsApi.md#create_attachment_for_object) | **POST** /attachments | Upload an attachment
  *AttachmentsApi* | [**delete_attachment**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/AttachmentsApi.md#delete_attachment) | **DELETE** /attachments/{attachment_gid} | Delete an attachment
  *AttachmentsApi* | [**get_attachment**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/AttachmentsApi.md#get_attachment) | **GET** /attachments/{attachment_gid} | Get an attachment
  *AttachmentsApi* | [**get_attachments_for_object**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/AttachmentsApi.md#get_attachments_for_object) | **GET** /attachments | Get attachments from an object
  *AuditLogAPIApi* | [**get_audit_log_events**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/AuditLogAPIApi.md#get_audit_log_events) | **GET** /workspaces/{workspace_gid}/audit_log_events | Get audit log events
  *BatchAPIApi* | [**create_batch_request**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/BatchAPIApi.md#create_batch_request) | **POST** /batch | Submit parallel requests
  *CustomFieldSettingsApi* | [**get_custom_field_settings_for_portfolio**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/CustomFieldSettingsApi.md#get_custom_field_settings_for_portfolio) | **GET** /portfolios/{portfolio_gid}/custom_field_settings | Get a portfolio&#x27;s custom fields
  *CustomFieldSettingsApi* | [**get_custom_field_settings_for_project**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/CustomFieldSettingsApi.md#get_custom_field_settings_for_project) | **GET** /projects/{project_gid}/custom_field_settings | Get a project&#x27;s custom fields
  *CustomFieldsApi* | [**create_custom_field**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/CustomFieldsApi.md#create_custom_field) | **POST** /custom_fields | Create a custom field
  *CustomFieldsApi* | [**create_enum_option_for_custom_field**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/CustomFieldsApi.md#create_enum_option_for_custom_field) | **POST** /custom_fields/{custom_field_gid}/enum_options | Create an enum option
  *CustomFieldsApi* | [**delete_custom_field**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/CustomFieldsApi.md#delete_custom_field) | **DELETE** /custom_fields/{custom_field_gid} | Delete a custom field
  *CustomFieldsApi* | [**get_custom_field**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/CustomFieldsApi.md#get_custom_field) | **GET** /custom_fields/{custom_field_gid} | Get a custom field
  *CustomFieldsApi* | [**get_custom_fields_for_workspace**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/CustomFieldsApi.md#get_custom_fields_for_workspace) | **GET** /workspaces/{workspace_gid}/custom_fields | Get a workspace&#x27;s custom fields
  *CustomFieldsApi* | [**insert_enum_option_for_custom_field**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/CustomFieldsApi.md#insert_enum_option_for_custom_field) | **POST** /custom_fields/{custom_field_gid}/enum_options/insert | Reorder a custom field&#x27;s enum
  *CustomFieldsApi* | [**update_custom_field**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/CustomFieldsApi.md#update_custom_field) | **PUT** /custom_fields/{custom_field_gid} | Update a custom field
  *CustomFieldsApi* | [**update_enum_option**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/CustomFieldsApi.md#update_enum_option) | **PUT** /enum_options/{enum_option_gid} | Update an enum option
  *EventsApi* | [**get_events**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/EventsApi.md#get_events) | **GET** /events | Get events on a resource
  *GoalRelationshipsApi* | [**add_supporting_relationship**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/GoalRelationshipsApi.md#add_supporting_relationship) | **POST** /goals/{goal_gid}/addSupportingRelationship | Add a supporting goal relationship
  *GoalRelationshipsApi* | [**get_goal_relationship**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/GoalRelationshipsApi.md#get_goal_relationship) | **GET** /goal_relationships/{goal_relationship_gid} | Get a goal relationship
  *GoalRelationshipsApi* | [**get_goal_relationships**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/GoalRelationshipsApi.md#get_goal_relationships) | **GET** /goal_relationships | Get goal relationships
  *GoalRelationshipsApi* | [**remove_supporting_relationship**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/GoalRelationshipsApi.md#remove_supporting_relationship) | **POST** /goals/{goal_gid}/removeSupportingRelationship | Removes a supporting goal relationship
  *GoalRelationshipsApi* | [**update_goal_relationship**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/GoalRelationshipsApi.md#update_goal_relationship) | **PUT** /goal_relationships/{goal_relationship_gid} | Update a goal relationship
  *GoalsApi* | [**add_followers**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/GoalsApi.md#add_followers) | **POST** /goals/{goal_gid}/addFollowers | Add a collaborator to a goal
  *GoalsApi* | [**create_goal**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/GoalsApi.md#create_goal) | **POST** /goals | Create a goal
  *GoalsApi* | [**create_goal_metric**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/GoalsApi.md#create_goal_metric) | **POST** /goals/{goal_gid}/setMetric | Create a goal metric
  *GoalsApi* | [**delete_goal**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/GoalsApi.md#delete_goal) | **DELETE** /goals/{goal_gid} | Delete a goal
  *GoalsApi* | [**get_goal**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/GoalsApi.md#get_goal) | **GET** /goals/{goal_gid} | Get a goal
  *GoalsApi* | [**get_goals**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/GoalsApi.md#get_goals) | **GET** /goals | Get goals
  *GoalsApi* | [**get_parent_goals_for_goal**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/GoalsApi.md#get_parent_goals_for_goal) | **GET** /goals/{goal_gid}/parentGoals | Get parent goals from a goal
  *GoalsApi* | [**remove_followers**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/GoalsApi.md#remove_followers) | **POST** /goals/{goal_gid}/removeFollowers | Remove a collaborator from a goal
  *GoalsApi* | [**update_goal**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/GoalsApi.md#update_goal) | **PUT** /goals/{goal_gid} | Update a goal
  *GoalsApi* | [**update_goal_metric**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/GoalsApi.md#update_goal_metric) | **POST** /goals/{goal_gid}/setMetricCurrentValue | Update a goal metric
  *JobsApi* | [**get_job**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/JobsApi.md#get_job) | **GET** /jobs/{job_gid} | Get a job by id
  *MembershipsApi* | [**create_membership**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/MembershipsApi.md#create_membership) | **POST** /memberships | Create a membership
  *MembershipsApi* | [**delete_membership**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/MembershipsApi.md#delete_membership) | **DELETE** /memberships/{membership_gid} | Delete a membership
  *MembershipsApi* | [**get_membership**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/MembershipsApi.md#get_membership) | **GET** /memberships/{membership_gid} | Get a membership
  *MembershipsApi* | [**get_memberships**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/MembershipsApi.md#get_memberships) | **GET** /memberships | Get multiple memberships
  *MembershipsApi* | [**update_membership**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/MembershipsApi.md#update_membership) | **PUT** /memberships/{membership_gid} | Update a membership
  *OrganizationExportsApi* | [**create_organization_export**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/OrganizationExportsApi.md#create_organization_export) | **POST** /organization_exports | Create an organization export request
  *OrganizationExportsApi* | [**get_organization_export**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/OrganizationExportsApi.md#get_organization_export) | **GET** /organization_exports/{organization_export_gid} | Get details on an org export request
  *PortfolioMembershipsApi* | [**get_portfolio_membership**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/PortfolioMembershipsApi.md#get_portfolio_membership) | **GET** /portfolio_memberships/{portfolio_membership_gid} | Get a portfolio membership
  *PortfolioMembershipsApi* | [**get_portfolio_memberships**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/PortfolioMembershipsApi.md#get_portfolio_memberships) | **GET** /portfolio_memberships | Get multiple portfolio memberships
  *PortfolioMembershipsApi* | [**get_portfolio_memberships_for_portfolio**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/PortfolioMembershipsApi.md#get_portfolio_memberships_for_portfolio) | **GET** /portfolios/{portfolio_gid}/portfolio_memberships | Get memberships from a portfolio
  *PortfoliosApi* | [**add_custom_field_setting_for_portfolio**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/PortfoliosApi.md#add_custom_field_setting_for_portfolio) | **POST** /portfolios/{portfolio_gid}/addCustomFieldSetting | Add a custom field to a portfolio
  *PortfoliosApi* | [**add_item_for_portfolio**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/PortfoliosApi.md#add_item_for_portfolio) | **POST** /portfolios/{portfolio_gid}/addItem | Add a portfolio item
  *PortfoliosApi* | [**add_members_for_portfolio**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/PortfoliosApi.md#add_members_for_portfolio) | **POST** /portfolios/{portfolio_gid}/addMembers | Add users to a portfolio
  *PortfoliosApi* | [**create_portfolio**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/PortfoliosApi.md#create_portfolio) | **POST** /portfolios | Create a portfolio
  *PortfoliosApi* | [**delete_portfolio**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/PortfoliosApi.md#delete_portfolio) | **DELETE** /portfolios/{portfolio_gid} | Delete a portfolio
  *PortfoliosApi* | [**get_items_for_portfolio**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/PortfoliosApi.md#get_items_for_portfolio) | **GET** /portfolios/{portfolio_gid}/items | Get portfolio items
  *PortfoliosApi* | [**get_portfolio**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/PortfoliosApi.md#get_portfolio) | **GET** /portfolios/{portfolio_gid} | Get a portfolio
  *PortfoliosApi* | [**get_portfolios**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/PortfoliosApi.md#get_portfolios) | **GET** /portfolios | Get multiple portfolios
  *PortfoliosApi* | [**remove_custom_field_setting_for_portfolio**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/PortfoliosApi.md#remove_custom_field_setting_for_portfolio) | **POST** /portfolios/{portfolio_gid}/removeCustomFieldSetting | Remove a custom field from a portfolio
  *PortfoliosApi* | [**remove_item_for_portfolio**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/PortfoliosApi.md#remove_item_for_portfolio) | **POST** /portfolios/{portfolio_gid}/removeItem | Remove a portfolio item
  *PortfoliosApi* | [**remove_members_for_portfolio**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/PortfoliosApi.md#remove_members_for_portfolio) | **POST** /portfolios/{portfolio_gid}/removeMembers | Remove users from a portfolio
  *PortfoliosApi* | [**update_portfolio**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/PortfoliosApi.md#update_portfolio) | **PUT** /portfolios/{portfolio_gid} | Update a portfolio
  *ProjectBriefsApi* | [**create_project_brief**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectBriefsApi.md#create_project_brief) | **POST** /projects/{project_gid}/project_briefs | Create a project brief
  *ProjectBriefsApi* | [**delete_project_brief**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectBriefsApi.md#delete_project_brief) | **DELETE** /project_briefs/{project_brief_gid} | Delete a project brief
  *ProjectBriefsApi* | [**get_project_brief**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectBriefsApi.md#get_project_brief) | **GET** /project_briefs/{project_brief_gid} | Get a project brief
  *ProjectBriefsApi* | [**update_project_brief**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectBriefsApi.md#update_project_brief) | **PUT** /project_briefs/{project_brief_gid} | Update a project brief
  *ProjectMembershipsApi* | [**get_project_membership**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectMembershipsApi.md#get_project_membership) | **GET** /project_memberships/{project_membership_gid} | Get a project membership
  *ProjectMembershipsApi* | [**get_project_memberships_for_project**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectMembershipsApi.md#get_project_memberships_for_project) | **GET** /projects/{project_gid}/project_memberships | Get memberships from a project
  *ProjectStatusesApi* | [**create_project_status_for_project**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectStatusesApi.md#create_project_status_for_project) | **POST** /projects/{project_gid}/project_statuses | Create a project status
  *ProjectStatusesApi* | [**delete_project_status**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectStatusesApi.md#delete_project_status) | **DELETE** /project_statuses/{project_status_gid} | Delete a project status
  *ProjectStatusesApi* | [**get_project_status**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectStatusesApi.md#get_project_status) | **GET** /project_statuses/{project_status_gid} | Get a project status
  *ProjectStatusesApi* | [**get_project_statuses_for_project**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectStatusesApi.md#get_project_statuses_for_project) | **GET** /projects/{project_gid}/project_statuses | Get statuses from a project
  *ProjectTemplatesApi* | [**delete_project_template**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectTemplatesApi.md#delete_project_template) | **DELETE** /project_templates/{project_template_gid} | Delete a project template
  *ProjectTemplatesApi* | [**get_project_template**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectTemplatesApi.md#get_project_template) | **GET** /project_templates/{project_template_gid} | Get a project template
  *ProjectTemplatesApi* | [**get_project_templates**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectTemplatesApi.md#get_project_templates) | **GET** /project_templates | Get multiple project templates
  *ProjectTemplatesApi* | [**get_project_templates_for_team**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectTemplatesApi.md#get_project_templates_for_team) | **GET** /teams/{team_gid}/project_templates | Get a team&#x27;s project templates
  *ProjectTemplatesApi* | [**instantiate_project**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectTemplatesApi.md#instantiate_project) | **POST** /project_templates/{project_template_gid}/instantiateProject | Instantiate a project from a project template
  *ProjectsApi* | [**add_custom_field_setting_for_project**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectsApi.md#add_custom_field_setting_for_project) | **POST** /projects/{project_gid}/addCustomFieldSetting | Add a custom field to a project
  *ProjectsApi* | [**add_followers_for_project**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectsApi.md#add_followers_for_project) | **POST** /projects/{project_gid}/addFollowers | Add followers to a project
  *ProjectsApi* | [**add_members_for_project**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectsApi.md#add_members_for_project) | **POST** /projects/{project_gid}/addMembers | Add users to a project
  *ProjectsApi* | [**create_project**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectsApi.md#create_project) | **POST** /projects | Create a project
  *ProjectsApi* | [**create_project_for_team**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectsApi.md#create_project_for_team) | **POST** /teams/{team_gid}/projects | Create a project in a team
  *ProjectsApi* | [**create_project_for_workspace**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectsApi.md#create_project_for_workspace) | **POST** /workspaces/{workspace_gid}/projects | Create a project in a workspace
  *ProjectsApi* | [**delete_project**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectsApi.md#delete_project) | **DELETE** /projects/{project_gid} | Delete a project
  *ProjectsApi* | [**duplicate_project**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectsApi.md#duplicate_project) | **POST** /projects/{project_gid}/duplicate | Duplicate a project
  *ProjectsApi* | [**get_project**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectsApi.md#get_project) | **GET** /projects/{project_gid} | Get a project
  *ProjectsApi* | [**get_projects**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectsApi.md#get_projects) | **GET** /projects | Get multiple projects
  *ProjectsApi* | [**get_projects_for_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectsApi.md#get_projects_for_task) | **GET** /tasks/{task_gid}/projects | Get projects a task is in
  *ProjectsApi* | [**get_projects_for_team**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectsApi.md#get_projects_for_team) | **GET** /teams/{team_gid}/projects | Get a team&#x27;s projects
  *ProjectsApi* | [**get_projects_for_workspace**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectsApi.md#get_projects_for_workspace) | **GET** /workspaces/{workspace_gid}/projects | Get all projects in a workspace
  *ProjectsApi* | [**get_task_counts_for_project**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectsApi.md#get_task_counts_for_project) | **GET** /projects/{project_gid}/task_counts | Get task count of a project
  *ProjectsApi* | [**project_save_as_template**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectsApi.md#project_save_as_template) | **POST** /projects/{project_gid}/saveAsTemplate | Create a project template from a project
  *ProjectsApi* | [**remove_custom_field_setting_for_project**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectsApi.md#remove_custom_field_setting_for_project) | **POST** /projects/{project_gid}/removeCustomFieldSetting | Remove a custom field from a project
  *ProjectsApi* | [**remove_followers_for_project**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectsApi.md#remove_followers_for_project) | **POST** /projects/{project_gid}/removeFollowers | Remove followers from a project
  *ProjectsApi* | [**remove_members_for_project**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectsApi.md#remove_members_for_project) | **POST** /projects/{project_gid}/removeMembers | Remove users from a project
  *ProjectsApi* | [**update_project**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectsApi.md#update_project) | **PUT** /projects/{project_gid} | Update a project
  *RulesApi* | [**trigger_rule**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/RulesApi.md#trigger_rule) | **POST** /rule_triggers/{rule_trigger_gid}/run | Trigger a rule
  *SectionsApi* | [**add_task_for_section**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/SectionsApi.md#add_task_for_section) | **POST** /sections/{section_gid}/addTask | Add task to section
  *SectionsApi* | [**create_section_for_project**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/SectionsApi.md#create_section_for_project) | **POST** /projects/{project_gid}/sections | Create a section in a project
  *SectionsApi* | [**delete_section**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/SectionsApi.md#delete_section) | **DELETE** /sections/{section_gid} | Delete a section
  *SectionsApi* | [**get_section**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/SectionsApi.md#get_section) | **GET** /sections/{section_gid} | Get a section
  *SectionsApi* | [**get_sections_for_project**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/SectionsApi.md#get_sections_for_project) | **GET** /projects/{project_gid}/sections | Get sections in a project
  *SectionsApi* | [**insert_section_for_project**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/SectionsApi.md#insert_section_for_project) | **POST** /projects/{project_gid}/sections/insert | Move or Insert sections
  *SectionsApi* | [**update_section**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/SectionsApi.md#update_section) | **PUT** /sections/{section_gid} | Update a section
  *StatusUpdatesApi* | [**create_status_for_object**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/StatusUpdatesApi.md#create_status_for_object) | **POST** /status_updates | Create a status update
  *StatusUpdatesApi* | [**delete_status**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/StatusUpdatesApi.md#delete_status) | **DELETE** /status_updates/{status_update_gid} | Delete a status update
  *StatusUpdatesApi* | [**get_status**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/StatusUpdatesApi.md#get_status) | **GET** /status_updates/{status_update_gid} | Get a status update
  *StatusUpdatesApi* | [**get_statuses_for_object**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/StatusUpdatesApi.md#get_statuses_for_object) | **GET** /status_updates | Get status updates from an object
  *StoriesApi* | [**create_story_for_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/StoriesApi.md#create_story_for_task) | **POST** /tasks/{task_gid}/stories | Create a story on a task
  *StoriesApi* | [**delete_story**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/StoriesApi.md#delete_story) | **DELETE** /stories/{story_gid} | Delete a story
  *StoriesApi* | [**get_stories_for_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/StoriesApi.md#get_stories_for_task) | **GET** /tasks/{task_gid}/stories | Get stories from a task
  *StoriesApi* | [**get_story**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/StoriesApi.md#get_story) | **GET** /stories/{story_gid} | Get a story
  *StoriesApi* | [**update_story**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/StoriesApi.md#update_story) | **PUT** /stories/{story_gid} | Update a story
  *TagsApi* | [**create_tag**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TagsApi.md#create_tag) | **POST** /tags | Create a tag
  *TagsApi* | [**create_tag_for_workspace**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TagsApi.md#create_tag_for_workspace) | **POST** /workspaces/{workspace_gid}/tags | Create a tag in a workspace
  *TagsApi* | [**delete_tag**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TagsApi.md#delete_tag) | **DELETE** /tags/{tag_gid} | Delete a tag
  *TagsApi* | [**get_tag**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TagsApi.md#get_tag) | **GET** /tags/{tag_gid} | Get a tag
  *TagsApi* | [**get_tags**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TagsApi.md#get_tags) | **GET** /tags | Get multiple tags
  *TagsApi* | [**get_tags_for_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TagsApi.md#get_tags_for_task) | **GET** /tasks/{task_gid}/tags | Get a task&#x27;s tags
  *TagsApi* | [**get_tags_for_workspace**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TagsApi.md#get_tags_for_workspace) | **GET** /workspaces/{workspace_gid}/tags | Get tags in a workspace
  *TagsApi* | [**update_tag**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TagsApi.md#update_tag) | **PUT** /tags/{tag_gid} | Update a tag
  *TaskTemplatesApi* | [**delete_task_template**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TaskTemplatesApi.md#delete_task_template) | **DELETE** /task_templates/{task_template_gid} | Delete a task template
  *TaskTemplatesApi* | [**get_task_template**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TaskTemplatesApi.md#get_task_template) | **GET** /task_templates/{task_template_gid} | Get a task template
  *TaskTemplatesApi* | [**get_task_templates**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TaskTemplatesApi.md#get_task_templates) | **GET** /task_templates | Get multiple task templates
  *TaskTemplatesApi* | [**instantiate_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TaskTemplatesApi.md#instantiate_task) | **POST** /task_templates/{task_template_gid}/instantiateTask | Instantiate a task from a task template
  *TasksApi* | [**add_dependencies_for_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#add_dependencies_for_task) | **POST** /tasks/{task_gid}/addDependencies | Set dependencies for a task
  *TasksApi* | [**add_dependents_for_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#add_dependents_for_task) | **POST** /tasks/{task_gid}/addDependents | Set dependents for a task
  *TasksApi* | [**add_followers_for_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#add_followers_for_task) | **POST** /tasks/{task_gid}/addFollowers | Add followers to a task
  *TasksApi* | [**add_project_for_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#add_project_for_task) | **POST** /tasks/{task_gid}/addProject | Add a project to a task
  *TasksApi* | [**add_tag_for_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#add_tag_for_task) | **POST** /tasks/{task_gid}/addTag | Add a tag to a task
  *TasksApi* | [**create_subtask_for_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#create_subtask_for_task) | **POST** /tasks/{task_gid}/subtasks | Create a subtask
  *TasksApi* | [**create_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#create_task) | **POST** /tasks | Create a task
  *TasksApi* | [**delete_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#delete_task) | **DELETE** /tasks/{task_gid} | Delete a task
  *TasksApi* | [**duplicate_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#duplicate_task) | **POST** /tasks/{task_gid}/duplicate | Duplicate a task
  *TasksApi* | [**get_dependencies_for_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#get_dependencies_for_task) | **GET** /tasks/{task_gid}/dependencies | Get dependencies from a task
  *TasksApi* | [**get_dependents_for_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#get_dependents_for_task) | **GET** /tasks/{task_gid}/dependents | Get dependents from a task
  *TasksApi* | [**get_subtasks_for_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#get_subtasks_for_task) | **GET** /tasks/{task_gid}/subtasks | Get subtasks from a task
  *TasksApi* | [**get_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#get_task) | **GET** /tasks/{task_gid} | Get a task
  *TasksApi* | [**get_task_for_custom_id**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#get_task_for_custom_id) | **GET** /workspaces/{workspace_gid}/tasks/custom_id/{custom_id} | Get a task for a given custom ID
  *TasksApi* | [**get_tasks**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#get_tasks) | **GET** /tasks | Get multiple tasks
  *TasksApi* | [**get_tasks_for_project**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#get_tasks_for_project) | **GET** /projects/{project_gid}/tasks | Get tasks from a project
  *TasksApi* | [**get_tasks_for_section**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#get_tasks_for_section) | **GET** /sections/{section_gid}/tasks | Get tasks from a section
  *TasksApi* | [**get_tasks_for_tag**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#get_tasks_for_tag) | **GET** /tags/{tag_gid}/tasks | Get tasks from a tag
  *TasksApi* | [**get_tasks_for_user_task_list**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#get_tasks_for_user_task_list) | **GET** /user_task_lists/{user_task_list_gid}/tasks | Get tasks from a user task list
  *TasksApi* | [**remove_dependencies_for_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#remove_dependencies_for_task) | **POST** /tasks/{task_gid}/removeDependencies | Unlink dependencies from a task
  *TasksApi* | [**remove_dependents_for_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#remove_dependents_for_task) | **POST** /tasks/{task_gid}/removeDependents | Unlink dependents from a task
  *TasksApi* | [**remove_follower_for_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#remove_follower_for_task) | **POST** /tasks/{task_gid}/removeFollowers | Remove followers from a task
  *TasksApi* | [**remove_project_for_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#remove_project_for_task) | **POST** /tasks/{task_gid}/removeProject | Remove a project from a task
  *TasksApi* | [**remove_tag_for_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#remove_tag_for_task) | **POST** /tasks/{task_gid}/removeTag | Remove a tag from a task
  *TasksApi* | [**search_tasks_for_workspace**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#search_tasks_for_workspace) | **GET** /workspaces/{workspace_gid}/tasks/search | Search tasks in a workspace
  *TasksApi* | [**set_parent_for_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#set_parent_for_task) | **POST** /tasks/{task_gid}/setParent | Set the parent of a task
  *TasksApi* | [**update_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#update_task) | **PUT** /tasks/{task_gid} | Update a task
  *TeamMembershipsApi* | [**get_team_membership**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TeamMembershipsApi.md#get_team_membership) | **GET** /team_memberships/{team_membership_gid} | Get a team membership
  *TeamMembershipsApi* | [**get_team_memberships**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TeamMembershipsApi.md#get_team_memberships) | **GET** /team_memberships | Get team memberships
  *TeamMembershipsApi* | [**get_team_memberships_for_team**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TeamMembershipsApi.md#get_team_memberships_for_team) | **GET** /teams/{team_gid}/team_memberships | Get memberships from a team
  *TeamMembershipsApi* | [**get_team_memberships_for_user**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TeamMembershipsApi.md#get_team_memberships_for_user) | **GET** /users/{user_gid}/team_memberships | Get memberships from a user
  *TeamsApi* | [**add_user_for_team**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TeamsApi.md#add_user_for_team) | **POST** /teams/{team_gid}/addUser | Add a user to a team
  *TeamsApi* | [**create_team**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TeamsApi.md#create_team) | **POST** /teams | Create a team
  *TeamsApi* | [**get_team**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TeamsApi.md#get_team) | **GET** /teams/{team_gid} | Get a team
  *TeamsApi* | [**get_teams_for_user**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TeamsApi.md#get_teams_for_user) | **GET** /users/{user_gid}/teams | Get teams for a user
  *TeamsApi* | [**get_teams_for_workspace**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TeamsApi.md#get_teams_for_workspace) | **GET** /workspaces/{workspace_gid}/teams | Get teams in a workspace
  *TeamsApi* | [**remove_user_for_team**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TeamsApi.md#remove_user_for_team) | **POST** /teams/{team_gid}/removeUser | Remove a user from a team
  *TeamsApi* | [**update_team**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TeamsApi.md#update_team) | **PUT** /teams/{team_gid} | Update a team
  *TimePeriodsApi* | [**get_time_period**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TimePeriodsApi.md#get_time_period) | **GET** /time_periods/{time_period_gid} | Get a time period
  *TimePeriodsApi* | [**get_time_periods**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TimePeriodsApi.md#get_time_periods) | **GET** /time_periods | Get time periods
  *TimeTrackingEntriesApi* | [**create_time_tracking_entry**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TimeTrackingEntriesApi.md#create_time_tracking_entry) | **POST** /tasks/{task_gid}/time_tracking_entries | Create a time tracking entry
  *TimeTrackingEntriesApi* | [**delete_time_tracking_entry**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TimeTrackingEntriesApi.md#delete_time_tracking_entry) | **DELETE** /time_tracking_entries/{time_tracking_entry_gid} | Delete a time tracking entry
  *TimeTrackingEntriesApi* | [**get_time_tracking_entries_for_task**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TimeTrackingEntriesApi.md#get_time_tracking_entries_for_task) | **GET** /tasks/{task_gid}/time_tracking_entries | Get time tracking entries for a task
  *TimeTrackingEntriesApi* | [**get_time_tracking_entry**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TimeTrackingEntriesApi.md#get_time_tracking_entry) | **GET** /time_tracking_entries/{time_tracking_entry_gid} | Get a time tracking entry
  *TimeTrackingEntriesApi* | [**update_time_tracking_entry**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TimeTrackingEntriesApi.md#update_time_tracking_entry) | **PUT** /time_tracking_entries/{time_tracking_entry_gid} | Update a time tracking entry
  *TypeaheadApi* | [**typeahead_for_workspace**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TypeaheadApi.md#typeahead_for_workspace) | **GET** /workspaces/{workspace_gid}/typeahead | Get objects via typeahead
  *UserTaskListsApi* | [**get_user_task_list**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/UserTaskListsApi.md#get_user_task_list) | **GET** /user_task_lists/{user_task_list_gid} | Get a user task list
  *UserTaskListsApi* | [**get_user_task_list_for_user**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/UserTaskListsApi.md#get_user_task_list_for_user) | **GET** /users/{user_gid}/user_task_list | Get a user&#x27;s task list
  *UsersApi* | [**get_favorites_for_user**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/UsersApi.md#get_favorites_for_user) | **GET** /users/{user_gid}/favorites | Get a user&#x27;s favorites
  *UsersApi* | [**get_user**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/UsersApi.md#get_user) | **GET** /users/{user_gid} | Get a user
  *UsersApi* | [**get_users**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/UsersApi.md#get_users) | **GET** /users | Get multiple users
  *UsersApi* | [**get_users_for_team**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/UsersApi.md#get_users_for_team) | **GET** /teams/{team_gid}/users | Get users in a team
  *UsersApi* | [**get_users_for_workspace**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/UsersApi.md#get_users_for_workspace) | **GET** /workspaces/{workspace_gid}/users | Get users in a workspace or organization
  *WebhooksApi* | [**create_webhook**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/WebhooksApi.md#create_webhook) | **POST** /webhooks | Establish a webhook
  *WebhooksApi* | [**delete_webhook**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/WebhooksApi.md#delete_webhook) | **DELETE** /webhooks/{webhook_gid} | Delete a webhook
  *WebhooksApi* | [**get_webhook**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/WebhooksApi.md#get_webhook) | **GET** /webhooks/{webhook_gid} | Get a webhook
  *WebhooksApi* | [**get_webhooks**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/WebhooksApi.md#get_webhooks) | **GET** /webhooks | Get multiple webhooks
  *WebhooksApi* | [**update_webhook**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/WebhooksApi.md#update_webhook) | **PUT** /webhooks/{webhook_gid} | Update a webhook
  *WorkspaceMembershipsApi* | [**get_workspace_membership**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/WorkspaceMembershipsApi.md#get_workspace_membership) | **GET** /workspace_memberships/{workspace_membership_gid} | Get a workspace membership
  *WorkspaceMembershipsApi* | [**get_workspace_memberships_for_user**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/WorkspaceMembershipsApi.md#get_workspace_memberships_for_user) | **GET** /users/{user_gid}/workspace_memberships | Get workspace memberships for a user
  *WorkspaceMembershipsApi* | [**get_workspace_memberships_for_workspace**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/WorkspaceMembershipsApi.md#get_workspace_memberships_for_workspace) | **GET** /workspaces/{workspace_gid}/workspace_memberships | Get the workspace memberships for a workspace
  *WorkspacesApi* | [**add_user_for_workspace**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/WorkspacesApi.md#add_user_for_workspace) | **POST** /workspaces/{workspace_gid}/addUser | Add a user to a workspace or organization
  *WorkspacesApi* | [**get_workspace**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/WorkspacesApi.md#get_workspace) | **GET** /workspaces/{workspace_gid} | Get a workspace
  *WorkspacesApi* | [**get_workspaces**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/WorkspacesApi.md#get_workspaces) | **GET** /workspaces | Get multiple workspaces
  *WorkspacesApi* | [**remove_user_for_workspace**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/WorkspacesApi.md#remove_user_for_workspace) | **POST** /workspaces/{workspace_gid}/removeUser | Remove a user from a workspace or organization
  *WorkspacesApi* | [**update_workspace**](https://github.com/Asana/python-asana/blob/v5.0.10/docs/WorkspacesApi.md#update_workspace) | **PUT** /workspaces/{workspace_gid} | Update a workspace


  ```python
  .
  .
  .
  try:
      task = tasks_api_instance.get_task(task_gid, opts)
      task_name = task['name']
      task_notes = task['notes']
  except ApiException as e:
      .
      .
      .
  ```

  In the scenario you want to access the response headers or the status code along with the response data you can
  provide the `_return_http_data_only` parameter argument in the request method and set the value to `False`
  ```python
  import asana
  from asana.rest import ApiException
  from pprint import pprint
  configuration = asana.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana.ApiClient(configuration)

  users_api_instance = asana.UsersApi(api_client)
  user_gid = 'me' # str | A string identifying a user. This can either be the string \"me\", an email, or the gid of a user.
  opts = {}
  try:
      
      (api_response, status, headers) = users_api_instance.get_user(user_gid, opts, _return_http_data_only=False) # returns a tuple: (response, status, headers)
      pprint(api_response)
      pprint(status)
      pprint(headers)
  except ApiException as e:
      print("Exception when calling UsersApi->get_user: %s\n" % e)
  ```


  ```python
  import asana
  from asana.rest import ApiException
  from pprint import pprint
  configuration = asana.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana.ApiClient(configuration)

  api_client.default_headers['asana-enable'] = 'string_ids'
  ```
  OR

  ```python
  import asana
  from asana.rest import ApiException
  from pprint import pprint
  configuration = asana.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana.ApiClient(configuration)

  users_api_instance = asana.UsersApi(api_client)
  user_gid = 'me' # str | A string identifying a user. This can either be the string \"me\", an email, or the gid of a user.
  opts = {}
  try:
      
      api_response = users_api_instance.get_user(user_gid, opts, header_params={'asana-enable': 'string_ids'})
      pprint(api_response)
  except ApiException as e:
      print("Exception when calling UsersApi->get_user: %s\n" % e)
  ```

  This client library uses multithreading to make async requests. To make async requests you can pass in `async_req=True` in the method call.
  NOTE:
  - This feature disables our auto-pagination feature
  - You will want to add logic to handle the Asana API rate limits
  The code belows is an example of how to make 15 async create task calls. It does not handle the Asana API rate limits.
  You will have to implement your own solution for API rate limits based on your tier.
  ```python
  import asana
  from asana.rest import ApiException
  from pprint import pprint
  configuration = asana.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana.ApiClient(configuration)
  tasks_api_instance = asana.TasksApi(api_client)
  threads = []
  for i in range(1, 15+1):
      body = {
          "data": {
              "name": f"Task: {i}",
              "projects": ["<YOUR_PROJECT_GID>"]
          }
      }
      opts = {}
      threads.append(tasks_api_instance.create_task(body, opts, async_req=True))
  for thread in threads:
      try:
          pprint(thread.get())
      except ApiException as e:
          print("Exception when calling TasksApi->create_task: %s\n" % e)
  ```

  The pagination feature is enabled by default. This means two things:
  1: Endpoints that return a single response (EX: [get_task](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#get_task) ([Get a task](https://developers.asana.com/reference/gettask)), [get_project](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#get_project) ([Get a project](https://developers.asana.com/reference/getproject)), etc...)
  will return a response with the `"data"` key abstracted from the response.
  Instead of returning:
  ```python
  {
      "data": {
          "gid": "123",
          "actual_time_minutes": null,
          "assignee": null,
          "workspace": {
              "gid": "1234567",
              "name": "user@example.com",
              "resource_type": "workspace"
          }
      }
  }
  ```
  It returns:
  ```python
  {
      "gid": "123",
      "actual_time_minutes": null,
      "assignee": null,
      "workspace": {
          "gid": "1234567",
          "name": "user@example.com",
          "resource_type": "workspace"
      }
  }
  ```
  2: Endpoints that return an array of resources (EX: [get_tasks](https://github.com/Asana/python-asana/blob/v5.0.10/docs/TasksApi.md#get_tasks) ([Get multiple tasks](https://developers.asana.com/reference/gettasks)), [get_projects](https://github.com/Asana/python-asana/blob/v5.0.10/docs/ProjectsApi.md#get_projects) ([Get multiple projects](https://developers.asana.com/reference/getprojects)), etc...)
  will return a generator object ([PageIterator.items](https://github.com/Asana/python-asana/blob/v5.0.10/asana/pagination/page_iterator.py)) that you can use to iterate through each result.
  Example usage 1:
  ```python
  import asana
  from asana.rest import ApiException
  from pprint import pprint
  configuration = asana.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana.ApiClient(configuration)
  tasks_api_instance = asana.TasksApi(api_client)
  opts = {"project": "<YOUR_PROJECT_GID>"}
  try:
      tasks = tasks_api_instance.get_tasks(opts)
      for task in tasks:
          pprint(task)
  except Exception as e:
      print("Exception when calling TasksApi->get_tasks: %s\n" % e)
  ```
  Example response:
  ```python
  {'gid': '123',
   'name': 'Task 1',
   'resource_subtype': 'default_task',
   'resource_type': 'task'},
   .
   .
   .
  ```
  Example usage 2:
  ```python
  import asana
  from asana.rest import ApiException
  from pprint import pprint
  configuration = asana.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana.ApiClient(configuration)
  tasks_api_instance = asana.TasksApi(api_client)
  opts = {"project": "<YOUR_PROJECT_GID>"}
  try:
      tasks = tasks_api_instance.get_tasks(opts)
      pprint(list(tasks))
  except Exception as e:
      print("Exception when calling TasksApi->get_tasks: %s\n" % e)
  ```
  Example response:
  ```python
  [{'gid': '123',
   'name': 'Task 1',
   'resource_subtype': 'default_task',
   'resource_type': 'task'},
   .
   .
   .]
  ```

  In the scenario where you want to end the pagination early, you can specify an `item_limit` in the method call. This will stop the iterator from going past that limit.
  **Example Scenario:** You have 1000 tasks in a project and are only interested in the first 2 tasks. Instead of letting the pagination code continue to run to get all those 1000 tasks you can specify that you only want the first X results with `item_limit`.
  **Without `item_limit` - The for loop will continue to run until it runs out of tasks:**
  ```python
      tasks = tasks_api_instance.get_tasks(opts)
      for task in tasks:
          pprint(task)
  ```
  **Sample response:**
  ```python
  {'gid': '123',
   'name': 'Task 1',
   'resource_subtype': 'default_task',
   'resource_type': 'task'},
   .
   .
   .
   <1000th_TASK>
  ```
  **With `item_limit` - the for loop will stop at the `item_limit` you specified:**
  ```python
      tasks = tasks_api_instance.get_tasks(opts, item_limit=2)
      for task in tasks:
          pprint(task)
  ```
  **Sample response:**
  ```python
  {'gid': '123',
   'name': 'Task 1',
   'resource_subtype': 'default_task',
   'resource_type': 'task'},
  {'gid': '456',
   'name': 'Task 2',
   'resource_subtype': 'default_task',
   'resource_type': 'task'}
  ```
  Alternatively, if you are iterating over the generator object in a for loop, you can also just break out of the loop.
  **EX:**
  ```python
  opts = {'project': "<YOUR_PROJECT_GID>"}
  try:
      count = 0
      tasks = tasks_api_instance.get_tasks(opts)
      for task in tasks:
          if count == 2:
              break
          pprint(task)
          count += 1
  ```
  **Sample response:**
  ```python
  {'gid': '123',
   'name': 'Task 1',
   'resource_subtype': 'default_task',
   'resource_type': 'task'},
   {'gid': '456',
   'name': 'Task 2',
   'resource_subtype': 'default_task',
   'resource_type': 'task'}
  ```

  If you do not want to use the default pagination behaviour there are two ways to disbale it.
  1: Per request - Disable pagination behavior for a single request - pass in `full_payload=True` in the method request
  ```python
  import asana
  from asana.rest import ApiException
  from pprint import pprint
  configuration = asana.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana.ApiClient(configuration)
  tasks_api_instance = asana.TasksApi(api_client)
  opts = {"project": "<YOUR_PROJECT>", "limit": 2}
  try:
      tasks = tasks_api_instance.get_tasks(opts, full_payload=True)
      pprint(tasks)
  except Exception as e:
      print("Exception when calling TasksApi->get_tasks: %s\n" % e)
  ```
  Sample response:
  ```python
  {'data': [{'gid': '123',
             'name': 'Task 1',
             'resource_subtype': 'default_task',
             'resource_type': 'task'},
            {'gid': '456',
             'name': 'Task 2',
             'resource_subtype': 'default_task',
             'resource_type': 'task'}],
   'next_page': {'offset': 'eyJ0...',
                 'path': '/tasks?project=789&limit=2&offset=eyJ0...',
                 'uri': 'https://app.asana.com/api/1.0/tasks?project=789&limit=2&offset=eyJ0...'}}
  ```
  2: Globally - Disable pagination behavior for all requests - Set `return_page_iterator` to False
  ```python
  configuration = asana.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  configuration.return_page_iterator = False
  api_client = asana.ApiClient(configuration)
  ```

  Use this to make HTTP calls when the endpoint does not exist in the current library version or has bugs


  ```python
  import asana
  from asana.rest import ApiException
  from pprint import pprint
  configuration = asana.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana.ApiClient(configuration)
  try:
      
      api_response = api_client.call_api(
          "/tasks/{task_gid}",
          "GET",
          path_params={"task_gid": "<YOUR_TASK_GID>"},
          query_params={},
          header_params={"Accept": "application/json; charset=utf-8"},
          body=None,
          post_params=[],
          files={},
          response_type=object, # You can specify one of the following types: float, bool, bytes, str, object
          auth_settings=["token"],
          async_req=None,
          _return_http_data_only=True,
          _preload_content=True,
          _request_timeout=None,
          collection_formats={},
      )
      pprint(api_response)
  except ApiException as e:
      print("Exception: %s\n" % e)
  ```

  ```python
  import asana
  from asana.rest import ApiException
  from pprint import pprint
  configuration = asana.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana.ApiClient(configuration)
  try:
      
      api_response = api_client.call_api(
          "/tasks",
          "GET",
          path_params={},
          query_params={
              "project": "<YOUR_PROJECT_GID>",
              "opt_fields": "name,notes,projects",
          },
          header_params={"Accept": "application/json; charset=utf-8"},
          body=None,
          post_params=[],
          files={},
          response_type=object, # You can specify one of the following types: float, bool, bytes, str, object
          auth_settings=["token"],
          async_req=None,
          _return_http_data_only=True,
          _preload_content=True,
          _request_timeout=None,
          collection_formats={},
      )
      pprint(api_response)
  except ApiException as e:
      print("Exception: %s\n" % e)
  ```

  ```python
  import asana
  from asana.rest import ApiException
  from pprint import pprint
  configuration = asana.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana.ApiClient(configuration)
  try:
      
      api_response = api_client.call_api(
          "/tasks",
          "POST",
          path_params={},
          query_params={},
          header_params={
              "Accept": "application/json; charset=utf-8",
              "Content-Type": "application/json; charset=utf-8",
          },
          body={
              "data": {
                  "name": "New Task",
                  "projects": ["<YOUR_PROJECT_GID>"],
              }
          },
          post_params=[],
          files={},
          response_type=object, # You can specify one of the following types: float, bool, bytes, str, object
          auth_settings=["token"],
          async_req=None,
          _return_http_data_only=True,
          _preload_content=True,
          _request_timeout=None,
          collection_formats={},
      )
      pprint(api_response)
  except ApiException as e:
      print("Exception: %s\n" % e)
  ```

  ```python
  import asana
  from asana.rest import ApiException
  from pprint import pprint
  configuration = asana.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana.ApiClient(configuration)
  try:
      
      api_response = api_client.call_api(
          "/tasks/{task_gid}",
          "PUT",
          path_params={"task_gid": "<YOUR_TASK_GID>"},
          query_params={},
          header_params={
              "Accept": "application/json; charset=utf-8",
              "Content-Type": "application/json; charset=utf-8",
          },
          body={
              "data": {
                  "name": "Updated Task",
              }
          },
          post_params=[],
          files={},
          response_type=object, # You can specify one of the following types: float, bool, bytes, str, object
          auth_settings=["token"],
          async_req=None,
          _return_http_data_only=True,
          _preload_content=True,
          _request_timeout=None,
          collection_formats={},
      )
      pprint(api_response)
  except ApiException as e:
      print("Exception: %s\n" % e)
  ```

  ```python
  import asana
  from asana.rest import ApiException
  from pprint import pprint
  configuration = asana.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana.ApiClient(configuration)
  try:
      
      api_response = api_client.call_api(
          "/tasks/{task_gid}",
          "DELETE",
          path_params={"task_gid": "<YOUR_TASK_GID>"},
          query_params={},
          header_params={"Accept": "application/json; charset=utf-8"},
          body=None,
          post_params=[],
          files={},
          response_type=object, # You can specify one of the following types: float, bool, bytes, str, object
          auth_settings=["token"],
          async_req=None,
          _return_http_data_only=True,
          _preload_content=True,
          _request_timeout=None,
          collection_formats={},
      )
      pprint(api_response)
  except ApiException as e:
      print("Exception: %s\n" % e)
  ```
  [release-image]: https://img.shields.io/github/release/asana/python-asana.svg
  [pypi-image]: https://img.shields.io/pypi/v/asana.svg?style=flat-square
  [pypi-url]: https://pypi.python.org/pypi/asana/


pkgId: 5d1eff92520de80fb36fdf1edb284e9201e9df2ad78cc3059ef08ab6ba510a05
name: python-asana-preview
arch: src
version: 1.2.40
epoch: 0
release: 1
summary: Asana
url: http://github.com/asana/python-asana-preview
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asana-preview-1.2.40-1.src.rpm
checksum_type: sha256
description:
  *AttachmentsApi* | [**create_attachment_for_object**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/AttachmentsApi.md#create_attachment_for_object) | **POST** /attachments | Upload an attachment
  *AttachmentsApi* | [**delete_attachment**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/AttachmentsApi.md#delete_attachment) | **DELETE** /attachments/{attachment_gid} | Delete an attachment
  *AttachmentsApi* | [**get_attachment**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/AttachmentsApi.md#get_attachment) | **GET** /attachments/{attachment_gid} | Get an attachment
  *AttachmentsApi* | [**get_attachments_for_object**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/AttachmentsApi.md#get_attachments_for_object) | **GET** /attachments | Get attachments from an object
  *AuditLogAPIApi* | [**get_audit_log_events**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/AuditLogAPIApi.md#get_audit_log_events) | **GET** /workspaces/{workspace_gid}/audit_log_events | Get audit log events
  *BatchAPIApi* | [**create_batch_request**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/BatchAPIApi.md#create_batch_request) | **POST** /batch | Submit parallel requests
  *CustomFieldSettingsApi* | [**get_custom_field_settings_for_portfolio**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/CustomFieldSettingsApi.md#get_custom_field_settings_for_portfolio) | **GET** /portfolios/{portfolio_gid}/custom_field_settings | Get a portfolio&#x27;s custom fields
  *CustomFieldSettingsApi* | [**get_custom_field_settings_for_project**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/CustomFieldSettingsApi.md#get_custom_field_settings_for_project) | **GET** /projects/{project_gid}/custom_field_settings | Get a project&#x27;s custom fields
  *CustomFieldsApi* | [**create_custom_field**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/CustomFieldsApi.md#create_custom_field) | **POST** /custom_fields | Create a custom field
  *CustomFieldsApi* | [**create_enum_option_for_custom_field**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/CustomFieldsApi.md#create_enum_option_for_custom_field) | **POST** /custom_fields/{custom_field_gid}/enum_options | Create an enum option
  *CustomFieldsApi* | [**delete_custom_field**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/CustomFieldsApi.md#delete_custom_field) | **DELETE** /custom_fields/{custom_field_gid} | Delete a custom field
  *CustomFieldsApi* | [**get_custom_field**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/CustomFieldsApi.md#get_custom_field) | **GET** /custom_fields/{custom_field_gid} | Get a custom field
  *CustomFieldsApi* | [**get_custom_fields_for_workspace**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/CustomFieldsApi.md#get_custom_fields_for_workspace) | **GET** /workspaces/{workspace_gid}/custom_fields | Get a workspace&#x27;s custom fields
  *CustomFieldsApi* | [**insert_enum_option_for_custom_field**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/CustomFieldsApi.md#insert_enum_option_for_custom_field) | **POST** /custom_fields/{custom_field_gid}/enum_options/insert | Reorder a custom field&#x27;s enum
  *CustomFieldsApi* | [**update_custom_field**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/CustomFieldsApi.md#update_custom_field) | **PUT** /custom_fields/{custom_field_gid} | Update a custom field
  *CustomFieldsApi* | [**update_enum_option**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/CustomFieldsApi.md#update_enum_option) | **PUT** /enum_options/{enum_option_gid} | Update an enum option
  *EventsApi* | [**get_events**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/EventsApi.md#get_events) | **GET** /events | Get events on a resource
  *GoalRelationshipsApi* | [**add_supporting_relationship**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/GoalRelationshipsApi.md#add_supporting_relationship) | **POST** /goals/{goal_gid}/addSupportingRelationship | Add a supporting goal relationship
  *GoalRelationshipsApi* | [**get_goal_relationship**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/GoalRelationshipsApi.md#get_goal_relationship) | **GET** /goal_relationships/{goal_relationship_gid} | Get a goal relationship
  *GoalRelationshipsApi* | [**get_goal_relationships**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/GoalRelationshipsApi.md#get_goal_relationships) | **GET** /goal_relationships | Get goal relationships
  *GoalRelationshipsApi* | [**remove_supporting_relationship**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/GoalRelationshipsApi.md#remove_supporting_relationship) | **POST** /goals/{goal_gid}/removeSupportingRelationship | Removes a supporting goal relationship
  *GoalRelationshipsApi* | [**update_goal_relationship**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/GoalRelationshipsApi.md#update_goal_relationship) | **PUT** /goal_relationships/{goal_relationship_gid} | Update a goal relationship
  *GoalsApi* | [**add_followers**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/GoalsApi.md#add_followers) | **POST** /goals/{goal_gid}/addFollowers | Add a collaborator to a goal
  *GoalsApi* | [**create_goal**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/GoalsApi.md#create_goal) | **POST** /goals | Create a goal
  *GoalsApi* | [**create_goal_metric**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/GoalsApi.md#create_goal_metric) | **POST** /goals/{goal_gid}/setMetric | Create a goal metric
  *GoalsApi* | [**delete_goal**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/GoalsApi.md#delete_goal) | **DELETE** /goals/{goal_gid} | Delete a goal
  *GoalsApi* | [**get_goal**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/GoalsApi.md#get_goal) | **GET** /goals/{goal_gid} | Get a goal
  *GoalsApi* | [**get_goals**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/GoalsApi.md#get_goals) | **GET** /goals | Get goals
  *GoalsApi* | [**get_parent_goals_for_goal**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/GoalsApi.md#get_parent_goals_for_goal) | **GET** /goals/{goal_gid}/parentGoals | Get parent goals from a goal
  *GoalsApi* | [**remove_followers**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/GoalsApi.md#remove_followers) | **POST** /goals/{goal_gid}/removeFollowers | Remove a collaborator from a goal
  *GoalsApi* | [**update_goal**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/GoalsApi.md#update_goal) | **PUT** /goals/{goal_gid} | Update a goal
  *GoalsApi* | [**update_goal_metric**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/GoalsApi.md#update_goal_metric) | **POST** /goals/{goal_gid}/setMetricCurrentValue | Update a goal metric
  *JobsApi* | [**get_job**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/JobsApi.md#get_job) | **GET** /jobs/{job_gid} | Get a job by id
  *MembershipsApi* | [**create_membership**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/MembershipsApi.md#create_membership) | **POST** /memberships | Create a membership
  *MembershipsApi* | [**delete_membership**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/MembershipsApi.md#delete_membership) | **DELETE** /memberships/{membership_gid} | Delete a membership
  *MembershipsApi* | [**get_membership**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/MembershipsApi.md#get_membership) | **GET** /memberships/{membership_gid} | Get a membership
  *MembershipsApi* | [**get_memberships**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/MembershipsApi.md#get_memberships) | **GET** /memberships | Get multiple memberships
  *OrganizationExportsApi* | [**create_organization_export**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/OrganizationExportsApi.md#create_organization_export) | **POST** /organization_exports | Create an organization export request
  *OrganizationExportsApi* | [**get_organization_export**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/OrganizationExportsApi.md#get_organization_export) | **GET** /organization_exports/{organization_export_gid} | Get details on an org export request
  *PortfolioMembershipsApi* | [**get_portfolio_membership**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/PortfolioMembershipsApi.md#get_portfolio_membership) | **GET** /portfolio_memberships/{portfolio_membership_gid} | Get a portfolio membership
  *PortfolioMembershipsApi* | [**get_portfolio_memberships**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/PortfolioMembershipsApi.md#get_portfolio_memberships) | **GET** /portfolio_memberships | Get multiple portfolio memberships
  *PortfolioMembershipsApi* | [**get_portfolio_memberships_for_portfolio**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/PortfolioMembershipsApi.md#get_portfolio_memberships_for_portfolio) | **GET** /portfolios/{portfolio_gid}/portfolio_memberships | Get memberships from a portfolio
  *PortfoliosApi* | [**add_custom_field_setting_for_portfolio**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/PortfoliosApi.md#add_custom_field_setting_for_portfolio) | **POST** /portfolios/{portfolio_gid}/addCustomFieldSetting | Add a custom field to a portfolio
  *PortfoliosApi* | [**add_item_for_portfolio**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/PortfoliosApi.md#add_item_for_portfolio) | **POST** /portfolios/{portfolio_gid}/addItem | Add a portfolio item
  *PortfoliosApi* | [**add_members_for_portfolio**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/PortfoliosApi.md#add_members_for_portfolio) | **POST** /portfolios/{portfolio_gid}/addMembers | Add users to a portfolio
  *PortfoliosApi* | [**create_portfolio**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/PortfoliosApi.md#create_portfolio) | **POST** /portfolios | Create a portfolio
  *PortfoliosApi* | [**delete_portfolio**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/PortfoliosApi.md#delete_portfolio) | **DELETE** /portfolios/{portfolio_gid} | Delete a portfolio
  *PortfoliosApi* | [**get_items_for_portfolio**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/PortfoliosApi.md#get_items_for_portfolio) | **GET** /portfolios/{portfolio_gid}/items | Get portfolio items
  *PortfoliosApi* | [**get_portfolio**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/PortfoliosApi.md#get_portfolio) | **GET** /portfolios/{portfolio_gid} | Get a portfolio
  *PortfoliosApi* | [**get_portfolios**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/PortfoliosApi.md#get_portfolios) | **GET** /portfolios | Get multiple portfolios
  *PortfoliosApi* | [**remove_custom_field_setting_for_portfolio**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/PortfoliosApi.md#remove_custom_field_setting_for_portfolio) | **POST** /portfolios/{portfolio_gid}/removeCustomFieldSetting | Remove a custom field from a portfolio
  *PortfoliosApi* | [**remove_item_for_portfolio**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/PortfoliosApi.md#remove_item_for_portfolio) | **POST** /portfolios/{portfolio_gid}/removeItem | Remove a portfolio item
  *PortfoliosApi* | [**remove_members_for_portfolio**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/PortfoliosApi.md#remove_members_for_portfolio) | **POST** /portfolios/{portfolio_gid}/removeMembers | Remove users from a portfolio
  *PortfoliosApi* | [**update_portfolio**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/PortfoliosApi.md#update_portfolio) | **PUT** /portfolios/{portfolio_gid} | Update a portfolio
  *ProjectBriefsApi* | [**create_project_brief**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectBriefsApi.md#create_project_brief) | **POST** /projects/{project_gid}/project_briefs | Create a project brief
  *ProjectBriefsApi* | [**delete_project_brief**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectBriefsApi.md#delete_project_brief) | **DELETE** /project_briefs/{project_brief_gid} | Delete a project brief
  *ProjectBriefsApi* | [**get_project_brief**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectBriefsApi.md#get_project_brief) | **GET** /project_briefs/{project_brief_gid} | Get a project brief
  *ProjectBriefsApi* | [**update_project_brief**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectBriefsApi.md#update_project_brief) | **PUT** /project_briefs/{project_brief_gid} | Update a project brief
  *ProjectMembershipsApi* | [**get_project_membership**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectMembershipsApi.md#get_project_membership) | **GET** /project_memberships/{project_membership_gid} | Get a project membership
  *ProjectMembershipsApi* | [**get_project_memberships_for_project**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectMembershipsApi.md#get_project_memberships_for_project) | **GET** /projects/{project_gid}/project_memberships | Get memberships from a project
  *ProjectStatusesApi* | [**create_project_status_for_project**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectStatusesApi.md#create_project_status_for_project) | **POST** /projects/{project_gid}/project_statuses | Create a project status
  *ProjectStatusesApi* | [**delete_project_status**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectStatusesApi.md#delete_project_status) | **DELETE** /project_statuses/{project_status_gid} | Delete a project status
  *ProjectStatusesApi* | [**get_project_status**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectStatusesApi.md#get_project_status) | **GET** /project_statuses/{project_status_gid} | Get a project status
  *ProjectStatusesApi* | [**get_project_statuses_for_project**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectStatusesApi.md#get_project_statuses_for_project) | **GET** /projects/{project_gid}/project_statuses | Get statuses from a project
  *ProjectTemplatesApi* | [**delete_project_template**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectTemplatesApi.md#delete_project_template) | **DELETE** /project_templates/{project_template_gid} | Delete a project template
  *ProjectTemplatesApi* | [**get_project_template**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectTemplatesApi.md#get_project_template) | **GET** /project_templates/{project_template_gid} | Get a project template
  *ProjectTemplatesApi* | [**get_project_templates**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectTemplatesApi.md#get_project_templates) | **GET** /project_templates | Get multiple project templates
  *ProjectTemplatesApi* | [**get_project_templates_for_team**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectTemplatesApi.md#get_project_templates_for_team) | **GET** /teams/{team_gid}/project_templates | Get a team&#x27;s project templates
  *ProjectTemplatesApi* | [**instantiate_project**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectTemplatesApi.md#instantiate_project) | **POST** /project_templates/{project_template_gid}/instantiateProject | Instantiate a project from a project template
  *ProjectsApi* | [**add_custom_field_setting_for_project**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectsApi.md#add_custom_field_setting_for_project) | **POST** /projects/{project_gid}/addCustomFieldSetting | Add a custom field to a project
  *ProjectsApi* | [**add_followers_for_project**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectsApi.md#add_followers_for_project) | **POST** /projects/{project_gid}/addFollowers | Add followers to a project
  *ProjectsApi* | [**add_members_for_project**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectsApi.md#add_members_for_project) | **POST** /projects/{project_gid}/addMembers | Add users to a project
  *ProjectsApi* | [**create_project**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectsApi.md#create_project) | **POST** /projects | Create a project
  *ProjectsApi* | [**create_project_for_team**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectsApi.md#create_project_for_team) | **POST** /teams/{team_gid}/projects | Create a project in a team
  *ProjectsApi* | [**create_project_for_workspace**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectsApi.md#create_project_for_workspace) | **POST** /workspaces/{workspace_gid}/projects | Create a project in a workspace
  *ProjectsApi* | [**delete_project**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectsApi.md#delete_project) | **DELETE** /projects/{project_gid} | Delete a project
  *ProjectsApi* | [**duplicate_project**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectsApi.md#duplicate_project) | **POST** /projects/{project_gid}/duplicate | Duplicate a project
  *ProjectsApi* | [**get_project**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectsApi.md#get_project) | **GET** /projects/{project_gid} | Get a project
  *ProjectsApi* | [**get_projects**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectsApi.md#get_projects) | **GET** /projects | Get multiple projects
  *ProjectsApi* | [**get_projects_for_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectsApi.md#get_projects_for_task) | **GET** /tasks/{task_gid}/projects | Get projects a task is in
  *ProjectsApi* | [**get_projects_for_team**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectsApi.md#get_projects_for_team) | **GET** /teams/{team_gid}/projects | Get a team&#x27;s projects
  *ProjectsApi* | [**get_projects_for_workspace**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectsApi.md#get_projects_for_workspace) | **GET** /workspaces/{workspace_gid}/projects | Get all projects in a workspace
  *ProjectsApi* | [**get_task_counts_for_project**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectsApi.md#get_task_counts_for_project) | **GET** /projects/{project_gid}/task_counts | Get task count of a project
  *ProjectsApi* | [**project_save_as_template**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectsApi.md#project_save_as_template) | **POST** /projects/{project_gid}/saveAsTemplate | Create a project template from a project
  *ProjectsApi* | [**remove_custom_field_setting_for_project**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectsApi.md#remove_custom_field_setting_for_project) | **POST** /projects/{project_gid}/removeCustomFieldSetting | Remove a custom field from a project
  *ProjectsApi* | [**remove_followers_for_project**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectsApi.md#remove_followers_for_project) | **POST** /projects/{project_gid}/removeFollowers | Remove followers from a project
  *ProjectsApi* | [**remove_members_for_project**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectsApi.md#remove_members_for_project) | **POST** /projects/{project_gid}/removeMembers | Remove users from a project
  *ProjectsApi* | [**update_project**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectsApi.md#update_project) | **PUT** /projects/{project_gid} | Update a project
  *RulesApi* | [**trigger_rule**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/RulesApi.md#trigger_rule) | **POST** /rule_triggers/{rule_trigger_gid}/run | Trigger a rule
  *SectionsApi* | [**add_task_for_section**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/SectionsApi.md#add_task_for_section) | **POST** /sections/{section_gid}/addTask | Add task to section
  *SectionsApi* | [**create_section_for_project**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/SectionsApi.md#create_section_for_project) | **POST** /projects/{project_gid}/sections | Create a section in a project
  *SectionsApi* | [**delete_section**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/SectionsApi.md#delete_section) | **DELETE** /sections/{section_gid} | Delete a section
  *SectionsApi* | [**get_section**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/SectionsApi.md#get_section) | **GET** /sections/{section_gid} | Get a section
  *SectionsApi* | [**get_sections_for_project**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/SectionsApi.md#get_sections_for_project) | **GET** /projects/{project_gid}/sections | Get sections in a project
  *SectionsApi* | [**insert_section_for_project**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/SectionsApi.md#insert_section_for_project) | **POST** /projects/{project_gid}/sections/insert | Move or Insert sections
  *SectionsApi* | [**update_section**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/SectionsApi.md#update_section) | **PUT** /sections/{section_gid} | Update a section
  *StatusUpdatesApi* | [**create_status_for_object**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/StatusUpdatesApi.md#create_status_for_object) | **POST** /status_updates | Create a status update
  *StatusUpdatesApi* | [**delete_status**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/StatusUpdatesApi.md#delete_status) | **DELETE** /status_updates/{status_update_gid} | Delete a status update
  *StatusUpdatesApi* | [**get_status**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/StatusUpdatesApi.md#get_status) | **GET** /status_updates/{status_update_gid} | Get a status update
  *StatusUpdatesApi* | [**get_statuses_for_object**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/StatusUpdatesApi.md#get_statuses_for_object) | **GET** /status_updates | Get status updates from an object
  *StoriesApi* | [**create_story_for_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/StoriesApi.md#create_story_for_task) | **POST** /tasks/{task_gid}/stories | Create a story on a task
  *StoriesApi* | [**delete_story**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/StoriesApi.md#delete_story) | **DELETE** /stories/{story_gid} | Delete a story
  *StoriesApi* | [**get_stories_for_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/StoriesApi.md#get_stories_for_task) | **GET** /tasks/{task_gid}/stories | Get stories from a task
  *StoriesApi* | [**get_story**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/StoriesApi.md#get_story) | **GET** /stories/{story_gid} | Get a story
  *StoriesApi* | [**update_story**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/StoriesApi.md#update_story) | **PUT** /stories/{story_gid} | Update a story
  *TagsApi* | [**create_tag**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TagsApi.md#create_tag) | **POST** /tags | Create a tag
  *TagsApi* | [**create_tag_for_workspace**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TagsApi.md#create_tag_for_workspace) | **POST** /workspaces/{workspace_gid}/tags | Create a tag in a workspace
  *TagsApi* | [**delete_tag**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TagsApi.md#delete_tag) | **DELETE** /tags/{tag_gid} | Delete a tag
  *TagsApi* | [**get_tag**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TagsApi.md#get_tag) | **GET** /tags/{tag_gid} | Get a tag
  *TagsApi* | [**get_tags**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TagsApi.md#get_tags) | **GET** /tags | Get multiple tags
  *TagsApi* | [**get_tags_for_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TagsApi.md#get_tags_for_task) | **GET** /tasks/{task_gid}/tags | Get a task&#x27;s tags
  *TagsApi* | [**get_tags_for_workspace**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TagsApi.md#get_tags_for_workspace) | **GET** /workspaces/{workspace_gid}/tags | Get tags in a workspace
  *TagsApi* | [**update_tag**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TagsApi.md#update_tag) | **PUT** /tags/{tag_gid} | Update a tag
  *TaskTemplatesApi* | [**delete_task_template**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TaskTemplatesApi.md#delete_task_template) | **DELETE** /task_templates/{task_template_gid} | Delete a task template
  *TaskTemplatesApi* | [**get_task_template**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TaskTemplatesApi.md#get_task_template) | **GET** /task_templates/{task_template_gid} | Get a task template
  *TaskTemplatesApi* | [**get_task_templates**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TaskTemplatesApi.md#get_task_templates) | **GET** /task_templates | Get multiple task templates
  *TaskTemplatesApi* | [**instantiate_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TaskTemplatesApi.md#instantiate_task) | **POST** /task_templates/{task_template_gid}/instantiateTask | Instantiate a task from a task template
  *TasksApi* | [**add_dependencies_for_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#add_dependencies_for_task) | **POST** /tasks/{task_gid}/addDependencies | Set dependencies for a task
  *TasksApi* | [**add_dependents_for_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#add_dependents_for_task) | **POST** /tasks/{task_gid}/addDependents | Set dependents for a task
  *TasksApi* | [**add_followers_for_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#add_followers_for_task) | **POST** /tasks/{task_gid}/addFollowers | Add followers to a task
  *TasksApi* | [**add_project_for_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#add_project_for_task) | **POST** /tasks/{task_gid}/addProject | Add a project to a task
  *TasksApi* | [**add_tag_for_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#add_tag_for_task) | **POST** /tasks/{task_gid}/addTag | Add a tag to a task
  *TasksApi* | [**create_subtask_for_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#create_subtask_for_task) | **POST** /tasks/{task_gid}/subtasks | Create a subtask
  *TasksApi* | [**create_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#create_task) | **POST** /tasks | Create a task
  *TasksApi* | [**delete_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#delete_task) | **DELETE** /tasks/{task_gid} | Delete a task
  *TasksApi* | [**duplicate_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#duplicate_task) | **POST** /tasks/{task_gid}/duplicate | Duplicate a task
  *TasksApi* | [**get_dependencies_for_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#get_dependencies_for_task) | **GET** /tasks/{task_gid}/dependencies | Get dependencies from a task
  *TasksApi* | [**get_dependents_for_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#get_dependents_for_task) | **GET** /tasks/{task_gid}/dependents | Get dependents from a task
  *TasksApi* | [**get_subtasks_for_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#get_subtasks_for_task) | **GET** /tasks/{task_gid}/subtasks | Get subtasks from a task
  *TasksApi* | [**get_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#get_task) | **GET** /tasks/{task_gid} | Get a task
  *TasksApi* | [**get_task_for_custom_id**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#get_task_for_custom_id) | **GET** /workspaces/{workspace_gid}/tasks/custom_id/{custom_id} | Get a task for a given custom ID
  *TasksApi* | [**get_tasks**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#get_tasks) | **GET** /tasks | Get multiple tasks
  *TasksApi* | [**get_tasks_for_project**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#get_tasks_for_project) | **GET** /projects/{project_gid}/tasks | Get tasks from a project
  *TasksApi* | [**get_tasks_for_section**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#get_tasks_for_section) | **GET** /sections/{section_gid}/tasks | Get tasks from a section
  *TasksApi* | [**get_tasks_for_tag**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#get_tasks_for_tag) | **GET** /tags/{tag_gid}/tasks | Get tasks from a tag
  *TasksApi* | [**get_tasks_for_user_task_list**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#get_tasks_for_user_task_list) | **GET** /user_task_lists/{user_task_list_gid}/tasks | Get tasks from a user task list
  *TasksApi* | [**remove_dependencies_for_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#remove_dependencies_for_task) | **POST** /tasks/{task_gid}/removeDependencies | Unlink dependencies from a task
  *TasksApi* | [**remove_dependents_for_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#remove_dependents_for_task) | **POST** /tasks/{task_gid}/removeDependents | Unlink dependents from a task
  *TasksApi* | [**remove_follower_for_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#remove_follower_for_task) | **POST** /tasks/{task_gid}/removeFollowers | Remove followers from a task
  *TasksApi* | [**remove_project_for_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#remove_project_for_task) | **POST** /tasks/{task_gid}/removeProject | Remove a project from a task
  *TasksApi* | [**remove_tag_for_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#remove_tag_for_task) | **POST** /tasks/{task_gid}/removeTag | Remove a tag from a task
  *TasksApi* | [**search_tasks_for_workspace**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#search_tasks_for_workspace) | **GET** /workspaces/{workspace_gid}/tasks/search | Search tasks in a workspace
  *TasksApi* | [**set_parent_for_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#set_parent_for_task) | **POST** /tasks/{task_gid}/setParent | Set the parent of a task
  *TasksApi* | [**update_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#update_task) | **PUT** /tasks/{task_gid} | Update a task
  *TeamMembershipsApi* | [**get_team_membership**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TeamMembershipsApi.md#get_team_membership) | **GET** /team_memberships/{team_membership_gid} | Get a team membership
  *TeamMembershipsApi* | [**get_team_memberships**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TeamMembershipsApi.md#get_team_memberships) | **GET** /team_memberships | Get team memberships
  *TeamMembershipsApi* | [**get_team_memberships_for_team**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TeamMembershipsApi.md#get_team_memberships_for_team) | **GET** /teams/{team_gid}/team_memberships | Get memberships from a team
  *TeamMembershipsApi* | [**get_team_memberships_for_user**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TeamMembershipsApi.md#get_team_memberships_for_user) | **GET** /users/{user_gid}/team_memberships | Get memberships from a user
  *TeamsApi* | [**add_user_for_team**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TeamsApi.md#add_user_for_team) | **POST** /teams/{team_gid}/addUser | Add a user to a team
  *TeamsApi* | [**create_team**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TeamsApi.md#create_team) | **POST** /teams | Create a team
  *TeamsApi* | [**get_team**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TeamsApi.md#get_team) | **GET** /teams/{team_gid} | Get a team
  *TeamsApi* | [**get_teams_for_user**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TeamsApi.md#get_teams_for_user) | **GET** /users/{user_gid}/teams | Get teams for a user
  *TeamsApi* | [**get_teams_for_workspace**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TeamsApi.md#get_teams_for_workspace) | **GET** /workspaces/{workspace_gid}/teams | Get teams in a workspace
  *TeamsApi* | [**remove_user_for_team**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TeamsApi.md#remove_user_for_team) | **POST** /teams/{team_gid}/removeUser | Remove a user from a team
  *TeamsApi* | [**update_team**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TeamsApi.md#update_team) | **PUT** /teams/{team_gid} | Update a team
  *TimePeriodsApi* | [**get_time_period**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TimePeriodsApi.md#get_time_period) | **GET** /time_periods/{time_period_gid} | Get a time period
  *TimePeriodsApi* | [**get_time_periods**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TimePeriodsApi.md#get_time_periods) | **GET** /time_periods | Get time periods
  *TimeTrackingEntriesApi* | [**create_time_tracking_entry**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TimeTrackingEntriesApi.md#create_time_tracking_entry) | **POST** /tasks/{task_gid}/time_tracking_entries | Create a time tracking entry
  *TimeTrackingEntriesApi* | [**delete_time_tracking_entry**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TimeTrackingEntriesApi.md#delete_time_tracking_entry) | **DELETE** /time_tracking_entries/{time_tracking_entry_gid} | Delete a time tracking entry
  *TimeTrackingEntriesApi* | [**get_time_tracking_entries_for_task**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TimeTrackingEntriesApi.md#get_time_tracking_entries_for_task) | **GET** /tasks/{task_gid}/time_tracking_entries | Get time tracking entries for a task
  *TimeTrackingEntriesApi* | [**get_time_tracking_entry**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TimeTrackingEntriesApi.md#get_time_tracking_entry) | **GET** /time_tracking_entries/{time_tracking_entry_gid} | Get a time tracking entry
  *TimeTrackingEntriesApi* | [**update_time_tracking_entry**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TimeTrackingEntriesApi.md#update_time_tracking_entry) | **PUT** /time_tracking_entries/{time_tracking_entry_gid} | Update a time tracking entry
  *TypeaheadApi* | [**typeahead_for_workspace**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TypeaheadApi.md#typeahead_for_workspace) | **GET** /workspaces/{workspace_gid}/typeahead | Get objects via typeahead
  *UserTaskListsApi* | [**get_user_task_list**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/UserTaskListsApi.md#get_user_task_list) | **GET** /user_task_lists/{user_task_list_gid} | Get a user task list
  *UserTaskListsApi* | [**get_user_task_list_for_user**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/UserTaskListsApi.md#get_user_task_list_for_user) | **GET** /users/{user_gid}/user_task_list | Get a user&#x27;s task list
  *UsersApi* | [**get_favorites_for_user**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/UsersApi.md#get_favorites_for_user) | **GET** /users/{user_gid}/favorites | Get a user&#x27;s favorites
  *UsersApi* | [**get_user**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/UsersApi.md#get_user) | **GET** /users/{user_gid} | Get a user
  *UsersApi* | [**get_users**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/UsersApi.md#get_users) | **GET** /users | Get multiple users
  *UsersApi* | [**get_users_for_team**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/UsersApi.md#get_users_for_team) | **GET** /teams/{team_gid}/users | Get users in a team
  *UsersApi* | [**get_users_for_workspace**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/UsersApi.md#get_users_for_workspace) | **GET** /workspaces/{workspace_gid}/users | Get users in a workspace or organization
  *WebhooksApi* | [**create_webhook**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/WebhooksApi.md#create_webhook) | **POST** /webhooks | Establish a webhook
  *WebhooksApi* | [**delete_webhook**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/WebhooksApi.md#delete_webhook) | **DELETE** /webhooks/{webhook_gid} | Delete a webhook
  *WebhooksApi* | [**get_webhook**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/WebhooksApi.md#get_webhook) | **GET** /webhooks/{webhook_gid} | Get a webhook
  *WebhooksApi* | [**get_webhooks**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/WebhooksApi.md#get_webhooks) | **GET** /webhooks | Get multiple webhooks
  *WebhooksApi* | [**update_webhook**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/WebhooksApi.md#update_webhook) | **PUT** /webhooks/{webhook_gid} | Update a webhook
  *WorkspaceMembershipsApi* | [**get_workspace_membership**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/WorkspaceMembershipsApi.md#get_workspace_membership) | **GET** /workspace_memberships/{workspace_membership_gid} | Get a workspace membership
  *WorkspaceMembershipsApi* | [**get_workspace_memberships_for_user**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/WorkspaceMembershipsApi.md#get_workspace_memberships_for_user) | **GET** /users/{user_gid}/workspace_memberships | Get workspace memberships for a user
  *WorkspaceMembershipsApi* | [**get_workspace_memberships_for_workspace**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/WorkspaceMembershipsApi.md#get_workspace_memberships_for_workspace) | **GET** /workspaces/{workspace_gid}/workspace_memberships | Get the workspace memberships for a workspace
  *WorkspacesApi* | [**add_user_for_workspace**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/WorkspacesApi.md#add_user_for_workspace) | **POST** /workspaces/{workspace_gid}/addUser | Add a user to a workspace or organization
  *WorkspacesApi* | [**get_workspace**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/WorkspacesApi.md#get_workspace) | **GET** /workspaces/{workspace_gid} | Get a workspace
  *WorkspacesApi* | [**get_workspaces**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/WorkspacesApi.md#get_workspaces) | **GET** /workspaces | Get multiple workspaces
  *WorkspacesApi* | [**remove_user_for_workspace**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/WorkspacesApi.md#remove_user_for_workspace) | **POST** /workspaces/{workspace_gid}/removeUser | Remove a user from a workspace or organization
  *WorkspacesApi* | [**update_workspace**](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/WorkspacesApi.md#update_workspace) | **PUT** /workspaces/{workspace_gid} | Update a workspace


  ```python
  .
  .
  .
  try:
      task = tasks_api_instance.get_task(task_gid, opts)
      task_name = task['name']
      task_notes = task['notes']
  except ApiException as e:
      .
      .
      .
  ```

  In the scenario you want to access the response headers or the status code along with the response data you can
  provide the `_return_http_data_only` parameter argument in the request method and set the value to `False`
  ```python
  import asana_preview
  from asana_preview.rest import ApiException
  from pprint import pprint
  configuration = asana_preview.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana_preview.ApiClient(configuration)

  users_api_instance = asana_preview.UsersApi(api_client)
  user_gid = 'me' # str | A string identifying a user. This can either be the string \"me\", an email, or the gid of a user.
  opts = {}
  try:
      
      (api_response, status, headers) = users_api_instance.get_user(user_gid, opts, _return_http_data_only=False) # returns a tuple: (response, status, headers)
      pprint(api_response)
      pprint(status)
      pprint(headers)
  except ApiException as e:
      print("Exception when calling UsersApi->get_user: %s\n" % e)
  ```


  ```python
  import asana_preview
  from asana_preview.rest import ApiException
  from pprint import pprint
  configuration = asana_preview.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana_preview.ApiClient(configuration)

  api_client.default_headers['asana-enable'] = 'string_ids'
  ```
  OR

  ```python
  import asana_preview
  from asana_preview.rest import ApiException
  from pprint import pprint
  configuration = asana_preview.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana_preview.ApiClient(configuration)

  users_api_instance = asana_preview.UsersApi(api_client)
  user_gid = 'me' # str | A string identifying a user. This can either be the string \"me\", an email, or the gid of a user.
  opts = {}
  try:
      
      api_response = users_api_instance.get_user(user_gid, opts, header_params={'asana-enable': 'string_ids'})
      pprint(api_response)
  except ApiException as e:
      print("Exception when calling UsersApi->get_user: %s\n" % e)
  ```

  This client library uses multithreading to make async requests. To make async requests you can pass in `async_req=True` in the method call.
  NOTE:
  - This feature disables our auto-pagination feature
  - You will want to add logic to handle the Asana API rate limits
  The code belows is an example of how to make 15 async create task calls. It does not handle the Asana API rate limits.
  You will have to implement your own solution for API rate limits based on your tier.
  ```python
  import asana_preview
  from asana_preview.rest import ApiException
  from pprint import pprint
  configuration = asana_preview.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana_preview.ApiClient(configuration)
  tasks_api_instance = asana_preview.TasksApi(api_client)
  threads = []
  for i in range(1, 15+1):
      body = {
          "data": {
              "name": f"Task: {i}",
              "projects": ["<YOUR_PROJECT_GID>"]
          }
      }
      opts = {}
      threads.append(tasks_api_instance.create_task(body, opts, async_req=True))
  for thread in threads:
      try:
          pprint(thread.get())
      except ApiException as e:
          print("Exception when calling TasksApi->create_task: %s\n" % e)
  ```

  The pagination feature is enabled by default. This means two things:
  1: Endpoints that return a single response (EX: [get_task](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#get_task) ([Get a task](https://developers.asana.com/reference/gettask)), [get_project](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#get_project) ([Get a project](https://developers.asana.com/reference/getproject)), etc...)
  will return a response with the `"data"` key abstracted from the response.
  Instead of returning:
  ```python
  {
      "data": {
          "gid": "123",
          "actual_time_minutes": null,
          "assignee": null,
          "workspace": {
              "gid": "1234567",
              "name": "user@example.com",
              "resource_type": "workspace"
          }
      }
  }
  ```
  It returns:
  ```python
  {
      "gid": "123",
      "actual_time_minutes": null,
      "assignee": null,
      "workspace": {
          "gid": "1234567",
          "name": "user@example.com",
          "resource_type": "workspace"
      }
  }
  ```
  2: Endpoints that return an array of resources (EX: [get_tasks](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/TasksApi.md#get_tasks) ([Get multiple tasks](https://developers.asana.com/reference/gettasks)), [get_projects](https://github.com/Asana/python-asana-preview/blob/v1.2.40/docs/ProjectsApi.md#get_projects) ([Get multiple projects](https://developers.asana.com/reference/getprojects)), etc...)
  will return a generator object ([PageIterator.items](https://github.com/Asana/python-asana-preview/blob/v1.2.40/asana_preview/pagination/page_iterator.py)) that you can use to iterate through each result.
  Example usage 1:
  ```python
  import asana_preview
  from asana_preview.rest import ApiException
  from pprint import pprint
  configuration = asana_preview.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana_preview.ApiClient(configuration)
  tasks_api_instance = asana_preview.TasksApi(api_client)
  opts = {"project": "<YOUR_PROJECT_GID>"}
  try:
      tasks = tasks_api_instance.get_tasks(opts)
      for task in tasks:
          pprint(task)
  except Exception as e:
      print("Exception when calling TasksApi->get_tasks: %s\n" % e)
  ```
  Example response:
  ```python
  {'gid': '123',
   'name': 'Task 1',
   'resource_subtype': 'default_task',
   'resource_type': 'task'},
   .
   .
   .
  ```
  Example usage 2:
  ```python
  import asana_preview
  from asana_preview.rest import ApiException
  from pprint import pprint
  configuration = asana_preview.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana_preview.ApiClient(configuration)
  tasks_api_instance = asana_preview.TasksApi(api_client)
  opts = {"project": "<YOUR_PROJECT_GID>"}
  try:
      tasks = tasks_api_instance.get_tasks(opts)
      pprint(list(tasks))
  except Exception as e:
      print("Exception when calling TasksApi->get_tasks: %s\n" % e)
  ```
  Example response:
  ```python
  [{'gid': '123',
   'name': 'Task 1',
   'resource_subtype': 'default_task',
   'resource_type': 'task'},
   .
   .
   .]
  ```

  In the scenario where you want to end the pagination early, you can specify an `item_limit` in the method call. This will stop the iterator from going past that limit.
  **Example Scenario:** You have 1000 tasks in a project and are only interested in the first 2 tasks. Instead of letting the pagination code continue to run to get all those 1000 tasks you can specify that you only want the first X results with `item_limit`.
  **Without `item_limit` - The for loop will continue to run until it runs out of tasks:**
  ```python
      tasks = tasks_api_instance.get_tasks(opts)
      for task in tasks:
          pprint(task)
  ```
  **Sample response:**
  ```python
  {'gid': '123',
   'name': 'Task 1',
   'resource_subtype': 'default_task',
   'resource_type': 'task'},
   .
   .
   .
   <1000th_TASK>
  ```
  **With `item_limit` - the for loop will stop at the `item_limit` you specified:**
  ```python
      tasks = tasks_api_instance.get_tasks(opts, item_limit=2)
      for task in tasks:
          pprint(task)
  ```
  **Sample response:**
  ```python
  {'gid': '123',
   'name': 'Task 1',
   'resource_subtype': 'default_task',
   'resource_type': 'task'},
  {'gid': '456',
   'name': 'Task 2',
   'resource_subtype': 'default_task',
   'resource_type': 'task'}
  ```
  Alternatively, if you are iterating over the generator object in a for loop, you can also just break out of the loop.
  **EX:**
  ```python
  opts = {'project': "<YOUR_PROJECT_GID>"}
  try:
      count = 0
      tasks = tasks_api_instance.get_tasks(opts)
      for task in tasks:
          if count == 2:
              break
          pprint(task)
          count += 1
  ```
  **Sample response:**
  ```python
  {'gid': '123',
   'name': 'Task 1',
   'resource_subtype': 'default_task',
   'resource_type': 'task'},
   {'gid': '456',
   'name': 'Task 2',
   'resource_subtype': 'default_task',
   'resource_type': 'task'}
  ```

  If you do not want to use the default pagination behaviour there are two ways to disbale it.
  1: Per request - Disable pagination behavior for a single request - pass in `full_payload=True` in the method request
  ```python
  import asana_preview
  from asana_preview.rest import ApiException
  from pprint import pprint
  configuration = asana_preview.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana_preview.ApiClient(configuration)
  tasks_api_instance = asana_preview.TasksApi(api_client)
  opts = {"project": "<YOUR_PROJECT>", "limit": 2}
  try:
      tasks = tasks_api_instance.get_tasks(opts, full_payload=True)
      pprint(tasks)
  except Exception as e:
      print("Exception when calling TasksApi->get_tasks: %s\n" % e)
  ```
  Sample response:
  ```python
  {'data': [{'gid': '123',
             'name': 'Task 1',
             'resource_subtype': 'default_task',
             'resource_type': 'task'},
            {'gid': '456',
             'name': 'Task 2',
             'resource_subtype': 'default_task',
             'resource_type': 'task'}],
   'next_page': {'offset': 'eyJ0...',
                 'path': '/tasks?project=789&limit=2&offset=eyJ0...',
                 'uri': 'https://app.asana.com/api/1.0/tasks?project=789&limit=2&offset=eyJ0...'}}
  ```
  2: Globally - Disable pagination behavior for all requests - Set `return_page_iterator` to False
  ```python
  configuration = asana_preview.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  configuration.return_page_iterator = False
  api_client = asana_preview.ApiClient(configuration)
  ```

  Use this to make HTTP calls when the endpoint does not exist in the current library version or has bugs


  ```python
  import asana_preview
  from asana_preview.rest import ApiException
  from pprint import pprint
  configuration = asana_preview.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana_preview.ApiClient(configuration)
  try:
      
      api_response = api_client.call_api(
          "/tasks/{task_gid}",
          "GET",
          path_params={"task_gid": "<YOUR_TASK_GID>"},
          query_params={},
          header_params={"Accept": "application/json; charset=utf-8"},
          body=None,
          post_params=[],
          files={},
          response_type=object, # You can specify one of the following types: float, bool, bytes, str, object
          auth_settings=["token"],
          async_req=None,
          _return_http_data_only=True,
          _preload_content=True,
          _request_timeout=None,
          collection_formats={},
      )
      pprint(api_response)
  except ApiException as e:
      print("Exception: %s\n" % e)
  ```

  ```python
  import asana_preview
  from asana_preview.rest import ApiException
  from pprint import pprint
  configuration = asana_preview.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana_preview.ApiClient(configuration)
  try:
      
      api_response = api_client.call_api(
          "/tasks",
          "GET",
          path_params={},
          query_params={
              "project": "<YOUR_PROJECT_GID>",
              "opt_fields": "name,notes,projects",
          },
          header_params={"Accept": "application/json; charset=utf-8"},
          body=None,
          post_params=[],
          files={},
          response_type=object, # You can specify one of the following types: float, bool, bytes, str, object
          auth_settings=["token"],
          async_req=None,
          _return_http_data_only=True,
          _preload_content=True,
          _request_timeout=None,
          collection_formats={},
      )
      pprint(api_response)
  except ApiException as e:
      print("Exception: %s\n" % e)
  ```

  ```python
  import asana_preview
  from asana_preview.rest import ApiException
  from pprint import pprint
  configuration = asana_preview.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana_preview.ApiClient(configuration)
  try:
      
      api_response = api_client.call_api(
          "/tasks",
          "POST",
          path_params={},
          query_params={},
          header_params={
              "Accept": "application/json; charset=utf-8",
              "Content-Type": "application/json; charset=utf-8",
          },
          body={
              "data": {
                  "name": "New Task",
                  "projects": ["<YOUR_PROJECT_GID>"],
              }
          },
          post_params=[],
          files={},
          response_type=object, # You can specify one of the following types: float, bool, bytes, str, object
          auth_settings=["token"],
          async_req=None,
          _return_http_data_only=True,
          _preload_content=True,
          _request_timeout=None,
          collection_formats={},
      )
      pprint(api_response)
  except ApiException as e:
      print("Exception: %s\n" % e)
  ```

  ```python
  import asana_preview
  from asana_preview.rest import ApiException
  from pprint import pprint
  configuration = asana_preview.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana_preview.ApiClient(configuration)
  try:
      
      api_response = api_client.call_api(
          "/tasks/{task_gid}",
          "PUT",
          path_params={"task_gid": "<YOUR_TASK_GID>"},
          query_params={},
          header_params={
              "Accept": "application/json; charset=utf-8",
              "Content-Type": "application/json; charset=utf-8",
          },
          body={
              "data": {
                  "name": "Updated Task",
              }
          },
          post_params=[],
          files={},
          response_type=object, # You can specify one of the following types: float, bool, bytes, str, object
          auth_settings=["token"],
          async_req=None,
          _return_http_data_only=True,
          _preload_content=True,
          _request_timeout=None,
          collection_formats={},
      )
      pprint(api_response)
  except ApiException as e:
      print("Exception: %s\n" % e)
  ```

  ```python
  import asana_preview
  from asana_preview.rest import ApiException
  from pprint import pprint
  configuration = asana_preview.Configuration()
  configuration.access_token = '<YOUR_ACCESS_TOKEN>'
  api_client = asana_preview.ApiClient(configuration)
  try:
      
      api_response = api_client.call_api(
          "/tasks/{task_gid}",
          "DELETE",
          path_params={"task_gid": "<YOUR_TASK_GID>"},
          query_params={},
          header_params={"Accept": "application/json; charset=utf-8"},
          body=None,
          post_params=[],
          files={},
          response_type=object, # You can specify one of the following types: float, bool, bytes, str, object
          auth_settings=["token"],
          async_req=None,
          _return_http_data_only=True,
          _preload_content=True,
          _request_timeout=None,
          collection_formats={},
      )
      pprint(api_response)
  except ApiException as e:
      print("Exception: %s\n" % e)
  ```
  [release-image]: https://img.shields.io/github/release/asana/python-asana-preview.svg
  [pypi-image]: https://img.shields.io/pypi/v/asana-preview.svg?style=flat-square
  [pypi-url]: https://pypi.python.org/pypi/asana-preview/


pkgId: 12d94820b4c9f7fb287c4158f54e0f1f40cf1659ca9984cfbca8d347abbe0870
name: python-asaniczka
arch: src
version: 3.1.4
epoch: 0
release: 1
summary: All my commonly used fuctions
url: https://github.com/asaniczka/asaniczka_pip
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asaniczka-3.1.4-1.src.rpm
checksum_type: sha256
description:
  The Asaniczka module provides quick functions to get up and running with a scraper.



  To install Asaniczka, you can use pip:

  `pip install asaniczka`



  - Remember to run `playwright install` on cmd/terminal after installation to install playwright browsers
  - Remember to lock in the version of this package that you're using. Backwards compatibilty between major & minor versions is not guranteed



  ```python
  import asaniczka
  import asaniczka.db_tools as dbt
  import asaniczka.scrape_helper as ash


  project = asaniczka.ProjectSetup("MyProject")


  project.save_temp_file("Content")


  formatted_error = asaniczka.format_error(error)


  response = asaniczka.get_request(url)


  response = asaniczka.post_request(url)


  response = await asaniczka.async_get_request(url)


  response = await asaniczka.async_post_request(url)


  random_id = asaniczka.generate_random_id()


  asaniczka.save_ndjson({"name": "raw dict"}, f"{project.data_folder}/my.ndjson")


  my_dir = asaniczka.create_dir(os.path.join(project.data_folder, "my_data"))


  rate_limit = ash.check_ratelimit("https://amazon.com")


  clean_filename = asaniczka.sanitize_filename("my)829filename")


  stopwatch = asaniczka.Stopwatch()
  time_taken = stopwatch.lap()
  ```


pkgId: bbf6f50bca39665226769d90d38ed9cc983bdd75d49139c3ca92fa495ed8f6a0
name: python-asc2csv
arch: src
version: 1.3
epoch: 0
release: 1
summary: A Python package for converting EyeLink .asc files to structured .csv files.
url: https://github.com/AhsanKhodami/asc2edf
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asc2csv-1.3-1.src.rpm
checksum_type: sha256
description:
  **ascii2edf** is a Python package developed for converting EyeLink `.asc` files into structured `.csv` files, facilitating the analysis of eye-tracking data. It extracts gaze data and event details such as blinks, saccades, and fixations, organizing them into an easy-to-use format.


  - Converts EyeLink `.asc` files to `.csv` format efficiently.
  - Extracts and processes blink (`EBLINK`), saccade (`ESACC`), and fixation (`EFIX`) event data.
  - Aligns timestamps relative to trial start for consistent temporal analysis.
  - Handles missing data by combining event and sample data fields where applicable.



  To install the package, run:

  ```bash
  pip install asc2csv
  ```



  Import the package and use the `process_asc_file()` function:

  ```python
  import asc2csv as convert

  convert.process_asc_file('input_file.asc', 'output_file.csv', header=True)
  ```


  - **`input_file_path`** (str): Path to the input `.asc` file.
  - **`output_csv_path`** (str): Path to save the output `.csv` file.
  - **`header`** (bool, optional): Whether to include a header row in the output CSV. Default is `True`.


  - Python >= 3.6
  - `pandas`



  This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.



  Contributions are welcome! If you find a bug or have an idea for an improvement, please submit a pull request or open an issue.



  **Mohammad Ahsan Khodami**
  - Personal Site: [khodami.site](https://khodami.site)
  - Google Scholar: [Profile](https://scholar.google.com/citations?user=WCqPnS4AAAAJ&hl=en)
  - Email: [ahsan.khodami@gmail.com](mailto:ahsan.khodami@gmail.com)


  - The EyeLink system and data format are provided by SR Research.


pkgId: 6fdd4590849d89a441cbebfa27a8ed1e2c58936863e852bebf8319fc452c2f41
name: python-asc2csv
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: A Python package for converting EyeLink .asc files to structured .csv files.
url: https://github.com/AhsanKhodami/asc2edf
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asc2csv-1.4.1-1.src.rpm
checksum_type: sha256
description:
  **asc2csv** is a Python package developed for converting EyeLink `.asc` files into structured `.csv` files, facilitating the analysis of eye-tracking data. It extracts gaze data and event details such as blinks, saccades, and fixations, organizing them into an easy-to-use format.


  - Converts EyeLink `.asc` files to `.csv` format efficiently.
  - Extracts and processes blink (`EBLINK`), saccade (`ESACC`), and fixation (`EFIX`) event data.
  - Aligns timestamps relative to trial start for consistent temporal analysis.
  - Handles missing data by combining event and sample data fields where applicable.



  <details>
    <summary>See the Changes in versions</summary>


  - Initial release of `asc2csv`.
  - V 1.4 Update 12/11/24   make adding `header=True` in conversion optional. By default `header=True` is applied.


  - Enhanced data importing

  </details>




  To install the package, run:

  ```bash
  pip install asc2csv
  ```



  Import the package and use the `process_asc_file()` function:

  ```python
  import asc2csv as convert

  convert.process_asc_file('input_file.asc', 'output_file.csv')
  ```


  - **`input_file_path`** (str): Path to the input `.asc` file.
  - **`output_csv_path`** (str): Path to save the output `.csv` file.
  - **`header`** (bool, optional): Whether to include a header row in the output CSV. Default is `True`.


  - Python >= 3.6
  - `pandas`



  This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.



  Contributions are welcome! If you find a bug or have an idea for an improvement, please submit a pull request or open an issue.



  **Mohammad Ahsan Khodami**
  - Personal Site: [khodami.site](https://khodami.site)
  - Google Scholar: [Profile](https://scholar.google.com/citations?user=WCqPnS4AAAAJ&hl=en)
  - Email: [ahsan.khodami@gmail.com](mailto:ahsan.khodami@gmail.com)


  - The EyeLink system and data format are provided by SR Research.


pkgId: c00d87507652b078c2f2e250d19d40b50f2690591da00c47099504b4d561f9bc
name: python-asc2mb
arch: src
version: 0.7.2
epoch: 0
release: 1
url: https://pypi.org/project/asc2mb/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asc2mb-0.7.2-1.src.rpm
checksum_type: sha256
summary:
  Manage your timetable by pasing the XML export from asc and format into two files suitable for upload into ManageBac

description:
  Requires Python 3.6 or above. For Windows, install Python via the Microsoft Store. For Mac, install Python at [python.org](https://www.python.org). Installing Python also installs a package manager (called `pip`) that can install the command `asc2mb` into your command line environment.

  After installing Python, open the terminal or command line or PowerShell, and peform the following:

  ```sh
  pip install asc2mb
  ```

  If for some reason the `pip` command doesn't work, you can manually install it by following [the relevant instructions](https://pip.pypa.io/en/stable/installing/) for your system.



  Should you need to update to the latest version, you can do:

  ```
  pip install --upgrade asc2mb
  ```



  After `pip install` worked, it is now installed on your path, and the command `asc2mb` should be available:

  ```
  asc2mb ~/path/to/xml.xml ~/path/to/save/timetable.csv ~/path/to/save/classes.csv
  ```

  It takes only a second to run. It reports how many records it processed.



  This script uses input from more than one international school to generate the expected output. The key to success is using aSc Divisions to match the `uniq_id`s found in ManageBac classes.



  For built-in help, and list of options and their functionality:

  ```
  asc2mb --help
  ```



  The command takes three required arguments, and there are additional options as well. The three required arguments tell the program where the xml file is located, and where to save the two csv files.

  The options depend on your school's needs. For example, the class id is how ManageBac knows which class you are referring to, so that program helps you derive the class ID based on information contains in the xml file. It's up to you to ensure there are classes that have those IDs in ManageBac, but the program does produce a csv so that they can be uploaded in bulk.

  By default, class id uses the pattern `{class_.short}_{division.name}`, which means "the short name of the class" plus an underscore, plus the name of the division." At the time of publication, having a different pattern is only possible by contacting the author (or, if you're a keen developer, add a pull request).

  If you run the program without any options, it'll prompt you to enter them.


pkgId: 1d2c6892377689d55d3c35de1df5eed8e6fe7c30c1d223d95eea93872ae27c3b
name: python-ascat
arch: src
version: 2.4.3
epoch: 0
release: 1
summary: Read and visualize for data from the Advanced Scatterometer (ASCAT)
url: https://tuwien.at/mg/geo/rs
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ascat-2.4.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPi](https://img.shields.io/pypi/v/ascat)](https://pypi.org/project/ascat/)
  [![Readthedocs](https://readthedocs.org/projects/ascat/badge/?version=latest)](http://ascat.readthedocs.org/)
  [![Downloads](https://img.shields.io/pypi/dm/ascat)](https://pypi.org/project/ascat)
  [![Linux actions status](https://github.com/TUW-GEO/ascat/actions/workflows/ubuntu.yml/badge.svg)](https://github.com/TUW-GEO/ascat/actions/workflows/ubuntu.yml)
  [![Windows actions status](https://github.com/TUW-GEO/ascat/actions/workflows/windows.yml/badge.svg)](https://github.com/TUW-GEO/ascat/actions/workflows/windows.yml)
  [![Coveralls](https://coveralls.io/repos/github/TUW-GEO/ascat/badge.svg?branch=master)](https://coveralls.io/github/TUW-GEO/ascat?branch=master)

  Read and visualize data from the Advanced Scatterometer (ASCAT) on-board the series of Metop satellites.



  [![Zenodo](https://zenodo.org/badge/DOI/10.5281/zenodo.4610836.svg)](https://doi.org/10.5281/zenodo.4610836)

  If you use the software in a publication then please cite it using the Zenodo
  DOI. Be aware that this badge links to the latest package version.

  Please select your specific version at https://doi.org/10.5281/zenodo.4610836 to
  get the DOI of that version. You should normally always use the DOI for the
  specific version of your record in citations. This is to ensure that other
  researchers can access the exact research artefact you used for reproducibility.

  You can find additional information regarding DOI versioning at
  http://help.zenodo.org/#versioning



  ASCAT data are distributed in BUFR, NetCDF, EPS Native and GRIB format.
  Unfortunately neither BUFR nor GRIB readers work on Windows so if you need these
  formats then Linux or OS X are your only options.

  The following script will download and install all the needed packages.

  Linux:

  > ```bash
  > conda env create -f environment.yml
  > ```

  Windows:

  > ```bash
  > conda env create -f environment_win.yml
  > ```



  This gives a short overview over the supported products. Please see the documentation for detailed examples of how to work with a product.

  Read ASCAT data from different sources into a common format supported by pytesmo.

  - [H SAF](http://h-saf.eumetsat.int/)
      - Surface Soil Moisture (SSM) and Root Zone Soil Moisture (RZSM) products
  - [Copernicus Global Land Service (CGLS)](http://land.copernicus.eu/global/products/swi)
      - CGLS Soil Water Index (SWI) products
  - [EUMETSAT](https://navigator.eumetsat.int/search?query=ascat)
      - ASCAT Soil Moisture at 12.5 km Swath Grid - Metop
      - ASCAT Soil Moisture at 25 km Swath Grid - Metop
      - ASCAT GDS Level 1 Sigma0 resampled at 12.5 km Swath Grid - Metop
      - ASCAT GDS Level 1 Sigma0 resampled at 25 km Swath Grid - Metop



  The latest ASCAT swath files (H122, H29, H129, H121) can be aggregated and/or regridded using a command line interface (CLI) provided by the ascat package.



  Surface soil moisture and backscatter40 from ASCAT swath files can be aggregated over a user-defined time period (e.g. 1 day, 10 days, 1 month) choosing one of the following methods: "mean", "median", "mode", "std", "min", "max", "argmin", "argmax", "quantile", "first", "last". The time span for processing is determined by the start and end times specified. Additionally, thresholds can be set for masks - such as those for frozen soil probability, snow cover probability, subsurface scattering probability, and surface soil moisture sensitivity - to filter surface soil moisture data as part of the aggregation process.

  > ```bash
  > ascat_swath_agg /path/to/input/h129_v1.0/swaths/ /path/to/output --start_dt 2020-06-15T00:00:00 --end_dt 2020-06-17T00:00:00 --t_delta 1D --agg mean --snow_cover_mask 80 --frozen_soil_mask 80 --subsurface_scattering_mask 10 --ssm_sensitivity_mask 1
  > ```

  There is also an option that no masking is applied using the argument ``--no-mask``.



  ASCAT swath files contain data that are provided on a Discrete Global Grid (DGG) and can be converted to a regular lat/lon grid. Either a single swath file or folder containing the swath files can be used as input argument.

  > ```bash
  > ascat_swath_regrid /path/to/input/file /path/to/output 0.1 --grid_store /path/to/tmp/folder --suffix _regrid_0.1deg
  > ```



  We are happy if you want to contribute. Please raise an issue explaining what is
  missing or if you find a bug. We will also gladly accept pull requests for new
  features or bug fixes.



  If you want to contribute please follow these steps:

  - Fork the ascat repository to your account
  - Clone the repository, make sure you use ``git clone --recursive`` to also get the test data repository.
  - Make a new feature branch from the ascat master branch
  - Add your feature
  - Please include tests for your contributions in one of the test directories
  - Submit a pull request


pkgId: 355cb946ed9929ea4a8e410b5d3b19b36a5aeabcf7eac994919e9495f62fcdbf
name: python-ascend-great-expectations-gcs
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: A wrapper around Great Expectations for building validation components in Ascend.io platform
url: https://pypi.org/project/ascend-great-expectations-gcs/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ascend-great-expectations-gcs-0.2.5-1.src.rpm
checksum_type: sha256
description:
  This image is a wrapper around official Ascend.io image to use Great Expectations validation tool.



  The image is built with Github action located in this file :  .github/workflows/docker-build.yaml.

  For now the image is pushed on docker hub at this address: fosk06/ascend-great-expectations-gcs:latest

  The image is build on push on main branch and with git tag with the following form "v{X}.{Y}.{Z}"

  With:

  - X = Major version
  - Y = Minor version
  - Z = Correction version



  This docker image is built for PySpark transforms on Ascend.io platform.
  First you need a Google cloud storage bucket named for example "great_expectations_store" and a service account with the role "storage.admin" on this bucket.
  Then upload this service account as a credentials on your Ascend.io instance and name it for example "great_expectations_sa".

  Now you can create your PySpark transform on Ascend.io.
  In the advanced settings> Runtime settings > container image URL set the correct docker hub image url : fosk06/ascend-great-expectations-gcs:latest

  Then in the "Custom Spark Params" click on "require credentials" and chose you credential previously uploaded "great_expectations_sa".



  ```python

  from ascend_great_expectations_gcs.validator import Validator


  def expectations(validator):
    validator.expect_column_to_exist("customer_id")
    validator.expect_column_values_to_not_be_null("customer_id")
    validator.expect_column_to_exist('created_at')


  def transform(spark_session: SparkSession, inputs: List[DataFrame], credentials=None):
      df = inputs[0]
      
      validator = Validator(
          name= NAME, # name of the validator
          gcp_project=PROJECT, # your GCP project
          bucket=BUCKET, # the name of your GCP bucket, for example "great_expectations_store"
          credentials=credentials, # credentials from the transform callback
      )
      validator.add_expectations(expectations)
      validator.run(df)
      return df
  ```



  create a virtual env
  then in ./venv/lib/python3.9/site-package write those two files

  ascend_great_expectations_gcs_test.pth => set you package folder path
  ascend_great_expectations_gcs.pth => set you package folder path here

  https://webdevdesigner.com/q/how-do-you-set-your-pythonpath-in-an-already-created-virtualenv-55773/

  git tag -d v1.4.1
  git push --delete origin v1.4.1


pkgId: bc216284274d2b252777b1c70cca88a84e623120dc21a9aa2bab09d50e985faf
name: python-ascender
arch: src
version: 0.2.0
epoch: 0
release: 1
url: https://github.com/AscenderTeam/AscenderCLI
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ascender-0.2.0-1.src.rpm
checksum_type: sha256
summary:
  The CLI tool for working with AscenderFramework: Installation, command execution and version management

description:
  CLI for interacting with core [framework](https://github.com/AscenderTeam/AscenderFramework) functionality.
  This CLI allows users to create new AscenderFramework projects, as well as manage existing projects running their CLI.



  - [Installation](#installation)
  - [Usage](#usage)
  - [Contributing](#contributing)
  - [License](#license)



  To install the CLI, run the following command:

  ```bash
  pip install ascender
  ```



  To create new project, just execute the following command:

  ```bash
  ascender projects new --name <project_name>
  ```

  To execute project commands, just execute the following command:

  ```bash
  ascender run <command>
  ```



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


  [GPLv3](https://choosealicense.com/licenses/gpl-3.0/)


pkgId: e5d008bd770364b2a7787fb4d9d050286e656ae24ff9a184ec18df318d76721e
name: python-ascendfly
arch: src
version: 1.4
epoch: 0
release: 1
summary: Ascend inference framework
url: https://gitee.com/ascend-fae/ascendfly
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ascendfly-1.4-1.src.rpm
checksum_type: sha256
description:
  [TOC]





  This project uses Python Ascend Computing Language (pyACL) APIs to implement the Ascendfly inference framework and encapsulates a series of easy-to-use Python APIs to simplify the PyACL development process and accelerate algorithm porting and deployment. The following describes the functions and dependencies of Ascendfly APIs and explains how to install and use them.



  The project provides the following functions:

  1. Encapsulate context and memory resource classes to simplify resource scheduling and allocation.
  2. Encapsulate the AscendArray class, which is similar to using numpy.ndray to manage images and tensors on the device, to implement data consistency. AscendArray automatically manages data memory.
  3. Encapsulate the VideoCapture and VideoWriter classes to obtain real-time H.264 (MAIN LEVEL without B frame) RTSP/RTMP streams and use Ascend 310 AI Processors to decode hardware or encode images into H.264/H.265 streams frame by frame.
  4. Encapsulate the Image class to implement image processing functions such as image decoding, scaling, cropping, and padding.
  5. Encapsulate the Model class to implement model inference.
  6. Encapsulate the Profiling class to facilitate model performance tuning.
  7. Provide other functions such as single-operator calling and post-processing.



  The system-level Ascendfly project includes the following modules:

  1. Resource:

     The Resource module consists of mem, context, and thread/multi-process. mem is a memory object used to allocate and deallocate memory resources. context is used to allocate and deallocate context resources. multi-process is used for parallel acceleration.

  2. Data:

     The Data module consists of AscendArray and Tensor. AscendArray implements AscendArray objects similar to numpy.ndarray. **It unifies the entire framework image and tensor data** and provides to_numpy, to_ascend, and clone methods that are different from ndarray to replicate numpy.ndarray data and objects. Tensor mainly implements the imgs2tensor and tensor2imgs functions to convert 3-dimensional images into 4-dimensional tensors for batch inference or tensor heatmap display.

  3. Model:
     The Model module encapsulates AscendModel for model inference. After AscendModel is instantiated, model.tensor is used to obtain the input and output tensor names, feed_data is used to feed data to the model, run is used to implement inference, and get_tensor_by_name is used to obtain the output tensor data.

  4. Image:

     The Image module involves image pre-processing (dynamic AIPP), image color space conversion (colorspace), image geometric transformation (geome), and image display (misc).

  5. Video:
     The Video module encapsulates the VideoCapture class for H.264/H.265 RTSP/RTMP video decoding. The implementation of the Video module is basically the same as that of OpenCV VideoCapture: pyav pulls and decompresses streams, and vdec (encapsulating the DVPP decoding function) decodes the data. The Video module also encapsulates the VideoWriter class, which encodes single-frame YUV images into H.264/H.265 real-time video streams. The implementation of the Video module is slightly different from that of the OpenCV VideoWriter class: The single-frame image data of AscendArray is encoded by using venc (encapsulating the DVPP encoding function), and the video streams are saved to the local host.

  6. Post_process:
     The Post_process module uses the bbox_overlaps function to calculate the Intersection over Union (IOU) of the bounding box (bbox), uses the nms function to calculate the NonMaximumSuppression, and uses the imshow and imshow_det_bboxes commands to display the detected target bbox or write the target bbox and confidence on the image and save the image.

  5. Ops:
     The Ops module calls operators in the Blas library and operators such as Argmax, Cast, Transpose, and FFT.

  7. Profiling
     The Profiling module encapsulates the Profiling class to simplify operator and model performance tuning, intuitively display the execution time of each operator, and sort the operators.

  The following figure demonstrates the system design.

  ![Description of the input image]()



  ![Description of the input image]()







  Ascendfly depends on **pyACL(CANN 21.0.1 or later)**, [**pyav**](https://github.com/PyAV-Org/PyAV), and [**PIL**](). The following describes how to install the dependent software.

  Table 2-1 Environment requirements

  | Environment Requirement| Description|
  | -------- | ----------------------------------------------------------- |
  | Hardware environment| Atlas 300 (model 3000 or 3010) or Atlas 800 (model 3000 or 3010)|
  | OS| CentOS 7.6/Ubuntu 18.04|

  Table 2-2 Environment-dependent software and software versions

  | Software Name| Software Version|
  | -------- | ------------------------------------- |
  | pyACL  | (If CANN 21.0.1 or later is installed, pyACL is automatically installed.)|
  | NumPy| ≥ 1.14 |
  | pyav   | ≥ 8.0.2|
  | PIL    | ≥ 8.0.2|
  | objgraph  | ≥ 3.5.0 |
  | prettytable | ≥ 2.1.0|
  | (Optional) OpenCV| ≥ 3.4.2|





  As Python AscendCL programming APIs, pyACL opens functions such as context creation, memory allocation, model, and operator. The Ascendfly inference framework depends on the APIs provided by pyACL. For details about the environment installation method, see *[CANN Software Installation Guide](https://support.huaweicloud.com/instg-cli-cann/atlascli_03_0001.html)*. After installing CANN, [configure environment variables](https://support.huaweicloud.com/asdevg-python-cann/atlaspython_01_0006.html).


  Ascendfly automatically installs related dependencies. You can run the following command to directly install them:

  ```shell
  pip install ascendfly
  ```



  If the ARM platform is used, install Python 3.7.5 before compiling and installing OpenCV-Python.

  - **Step 1** Download OpenCV-Python.

     https://pypi.org/project/opencv-python/4.4.0.46/#files

  - **Step 2** Decompress OpenCV-Python.

     tar -zxvf opencv-python-4.4.0.46.tar.gz && cd opencv-python-4.4.0.46

  - **Step 3** Compile OpenCV-Python.

     python3.7.5 setup.py install





  This section describes the Ascendfly restrictions.

  Table 3-1 Restrictions

  | Item| Restriction |
  | -------- | ------------------------------------------------------------ |
  | pyACL    | For details, see [Application Development Guide (Python)](https://support.huaweicloud.com/intl/en-us/asdevg-python-cann/atlaspython_01_0001.html).|
  | context| A context is created based on the device ID. Each context corresponds to a unique device ID.|
  | VideoCapture | Currently, only the Real-Time Streaming Protocol (RTSP) is supported to pull H.264 video streams (excluding B frames).|





  Before running a model, convert the model and modify its configuration file. The storage locations of models and configuration files can be customized.



  - **Step 1:** Download a model.

    Obtain the original network model, weight file, and **aipp_cfg** file (for details about how to download related models, visit the **tools/modelzoo** link), and save them to any directory of a common user in the development environment, for example, **/home/model/**.


  - **Step 2:** Convert the model.

    Configure the AIPP by following the instructions in the [ATC Tool Instructions](https://support.huaweicloud.com/intl/en-us/tg-Inference-cann/atlasatc_16_0007.html) and convert the Caffe, TensorFlow, or ONNX model into an OM model of the Ascend platform. For details, see the **tools/convert** script.



  You can use Ascendfly APIs to develop the inference process based on the sample in the demo and *[API User Guide](#4.1)*.



  Go to the **demo** directory, modify the configurations such as **device id** and **video_stream_path** of the demo to be run, and run the demo.

  ```shell
  python3.7.5 yolov3_caffe_demo.py
  ```





  For details, see the **index.html** file in the **doc** directory of [Source Code](https://gitee.com/ascend-fae/ascendfly).


pkgId: 7cc0892f4089d75307651507ef5c8fa919c9e23b0d5cd6f09c96876f4cc270ff
name: python-ascendpbm-package
arch: src
version: 0.0.2.16
epoch: 0
release: 1
summary: Common methods for handling ascendpbm's IT needs.
url: https://pypi.org/project/ascendpbm-package/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ascendpbm-package-0.0.2.16-1.src.rpm
checksum_type: sha256
description:
  This is a growing library intended to make use of other python packages streamlined and scaleable for ascendpbm. It is to include tools for interfacing with FTP, SFTP, FTPS, email, Microsoft Graph API, PostgreSQL, bash scripts, reporting infrastructure/packages, and much more. Please note that it will require several unlisted dependencies and requirements such as our business environments, Anaconda installations, and many python packages.


pkgId: af7dd26617f0ce0021901bbf4c3c044804036321a1cc51e21fabfa1294daadfc
name: python-ascii-canvas
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Treat strings like Items on a 2D Canvas.
url: https://pypi.org/project/ascii-canvas/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ascii-canvas-2.0.1-1.src.rpm
checksum_type: sha256
description:
  [![Version](https://img.shields.io/pypi/v/ascii_canvas.svg)](https://pypi.org/project/ascii_canvas/)



  With this primitive library you can do things like this:

  ```python
  from ascii_canvas import canvas
  from ascii_canvas import item

  canvas_ = canvas.Canvas()

  rect_a = item.Item('+-----+\n|Hello|\n+-----+', position=[0, 0])
  rect_b = item.Item('+-----+\n|World|\n+-----+', position=[16, 5])
  rect_c = item.Item('+-+\n|!|\n+-+', position=[32, 0])
  line_a = item.Line(start=[7, 1], end=[15, 6])
  line_b = item.Line(start=[23, 6], end=[31, 1])

  canvas_.add_item(rect_a)
  canvas_.add_item(rect_b)
  canvas_.add_item(rect_c)
  canvas_.add_item(line_a)
  canvas_.add_item(line_b)
  print(canvas_.render())
  ```

  Which results in this output:

  ```
  +-----+                         +-+
  |Hello|----+               +----|!|
  +-----+    |               |    +-+
             |               |
             |               |
             |    +-----+    |
             +----|World|----+
                  +-----+
  ```


pkgId: eb7f7e0ba5fb4858a898c1b660e2843142a879278305c31ca61cbf60940f84d2
name: python-ascii-designer
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Builds dialogs from ASCII art definition.
url: http://github.com/loehnertj/ascii_designer
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ascii-designer-0.6.0-1.src.rpm
checksum_type: sha256
description:
  A library that:
  * creates GUI from ASCII-art (with well-defined syntax)
  * maps widgets to virtual class attributes
  * relieves you from the boring parts of Form building while leaving you in
    control.
  Did you ever design a form by scribbling something like this in your editor::
          Text to transform:   [ Text_      ]
          Select transformation:
          (x) Uppercase
          ( ) Lowercase
          ( ) Title-case
              [ OK ]            [ Cancel ]
      from ascii_designer import AutoFrame
      class TextTransformer(AutoFrame):
          f_body='''
                                  |    <->       |
              Text to transform:   [ Text_      ]
              Select transformation:
              (x) Uppercase
              ( ) Lowercase
              ( ) Title-case
                  [ OK ]            [ Cancel ]~
          '''
          def ok(self):
              text = self.text
              if self.uppercase:
                  text = text.upper()
              elif self.lowercase:
                  text = text.lower()
              elif self.titlecase:
                  text = text.title()
              print(text)
              self.close()
          def cancel(self):
              self.close()
      if __name__ == '__main__':
          TextTransformer().f_show()
  Some comments, incidentally highlighting the features of this library:
  * As you probably guessed, all the magic happens in ``AutoFrame``. The
    ``f_show`` call triggers rendering of the form. All the reserved attributes
    are prepended with ``f_`` to get out of your way when subclassing.
  * There is a **well-defined syntax** for how to get the usual widget types. In the
    example you can find labels (plain text), a text box, radio buttons and normal
    buttons.
  * The columns are defined by the **header row** with the pipe characters. The
    minus sign denotes stretching columns. (The ``<`` / ``>`` chars are just
    decoration.)
  * **Column-span** is easily done by having not-a-space underneath the pipe
    symbol. **Row-span** can also be done by prepending subsequent cells with a
    ``{`` character.
  * **Anchoring** is controlled by whether the cell is space-padded or not. For
    example, the Text box stretches, while the cancel button is centered. The
    tilde character can be used instead of a fragile trailing space.
  * **Widget IDs** are automatically generated by lowercasing and whitelisting the
    captions.
  * If a method exists with the same name as a widget id, it is **automatically
    bound** to the usually-wanted event (click in case of button, value-changed in
    case of basically anything else). Oh, and ``close`` and ``quit`` are already
    there for your convenience.
  * Otherwise, you can retrieve and set the widget's value by using its id like
    a class **attribute**.
  * ``f_show()`` captures all the usual boilerplate and simply f***ing shows
    the frame. It can be used for both the toplevel and additional frames.
  * Also note how the class name automatically turned into the window title.
    Override by setting ``.f_title``.
  * The created widgets are **"raw", native widgets**. You can configure the toolkit
    to use. Currently there is a Qt and a Tkinter implementation. The native
    widget can accessed using ``form["widget_id"]`` (or
    ``form.f_controls["widget_id"]``).
  The general philosophy is to not paint everything over with wrappers. Instead,
  the library focuses on specific tasks - building the layout, event-/value
  binding - and lets you do everything else with the API you know and (maybe) love.


pkgId: 3ac137f84db39dcafd08ecf0a7f96802d3963f7803e759a8110bacce82a5b4c1
name: python-ascii-magic
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: Converts pictures into ASCII art
url: https://github.com/LeandroBarone/python-ascii_magic
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ascii-magic-2.3.0-1.src.rpm
checksum_type: sha256
description:
  Python package that converts images into ASCII art for terminals and HTML. Thanks to [Colorama](https://github.com/tartley/colorama) it's compatible with the Windows terminal.

  Code based on [ProfOak's Ascii Py](https://github.com/ProfOak/Ascii_py/).




  - Craiyon support: from_craiyon()


  - Stable Diffusion support: from_stable_diffusion()


  - DALL-E support: from_dalle()


  - Complete rewrite, full OOP, no longer compatible with 1.x
  - Added support for foreground color
  - to_html()


  - OOP functionality
  - to_file()


  - First public release



      pip install ascii_magic



  ```python
  from ascii_magic import AsciiArt

  my_art = AsciiArt.from_image('moon.jpg')
  my_art.to_terminal()
  ```

  Result:

  ![ASCII Magic example](https://raw.githubusercontent.com/LeandroBarone/python-ascii_magic/master/example_moon.png)




  This module's entire functionality is contained within the class AsciiArt, which has a collection class methods, such as ```AsciiArt.from_image()```, that return ```AsciiArt``` objects with pictures from different sources: files, URLs, the clipboard, etc.

  These objects have multiple methods, such as ```my_art.to_terminal()```, that generate ASCII art pieces from the picture. These methods have parameters such as ```columns``` that allow you to change the appearance of the art piece.

  For convenience, the module ```ascii_magic``` also exposes a collection of functions with the same name as the class methods mentioned above, which do exactly the same.

  Example:

  ```python
  from ascii_magic import AsciiArt, from_image


  my_art = AsciiArt.from_image('lion.jpg')
  my_art.to_terminal()


  my_art = from_image('lion.jpg')
  my_art.to_terminal()
  ```

  This class is essentially a wrapper for a Pillow image. The property ```AsciiArt.image``` exposes the underlying Pillow object so you can manipulate it directly.

  Example:

  ```python
  from ascii_magic import AsciiArt
  from PIL import ImageEnhance

  my_art = AsciiArt.from_image('lion.jpg')
  my_art.image = ImageEnhance.Brightness(my_art.image).enhance(0.2)
  my_art.to_terminal()
  ```



  Loads a random Unsplash picture with the default parameters and prints it to the terminal, allowing you to verify in a single line of code that everything is running O.K.

  ```python
  AsciiArt.quick_test() -> None
  ```

  Example:

  ```python
  from ascii_magic import AsciiArt

  AsciiArt.quick_test()
  ```



  Creates an ```AsciiArt``` object from an image file.

  ```python
  from_image(path: str) -> AsciiArt
  ```

  Parameters:

  - ```path (str)```: an image file compatible with Pillow, such as a jpeg or png

  Example:

  ```python
  from ascii_magic import AsciiArt, Back

  my_art = AsciiArt.from_image('lion.jpg')
  my_art.to_terminal(columns=200, back=Back.BLUE)
  ```

  Result:

  ![ASCII Magic TERMINAL mode example](https://raw.githubusercontent.com/LeandroBarone/python-ascii_magic/master/example_lion_blue.png)

  Example:

  ```python
  from ascii_magic import AsciiArt

  my_art = AsciiArt.from_image('lion.jpg')
  my_art.to_html_file('ascii_art.html', columns=200, width_ratio=2)
  ```

  Result:

  ![ASCII Magic HTML mode example](https://raw.githubusercontent.com/LeandroBarone/python-ascii_magic/master/example_lion_html.png)

  Example:

  ```python
  from ascii_magic import AsciiArt

  my_art = AsciiArt.from_image('lion.jpg')
  my_art.to_terminal(columns=200, monochrome=True)

  ```

  Result:

  ![ASCII Magic ASCII mode example](https://raw.githubusercontent.com/LeandroBarone/python-ascii_magic/master/example_lion_ascii.png)




  Creates an ```AsciiArt``` object with [Craiyon](https://www.craiyon.com/), previously known as DALL-E Mini, a machine learning model that can generate realistic images from a description in natural language.

  ```python
  from_craiyon(prompt: str) -> AsciiArt
  ```

  Parameters:

  - ```prompt (str)```: a description of an image in natural language

  Example:

  ```python
  from ascii_magic import AsciiArt

  my_art = AsciiArt.from_craiyon('A portrait of a cow with noble clothes')
  my_art.to_html_file('cow_craiyon.html', columns=200)
  ```

  Result:

  ![ASCII Magic Craiyon example](https://raw.githubusercontent.com/LeandroBarone/python-ascii_magic/master/example_craiyon.png)



  Creates an ```AsciiArt``` object with [DALL-E](https://openai.com/dall-e/), a machine learning model that can generate realistic images from a description in natural language. Requires a [DALL-E API key](https://platform.openai.com/account/api-keys). The API key can be configured in the module as described in the OpenAI documentation (```openai.api_key = api_key```) or through this function call.

  ```python
  from_dalle(
      prompt: str,
      api_key: Optional[str]
  ) -> AsciiArt
  ```

  Parameters:

  - ```prompt (str)```: a description of an image in natural language
  - ```api_key (str, optional)```: a DALL-E API key

  Example:

  ```python
  from ascii_magic import AsciiArt

  api_key = 'SK-AFAKEDALLEAPIKEY'
  my_art = AsciiArt.from_dalle('A portrait of a cow with noble clothes', api_key)
  my_art.to_html_file('cow_dalle.html', columns=200)
  ```

  Result:

  ![ASCII Magic DALL-E example](https://raw.githubusercontent.com/LeandroBarone/python-ascii_magic/master/example_dalle.png)


  Creates an ```AsciiArt``` object with [Stable Diffusion](https://stability.ai/), a machine learning model that can generate realistic images from a description in natural language. Requires a [Stable Diffusion API key](https://platform.stability.ai/).

  ```python
  from_stable_diffusion(
      prompt: str,
      api_key: str,
      steps: int = 30,
      engine: Optional[str],
  ) -> AsciiArt
  ```

  Parameters:

  - ```prompt (str)```: a description of an image in natural language
  - ```api_key (str, optional)```: a Stable Diffusion API key
  - ```steps (int, optional)```: amount of inference steps performed (see Stable Diffusion documentation)
  - ```engine (str, optional)```: set the engine to use for generation (see Stable Diffusion documentation)

  Example:

  ```python
  from ascii_magic import AsciiArt

  api_key = 'SK-AFAKESTABLEDIFFUSIONAPIKEY'
  my_art = AsciiArt.from_stable_diffusion('A portrait of a cow with noble clothes', api_key)
  my_art.to_html_file('cow_stable_diffusion.html', columns=200)
  ```

  Result:

  ![ASCII Magic Stable Diffusion example](https://raw.githubusercontent.com/LeandroBarone/python-ascii_magic/master/example_stable_diffusion.png)



  Creates an ```AsciiArt``` object from an image URL. Raises an ```urllib.error.URLError``` if something goes wrong while requesting the image, but you can also catch it as an ```OSError``` if you don't want to import ```urllib``` into your project.

  ```python
  from_url(url: str) -> AsciiArt
  ```

  Parameters:

  - ```url (str)```: an URL which will be loaded via urllib (supports redirects)

  Example:

  ```python
  from ascii_magic import AsciiArt

  try:
      my_art = AsciiArt.from_url('https://source.unsplash.com/800x600?nature')
  except OSError as e:
      print(f'Could not load the image, server said: {e.code} {e.msg}')
  my_art.to_terminal()
  ```



  Creates an ```AsciiArt``` object from the contents of the clipboard. Raises an ```OSError``` if the clipboard doesn't contain an image. Requires [PyGObject](https://pygobject.readthedocs.io/en/latest/getting_started.html) under Linux.

  ```python
  from_clipboard() -> AsciiArt
  ```

  Example:

  ```python
  from ascii_magic import AsciiArt

  try:
      my_art = AsciiArt.from_clipboard()
  except OSError:
      print('The clipboard does not contain an image')
  my_art.to_terminal()
  ```



  Creates an ```AsciiArt``` object from an image object created with Pillow. This allows you to handle the image loading yourself.

  ```python
  from_pillow_image(img: PIL.Image) -> AsciiArt
  ```

  Parameters:

  - ```img (obj)```: an image object created with Pillow

  Example:

  ```python
  from ascii_magic import AsciiArt
  from PIL import Image

  img = Image.open('lion.jpg')
  my_art = AsciiArt.from_pillow_image(img)
  my_art.to_terminal()
  ```




  An ```AsciiArt``` object created as explained above has a collection of methods, such as ```to_ascii()```, that allows you to create and display ASCII art pieces. All of them return a string, and some have additional functionality, as described below.




  Returns a string containing ASCII art and, by default, control characters that allows most terminals (also known as shells) to display color.

  The module ```ascii_magic``` exposes two enums to handle color: ```Front``` and ```Back``` which allow you to select terminal-compatible colors.

  ```python
  AsciiArt.to_ascii(
      columns: int = 120,
      width_ratio: float = 2.2,
      monochrome: bool = False,
      char: Optional[str],
      front: Optional[Front],
      back: Optional[Back]
  ) -> str
  ```

  Parameters:

  - ```columns (int, optional)```: the number of characters per row, more columns = wider art
  - ```width_ratio (float, optional)```: ASCII characters are not squares, so this adjusts the width to height ratio during generation
  - ```monochrome (bool, optional)```: if set to True, disables the usage of control characters that display color
  - ```char (str, optional)```: instead of using many different ASCII glyphs, you can use a single one, such as '#'
  - ```front (enum, optional)```: overrides the foreground color with one of:
    - ```Front.BLACK```
    - ```Front.RED```
    - ```Front.GREEN```
    - ```Front.YELLOW```
    - ```Front.BLUE```
    - ```Front.MAGENTA```
    - ```Front.CYAN```
    - ```Front.WHITE```
  - ```back (enum, optional)```: sets the background color to one of:
    - ```Back.BLACK```
    - ```Back.RED```
    - ```Back.GREEN```
    - ```Back.YELLOW```
    - ```Back.BLUE```
    - ```Back.MAGENTA```
    - ```Back.CYAN```
    - ```Back.WHITE```

  Example:

  ```python
  from ascii_magic import AsciiArt, Back

  my_art = AsciiArt.from_image('lion.jpg')
  my_output = my_art.to_ascii(columns=200, back=Back.BLUE)
  print(my_output)
  ```

  Result:

  ![ASCII Magic TERMINAL mode example](https://raw.githubusercontent.com/LeandroBarone/python-ascii_magic/master/example_lion_blue.png)




  Identical to ```AsciiArt.to_ascii()```, but it also does a ```print()``` of the result, saving you one line of code ;)



  Identical to ```AsciiArt.to_ascii()```, but it also saves the result to a text file.

  ```python
  AsciiArt.to_file(
      path: str,
      
  ) -> str
  ```
  Parameters:

  - ```path (str)```: the output file path

  Example:

  ```python
  from ascii_magic import AsciiArt

  my_art = AsciiArt.from_image('lion.jpg')
  my_art.to_file('lion.txt', monochrome=True)
  ```



  Returns a string with ASCII art created as HTML markup. Accepts the same parameters as ```AsciiArt.to_ascii()```, except for ```back``` and ```front``` colors. By default the HTML ASCII art is generated with a 24-bit palette (16 million colors).

  ```python
  AsciiArt.to_html(
      full_color: bool = True,
      
  ) -> str
  ```

  Parameters:

  - ```full_color (bool, optional)```: if set to False, limits color palette to 8 colors

  Example:

  ```python
  from ascii_magic import AsciiArt

  my_art = AsciiArt.from_image('lion.jpg')
  my_html_markup = my_art.to_html(columns=200)
  ```



  Identical to ```AsciiArt.to_html()```, but it also saves the markup to a barebones HTML file inside a ```<pre>``` tag with a bunch of default CSS styles that you can easily open in your browser.

  ```python
  AsciiArt.to_html_file(
      path: str,
      styles: str = '...',  # See description below
      additional_styles: str = '',
      auto_open: bool = False
      
  ) -> str
  ```

  Parameters:

  - ```path (str)```: the output file path
  - ```styles (str, optional)```: a string with a bunch of CSS styles for the ```<pre>``` element, by default:
    - display: inline-block;
    - border-width: 4px 6px;
    - border-color: black;
    - border-style: solid;
    - background-color: black;
    - font-size: 8px;
  - ```additional_styles (str, optional)```: use this to add your own CSS styles without removing the default ones
  - ```auto_open (bool, optional)```: if True, the file will be opened with ```webbrowser.open()```


  Example:

  ```python
  from ascii_magic import AsciiArt

  my_art = AsciiArt.from_image('lion.jpg')
  my_art.to_html_file('lion.html', columns=200, additional_styles='font-family: MonoLisa;')
  ```

  Result:

  ![ASCII Magic HTML mode example](https://raw.githubusercontent.com/LeandroBarone/python-ascii_magic/master/example_lion_html.png)



  Copyright (c) 2020 Leandro Barone.

  Usage is provided under the MIT License. See LICENSE for the full details.


pkgId: fab0760d4418ee3adacac6999126112ea5406a98038e767f0ff118c0d93b0e87
name: python-asciidoc
arch: src
version: 10.2.1
epoch: 0
release: 1
summary: AsciiDoc is a text document format for writing things.
url: https://github.com/asciidoc/asciidoc-py3
rpm_license: GPLv2+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asciidoc-10.2.1-1.src.rpm
checksum_type: sha256
description:
  [![Test](https://github.com/asciidoc-py/asciidoc-py/actions/workflows/test.yml/badge.svg?branch=main&event=push)](https://github.com/asciidoc-py/asciidoc-py/actions/workflows/test.yml)
  [![codecov](https://codecov.io/gh/asciidoc-py/asciidoc-py/branch/main/graph/badge.svg?token=fNh3QlLTw0)](https://codecov.io/gh/asciidoc-py/asciidoc-py)
  [![PyPI version](https://badge.fury.io/py/asciidoc.svg)](https://badge.fury.io/py/asciidoc)
  AsciiDoc is a text document format for writing notes, documentation,
  articles, books, ebooks, slideshows, web pages, man pages and blogs.
  AsciiDoc files can be translated to many formats including HTML, PDF,
  EPUB, man page.
  AsciiDoc.py is a legacy processor for this syntax, handling an older
  rendition of AsciiDoc. As such, this will not properly handle the
  [current AsciiDoc specification](https://projects.eclipse.org/projects/technology.asciidoc).
  It is suggested that unless you specifically require the AsciiDoc.py
  toolchain, you should find a processor that handles the modern AsciiDoc
  syntax.
  AsciiDoc.py is highly configurable: both the AsciiDoc source file syntax
  and the backend output markups (which can be almost any type of
  SGML/XML markup) can be customized and extended by the user.

  AsciiDoc.py is written in Python so you need a Python interpreter
  (version 3.5 or later) to execute asciidoc(1). You can install Python using the
  package manager for your OS or by downloading it from the official Python
  website http://www.python.org.
  Additionally, you will need:
  * DocBook XSL Stylesheets 1.76.1
  * xsltproc (libxml 20706, libxslt 10126 and libexslt 815).
  * w3m 0.5.2
  * dblatex 0.3
  * FOP 0.95
  to enable the full AsciiDoc.py toolchain.

  Documentation and installation instructions are on the AsciiDoc.py website
  https://asciidoc.org/. Simply, you should use use pip to install it:
  ```
  pip3 install asciidoc
  ```

  To contribute and test your changes, you will need to install:
  * flake8
  * pytest
  * pytest-mock
  To lint the codebase: `python3 -m flake8`
  AsciiDoc.py has the following types of tests:
  1. doctests: `python3 -m asciidoc.asciidoc --doctest`
  1. unit tests: `python3 -m pytest`
  1. integration tests: `python3 tests/testasciidoc.py`


pkgId: 69545c856174eb1df8653c59cff86b99baa6432b8ee7480ab4a114089666b403
name: python-asciidoc3
arch: src
version: 3.2.3
epoch: 0
release: 1
url: https://asciidoc3.org
rpm_license: GPLv2+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asciidoc3-3.2.3-1.src.rpm
checksum_type: sha256
summary:
  AsciiDoc3 Python3 GNU/Linux Windows AsciiDoc - see https://asciidoc3.org/pypi.html BEFORE installing

description:
  *AsciiDoc3* is a text document format for writing notes, documentation, articles, books,
  ebooks, slideshows, web pages, man pages and blogs. *AsciiDoc3* files can be translated
  to many formats including HTML, PDF, EPUB, man page, and DocBook markup (at your choice v4.5 or v5.1).
  *AsciiDoc3* is highly configurable: both the *AsciiDoc3* source file syntax and the backend
  output markups (which can be almost any type of SGML/XML markup) can be customized and extended by the user.


  *AsciiDoc3* is written in 100% pure Python3. So you need a Python interpreter (version 3.7 or later)
  to execute asciidoc3.py. Python is installed by default in most Linux distributions. You can download
  Python from the official website https://www.python.org.


  deb rpm docker tarball generic installer zip PyPI (GNU/Linux and Windows) Pelican Plugin available!
  See documentation and installation instructions on the *AsciiDoc3* website https://asciidoc3.org/


  Current *AsciiDoc3* version tested on Debian Siduction, Ubuntu 20.04 LTS (Focal Fossa), GhostBSD,
  openSUSE Tumbleweed, Windows 10, and other platforms (Python 3.7 to 3.10).


  *AsciiDoc3* comes without dependencies (aside Python3, of course). To exploit all features of *AsciiDoc3*,
  you need - where necessary - DocBook XSL Stylesheets, xsltproc, w3m, dblatex, FOP, Pygments, graphviz ...
  You'll find these packages in the repos of your operating system - to avoid this hassle use Docker.


  Copyright © Stuart Rackham (and contributors) for AsciiDoc v8.6.9 (Python2)
  Copyright © 2018-2021 Berthold Gehrke <berthold.gehrke@gmail.com> for AsciiDoc3 (Python3)

  Free use of this software is granted under the terms of the
  GNU General Public License version 2 or later (GPLv2+).


pkgId: c3ebc46855e99c187cd2ad09085054cc742ef42c2e79774dc045efb067d4bacb
name: python-asciidots
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Interpreter for the AsciiDots esolang.
url: https://github.com/aaronduino/asciidots
rpm_license: APGL-v3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asciidots-1.4.0-1.src.rpm
checksum_type: sha256
description:
  asciidots is a esolang inspired by ascii art.

  See its documentation on GitHub: https://github.com/aaronjanse/asciidots/


pkgId: 7e5f698de83e598782157b8d0b73a9ebe02309bb777dc0eca8e1dd287b94dbde
name: python-asciidoxy
arch: src
version: 0.8.7
epoch: 0
release: 1
summary: AsciiDoxy generates API documentation from Doxygen XML output to AsciiDoc.
url: https://asciidoxy.org
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asciidoxy-0.8.7-1.src.rpm
checksum_type: sha256
description:
  ```
      ___              _ _ ____
     /   |  __________(_|_) __ \____  _  ____  __
    / /| | / ___/ ___/ / / / / / __ \| |/_/ / / /
   / ___ |(__  ) /__/ / / /_/ / /_/ />  </ /_/ /
  /_/  |_/____/\___/_/_/_____/\____/_/|_|\__, /
                                        /____/
  ```

  [ [Home](https://asciidoxy.org) |
  [What is AsciiDoxy?](https://asciidoxy.org/about.html) |
  [Getting started](https://asciidoxy.org/getting-started.html) |
  [Reference documentation](https://asciidoxy.org/reference.html) |
  [Examples](https://asciidoxy.org/examples.html) |
  [Contributing](https://asciidoxy.org/contributing.html) |
  [Changelog](CHANGELOG.adoc) |
  [GitHub](https://github.com/tomtom-international/asciidoxy) ]

  [![License](https://img.shields.io/badge/License-Apache%202.0-green.svg)](LICENSE)
  [![pip downloads](https://img.shields.io/pypi/dm/asciidoxy)](https://pypi.org/project/asciidoxy)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/asciidoxy)](https://pypi.org/project/asciidoxy)
  [![PyPI](https://img.shields.io/pypi/v/asciidoxy)](https://pypi.org/project/asciidoxy)

  AsciiDoxy let's you generate beautiful documentation using the combined power of AsciiDoc and
  Python. Write your documentation in [AsciiDoc
  format](https://docs.asciidoctor.org/asciidoc/latest/)
  and use [Python code](https://python.org) and [Mako Templates](https://makotemplates.org) to
  generate additional content. To top it all off, insert API documentation generated by
  [Doxygen](https://doxygen.nl) to document your software.

  For API documentation, the following languages are currently supported through Doxygen:

  - C++
  - Java
  - Objective-C
  - Python (using [doxypypy](https://github.com/Feneric/doxypypy))
  - Swift (transcoded from Objective-C only, native support expected in 0.9.x)
  - Kotlin (transcoded from Java only, native support expected in 0.9.x)

  Other features:

  - Collect AsciiDoc files, images, API documentation and other resources from remote servers.
  - Generate either a single HTML page or a multipage hierarchy.
  - Transcoding: showing how to use elements written in one language in another compatible language.




  Want to try out AsciiDoxy together with all the tools it supports? Use our Docker image:

  ```bash
  docker run --rm -it silvester747/asciidoxy:latest asciidoxy --help
  ```

  All you need to get started writing beautiful documentation can be found in our
  [getting started guide](https://asciidoxy.org/getting-started.html).




  Inspiration for creating AsciiDoxy was found in this article by Sy Brand:
  https://devblogs.microsoft.com/cppblog/clear-functional-c-documentation-with-sphinx-breathe-doxygen-cmake/

  Before going public on GitHub, several people inside [TomTom](https://www.tomtom.com) contributed to
  the internal version of AsciiDoxy. Many thanks to:

  - Andy Salter
  - Arkadiusz Skalski
  - Lukasz Glowcyk
  - Nebojsa Mrmak
  - Niels van der Schans
  - Robert Gernert
  - Tomasz Maj

  The python package was created with [Cookiecutter](https://github.com/audreyr/cookiecutter) and the
  [audreyr/cookiecutter-pypackage](https://github.com/audreyr/cookiecutter-pypackage) project template.


pkgId: 14c3c551c982072a62c98cd33bf8a5553b87847112f0b0a52011c3b0eed2a44e
name: python-asciigraf
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: A python library for making ascii-art into network graphs.
url: https://pypi.org/project/asciigraf/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asciigraf-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Asciigraf is a python library that turns ascii diagrams of networks into
  network objects. It returns a `networkx <https://networkx.github.io/>`__
  graph of nodes for each alpha-numeric element in the input text; nodes
  are connected in the graph to match the edges represented in the diagram
  by ``-``, ``/``, ``\`` and ``|``.

rpm_license:
  copyright 2017 Anton Lodder  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: 63c23d0a4a814e2728ae6bc92cc87efff1ccb2438ff3beab2f7c361e25561587
name: python-asciii
arch: src
version: 1.0.14
epoch: 0
release: 1
summary: A library that converts images to ascii
url: https://pypi.org/project/asciii/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asciii-1.0.14-1.src.rpm
checksum_type: sha256
description:
  A library that converts images to ascii


  check the description on my [github](https://github.com/acup1/asciii)




  ![original](https://raw.githubusercontent.com/acup1/asciii/main/examples/dota-2-broodmother-pauchiha.jpg)


  ![ascii](https://raw.githubusercontent.com/acup1/asciii/main/examples/ascii_example2.png)


  ![original](https://bipbap.ru/wp-content/uploads/2017/04/priroda_kartinki_foto_03.jpg)


  ![ascii](https://raw.githubusercontent.com/acup1/asciii/main/examples/asciii_example1.png)


pkgId: d01c2ce89b4554d6892ec6f0c9ee59fc512136bdc01228d7f9439e25f81dc042
name: python-asciimathml
arch: src
version: 0.9.5.1
epoch: 0
release: 1
summary: ASCIIMathML to MathML translator
url: http://github.com/ShadowKyogre/python-asciimathml
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asciimathml-0.9.5.1-1.src.rpm
checksum_type: sha256
description:
  Translates from ASCIIMathML (an easy to type and highly readable way to
  represent math formulas) into Presentation MathML (a w3c standard directly
  displayable by some web browsers).

  The MathML tree is represented by Elements from the standard
  xml.etree.ElementTree python library.

  The obtained tree can then be further manipulated and then serialized into a
  string to be included for example in a HTML document.

  Also included is a markdown extension that allows the use of ASCIIMathML,
  eclosed between $$, inside markdown documents.


pkgId: a2700542c913247875b9b14d755c9124be9faab12759de7d61b8537d91273d16
name: python-asciimatics
arch: src
version: 1.15.0
epoch: 0
release: 1
url: https://github.com/peterbrittain/asciimatics
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asciimatics-1.15.0-1.src.rpm
checksum_type: sha256
summary:
  A cross-platform package to replace curses (mouse/keyboard input & text colours/positioning) and create ASCII animations

description:
  Asciimatics is a package to help people create full-screen text UIs (from interactive forms to
  ASCII animations) on any platform.  It is licensed under the Apache Software Foundation License 2.0.


pkgId: 799f51affd28b55bda8913161cd0e492f8b436d53db9f7d28bf05b9bd24cc210
name: python-asciimol
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: An ASCII molecule viewer.
url: https://github.com/dewberryants/asciimol
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asciimol-1.2.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/asciimol.svg)](https://badge.fury.io/py/asciimol)

  ![Screenshots](https://raw.githubusercontent.com/dewberryants/asciiMol/master/docs/animation.gif)

  A basic molecule viewer written in Python, using curses; Thus, meant for linux terminals.

  Features:

  * Opening default cartesian .xyz files
  * Orthographic view
  * Navigation
  * Zoom, Rotation, Auto-Rotation
  * Bond detection and display
  * Support for simple .xyz trajectories
  * Optional integration of ASE and RDKit pypi packages for more formats and SMILES



  ```sh
  pip install asciimol
  ```

  (Note: pip will install a run script in $HOME/.local/bin/ if you do not install with root permissions, so make sure this
  directory is part of your $PATH.)

  You can also run

  ```sh
  pip install asciimol[formats,smiles]
  ```

  to automatically install ASE for formats and RDKit for smiles.

rpm_license:
  BSD 2-Clause License  Copyright (c) 2020, Dominik Behrens All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 8f8a404f2adc036eb2cbcce61b7e53bb9fe28e6c8e70ddc87285eb3933090a00
name: python-asciinema
arch: src
version: 2.4.0
epoch: 0
release: 1
summary: Terminal session recorder
url: https://asciinema.org
rpm_license: GNU GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asciinema-2.4.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/asciinema/asciinema/actions/workflows/asciinema.yml/badge.svg)](https://github.com/asciinema/asciinema/actions/workflows/asciinema.yml)
  [![PyPI](https://img.shields.io/pypi/v/asciinema.svg)](https://pypi.org/project/asciinema/)
  [![license](http://img.shields.io/badge/license-GNU-blue.svg)](https://raw.githubusercontent.com/asciinema/asciinema/master/LICENSE)

  Terminal session recorder and the best companion of
  [asciinema.org](https://asciinema.org).

  [![demo](https://asciinema.org/a/335480.svg)](https://asciinema.org/a/335480?autoplay=1)

  asciinema _[as-kee-nuh-muh]_ is a free and open source solution for recording
  terminal sessions and sharing them on the web.

  Shout-out to our Platinum [sponsors](https://github.com/sponsors/ku1ik), whose
  financial support helps keep the project alive:

  [<img src="./.github/sponsor-logos/dashcam/logo-on-light.png" width="200" />](https://dashcam.io?utm_source=asciinemagithub)



  asciinema lets you easily record terminal sessions and replay
  them in a terminal as well as in a web browser.

  Install latest version ([other installation options](#installation))
  using [pipx](https://pypa.github.io/pipx/) (if you have it):

  ```sh
  pipx install asciinema
  ```

  If you don't have pipx, install using pip with your preferred Python version:

  ```sh
  python3 -m pip install asciinema
  ```

  Record your first session:

  ```sh
  asciinema rec first.cast
  ```

  Now replay it with double speed:

  ```sh
  asciinema play -s 2 first.cast
  ```

  Or with normal speed but with idle time limited to 2 seconds:

  ```sh
  asciinema play -i 2 first.cast
  ```

  You can pass `-i 2` to `asciinema rec` as well, to set it permanently on a
  recording. Idle time limiting makes the recordings much more interesting to
  watch. Try it.

  If you want to watch and share it on the web, upload it:

  ```sh
  asciinema upload first.cast
  ```

  The above uploads it to [asciinema.org](https://asciinema.org), which is a
  default [asciinema-server](https://github.com/asciinema/asciinema-server)
  instance, and prints a secret link you can use to watch your recording in a web
  browser.

  You can record and upload in one step by omitting the filename:

  ```sh
  asciinema rec
  ```

  You'll be asked to confirm the upload when the recording is done. Nothing is
  sent anywhere without your consent.

  These are the basics, but there's much more you can do. The following sections
  cover installation, usage and hosting of the recordings in more detail. Also,
  checkout [agg](https://github.com/asciinema/agg) if you're interested in GIF generation.





  [pypi]: https://pypi.python.org/pypi/asciinema

  asciinema is available on [PyPI] and can be installed with
  [pipx](https://pypa.github.io/pipx/) (if you have it) or with pip (Python 3
  with setuptools required):

  ```sh
  pipx install asciinema
  ```

  Or with pip (using your preferred Python version):

  ```sh
  python3 -m pip install asciinema
  ```

  Installing from [PyPI] is the recommended way of installation, which gives you the latest released version.



  asciinema is included in repositories of most popular package managers on Mac OS
  X, Linux and FreeBSD. Look for package named `asciinema`. See the
  [list of available packages](https://asciinema.org/docs/installation).



  If you can't use Python package or native package for your OS is outdated you
  can clone the repo and run asciinema straight from the checkout.

  Clone the repo:

  ```sh
  git clone https://github.com/asciinema/asciinema.git
  cd asciinema
  ```

  If you want latest stable version:

  ```sh
  git checkout master
  ```

  If you want current development version:

  ```sh
  git checkout develop
  ```

  Then run it with:

  ```sh
  python3 -m asciinema --version
  ```



  asciinema Docker image is based on [Ubuntu
  22.04](https://releases.ubuntu.com/22.04/) and has the latest version of
  asciinema recorder pre-installed.

  ```sh
  docker pull ghcr.io/asciinema/asciinema
  ```

  When running it don't forget to allocate a pseudo-TTY (`-t`), keep STDIN open
  (`-i`) and mount config directory volume (`-v`):

  ```sh
  docker run --rm -it -v "${HOME}/.config/asciinema:/root/.config/asciinema" ghcr.io/asciinema/asciinema rec
  ```

  Container's entrypoint is set to `/usr/local/bin/asciinema` so you can run the
  container with any arguments you would normally pass to `asciinema` binary (see
  Usage section for commands and options).

  There's not much software installed in this image though. In most cases you may
  want to install extra programs before recording. One option is to derive new
  image from this one (start your custom Dockerfile with `FROM
  ghcr.io/asciinema/asciinema`). Another option is to start the container with
  `/bin/bash` as the entrypoint, install extra packages and manually start
  `asciinema rec`:

  ```console
  docker run --rm -it -v "${HOME}/.config/asciinema:/root/.config/asciinema" --entrypoint=/bin/bash ghcr.io/asciinema/asciinema rec
  root@6689517d99a1:~# apt-get install foobar
  root@6689517d99a1:~# asciinema rec
  ```

  It is also possible to run the docker container as a non-root user, which has
  security benefits. You can specify a user and group id at runtime to give the
  application permission similar to the calling user on your host.

  ```sh
  docker run --rm -it \
      --env=ASCIINEMA_CONFIG_HOME="/run/user/$(id -u)/.config/asciinema" \
      --user="$(id -u):$(id -g)" \
      --volume="${HOME}/.config/asciinema:/run/user/$(id -u)/.config/asciinema:rw" \
      --volume="${PWD}:/data:rw" \
      --workdir='/data' \
      ghcr.io/asciinema/asciinema rec
  ```



  asciinema is composed of multiple commands, similar to `git`, `apt-get` or
  `brew`.

  When you run `asciinema` with no arguments help message is displayed, listing
  all available commands with their options.



  **Record terminal session.**

  By running `asciinema rec [filename]` you start a new recording session. The
  command (process) that is recorded can be specified with `-c` option (see
  below), and defaults to `$SHELL` which is what you want in most cases.

  You can temporarily pause the capture of your terminal by pressing
  <kbd>Ctrl+\\</kbd>.  This is useful when you want to execute some commands during
  the recording session that should not be captured (e.g. pasting secrets). Resume
  by pressing <kbd>Ctrl+\\</kbd> again. When pausing desktop notification is
  displayed so you're sure the sensitive output won't be captured in the
  recording.

  Recording finishes when you exit the shell (hit <kbd>Ctrl+D</kbd> or type
  `exit`). If the recorded process is not a shell then recording finishes when
  the process exits.

  If the `filename` argument is omitted then (after asking for confirmation) the
  resulting asciicast is uploaded to
  [asciinema-server](https://github.com/asciinema/asciinema-server) (by default to
  asciinema.org), where it can be watched and shared.

  If the `filename` argument is given then the resulting recording (called
  [asciicast](doc/asciicast-v2.md)) is saved to a local file. It can later be
  replayed with `asciinema play <filename>` and/or uploaded to asciinema server
  with `asciinema upload <filename>`.

  `ASCIINEMA_REC=1` is added to recorded process environment variables. This
  can be used by your shell's config file (`.bashrc`, `.zshrc`) to alter the
  prompt or play a sound when the shell is being recorded.

  Available options:

  - `--stdin` - Enable stdin (keyboard) recording (see below)
  - `--append` - Append to existing recording
  - `--raw` - Save raw STDOUT output, without timing information or other metadata
  - `--overwrite` - Overwrite the recording if it already exists
  - `-c, --command=<command>` - Specify command to record, defaults to $SHELL
  - `-e, --env=<var-names>` - List of environment variables to capture, defaults
    to `SHELL,TERM`
  - `-t, --title=<title>` - Specify the title of the asciicast
  - `-i, --idle-time-limit=<sec>` - Limit recorded terminal inactivity to max `<sec>` seconds
  - `--cols=<n>` - Override terminal columns for recorded process
  - `--rows=<n>` - Override terminal rows for recorded process
  - `-y, --yes` - Answer "yes" to all prompts (e.g. upload confirmation)
  - `-q, --quiet` - Be quiet, suppress all notices/warnings (implies -y)

  Stdin recording allows for capturing of all characters typed in by the user in
  the currently recorded shell. This may be used by a player (e.g.
  [asciinema-player](https://github.com/asciinema/asciinema-player)) to display
  pressed keys. Because it's basically key-logging (scoped to a single shell
  instance), it's disabled by default, and has to be explicitly enabled via
  `--stdin` option.



  **Replay recorded asciicast in a terminal.**

  This command replays given asciicast (as recorded by `rec` command) directly in
  your terminal.

  Following keyboard shortcuts are available by default:

  - <kbd>Space</kbd> - toggle pause,
  - <kbd>.</kbd> - step through a recording a frame at a time (when paused),
  - <kbd>Ctrl+C</kbd> - exit.

  See "Configuration file" section for information on how to customize the
  keyboard shortcuts.

  Playing from a local file:

  ```sh
  asciinema play /path/to/asciicast.cast
  ```

  Playing from HTTP(S) URL:

  ```sh
  asciinema play https://asciinema.org/a/22124.cast
  asciinema play http://example.com/demo.cast
  ```

  Playing from asciicast page URL (requires `<link rel="alternate" type="application/x-asciicast" href="/my/ascii.cast">` in page's HTML):

  ```sh
  asciinema play https://asciinema.org/a/22124
  asciinema play http://example.com/blog/post.html
  ```

  Playing from stdin:

  ```sh
  cat /path/to/asciicast.cast | asciinema play -
  ssh user@host cat asciicast.cast | asciinema play -
  ```

  Playing from IPFS:

  ```sh
  asciinema play dweb:/ipfs/QmNe7FsYaHc9SaDEAEXbaagAzNw9cH7YbzN4xV7jV1MCzK/ascii.cast
  ```

  Available options:

  - `-i, --idle-time-limit=<sec>` - Limit replayed terminal inactivity to max `<sec>` seconds
  - `-s, --speed=<factor>` - Playback speed (can be fractional)
  - `-l, --loop` - Play in a loop
  - `-m, --pause-on-markers` - Automatically pause on [markers](#markers)
  - `--stream=<stream>` - Select stream to play (see below)
  - `--out-fmt=<format>` - Select output format (see below)

  By default the output stream (`o`) is played. This is what you want in most
  cases.  If you recorded the input stream (`i`) with `asciinema rec --stdin` then
  you can replay it with `asciinema play --stream=i <filename>`.

  By default the selected stream is written to stdout in original, raw data form.
  This is also what you want in majority of cases. However you can change the
  output format to asciicast (newline delimited JSON) with `asciinema play
  --out-fmt=asciicast <filename>`. This allows delegating actual rendering to
  another place (e.g. outside of your terminal) by piping output of `asciinema
  play` to a tool of your choice.

  > For the best playback experience it is recommended to run `asciinema play` in
  > a terminal of dimensions not smaller than the one used for recording, as
  > there's no "transcoding" of control sequences for new terminal size.



  **Print full output of recorded asciicast to a terminal.**

  While `asciinema play <filename>` replays the recorded session using timing
  information saved in the asciicast, `asciinema cat <filename>` dumps the full
  output (including all escape sequences) to a terminal immediately.

  `asciinema cat existing.cast >output.txt` gives the same result as recording via
  `asciinema rec --raw output.txt`.



  **Upload recorded asciicast to asciinema.org site.**

  This command uploads given asciicast (recorded by `rec` command) to
  asciinema.org, where it can be watched and shared.

  `asciinema rec demo.cast` + `asciinema play demo.cast` + `asciinema upload demo.cast` is a nice combo if you want to review an asciicast before
  publishing it on asciinema.org.



  **Link your install ID with your asciinema.org user account.**

  If you want to manage your recordings (change title/theme, delete) at
  asciinema.org you need to link your "install ID" with asciinema.org user
  account.

  This command displays the URL to open in a web browser to do that. You may be
  asked to log in first.

  Install ID is a random ID ([UUID
  v4](https://en.wikipedia.org/wiki/Universally_unique_identifier)) generated
  locally when you run asciinema for the first time, and saved at
  `$HOME/.config/asciinema/install-id`. Its purpose is to connect local machine
  with uploaded recordings, so they can later be associated with asciinema.org
  account. This way we decouple uploading from account creation, allowing them to
  happen in any order.

  > A new install ID is generated on each machine and system user account you use
  > asciinema on, so in order to keep all recordings under a single asciinema.org
  > account you need to run `asciinema auth` on all of those machines.

  > asciinema versions prior to 2.0 confusingly referred to install ID as "API
  > token".



  Markers allow marking specific time locations in a recording, which can be used
  for navigation, as well as for automatic pausing of the playback.

  Markers can be added to a recording in several ways:

  - while you are recording, by pressing a configured hotkey, see [add_marker_key
    config option](#configuration-file)
  - for existing recording, by inserting marker events (`"m"`) in the asciicast
    file, see [marker event](doc/asciicast-v2.md#m---marker)

  When replaying a recording with `asciinema play` you can enable
  auto-pause-on-marker behaviour with `-m`/`--pause-on-markers` option (it's off
  by default). When a marker is encountered, the playback automatically pauses and
  can be resumed by pressing space bar key. The playback continues until next
  marker is encountered. You can also fast-forward to the next marker by pressing
  `]` key (when paused).

  Markers can be useful in e.g. live demos: you can create a recording with
  markers, then play it back during presentation, and have it stop wherever you
  want to explain terminal contents in more detail.



  As mentioned in the `Usage > rec` section above, if the `filename` argument to
  `asciinema rec` is omitted then the recorded asciicast is uploaded to
  [asciinema.org](https://asciinema.org). You can watch it there and share it via
  secret URL.

  If you prefer to host the recordings yourself, you can do so by either:

  - recording to a file (`asciinema rec demo.cast`), and using [asciinema's
    standalone web
    player](https://github.com/asciinema/asciinema-player#self-hosting-quick-start)
    in your HTML page, or
  - setting up your own
    [asciinema-server](https://github.com/asciinema/asciinema-server) instance,
    and [setting API URL
    accordingly](https://github.com/asciinema/asciinema-server/wiki/Installation-guide#using-asciinema-recorder-with-your-instance).



  You can configure asciinema by creating config file at
  `$HOME/.config/asciinema/config`.

  Configuration is split into sections (`[api]`, `[record]`, `[play]`). Here's a
  list of all available options for each section:

  ```ini
  [api]

  ; API server URL, default: https://asciinema.org
  ; If you run your own instance of asciinema-server then set its address here
  ; It can also be overriden by setting ASCIINEMA_API_URL environment variable
  url = https://asciinema.example.com

  [record]

  ; Command to record, default: $SHELL
  command = /bin/bash -l

  ; Enable stdin (keyboard) recording, default: no
  stdin = yes

  ; List of environment variables to capture, default: SHELL,TERM
  env = SHELL,TERM,USER

  ; Limit recorded terminal inactivity to max n seconds, default: off
  idle_time_limit = 2

  ; Answer "yes" to all interactive prompts, default: no
  yes = true

  ; Be quiet, suppress all notices/warnings, default: no
  quiet = true

  ; Define hotkey for pausing recording (suspending capture of output),
  ; default: C-\ (control + backslash)
  pause_key = C-p

  ; Define hotkey for adding a marker, default: none
  add_marker_key = C-x

  ; Define hotkey prefix key - when defined other recording hotkeys must
  ; be preceeded by it, default: no prefix
  prefix_key = C-a

  [play]

  ; Playback speed (can be fractional), default: 1
  speed = 2

  ; Limit replayed terminal inactivity to max n seconds, default: off
  idle_time_limit = 1

  ; Define hotkey for pausing/resuming playback,
  ; default: space
  pause_key = p

  ; Define hotkey for stepping through playback, a frame at a time,
  ; default: . (dot)
  step_key = s

  ; Define hotkey for jumping to the next marker,
  ; default: ]
  next_marker_key = m

  [notifications]
  ; Desktop notifications are displayed on certain occasions, e.g. when
  ; pausing/resuming the capture of terminal with C-\ keyboard shortcut.

  ; Should desktop notifications be enabled, default: yes
  enabled = no

  ; Custom notification command
  ; asciinema automatically detects available desktop notification system
  ; (notify-send on GNU/Linux, osacript/terminal-notifier on macOS). Custom
  ; command can be used if needed.
  ; When invoked, environment variable $TEXT contains notification text, while
  ; $ICON_PATH contains path to the asciinema logo image.
  command = tmux display-message "$TEXT"
  ```

  A very minimal config file could look like that:

  ```ini
  [record]
  idle_time_limit = 2
  ```

  Config directory location can be changed by setting `$ASCIINEMA_CONFIG_HOME`
  environment variable.

  If `$XDG_CONFIG_HOME` is set on Linux then asciinema uses
  `$XDG_CONFIG_HOME/asciinema` instead of `$HOME/.config/asciinema`.

  > asciinema versions prior to 1.1 used `$HOME/.asciinema`. If you have it
  > there you should `mv $HOME/.asciinema $HOME/.config/asciinema`.



  asciinema is sponsored by:

  - [**Dashcam**](https://dashcam.io?utm_source=asciinemagithub)
  - [Brightbox](https://www.brightbox.com/)



  I offer consulting services for asciinema project. See https://asciinema.org/consulting for more information.



  If you want to contribute to this project check out
  [Contributing](https://asciinema.org/contributing) page.



  Developed with passion by [Marcin Kulik](http://ku1ik.com) and great open
  source [contributors](https://github.com/asciinema/asciinema/contributors).



  © 2011 Marcin Kulik.

  All code is licensed under the GPL, v3 or later. See [LICENSE](./LICENSE) file
  for details.


pkgId: 9dbd1db9877e5367d09a428799291370cb165a651c95d8dc739d268bfd224b08
name: python-asciinet
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: A wrapper around the scala ascii-graphs library
url: https://pypi.org/project/asciinet/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asciinet-0.3.1-1.src.rpm
checksum_type: sha256
description:
  *NOTE*: this is a fork of the original asciinet libary which seems to be abandoned. This fork is mainly intended to build artifacts to upload to pypi and conda.
  asciinet is a wrapper over the [ascii-graphs](https://github.com/cosminbasca/ascii-graphs) library for printing [networkx](https://networkx.github.io/) graphs as ASCII.


pkgId: f32623ca32ac3ac9893eecfaa961e241e2023769629441788d293cbc17d2ef09
name: python-asciistuff
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: Library for producing ASCII arts from a text or an image
url: https://pypi.org/project/asciistuff/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asciistuff-1.3.1-1.src.rpm
checksum_type: sha256
description:
      \
       \
      ^__^         /
      (oo)\_______/  _________
      (__)\       )=(  ____|_ \_____
        ||----w |  \ \     \_____ |
          ||     ||   ||           ||
  ```

  ```
  from asciistuff import *
  file = AsciiFile("test.asc")
  ```

rpm_license:
[cell repeats an earlier one in this file: 34486 characters]


pkgId: c9f15194d214e306b08fb7e579c9ced2297b1fc53654ec0dbdf47bda2ab42753
name: python-asciitable
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Extensible ASCII table reader and writer
url: http://cxc.harvard.edu/contrib/asciitable
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asciitable-0.8.0-1.src.rpm
checksum_type: sha256
description:
  Asciitable can read and write a wide range of ASCII table formats via built-in
  Extension Reader Classes:

  * **Basic**: basic table with customizable delimiters and header configurations
  * **Cds**: `CDS format table <http://vizier.u-strasbg.fr/doc/catstd.htx>`_ (also Vizier and ApJ machine readable tables)
  * **CommentedHeader**: column names given in a line that begins with the comment character
  * **Daophot**: table from the IRAF DAOphot package
  * **FixedWidth**: table with fixed-width columns
  * **Ipac**: `IPAC format table <http://irsa.ipac.caltech.edu/applications/DDGEN/Doc/ipac_tbl.html>`_
  * **Latex**: LaTeX tables (plain and AASTex)
  * **Memory**: table already in memory (list of lists, dict of lists, etc)
  * **NoHeader**: basic table with no header where columns are auto-named
  * **Rdb**: tab-separated values with a column types line after the column names line
  * **Tab**: tab-separated values

  **This is the last major release of the asciitable package:**

  The asciitable package was moved into the `Astropy <http://astropy.org>`_ project
  as `astropy.io.ascii <http://astropy.readthedocs.org/en/latest/io/ascii/index.html>`_.
  This sub-package is being actively developed and contains many new features and
  bug fixes.  Users are encouraged to migrate to ``astropy.io.ascii``.


