# packages

pkgId: b7ab163fe3e3b39f2c176fd6b981e7c1262e527ff36ccc229856d484cf974824
name: python-atproto
arch: src
version: 0.0.54
epoch: 0
release: 1
summary: The AT Protocol SDK
url: https://github.com/MarshalX/atproto
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-atproto-0.0.54-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <a href="https://github.com/MarshalX/atproto">
          <img alt="Logo of atproto SDK for Python by Midjourney'" src="https://github.com/MarshalX/atproto/raw/main/.github/images/logo.png">
      </a>
      <br>
      <b>Autogenerated from lexicons, well type hinted, documented, sync and async SDK for Python</b>
      <br>
      <a href="https://github.com/MarshalX/atproto/tree/main/examples">
          Examples
      </a>
      •
      <a href="https://atproto.blue">
          Documentation
      </a>
      •
      <a href="https://discord.gg/PCyVJXU9jN">
          Discord Bluesky API
      </a>
  </p>



  > ⚠️ Under construction. Until the 1.0.0 release compatibility between versions is not guaranteed.

  Code snippet:

  ```python
  from atproto import Client, client_utils


  def main():
      client = Client()
      profile = client.login('my-handle', 'my-password')
      print('Welcome,', profile.display_name)

      text = client_utils.TextBuilder().text('Hello World from ').link('Python SDK', 'https://atproto.blue')
      post = client.send_post(text)
      client.like(post.uri, post.cid)


  if __name__ == '__main__':
      main()

  ```

  <details>
    <summary>Code snippet of async version</summary>

  ```python
  import asyncio

  from atproto import AsyncClient, client_utils


  async def main():
      client = AsyncClient()
      profile = await client.login('my-handle', 'my-password')
      print('Welcome,', profile.display_name)

      text = client_utils.TextBuilder().text('Hello World from ').link('Python SDK', 'https://atproto.blue')
      post = await client.send_post(text)
      await client.like(post.uri, post.cid)


  if __name__ == '__main__':
      
      asyncio.get_event_loop().run_until_complete(main())

  ```
  </details>

  💬 [Direct Messages (Chats)](https://atproto.blue/en/latest/dm.html)

  🍿 [Example project with custom feed generator](https://github.com/MarshalX/bluesky-feed-generator)

  🔥 [Firehose data streaming is available](https://atproto.blue/en/latest/atproto_firehose/index.html)

  🌐 [Identity resolvers for DID and Handle](https://atproto.blue/en/latest/atproto_identity/index.html)



  This SDK attempts to implement everything that provides ATProto. There is support for Lexicon Schemes, XRPC clients, Firehose, Identity, DID keys, signatures, and more. All models, queries, and procedures are generated automatically. The main focus is on the lexicons of atproto.com and bsky.app, but it doesn't have a vendor lock on it. Feel free to use the code generator for your own lexicon schemes. SDK also provides utilities to work with CID, NSID, AT URI Schemes, DAG-CBOR, CAR files, DID Documents and more.



  - Python 3.8 or higher.



  ``` bash
  pip install atproto
  ```



  First of all, you need to create the instance of the XRPC Client. To do so, you have two major options: asynchronous, and synchronous. The difference only in import and how you call the methods. If you are not familiar with async, use sync instead.

  For sync:

  ```python
  from atproto import Client

  client = Client()


  ```

  For async:

  ```python
  from atproto import AsyncClient

  client = AsyncClient()


  ```

  In the snippets below, only the sync version will be presented.

  Right after the creation of the Client instance, you probably want to access the full API and perform actions by profile. To achieve this, you should log in to the network using your handle and password. The password could be app-specific.

  ```python
  from atproto import Client

  client = Client()
  client.login('my-username', 'my-password')
  ```

  You are awesome! Now you feel to pick any high-level method that you want and perform it!

  Code to send post:

  ```python
  from atproto import Client

  client = Client()
  client.login('my-username', 'my-password')
  client.send_post(text='Hello World!')
  ```

  Useful links to continue:

  - [List of all methods with documentation](https://atproto.readthedocs.io/en/latest/atproto_client/index.html).
  - [Examples of using the methods](https://github.com/MarshalX/atproto/tree/main/examples).



  The SDK is built upon the following components:

  | Package            | Description                                                                 |
  |--------------------|-----------------------------------------------------------------------------|
  | `atproto`          | Import shortcuts to other packages.                                         |
  | `atproto_cli`      | CLI tool to generate code.                                                  |
  | `atproto_client`   | XRPC Client, data models, and utils like rich text helper.                  |
  | `atproto_codegen`  | Code generator of models, clients, and namespaces.                          |
  | `atproto_core`     | Tools to work with NSID, AT URI Schemes, CID, CAR files, and DID Documents. |
  | `atproto_crypto`   | Crypto utils like multibase, signature verification, work with DID keys.    |
  | `atproto_firehose` | Firehose (data streaming) client and models.                                |
  | `atproto_identity` | Identity resolvers for DID, Handle, AT Protocol data, signing keys.         |
  | `atproto_lexicon`  | Lexicon parser.                                                             |
  | `atproto_server`   | Server-side utils like JWT.                                                 |

  I highly recommend you to use the `atproto` package to import everything that you need.
  It contains shortcuts to all other packages.



  The documentation is live at [atproto.blue](https://atproto.blue/).



  You can get help in several ways:
  - Report bugs, request new features by [creating an issue](https://github.com/MarshalX/atproto/issues/new).
  - Ask questions by [starting a discussion](https://github.com/MarshalX/atproto/discussions/new).
  - Ask questions in [Discord server](https://discord.gg/PCyVJXU9jN).



  I'll be honest. The high-level Client that was shown in the "Quick Start" section is not a real ATProto API. This is syntax sugar built upon the real XRPC methods! The high-level methods are not cover the full need of developers. To be able to do anything that you want, you should know to work with low-level API. Let's dive into it!

  The basics:
  - Namespaces – classes that group sub-namespaces and the XRPC queries and procedures. Built upon NSID ATProto semantic.
  - Model – dataclasses for input, output, and params of the methods from namespaces. Models describe Record and all other types in the Lexicon Schemes.



  The client contains references to the root of all namespaces. It's `com` and `app` for now.

  ```python
  from atproto import Client

  Client().com
  Client().app
  ```

  To dive deeper, you can navigate using hints from your IDE. Thanks to well-type hinted SDK, it's much easier.

  ```python
  from atproto import Client

  Client().com.atproto.server.create_session(...)
  Client().com.atproto.sync.get_blob(...)
  Client().app.bsky.feed.get_likes(...)
  Client().app.bsky.graph.get_follows(...)
  ```

  The endpoint of the path is always the method that you want to call. The method presents a query or procedure in XRPC. You should not care about it much. The only thing you need to know is that the procedures required data objects. Queries could be called with or without params.



  In some sub-namespaces, you can find records. Such record classes provide a syntax sugar not defined in the lexicon scheme. This sugar provides a more convenient way to work with repository operations. Such as creating a record, deleting a record, and so on.

  Here are some available records of Bluesky records:

  ```python
  from atproto import Client

  Client().app.bsky.feed.post
  Client().app.bsky.feed.like
  Client().app.bsky.graph.follow
  Client().app.bsky.graph.block
  Client().app.bsky.actor.profile

  ```

  Usage example with the `post` record:

  ```python
  from atproto import AtUri, Client, models

  client = Client()
  client.login('my-username', 'my-password')

  posts = client.app.bsky.feed.post.list(client.me.did, limit=10)
  for uri, post in posts.records.items():
      print(uri, post.text)

  post = client.app.bsky.feed.post.get(client.me.did, AtUri.from_str(uri).rkey)
  print(post.value.text)

  post_record = models.AppBskyFeedPost.Record(text='test record namespaces', created_at=client.get_current_time_iso())
  new_post = client.app.bsky.feed.post.create(client.me.did, post_record)
  print(new_post)

  deleted_post = client.app.bsky.feed.post.delete(client.me.did, AtUri.from_str(new_post.uri).rkey)
  print(deleted_post)
  ```

  Please note that not all repository operations are covered by these syntax sugars. You can always use the low-level methods to perform any desired action. One such action is updating a record.



  To deal with methods, we need to deal with models! Models are available in the `models` module and have NSID-based aliases. Let's take a look at it.

  ```python
  from atproto import models

  models.ComAtprotoIdentityResolveHandle
  models.AppBskyFeedPost
  models.AppBskyActorGetProfile

  ```

  The model classes in the "models" aliases could be:

  - Data model
  - Params model
  - Response model
  - Sugar response model
  - Record model
  - Type model

  The only thing you need to know is how to create instances of models. Not with all models, you will work as model-creator. For example, SDK will create Response models for you.

  There are a few ways how to create the instance of a model:

  - Dict-based
  - Class-based

  The instances of data and params models should be passed as arguments to the methods that were described above.

  Dict-based:

  ```python
  from atproto import Client

  client = Client()
  client.login('my-username', 'my-password')

  print(client.com.atproto.identity.resolve_handle({'handle': 'marshal.dev'}))
  ```

  Class-based:

  ```python
  from atproto import Client, models

  client = Client()
  client.login('my-username', 'my-password')
  params = models.ComAtprotoIdentityResolveHandle.Params(handle='marshal.dev')
  print(client.com.atproto.identity.resolve_handle(params))
  ```

  Tip: look at typehint of the method to figure out the name and the path to the input/data model!

  Pro Tip: use IDE autocompletion to find necessary models! Just start typing the method name right after the dot (`models.{type method name in camel case`).

  Models could be nested as hell. Be ready for it!

  This is how we can send a post with the image using low-level XRPC Client:

  ```python
  from atproto import Client, models

  client = Client()
  client.login('my-username', 'my-password')

  with open('cat.jpg', 'rb') as f:
      img_data = f.read()

      upload = client.upload_blob(img_data)
      images = [models.AppBskyEmbedImages.Image(alt='Img alt', image=upload.blob)]
      embed = models.AppBskyEmbedImages.Main(images=images)

      client.com.atproto.repo.create_record(
          models.ComAtprotoRepoCreateRecord.Data(
              repo=client.me.did,
              collection=models.ids.AppBskyFeedPost,
              record=models.AppBskyFeedPost.Record(
                  created_at=client.get_current_time_iso(), text='Text of the post', embed=embed
              ),
          )
      )

      
      post = models.AppBskyFeedPost.Record(text='Text of the post', embed=embed, created_at=client.get_current_time_iso())
      client.app.bsky.feed.post.create(client.me.did, post)
      
      client.send_image(text='Text of the post', image=img_data, image_alt='Img alt')
      
  ```

  I hope you are not scared. May the Force be with you. Good luck!



  The full change log is available in [CHANGES.md](https://github.com/MarshalX/atproto/blob/main/CHANGES.md).



  Contributions of all sizes are welcome. The contribution guidelines will be presented later.



  MIT


pkgId: c2ded1f4d2a094d2fe2574cc2172d5fbddbe0b9cdd9923232b2322917cc05a6f
name: python-atptools
arch: src
version: 0.0.21
epoch: 0
release: 1
summary: Dataset manipulation tool.
url: https://pypi.org/project/atptools/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-atptools-0.0.21-1.src.rpm
checksum_type: sha256
description:
  Simple tools for data manipulation.



  - [GitHub](https://github.com/atp-things/pkgpy-atp-tools)
  - [PyPI](https://pypi.org/project/atptools/)





  ```bash
  pip install atptools
  ```

  ```bash
  pipenv install atptools
  ```


pkgId: 29e93994ba5dbe412ac239d706715698ffdbd647f5019a8cb7aef19ebd8a73f7
name: python-atqdm
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: Tqdm replacement for Comet / W&B reporting
url: https://github.com/skrbnv/atqdm
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-atqdm-0.0.7-1.src.rpm
checksum_type: sha256
description:
  Replaces progressbar with sequential output

  To use, replace
  `from tqdm import tqdm`
  with
  `from atqdm import tqdm`

  Supports two basic methods similar to tqdm:
  - set_descripion_str
  - set_postfix_str

  AS IS. I'm tired downloading 50Mb logs from Comet/W&B so I cooked this one.


pkgId: 87567c7e3b7bcaca648314572063d484ad01c9238771f33681270fc779834ff7
name: python-atqo
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Async Task Queue Orchestrator with Complex Resource Management
url: https://github.com/endremborza/atqo
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-atqo-0.4.1-1.src.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/atqo/badge/?version=latest)](https://atqo.readthedocs.io/en/latest)
  [![codeclimate](https://img.shields.io/codeclimate/maintainability/endremborza/atqo.svg)](https://codeclimate.com/github/endremborza/atqo)
  [![codecov](https://img.shields.io/codecov/c/github/endremborza/atqo)](https://codecov.io/gh/endremborza/atqo)
  [![pypi](https://img.shields.io/pypi/v/atqo.svg)](https://pypi.org/project/atqo/)

  Async Task Queue Orchestrator

  (task) properties can have arbitrary limits
  (actor) capabilities must have linear limits - based on (global) resources

  with
  - complex resource manager
  - flexible abstractions for schedulers, actors, resources and resource limits

  came from [aswan](https://github.com/endremborza/aswan), as part of [sscub](https://sscu-budapest.github.io/) ecosystem cleanup


pkgId: fc7b7a37df625b63b51a3f103e5f6d094fdd56a95237dcd359d213a9de2a258f
name: python-atr-dan
arch: src
version: 0.2.0rc11
epoch: 0
release: 1
summary: Teklia DAN
url: https://atr.pages.teklia/dan/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-atr-dan-0.2.0rc11-1.src.rpm
checksum_type: sha256
description:
  [![Python >= 3.10](https://img.shields.io/badge/Python-%3E%3D3.10-blue.svg)](https://www.python.org/downloads/release/python-3100/)

  For more details about this package, make sure to see the documentation available at <https://atr.pages.teklia.com/dan/>.

  This is an open-source project, licensed using [the CeCILL-C license](https://cecill.info/index.en.html).



  To apply DAN to an image, one needs to first add a few imports and to load an image. Note that the image should be in RGB.

  ```python
  import cv2
  from dan.ocr.predict.inference import DAN

  image = cv2.cvtColor(cv2.imread(IMAGE_PATH), cv2.COLOR_BGR2RGB)
  ```

  Then one can initialize and load the trained model with the parameters used during training. The directory passed as parameter should have:

  - a `model.pt` file,
  - a `charset.pkl` file,
  - a `parameters.yml` file corresponding to the `inference_parameters.yml` file generated during training.

  ```python
  from pathlib import Path

  model_path = Path("models")

  model = DAN("cpu")
  model.load(model_path, mode="eval")
  ```

  To run the inference on a GPU, one can replace `cpu` by the name of the GPU. In the end, one can run the prediction:

  ```python
  from pathlib import Path
  from dan.utils import parse_charset_pattern


  image_path = "images/page.jpg"
  _, image = dan_model.preprocess(str(image_path))

  input_tensor = image.unsqueeze(0)
  input_tensor = input_tensor.to("cpu")
  input_sizes = [image.shape[1:]]


  text, confidence_scores = model.predict(
      input_tensor,
      input_sizes,
      char_separators=parse_charset_pattern(dan_model.charset),
      confidences=True,
  )
  ```



  This package provides three subcommands. To get more information about any subcommand, use the `--help` option.



  See the [dedicated page](https://atr.pages.teklia.com/dan/get_started/training/) on the official DAN documentation.



  See the [dedicated page](https://atr.pages.teklia.com/dan/usage/datasets/extract/) on the official DAN documentation.



  See the [dedicated page](https://atr.pages.teklia.com/dan/usage/train/) on the official DAN documentation.



  See the [dedicated page](https://atr.pages.teklia.com/dan/usage/predict/) on the official DAN documentation.


pkgId: b50da56460ef207477340b23b6a618458d384bec998dfb923a6b8d471dab98b1
name: python-atrium
arch: src
version: 2.11.7
epoch: 0
release: 1
summary: MX API
url: https://atrium.mx.com
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-atrium-2.11.7-1.src.rpm
checksum_type: sha256
description:
      The MX Atrium API supports over 48,000 data connections to thousands of financial institutions. It provides secure access to your users&#39; accounts and transactions with industry-leading cleansing, categorization, and classification.  Atrium is designed according to resource-oriented REST architecture and responds with JSON bodies and HTTP response codes.  Use Atrium&#39;s development environment, vestibule.mx.com, to quickly get up and running. The development environment limits are 100 users, 25 members per user, and access to the top 15 institutions. Contact MX to purchase production access.   # noqa: E501


pkgId: 20670b087184d501fa581fa13edb687e2571626214361eb437601abe172eb27e
name: python-atriumsports-sdk
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Python module for integration to Atrium Sports APIs
url: https://pypi.org/project/atriumsports-sdk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-atriumsports-sdk-2.0.1-1.src.rpm
checksum_type: sha256
description:
  Python module to make use of the Atrium Sports Datacore API



  ```python
  from atriumsports import AtriumSports

  atrium = AtriumSports(
      {
          "sport": "basketball",
          "credential_id": "XXXXX",
          "credential_secret": "YYYY",
          "organizations": ["b1a23"],
      }
  )
  datacore = atrium.client("datacore")
  response = datacore.get("/o/b1a23/competitions", limit=500)
  for data in response.data():
      print(data)
  ```

  or using **openapi client**



  ```python
  from pprint import pprint

  from atriumsports import AtriumSports
  from atriumsports.datacore.openapi import CompetitionsApi

  atrium = AtriumSports(
      {
          "sport": "basketball",
          "credential_id": "XXXXX",
          "credential_secret": "YYYY",
          "organizations": ["b1a23"],
      }
  )
  datacore = atrium.client("datacore")

  with datacore as api_client:
      
      api_instance = CompetitionsApi(api_client)
      response = api_instance.competition_list(sport="basketball", organization_id="b1a23")

      pprint(response)
  ```



  ```python
  from atriumsports import AtriumSports
  from atriumsports.datacore.openapi import EntitiesApi
  from atriumsports.datacore.openapi import EntityPostBody
  from atriumsports.datacore.openapi import EntityPutBody

  atrium = AtriumSports(
      {
          "sport": "basketball",
          "credential_id": "XXXXX",
          "credential_secret": "YYYY",
          "organizations": ["b1a23"],
      }
  )
  datacore = atrium.client("datacore")
  with datacore as api_client:
      api_instance = EntitiesApi(api_client)

      response = api_instance.entity_insert(
          sport="basketball",
          organization_id="b1a23",
          entity_post_body=EntityPostBody(
              name_full_local="Test",
              status="INACTIVE",
          ),
      )

      entity_id = response.data[0].entity_id

      response = api_instance.entity_update(
          sport="basketball",
          organization_id="b1a23",
          entity_id=entity_id,
          entity_put_body=EntityPutBody(
              status="ACTIVE",
          ),
      )

      assert response.data[0].status == "ACTIVE"
  ```



  Response body is a pydantic object containing deserialized response data.

  Example:

  ```python
  from atriumsports import AtriumSports
  from atriumsports.datacore.openapi import LeaguesApi

  atrium = AtriumSports(
      {
          "sport": "basketball",
          "credential_id": "XXXXX",
          "credential_secret": "YYYY",
          "organizations": ["b1a23"],
      }
  )
  datacore = atrium.client("datacore")
  with datacore as api_client:
      api_instance = LeaguesApi(api_client)
      
      response = api_instance.league_list("b1a23", "basketball")
      print(response.data)
      print(response.data[0].region_type)
  ```



  ```python
  import time

  from atriumsports import AtriumSports

  atrium = AtriumSports(
      {
          "sport": "basketball",
          "credential_id": "XXXXX",
          "credential_secret": "YYYY",
          "environment": "sandpit",
      }
  )
  stream_api = atrium.client("datacore-stream")


  def on_connect_callback_function(client):
      """example callback when connected"""
      print("connected")


  def on_read_callback_function(client, topic, message):
      """example callback when message read"""
      print("{}: {}".format(topic, message))


  connected = stream_api.connect(
      {
          "fixture_id": "f71dfdd6-51f1-11ea-8889-22953e2ee7e2",  # fixture_id
          "scopes": ["write:stream_events", "read:stream_events"],  # Scopes
          "on_read": on_read_callback_function,
          "on_connect": on_connect_callback_function,
      }
  )
  if not connected:
      print(stream_api.error())
  else:
      stream_api.publish(
          "write:stream_events",
          {
              "type": "event",
              "data": {
                  "eventClass": "sport",
                  "eventId": "c2404cc0-9f75-11e8-98d0-529269fb1459",
                  "entityId": "c24048a6-9f75-11e8-98d0-529269fb1459",
                  "personId": "c2405b2a-9f75-11e8-98d0-529269fb1459",
                  "eventType": "2pt",
                  "subType": "jumpshot",
                  "clock": "PT08:23",
                  "shotClock": "PT12.3",
                  "periodId": 2,
                  "success": True,
                  "timestamp": "2018-08-14T16:45:34.34",
                  "clientId": "c2408302-9f75-11e8-98d0-529269fb1459",
                  "clientType": "TestApi:1.1.2",
              },
          },
          qos=1,  # QoS level 0=at most once, 1=at least once, 2=exactly once
      )
      time.sleep(40)

      stream_api.disconnect()
  ```

  For the available apis and models please check modules under `atriumsports.datacore.openapi`.

  Using your IDE, navigate to this module to see all details of the generated API classes.


pkgId: 6e77f53eed10912964df63bc9527079f1dc38b52f8070c09a6c6bf0bced53dfd
name: python-atro-args
arch: src
version: 0.7.15
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/atro-args/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-atro-args-0.7.15-1.src.rpm
checksum_type: sha256
description:
  <!--intro-start-->



  Python package that allows one to source arguments from command line arguments, environment variables, environment files and yaml files with overwritable prioritization and decent logging.



  ```bash
  pip install -U atro-args
  ```



  Suppose you want to obtain two variables `app_name` and `app_namespace` from cli inputs and environment variables. You can do the following:

  ```python
  from atro_args import Arg, InputArgs
  input_args = InputArgs(prefix="ATRO_TEST")
  input_args.add_arg(Arg(name="app_name", arg_type=str, help="App name", required=True))
  input_args.add_arg(Arg(name="app_namespace", arg_type=str, help="App name", required=True))

  model = input_args.get_dict()
  ```

  The following model will be a dictionary `dict` which will contain both `app_name` and `app_namespace` as keys with their respective values.

  <!--intro-end-->

  For more examples and more explanations please refer to the [documentation](https://atropos112.github.io/atro-args/)


pkgId: 2fcd66992860c6eaffb089f43c8e5f5a927af2c5656be6cdf70b9db2da3932e7
name: python-atro-pylog
arch: src
version: 0.4.0
epoch: 0
release: 1
url: https://pypi.org/project/atro-pylog/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-atro-pylog-0.4.0-1.src.rpm
checksum_type: sha256
summary:
  A simple logging library for Python. That either uses Loguru or OpenTelmetry collector (useful for local & cluster logging).


pkgId: 9750c1b322386d40ec96002b12794ec48ab55cb8baf669fcc6549a2e3e11b94c
name: python-ats-base
arch: src
version: 1.3.2
epoch: 0
release: 1
summary: Test Script Development Library
url: https://gitee.com/henry9000/ats_base
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ats-base-1.3.2-1.src.rpm
checksum_type: sha256
description:
  **1. 制作requirement.txt**

  pip freeze > requirement.txt

  **2. 打包**

  pip install --upgrade pip twine wheel setuptools

  python setup.py sdist bdist_wheel

  twine upload dist/*

  使用twine upload --skip-existing dist/* 来忽略已经存在的库

  **3. 安装更新插件**

  pip install --upgrade tsdl

  **4. 参数说明**

  package_dir:
  告诉Distutils哪些目录下的文件被映射到哪个源码包。一个例子：package_dir = {'': 'lib'}，表示“root package”中的模块都在lib目录中。


pkgId: 7642a98f042b32e5ecc7eb696c290197ef4e3ec726a706684d55e7db14e52286
name: python-ats-case
arch: src
version: 2.1.14
epoch: 0
release: 1
summary: Test Script Development Library
url: https://gitee.com/henry9000/ats_case
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ats-case-2.1.14-1.src.rpm
checksum_type: sha256
description:
  **1. 制作requirement.txt**

  pip freeze > requirement.txt

  **2. 打包**

  ****pip install --upgrade pip twine wheel setuptools

  python setup.py sdist bdist_wheel

  twine upload dist/*

  使用twine upload --skip-existing dist/* 来忽略已经存在的库

  **3. 安装更新插件**

  pip install --upgrade tsdl

  **4. 参数说明**

  package_dir:
  告诉Distutils哪些目录下的文件被映射到哪个源码包。一个例子：package_dir = {'': 'lib'}，表示“root package”中的模块都在lib目录中。


pkgId: 8f2de07c095c5a6c92445456deb9c5f070a0afde3f2d62a72c62f9d48b901128
name: python-atsd-client
arch: src
version: 3.0.6
epoch: 0
release: 1
summary: Axibase Time Series Database API Client for Python
url: https://github.com/axibase/atsd-api-python
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-atsd-client-3.0.6-1.src.rpm
checksum_type: sha256
description:
  The `ATSD API Client for Python <https://github.com/axibase/atsd-api-python>`__ simplifies the
  process of interacting with `Axibase Time Series Database <https://axibase.com/docs/atsd/>`__ through REST API and SQL
  endpoints.


pkgId: c56eda399ecb9884a6432a7585ee0ec6cfc7c54e2d4cc53687f934fa45806060
name: python-attackcti
arch: src
version: 0.4.4
epoch: 0
release: 1
summary: MITRE ATTACK CTI Python Libary
url: https://github.com/OTRF/ATTACK-Python-Client
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-attackcti-0.4.4-1.src.rpm
checksum_type: sha256
description:
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/OTRF/ATTACK-Python-Client/master)
  [![Open_Threat_Research Community](https://img.shields.io/badge/Open_Threat_Research-Community-brightgreen.svg)](https://twitter.com/OTR_Community)
  [![Open Source Love svg1](https://badges.frapsoft.com/os/v3/open-source.svg?v=103)](https://github.com/ellerbrock/open-source-badges/)
  [![Downloads](https://pepy.tech/badge/attackcti)](https://pepy.tech/project/attackcti)

  A Python module to access up-to-date ATT&CK content available in [STIX](https://oasis-open.github.io/cti-documentation/stix/intro) via a public [TAXII](https://oasis-open.github.io/cti-documentation/taxii/intro) server. This project leverages python classes and functions from the [cti-python-stix2](https://github.com/oasis-open/cti-python-stix2) and [cti-taxii-client](https://github.com/oasis-open/cti-taxii-client) libraries developed by MITRE.



  * Provide an easy way to access and interact with up-to-date ATT&CK content available in STIX via public TAXII server.
  * Allow security analysts to quickly explore ATT&CK content and apply it in their daily operations.
  * Allow the integration of ATT&CK content with other platforms to host up to date information from the framework.
  * Help security analysts during the transition from the old ATT&CK MediaWiki API to the STIX/TAXII 2.0 API.
  * Learn STIX2 and TAXII Client Python libraries







  The project is currently in a Production/Stable stage, which means that the current main functions are more stable. I would love to get your feedback to make it a better project.



  * [MITRE CTI](https://github.com/mitre/cti)
  * [OASIS CTI TAXII Client](https://github.com/oasis-open/cti-taxii-client)
  * [OASIS CTI Python STIX2](https://github.com/oasis-open/cti-python-stix2)
  * [MITRE ATT&CK Framework](https://attack.mitre.org/wiki/Main_Page)
  * [ATT&CK MediaWiki API](https://attack.mitre.org/wiki/Using_the_API)
  * [Invoke-ATTACKAPI](https://github.com/Cyb3rWard0g/Invoke-ATTACKAPI)
  * [Mitre-Attack-API](https://github.com/annamcabee/Mitre-Attack-API)



  - Python >= 3.0
  - stix2 >= 2.1.0
  - taxii2-client >= 2.3.0
  - six >= 1.16.0
  - pydantic



  You can install it via pip:

  ```
  pip install attackcti
  ```

  Or you can also do the following:

  ```
  git clone https://github.com/OTRF/ATTACK-Python-Client
  cd ATTACK-Python-Client
  pip install .
  ```



  * Now that the project is more stable, It would be great to get your feedback and hopefully get more contributions to the project. Let us know if you have any features in mind. We would love to collaborate to make them happen in the project.
  * Check our basic contribution guidelines and submit an issue with your ideas.
  * Be concise but clear when adding a title and description to your feature proposal.
  * One pull request per issue.
  * Select one or more labels when you submit an issue.
  * Make sure you are in the correct branch [Master].
  * Try to avoid sizeable changes unless warranted.
  * Be patient and polite as the project is still relatively small, which is why we would appreciate your help where possible.



  * Roberto Rodriguez [@Cyb3rWard0g](https://twitter.com/Cyb3rWard0g)



  * Jose Luis Rodriguez [@Cyb3rPandaH](https://twitter.com/Cyb3rPandaH)


pkgId: a18a5a2628d7894e5e1fa51e407021a04cc7642c83a62c61bd2a7dd9491c6fd1
name: python-attackmate
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: AttackMate is an attack orchestration tool that executes full attack-chains based on playbooks.
url: https://pypi.org/project/attackmate/
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-attackmate-0.4.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://aecidjenkins.ait.ac.at/buildStatus/icon?job=AECID%2FAECID%2Fattackmate%2Fmain)]( "https://aecidjenkins.ait.ac.at/job/AECID/job/AECID/job/attackmate/job/main/")
  AttackMate is a tool to automate cyber attack scenarios that supports scripting of attack techniques across all phases of the Cyber Kill Chain. AttackMate's design principles aim to integrate with penetration testing and attack emulation frameworks such as Metasploit and Sliver Framework and enables simple execution of commands via shell or ssh. For example, AttackMate enables to execute Metasploit modules or generate payloads and run commands in Metasploit sessions. Moreover, it is able to generate Sliver implants, automatize Sliver to send C2 commands, and configure and compile LD_PRELOAD-rootkits. AttackMate also offers a simple interface to automate shell or ssh interaction, run commands in background mode, transfer files via sftp, and start http clients or servers. All attack steps may be scheduled, chained, and repeatedly executed using a simple configuration file that supports variable declarations and conditional workflows.
  ![AttackMate Schema](docs/source/images/attackmate-schema.png "AttackMate Schema")

  * python >= 3.10
  * libmagic

  Manually:
  ```
  $ git clone https://github.com/ait-aecid/attackmate.git
  $ cd attackmate
  $ pip3 install .
  ```
  Using pip:
  ```
  $ pip3 install attackmate
  ```

  ```
  $ attackmate playbook.yml
  ```
  ![AttackMate Demo](docs/source/images/Demo.gif "AttackMate Demo")

  Please take a look at our documentation for how to install and use attackmate:
  * [Installation](https://aeciddocs.ait.ac.at/attackmate/current/installation/index.html)
  * [Documentation](https://aeciddocs.ait.ac.at/attackmate/current)
  * [Command Reference](https://aeciddocs.ait.ac.at/attackmate/current/playbook/commands/index.html)
  * [Example Playbooks](https://aeciddocs.ait.ac.at/attackmate/current/playbook/examples.html)

  AttackMate is purely for educational and academic purposes. The software is provided "as is"
  and the authors are not responsible for any damage or mishaps that may occur during its use.
  Do not attempt to use AttackMate to violate the law. Misuse of the provided software and
  information may result in criminal charges.

  AttackMate should only be executed against own test or training systems.
  For this reason, every software bug is treated equally, regardless of
  whether it is security relevant or not.
  *Please note that AttackMate could easily be executed in a dangerous way. For example, by
  parsing the RESULT_STDOUT of a malicious server. The server response could lead to
  a command injection. Keep that in mind!

  [GPL-3.0](LICENSE)


pkgId: e9dfafb80cd64bb2fbb561f3b735028dae48005071a4d6a5cc373c79a1da28d0
name: python-attacut
arch: src
version: 1.0.6
epoch: 0
release: 1
summary: Fast and Reasonably Accurate Word Tokenizer for Thai
url: https://github.com/PyThaiNLP/attacut
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-attacut-1.0.6-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/PyThaiNLP/attacut.svg?branch=master)](https://travis-ci.org/PyThaiNLP/attacut)
  [![Build status](https://ci.appveyor.com/api/projects/status/ittfnb2pyg95kpxk/branch/master?svg=true)](https://ci.appveyor.com/project/wannaphongcom/attacut/branch/master)
  [![](https://img.shields.io/badge/-presentation-informational)](https://drive.google.com/file/d/16AUNZv1HXVmERgryfBf4JpCo1QrQyHHE/view?usp=sharing)
  [![](http://img.shields.io/badge/arXiv-1911.07056-yellow.svg?style=flat)](https://arxiv.org/abs/1911.07056)



  <div align="center">
      <img src="https://i.imgur.com/8yMq7IB.png" width="700px"/>
      <br/>
      <b>TL;DR:</b>
  3-Layer Dilated CNN on syllable and character features. It’s <b>6x faster</b> than DeepCut (SOTA) while its WL-f1 on BEST is <b>91%</b>, only 2% lower.
  </div>



  ```
  $ pip install attacut
  ```

  **Remarks:** Windows users need to install **PyTorch** before the command above.
  Please consult [PyTorch.org](https://pytorch.org) for more details.





  ```
  $ attacut-cli -h
  AttaCut: Fast and Reasonably Accurate Word Tokenizer for Thai

  Usage:
    attacut-cli <src> [--dest=<dest>] [--model=<model>]
    attacut-cli [-v | --version]
    attacut-cli [-h | --help]

  Arguments:
    <src>             Path to input text file to be tokenized

  Options:
    -h --help         Show this screen.
    --model=<model>   Model to be used [default: attacut-sc].
    --dest=<dest>     If not specified, it'll be <src>-tokenized-by-<model>.txt
    -v --version      Show version
  ```


  ```
  from attacut import tokenize, Tokenizer


  words = tokenize(txt)



  atta = Tokenizer(model="attacut-sc")
  words = atta.tokenize(txt)
  ```



  Belows are brief summaries. More details can be found on [our benchmarking page](https://pythainlp.github.io/attacut/benchmark.html).



  ![](https://pythainlp.github.io/attacut/_images/quality-benchmark-in-of-domain.png)


  ![](https://pythainlp.github.io/attacut/_images/speed-benchmark-ec2.png)



  Please refer to [our retraining page](https://pythainlp.github.io/attacut/)


  - [Tokenization Visualization][tovis]
  - [Thai Tokenizer Dockers][docker]


  This repository was initially done by [Pattarawat Chormai][pat], while interning at [Dr. Attapol Thamrongrattanarit's NLP Lab][ate], Chulalongkorn University, Bangkok, Thailand.
  Many people have involed in this project. Complete list of names can be found on [Acknowledgement](https://pythainlp.github.io/attacut/acknowledgement.html).


  [pat]: http://pat.chormai.org
  [ate]: https://attapol.github.io/lab.html
  [noom]: https://github.com/Ekkalak-T
  [can]: https://github.com/c4n
  [ake]: https://github.com/ekapolc
  [tovis]: https://pythainlp.github.io/tokenization-benchmark-visualization/
  [docker]: https://github.com/PyThaiNLP/docker-thai-tokenizers


pkgId: bed059257de44837ec446ff3da55ce7ce59bb97dbe401d5137eb9e2dc0c5da8a
name: python-attendance-tracker-email
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Attendance tracker package using emails
url: https://pypi.org/project/attendance-tracker-email/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-attendance-tracker-email-0.1.5-1.src.rpm
checksum_type: sha256
description:
  ```day1.txt
  first2emai@outlook.com
  second12email@gmail.com
  ```

  ```
  from attendance_tracker_email import attended
  ```
  Directory with emails as day1.txt, day2.txt etc
  ```
  directory = 'email_files'
  print( attended.show_attended(directory))
  ```

  - [X] Published for easy plug n play
  - [ ] #739 Create a chrome extension for the frontend
  - [ ] Authentication to take attendance automatically
  - [ ] Track time attended
  - [ ] Add more features

  a)  [Open an issue](https://github.com/morehwachege/attendance-tracker-email/issues)
  b) [Star this for the future](https://github.com/morehwachege/attendance-tracker-email/fork)

  MIT
  Contributions are welcome. Pull requests are welcome.


pkgId: 74cb2dea5b814d58ea8f46b4f68b325a928caba8d1d0c5d477aa49530b2aa91d
name: python-attention
arch: src
version: 5.0.0
epoch: 0
release: 1
summary: Keras Attention Layer
url: https://pypi.org/project/attention/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-attention-5.0.0-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](https://pepy.tech/badge/attention)](https://pepy.tech/project/attention)
  [![Downloads](https://pepy.tech/badge/attention/month)](https://pepy.tech/project/attention)
  [![license](https://img.shields.io/badge/License-Apache_2.0-brightgreen.svg)](https://github.com/philipperemy/keras-attention-mechanism/blob/master/LICENSE) [![dep1](https://img.shields.io/badge/Tensorflow-2.0+-brightgreen.svg)](https://www.tensorflow.org/)
  ![Simple Keras Attention CI](https://github.com/philipperemy/keras-attention-mechanism/workflows/Simple%20Keras%20Attention%20CI/badge.svg)

  Many-to-one attention mechanism for Keras.

  <p align="center">
    <img src="examples/equations.png" width="600">
  </p>




  *PyPI*

  ```bash
  pip install attention
  ```



  ```python
  import numpy as np
  from tensorflow.keras import Input
  from tensorflow.keras.layers import Dense, LSTM
  from tensorflow.keras.models import load_model, Model

  from attention import Attention


  def main():
      
      num_samples, time_steps, input_dim, output_dim = 100, 10, 1, 1
      data_x = np.random.uniform(size=(num_samples, time_steps, input_dim))
      data_y = np.random.uniform(size=(num_samples, output_dim))

      
      model_input = Input(shape=(time_steps, input_dim))
      x = LSTM(64, return_sequences=True)(model_input)
      x = Attention(units=32)(x)
      x = Dense(1)(x)
      model = Model(model_input, x)
      model.compile(loss='mae', optimizer='adam')
      model.summary()

      
      model.fit(data_x, data_y, epochs=10)

      
      pred1 = model.predict(data_x)
      model.save('test_model.h5')
      model_h5 = load_model('test_model.h5', custom_objects={'Attention': Attention})
      pred2 = model_h5.predict(data_x)
      np.testing.assert_almost_equal(pred1, pred2)
      print('Success.')


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



  Browse [examples](examples).

  Install the requirements before running the examples: `pip install -r examples/examples-requirements.txt`.




  In this experiment, we demonstrate that using attention yields a higher accuracy on the IMDB dataset. We consider two
  LSTM networks: one with this attention layer and the other one with a fully connected layer. Both have the same number
  of parameters for a fair comparison (250K).

  Here are the results on 10 runs. For every run, we record the max accuracy on the test set for 10 epochs.


  | Measure  | No Attention (250K params) | Attention (250K params) |
  | ------------- | ------------- | ------------- |
  | MAX Accuracy | 88.22 | 88.76 |
  | AVG Accuracy | 87.02 | 87.62 |
  | STDDEV Accuracy | 0.18 | 0.14 |

  As expected, there is a boost in accuracy for the model with attention. It also reduces the variability between the runs, which is something nice to have.




  Let's consider the task of adding two numbers that come right after some delimiters (0 in this case):

  `x = [1, 2, 3, 0, 4, 5, 6, 0, 7, 8]`. Result is `y = 4 + 7 = 11`.

  The attention is expected to be the highest after the delimiters. An overview of the training is shown below, where the
  top represents the attention map and the bottom the ground truth. As the training  progresses, the model learns the
  task and the attention map converges to the ground truth.

  <p align="center">
    <img src="examples/attention.gif" width="320">
  </p>



  We consider many 1D sequences of the same length. The task is to find the maximum of each sequence.

  We give the full sequence processed by the RNN layer to the attention layer. We expect the attention layer to focus on the maximum of each sequence.

  After a few epochs, the attention layer converges perfectly to what we expected.

  <p align="center">
    <img src="examples/readme/example.png" width="320">
  </p>



  - https://www.cs.cmu.edu/~./hovy/papers/16HLT-hierarchical-attention-networks.pdf
  - https://arxiv.org/abs/1508.04025
  - https://arxiv.org/abs/1409.0473


pkgId: 2e8ac54f8d14f598997e810efbef56ac70f2894ec4089854c101e3295e4f44a7
name: python-attentionme
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A library for person-focused image processing
url: https://github.com/Looking-4-Attention/AttentionMe
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-attentionme-0.1.1-1.src.rpm
checksum_type: sha256
description:
  - [Background](#background)
  - [Features](#features)
  - [Installation](#installation)
  - [Usage](#usage)
  - [Modules](#modules)
  - [Maintainer](#maintainer)
  - [Contributing](#contributing)


pkgId: 12f8ec671b322b24adce0269d307c34672baddb7f245e02771e558328d114627
name: python-attmap
arch: src
version: 0.13.2
epoch: 0
release: 1
summary: Multiple access patterns for key-value reference
url: https://github.com/pepkit/attmap/
rpm_license: BSD2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-attmap-0.13.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/pepkit/attmap.svg?branch=master)](https://travis-ci.org/pepkit/attmap)
  [![Coverage Status](https://coveralls.io/repos/github/pepkit/attmap/badge.svg?branch=master)](https://coveralls.io/github/pepkit/attmap?branch=master)

  Key-value Mapping supporting nesting and attribute-style access

  Originally motivated by and designed for the [pepkit family projects](https://pepkit.github.io/).


pkgId: 2ae72023671b84329ea42083896c90859a3b15de4996bfd63e8b8084835b7acb
name: python-attr
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Simple decorator to set attributes of target function or class in a DRY way.
url: https://github.com/denis-ryzhkov/attr
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-attr-0.3.2-1.src.rpm
checksum_type: sha256
description:
  Usage example::

      
      def my_calculated_field(...
      my_calculated_field.short_description = 'Field'
      my_calculated_field.admin_order_field = 'real_field'

      
      @attr(short_description='Field', admin_order_field='real_field')
      def my_calculated_field(...

  Get it::

      sudo pip install attr
      from attr import attr

  New popular `attrs.org <http://attrs.org>`_ used by `pytest.org <https://pytest.org>`_ defines another "attr" package that shadows this "attr" module.

  Please use "dry_attr" alias to unshadow it::

      from dry_attr import attr
      from dry_attr import dry_attr


pkgId: 12f2e1f220e0955ab76dd4c00e23c49985e399663a56f332c2401504b27089e6
name: python-attrbox
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Attribute-based data structures.
url: https://github.com/metaist/attrbox
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-attrbox-0.1.5-1.src.rpm
checksum_type: sha256
description:
  _Attribute-based data structures._

  [![Build Status](https://img.shields.io/github/actions/workflow/status/metaist/attrbox/.github/workflows/ci.yaml?branch=main&style=for-the-badge)](https://github.com/metaist/attrbox/actions)
  [![attrbox on PyPI](https://img.shields.io/pypi/v/attrbox.svg?color=blue&style=for-the-badge)](https://pypi.org/project/attrbox)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/attrbox?style=for-the-badge)](https://pypi.org/project/attrbox)

  [Changelog] - [Issues] - [Documentation]

  [changelog]: https://github.com/metaist/attrbox/blob/main/CHANGELOG.md
  [issues]: https://github.com/metaist/attrbox/issues
  [documentation]: https://metaist.github.io/attrbox/



  I have common use cases where I want to improve python's `dict` and `list`:

  - [`AttrDict`](#attrdict): attribute-based `dict` with better merge and deep value access
  - [`AttrList`](#attrlist): `list` that broadcasts operations to its members
  - [Environment](#environment): reading environment files
  - [Configuration](#configuration): loading command-line arguments and configuration files
  - [`JSend`](#jsend): sending JSON responses



  ```bash
  python -m pip install attrbox
  ```



  `AttrDict` features:

  - **Attribute Syntax** for `dict` similar to [accessing properties in JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Working_with_objects#accessing_properties): `thing.prop` means `thing["prop"]` for get / set / delete.

  - **No `KeyError`**: if a key is missing, just return `None` (like `dict.get()`).

  - **Deep Indexing**: use a list of keys and `int` to get and set deeply nested values. This is similar to [lodash.get](https://lodash.com/docs/#get) except that only the array-like syntax is supported and you must use actual `int` to index across `list` objects.

  - **Deep Merge**: combine two `dict` objects by extending deeply-nested keys where possible. This is different than the new `dict` union operator ([PEP 584](https://peps.python.org/pep-0584/)).

  ```python
  from attrbox import AttrDict

  items = AttrDict(a=1, b=[{"c": {"d": 5}}], e={"f": {"g": 7}})
  items.a

  items.x is None

  items.x = 10
  items['x']

  items.get(["b", 0, "c", "d"])

  items <<= {"e": {"f": {"g": 20, "h": [30, 40]}}}
  items.e.f.g

  items[['e', 'f', 'h', 1]]

  ```

  [Read more about `AttrDict`](https://metaist.github.io/attrbox/attrdict.html#attrbox.attrdict.AttrDict)



  `AttrList` provides **member broadcast**: performing operations on the list performs the operation on all the items in the list. I typically use this to achieve the [Composite design pattern](https://en.wikipedia.org/wiki/Composite_pattern).

  ```python
  from attrbox import AttrDict, AttrList

  numbers = AttrList([complex(1, 2), complex(3, 4), complex(5, 6)])
  numbers.real


  words = AttrList(["Apple", "Bat", "Cat"])
  words.lower()


  items = AttrList([AttrDict(a=1, b=2), AttrDict(a=5)])
  items.a

  items.b

  ```

  [Read more about `AttrList`](https://metaist.github.io/attrbox/attrlist.html#attrbox.attrlist.AttrList)



  `attrbox.env` is similar to [python-dotenv](https://github.com/theskumar/python-dotenv), but uses the `AttrDict` ability to do deep indexing to allow for things like dotted variable names. Typically, you'll use it by calling `attrbox.load_env()` which will find the nearest <code>.env</code> file and load it into `os.environ`.

  [Read more about `attrbox.env`](https://metaist.github.io/attrbox/env.html)



  `attrbox` supports loading configuration files from `.json`, `.toml`, and `.env` files. By default, `load_config()` looks for a key `imports` and will recursively import those files (relative to the current file) before loading the rest of the current file (data is merged using `AttrDict`). This allows you to create templates or smaller configurations that build up to a larger configuration.

  For CLI applications, `attrbox.parse_docopt()` let's you use the power of [`docopt`](https://github.com/docopt/docopt) with the flexibility of `AttrDict`. By default, `--config` and `<config>` arguments will load the file using the `load_config()`

  ```python
  """Usage: prog.py [--help] [--version] [-c CONFIG] --file FILE

  Options:
    --help                show this message and exit
    --version             show the version number and exit
    -c, --config CONFIG   load this configuration file (supported: .toml, .json, .env)
    --file FILE           the file to process
  """

  def main():
      args = parse_docopt(__doc__, version=__version__)
      args.file # has the value of --file

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

  Building on top of `docopt` we strip off leading dashes and convert them to underscores so that we can access the arguments as `AttrDict` attributes.

  [Read more about `attrbox.config`](https://metaist.github.io/attrbox/config.html)



  `JSend` is an approximate implementation of the [`JSend` specification](https://labs.omniti.com/labs/jsend) that makes it easy to create standard JSON responses. The main difference is that I added an `ok` attribute to make it easy to tell if there was a problem (`fail` or `error`).

  ```python
  from attrbox import JSend

  def some_function(arg1):
      result = JSend() # default is "success"

      if not is_good(arg1):
          
          return result.fail(message="You gone messed up.")

      try:
          result.success(data=process(arg1))
      except Exception:
          
          return result.error(message="We have a problem.")

      return result
  ```

  Because the `JSend` object is an `AttrDict`, it acts like a `dict` in every other respect (e.g., it is JSON-serializable).

  [Read more about `JSend`](https://metaist.github.io/attrbox/jsend.html#attrbox.jsend.JSend)



  [MIT License](https://github.com/metaist/attrbox/blob/main/LICENSE.md)


pkgId: e730b8ecb520dd97e59768fffdfb66878075fe318a038ebd12801346fad89045
name: python-attrdictionary
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: A dict with attribute-style access
url: https://github.com/kiselas/AttrDictionary
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-attrdictionary-1.0.0-1.src.rpm
checksum_type: sha256
description:
  AttrDictionary is an MIT-licensed library that provides mapping objects that allow their elements to be accessed both as keys and as attributes. It originates from a fork of AttrDict which is sadly no longer maintained. AttrDictionary fully compatible with AttrDict except support for Python 2 versions. This version was tested on Python 3.11:


pkgId: 2eb60a6366514b44e2b3a469ca6b1a67c53dfc5bff93fa57f0e4713ae3a9493d
name: python-attribute
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Attribute management made easy
url: https://github.com/tombulled/attribute
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-attribute-0.1.4-1.src.rpm
checksum_type: sha256
description:
  Attribute management made easy


  ```console
  pip install git+https://github.com/tombulled/attribute@main
  ```


  ```python
  >>> import attribute
  >>>
  >>> def foo(): pass
  >>>
  >>> name = attribute.Attribute('__name__')
  >>>
  >>> name.get(foo)
  'foo'
  ```


pkgId: 0f097a4ed77fe71c66a7dee230d74f22fe2aaaf356650a00cd0f026cccf5f5fe
name: python-attributedict
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: A dictionary object with attributes support.
url: https://github.com/grimen/python-attributedict
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-attributedict-0.3.0-1.src.rpm
checksum_type: sha256
description:
  *A dictionary object with attributes support.*




  Install using **pip**:

  ```sh
  $ pip install attributedict
  ```




  Example:

  ```python
  from attributedict.collections import AttributeDict

  data = AttributeDict({'foo': {'bar': [1, 2, 3]}})

  data.foo # => `{'bar': [1, 2, 3]}}`
  data.foo.bar # => `[1, 2, 3]`

  data.foo = {'baz': True}
  data.foo = # => `{'baz': True}`

  del data.foo.baz



  data = AttributeDict({'foo': {'bar': [1, 2, 3]}})

  data['foo'] # => `{'bar': [1, 2, 3]}}`
  data['foo']['bar'] # => `[1, 2, 3]`

  data['foo'] = {'baz': True}
  data['foo'] = # => `{'baz': True}`

  del data['foo']['baz']



  isinstance(data, dict) # => True
  isinstance(data, attributedict.collections.AttributeDict) # => True

  isinstance(data.__dict__, dict) # => True
  isinstance(data.__dict__, attributedict.collections.AttributeDict) # => False



  data = AttributeDict({'foo': {'bar': [1, 2, 3]}})

  json.dumps(data) # => `{"foo": {"bar": [1, 2, 3]}}`
  json.dumps(data.__dict__) # => `{"foo": {"bar": [1, 2, 3]}}`



  ```




  Clone down source code and run:

  ```sh
  $ make install
  $ make test
  ```




  Released under the MIT license.


pkgId: 378ea355349dd3d48671debca1d1af7ad9f100bdd6029ed9ae1db28f252901f5
name: python-attributes-doc
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: PEP 224 implementation
url: https://github.com/tkukushkin/attributes-doc
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-attributes-doc-0.4.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/attributes-doc.svg)](https://pypi.org/project/attributes-doc/)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/attributes-doc.svg?color=green)
  [![Build Status](https://github.com/tkukushkin/attributes-doc/workflows/build/badge.svg?branch=master)](https://github.com/tkukushkin/attributes-doc/actions?query=workflow%3Abuild+branch%3Amaster)
  [![codecov](https://codecov.io/gh/tkukushkin/attributes-doc/branch/master/graph/badge.svg)](https://codecov.io/gh/tkukushkin/attributes-doc)


  Hacky implementation of [PEP 224](https://www.python.org/dev/peps/pep-0224/).



  This package provides the following functions:
  - `attributes_doc`
  - `get_attributes_doc`
  - `enum_doc`
  - `get_doc`



  This function is a class decorator, and using it on a class will set class attributes called `__doc_ATTRNAME__` for each existing attribute.

  ```py
  from attributes_doc import attributes_doc

  @attributes_doc
  class Foo:
      bar = 1
      """This is the docstring for the bar attribute.

      It will be stored in `Foo.__doc_bar__` and will be accessible at runtime.
      """

      baz = 2
      """This is the docstring for the baz attribute."""


  print(Foo.__doc_bar__)
  print(getattr(Foo, "__doc_baz__"))
  ```



  This function will return a dictionary with the docstrings for all attributes of a class without setting them.

  ```py
  from attributes_doc import get_attributes_doc

  class Goo:
      """This class doesn't use attributes_doc and we don't want to modify it at all."""
      bar = 1
      """This is the docstring for the bar attribute."""
      baz = 2
      """This is the docstring for the baz attribute."""

  docs = get_attributes_doc(Goo)
  print(docs["bar"])
  print(docs["baz"])
  ```



  This is also a class decorator, but it is intended for Enum classes. Instead of setting one doc attribute per attribute to the containing class, it will set the `__doc__` attribute for each enum value.

  ```py
  from attributes_doc import enum_doc
  from enum import Enum

  @enum_doc
  class Foo(Enum):
      bar = 1
      """This is the docstring for the bar attribute."""
      baz = 2
      """This is the docstring for the baz attribute."""

  print(Foo.bar.__doc__)
  ```



  This function will return the docstring of an attribute of a class.

  ```py
  from attributes_doc import get_doc

  print(get_doc(Foo, "baz")) # Instead of getattr(Foo, "__doc_baz__") above
  ```


pkgId: 76491044baaeb7d94c4ce5cebae4521fd111eb3564e9eadbbf3ae7bdef23e062
name: python-attributes-serializer
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Module to interact with marketplaces
url: https://pypi.org/project/attributes-serializer/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-attributes-serializer-1.0.1-1.src.rpm
checksum_type: sha256
description:
  Package to interact with marketplaces.




  ```bash
  pip install attributes_serializer
  ```


  ```bash
  poetry add attributes_serializer
  ```



  ```python
  from attributes_serializer import SalePrices

  sale_prices = SalePrices(colletor_product['sale_prices'])


  print(sale_prices.attributes)

  entry = sale_prices.manualMinPriceOzon
  print(entry.name)
  print(entry.value)
  print(entry.id)

  for attribute in sale_prices.attributes:
      print(getattr(sale_prices, attribute))


  entry = sale_prices.get("manualMinPriceOzon")
  print(entry.name)
  print(entry.value)
  print(entry.id)

  for attribute in sale_prices.attributes:
      print(sale_prices.get(attribute))

  ```


pkgId: 15c3025433cd8085bd9e3675e9d110f443f40759d5a83da7c0fee551fa0f4546
name: python-attribution
arch: src
version: 1.8.0
epoch: 0
release: 1
summary: Generate changelogs based on tag messages and shortlogs
url: https://pypi.org/project/attribution/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-attribution-1.8.0-1.src.rpm
checksum_type: sha256
description:
  Automate releases and changelogs based on commit tags and shortlogs.
  attribution provides a simple tool for automating a basic release workflow
  for Python projects. At its core, it generates Markdown-formatted changelogs
  based on the version tags in your repository, and can both fit into existing
  workflows, or automate the entire release preparation process with a single
  command.
  When generating a changelog, attribution will find all tag names starting with
  "v" followed by a valid `PEP 440 version identifier`_. It will then use the
  message from each tag, combined with the "shortlog", to generate an ordered
  changelog that includes recognition for all contributers to your project.
  The output can be saved to your preferred changelog file, or piped to other
  tools as part of your release workflow:
      $ attribution generate


pkgId: 983545b7c4be3fffd5ceeb49c6b265e8e041be75d0d8f4721dbd396fef337043
name: python-attribuutit
arch: src
version: 2022.8.1
epoch: 0
release: 1
summary: Nodes, Edges, Faces, and Attributes (Finnish: "Solmut, reunat, pinnat ja attribuutit").
url: https://git.sr.ht/~sthagen/attribuutit
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-attribuutit-2022.8.1-1.src.rpm
checksum_type: sha256
description:
  Nodes, Edges, Faces, and Attributes (Finnish: "Solmut, reunat, pinnat ja attribuutit").

  [License: MIT](https://git.sr.ht/~sthagen/attribuutit/tree/default/item/LICENSE)

  [![version](https://img.shields.io/pypi/v/attribuutit.svg?style=flat)](https://pypi.python.org/pypi/attribuutit/)
  [![downloads](https://pepy.tech/badge/attribuutit/month)](https://pepy.tech/project/attribuutit)
  [![wheel](https://img.shields.io/pypi/wheel/attribuutit.svg?style=flat)](https://pypi.python.org/pypi/attribuutit/)
  [![supported-versions](https://img.shields.io/pypi/pyversions/attribuutit.svg?style=flat)](https://pypi.python.org/pypi/attribuutit/)
  [![supported-implementations](https://img.shields.io/pypi/implementation/attribuutit.svg?style=flat)](https://pypi.python.org/pypi/attribuutit/)



  User and developer [documentation of attribuutit](https://codes.dilettant.life/docs/attribuutit).



  Feature requests and bug reports are bested entered in the [todos of attribuutit](https://todo.sr.ht/~sthagen/attribuutit).



  The primary source repository of [attribuutit is at sourcehut](https://git.sr.ht/~sthagen/attribuutit)
  a collection of tools useful for software development.



  Experimental.

  **Note** The default branch is `default`.


pkgId: 4dbea2331b2d8217f3000f910791c3e78a59882763ea8bdbaf4d326f97e1075e
name: python-attridict
arch: src
version: 0.0.9
epoch: 0
release: 1
summary: A dict implementation with support for easy and clean access of its values through attributes
url: https://github.com/alvinshaita/attridict
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-attridict-0.0.9-1.src.rpm
checksum_type: sha256
description:
  ![Build Status](https://github.com/alvinshaita/attridict/actions/workflows/attridict.yml/badge.svg?branch=main)
  ![GitHub](https://img.shields.io/github/license/alvinshaita/attridict.svg)


  A Python package implementing atrribute dictionary.

  This provides an easier and cleaner way to access dict values using their keys as attributes. It is typically a dict child, maintaining all the dict functionalities, but including some extra features.




  To install the package from PyPI, use:
  ```
  pip install attridict
  ```






  Creating an attridict object
  ```python
  >>> import attridict
  >>> att = attridict()
  >>> att
  {}
  >>> att.foo = "bar"
  >>> att.foo
  'bar'
  >>> att
  {'foo': 'bar'}
  ```
  <br/>

  A dict can be converted into an attridict object by passing it as an argument
  ```python
  >>> import attridict

  >>> data = {'red': 'hot', 'blue': 'cold'}

  >>> colors = attridict(data)
  >>> colors
  {'red': 'hot', 'blue': 'cold'}

  >>> colors.red
  'hot'
  ```
  <br/>

  Modifying attridict object
  ```python
  >>> import attridict

  >>> data = {'red': 'hot', 'blue': 'cold'}

  >>> colors = attridict(data)
  >>> colors
  {'red': 'hot', 'blue': 'cold'}

  >>> colors.blue
  'cold'

  >>> colors.blue = "sky"
  >>> colors.red = "rose"
  >>> colors.blue
  'sky'
  >>> colors.red
  'rose'
  >>> colors
  {'red': 'rose', 'blue': 'sky'}

  >>> colors.green = "grass"
  >>> colors
  {'red': 'rose', 'blue': 'sky', 'green': 'grass'}
  ```
  <br/>

  Typical `dict` operations work on attridict objects
  ```python
  >>> import attridict

  >>> data = {'red': 'rose', 'blue': 'sky'}

  >>> colors = attridict(data)
  >>> colors
  {'red': 'rose', 'blue': 'sky'}

  >>> colors.red
  'rose'
  >>> colors["red"]
  'rose'

  >>> colors["red"] = "tomato"
  >>> colors["red"]
  'tomato'
  >>> colors.red
  'tomato'
  ```
  <br/>

  Nested attribute access
  ```python
  >>> import attridict

  >>> data = {'foo': {}}
  >>> att = attridict(data)

  >>> att
  {'foo': {}}

  >>> att.foo.bar = 'baz'

  >>> att.foo.bar
  'baz'

  >>> att
  {'foo': {'bar': 'baz'}}
  ```
  <br/>

  YAML serializable
  ```python
  >>> import attridict
  >>> import yaml

  >>> data = {'foo': {'bar': 'baz'}}

  >>> att = attridict(data)

  >>> yaml.dump(att)
  '!attridict\nfoo:\n  bar: baz\n'

  >>> yaml.safe_dump(att)
  'foo:\n  bar: baz\n'
  ```

  The project is MIT licensed


pkgId: 64876c121cf581870f679150a30e7e0d9d18ab6a2c776ebce981edb1d783caa4
name: python-attrify
arch: src
version: 3.0
epoch: 0
release: 1
summary: Convert dict to access dict keys as attributes.
url: https://github.com/DragSama/attrify
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-attrify-3.0-1.src.rpm
checksum_type: sha256
description:
  [![Codacy Badge](https://app.codacy.com/project/badge/Grade/1daae9072d214d199f95c53c8fe16d05)](https://www.codacy.com/gh/DragSama/Attrify/dashboard?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=DragSama/Attrify&amp;utm_campaign=Badge_Grade)
  [![PyPI Download Stats](https://img.shields.io/pypi/dd/attrify)](https://pypi.org/project/attrify/)
  [![PyPI Version](https://img.shields.io/pypi/v/attrify?color=brightgreen)](https://pypi.org/project/attrify/)
  [![Code style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  **Access python dict keys as attributes**



  - Install using pip: `pip install attrify`




  -  Convert normal dict
  ```python
  from attrify import Attrify

  normal_dict = {'name': 'Cool'}
  attrified_dict = Attrify(normal_dict)

  attrified_dict = Attrify(**normal_dict)

  assert attrified_dict['name'] == attrified_dict.name
  ```
  -  Convert complex nested dict
  ```python
  complex_nested_normal_dict = {"data": {"results": [{"name": "something"}, {"name": "anything"}]}}
  complex_nested_attrified_dict = Attrify(complex_nested_normal_dict)

  complex_nested_attrified_dict = Attrify(**complex_nested_normal_dict)

  assert complex_nested_attrified_dict.data.results[0].name == complex_nested_normal_dict['data']['results'][0]['name']
  ```
  -  Convert back to dict
  ```python
  normal_dict = {'name': 'Cool'}
  attrified_dict = Attrify(normal_dict)
  assert type(attrified_dict.to_dict()) == type(normal_dict)
  ```
  -  Keys inside dir: **Will only contain with alphabetic keys, To see which keys are considered alphabetic see `help(str.isalpha)`**
  ```python
  attrified_dict = Attrify({'name': 'Cool'})
  print(dir(attrified_dict)) # List return will contain the key 'name'.
  ```
  -  There is also a shortcut method to prettify dict, Just calls json.dumps with some args set.
  ```python
  print(complex_nested_attrified_dict.prettify())
  ```


pkgId: 3af8d79f9f870531005e0b536dd0f30eacf31b10997a48259a6922efe4af167a
name: python-attrs
arch: src
version: 24.2.0
epoch: 0
release: 1
summary: Classes Without Boilerplate
url: https://pypi.org/project/attrs/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-attrs-24.2.0-1.src.rpm
checksum_type: sha256
description:
  This example uses *attrs*'s modern APIs that have been introduced in version 20.1.0, and the *attrs* package import name that has been added in version 21.3.0.
  The classic APIs (`@attr.s`, `attr.ib`, plus their serious-business aliases) and the `attr` package import name will remain **indefinitely**.
  Check out [*On The Core API Names*](https://www.attrs.org/en/latest/names.html) for an in-depth explanation!

  No problem!
  Types are entirely **optional** with *attrs*.
  Simply assign `attrs.field()` to the attributes instead of annotating them with types:
  ```python
  from attrs import define, field
  @define
  class SomeClass:
      a_number = field(default=42)
      list_of_numbers = field(factory=list)
  ```

  On the tin, *attrs* might remind you of `dataclasses` (and indeed, `dataclasses` [are a descendant](https://hynek.me/articles/import-attrs/) of *attrs*).
  In practice it does a lot more and is more flexible.
  For instance, it allows you to define [special handling of NumPy arrays for equality checks](https://www.attrs.org/en/stable/comparison.html#customization), allows more ways to [plug into the initialization process](https://www.attrs.org/en/stable/init.html#hooking-yourself-into-initialization), has a replacement for `__init_subclass__`, and allows for stepping through the generated methods using a debugger.
  For more details, please refer to our [comparison page](https://www.attrs.org/en/stable/why.html#data-classes), but generally speaking, we are more likely to commit crimes against nature to make things work that one would expect to work, but that are quite complicated in practice.

  - [**Changelog**](https://www.attrs.org/en/stable/changelog.html)
  - [**Documentation**](https://www.attrs.org/)
  - [**PyPI**](https://pypi.org/project/attrs/)
  - [**Source Code**](https://github.com/python-attrs/attrs)
  - [**Contributing**](https://github.com/python-attrs/attrs/blob/main/.github/CONTRIBUTING.md)
  - [**Third-party Extensions**](https://github.com/python-attrs/attrs/wiki/Extensions-to-attrs)
  - **Get Help**: use the `python-attrs` tag on [Stack Overflow](https://stackoverflow.com/questions/tagged/python-attrs)

  Available as part of the Tidelift Subscription.
  The maintainers of *attrs* and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source packages you use to build your applications.
  Save time, reduce risk, and improve code health, while paying the maintainers of the exact packages you use.
  [Learn more](https://tidelift.com/?utm_source=lifter&utm_medium=referral&utm_campaign=hynek).


  - Given the amount of warnings raised in the broader ecosystem, we've decided to only soft-deprecate the *hash* argument to `@define` / `@attr.s`.
    Please don't use it in new code, but we don't intend to remove it anymore.
    [#1330](https://github.com/python-attrs/attrs/issues/1330)

  - `attrs.converters.pipe()` (and its syntactic sugar of passing a list for `attrs.field()`'s / `attr.ib()`'s *converter* argument) works again when passing `attrs.setters.convert` to *on_setattr* (which is default for `attrs.define`).
    [#1328](https://github.com/python-attrs/attrs/issues/1328)
  - Restored support for PEP [649](https://peps.python.org/pep-0649/) / [749](https://peps.python.org/pep-0749/)-implementing Pythons -- currently 3.14-dev.


pkgId: d3f817cfbf791bf5a1f7f45b3f5367e5a6050504e4e5902657a15b54a6104995
name: python-attrs-strict
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Runtime validators for attrs
url: https://github.com/bloomberg/attrs-strict
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-attrs-strict-1.0.1-1.src.rpm
checksum_type: sha256
description:
  [![Latest version on
  PyPi](https://badge.fury.io/py/attrs-strict.svg)](https://badge.fury.io/py/attrs-strict)
  [![Supported Python
  versions](https://img.shields.io/pypi/pyversions/attrs-strict.svg)](https://pypi.org/project/attrs-strict/)
  [![PyPI - Implementation](https://img.shields.io/pypi/implementation/attrs-strict?style=flat-square)](https://pypi.org/project/attrs-strict)
  [![Build Status](https://github.com/bloomberg/attrs-strict/workflows/check/badge.svg)](https://github.com/bloomberg/attrs-strict/actions)
  [![Code style:
  black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)



  `attrs-strict` is a Python package which contains runtime validation for
  [`attrs`](https://github.com/python-attrs/attrs) data classes based on the types existing in the typing module.





  The purpose of the library is to provide runtime validation for attributes specified in
  [`attrs`](https://www.attrs.org/en/stable/) data classes. The types supported are all the builtin types and most of the
  ones defined in the typing library. For Python 2, the typing module is available through the backport found
  [`here`](https://pypi.org/project/typing/).



  Type enforcement is based on the `type` attribute set on any field specified in an `attrs` dataclass. If the type
  argument is not specified, no validation takes place.

  `pip install attrs-strict`

  ```python
  from typing import List
  import attr
  from attrs_strict import type_validator


  @attr.s
  class SomeClass(object):
      list_of_numbers = attr.ib(validator=type_validator(), type=List[int])


  sc = SomeClass([1, 2, 3, 4])
  print(sc)
  SomeClass(list_of_numbers=[1, 2, 3, 4])

  try:
      SomeClass([1, 2, 3, "four"])
  except ValueError as exception:
      print(repr(exception))
  ```

  ```console
  SomeClass(list_of_numbers=[1, 2, 3, 4])
  <list_of_numbers must be typing.List[int] (got four that is a <class 'str'>) in [1, 2, 3, 'four']>
  ```

  Nested type exceptions are validated accordingly, and a backtrace to the initial container is maintained to ease with
  debugging. This means that if an exception occurs because a nested element doesn't have the correct type, the
  representation of the exception will contain the path to the specific element that caused the exception.

  ```python
  from typing import List, Tuple
  import attr
  from attrs_strict import type_validator


  @attr.s
  class SomeClass(object):
      names = attr.ib(validator=type_validator(), type=List[Tuple[str, str]])


  try:
      SomeClass(names=[("Moo", "Moo"), ("Zoo", 123)])
  except ValueError as exception:
      print(exception)
  ```

  ```console
  names must be typing.List[typing.Tuple[str, str]] (got 123 that is a <class 'int'>) in ('Zoo', 123) in [('Moo', 'Moo'), ('Zoo', 123)]
  ```



  Currently, there's support for simple types and types specified in the `typing` module: `List`, `Dict`, `DefaultDict`,
  `Set`, `Union`, `Tuple`, `NewType` `Callable`, `Literal` and any combination of them. This means that you can specify
  nested types like `List[List[Dict[int, str]]]` and the validation would check if attribute has the specific type.

  `Callable` will validate if the callable function's annotation matches the type definition. If type does not specify any
  annotations then all callables will pass the validation against it. Support for `Callable` is not available for
  `python2`.

  `Literal` only allows using instances of `int`, `str`, `bool`, `Enum` or valid `Literal` types. Type checking `Literal`
  with any other type as argument raises `attrs_strict._error.UnsupportedLiteralError`.

  ```python
  def fully_annotated_function(self, a: int, b: int) -> str:
      ...


  def un_annonated_function(a, b):
      ...


  @attr.s
  class Something(object):
      a = attr.ib(
          validator=type_validator(), type=typing.Callable
      )  # Will work for any callable
      b = attr.ib(validator=type_validator(), type=typing.Callable[[int, int], str])


  Something(a=un_annonated_function, b=fully_annotated_function)
  ```

  `TypeVars` or `Generics` are not supported yet but there are plans to support this in the future.



  For development, the project uses [`tox`](http://tox.readthedocs.org/) in order to install dependencies, run tests and
  generate documentation. In order to be able to do this, you need tox `pip install tox` and after that invoke `tox` in
  the root of the project.



  Run `pip install attrs-strict` to install the latest stable version from [PyPi](https://pypi.org/project/attrs-strict/).
  Documentation is hosted on [readthedocs](https://attrs-strict.readthedocs.io/en/latest/).

  For the latest version, on github `pip install git+https://github.com/bloomberg/attrs-strict`.


pkgId: 544aeb038bc30cddb56dafe911ff3daff5c645a54a444386e83c19999157ce75
name: python-attune
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Tools for tuning optical parametric amplifiers and multidimensional spectrometers.
url: https://github.com/wright-group/attune
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-attune-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  Tools for tuning optical parametric amplifiers and multidimensional spectrometers.

  Documentation is available at <https://attune.wright.tools/en/latest/>.



  `attune` has three primary jobs:

  1.  attune parses calibration data to find optimal motor positions
      ```
      
      
      
      calibration_data = wt.open(path_to_data.wt5)
      calibration_data.transform("opa_color", "motor")
      args = {
          "data": calibration_data,
          "channel": "signal",
          "arrangement": "SHS",
          "tune": "SHS_crystal",
          "instrument": "OPA1",
      }
      tuned_opa1 = attune.intensity(**args)
      ```

  2.  `attune` organizes optimal motor positions.  The motor positions are stored in a hierarchy of mappings.  Beginning at the lowest level:

      * Tune : a map of OPA color (the "independent") to positions of a single motor (the "dependent").
          ```
          my_tune = attune.Tune(
              independent=[450, 600, 700],
              dependent=[3.225, 2.332, 1.987]
          )  # relate color to bbo angle
          ```

      * Arrangement : a collection of Tunes that define a concerted process (e.g. to generate idler photons, one might move several motors (`bbo`, `g1`, etc.))
          ```
          idler = attune.Arrangement("idler", dict(bbo=my_tune, g1=my_other_tune))
          ```

      * Instrument : a collection of Arrangements (e.g. an OPA may have signal and idler)
          ```
          my_opa = attune.Instrument({"idler": idler, "signal": signal}, name="opa1")
          ```

          Note: arrangements can be called as tunables if they exist in the same instrument.  This can allow nested naming
          ```
          shi = attune.Arrangement(Dict(
              idler = Tune(shi_colors, idler_colors),
              sh_crystal = Tune(shi_colors, angles)
          ))
          ```

  3. `attune` stores motor mappings and remembers them through version tracking.
      * save a new instrument (or update an existing one)
          ```
          attune.store(my_opa)
          ```

      * lookup a saved instrument (by name)
          ```
          attune.catalog()  # lists all saved instruments
          my_opa = attune.load("opa1")  # fetches the most recent version of the instrument
          my_previous_opa = attune.undo(my_opa) # fetches the previous version of the instrument
          my_old_opa = attune.load("opa1", time="yesterday")  # optional kwarg specifies the version by time of usage
          ```




  * `attune` uses default units of nanometers ("nm") for its independent variables.
      _At this time, units cannot be changed, so alternate units must be handled externally_ (PRs are welcome!).
      WrightTools calibration data is automatically converted into "nm" units for parsing.


pkgId: ce6091186ac1ec378ead16399031cd4cc388f584ac9d222c593e4efe9a37ae53
name: python-atup
arch: src
version: 0.0.12
epoch: 0
release: 1
summary: atup
url: https://github.com/dsm-72/atup
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-atup-0.0.12-1.src.rpm
checksum_type: sha256
description:
  <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->





  ``` sh

  $ mamba env create -f env.yml


  $ mamba env update -n atup --file env.yml
  ```



  ``` sh
  pip install -e .


  pip install atup
  ```



  ``` sh

  $ conda activate atup


  $ pip install -e .





  $ nbdev_prepare
  ```



  ``` sh

  $ nbdev_pypi


  $ nbdev_conda --build_args '-c conda-forge'
  $ nbdev_conda --mambabuild --build_args '-c conda-forge -c dsm-72'
  ```





  Install latest from the GitHub
  [repository](https://github.com/dsm-72/atup):

  ``` sh
  $ pip install git+https://github.com/dsm-72/atup.git
  ```

  or from [conda](https://anaconda.org/dsm-72/atup)

  ``` sh
  $ conda install -c dsm-72 atup
  ```

  or from [pypi](https://pypi.org/project/atup/)

  ``` sh
  $ pip install atup
  ```



  Documentation can be found hosted on GitHub
  [repository](https://github.com/dsm-72/atup)
  [pages](https://dsm-72.github.io/atup/). Additionally you can find
  package manager specific guidelines on
  [conda](https://anaconda.org/dsm-72/atup) and
  [pypi](https://pypi.org/project/atup/) respectively.


pkgId: 3f202ab1e92d023d598cb8518cb83f7e716692e879076211281205258867ae55
name: python-atuproot
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: AlphaTwirl + uproot = FAST analysis code
url: https://github.com/shane-breeze/atuproot
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-atuproot-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [alphatwirl](https://github.com/alphatwirl/alphatwirl) interface to process and read [ROOT](https://root.cern.ch/) `TTrees` with [uproot](https://github.com/scikit-hep/uproot).



  Can be installed via pip
  ```
  pip install atuproot
  ```

  or for developing:
  ```
  git clone git@github.com:shane-breeze/atuproot.git
  cd atuproot
  python setup.py install
  ```



  An example of how to use this is shown in a binder tutorial linked below.

  [![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/shane-breeze/atuproot/master?filepath=binder%2Ftutorial.ipynb)


pkgId: 5de5a9d2e1dcd7242143205f0b05f12f27bb1488e6c74e29924c673a40a825fd
name: python-atyp
arch: src
version: 0.0.62
epoch: 0
release: 1
summary: atyp (type alias)
url: https://github.com/dsm-72/atyp
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-atyp-0.0.62-1.src.rpm
checksum_type: sha256
description:
  <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->







  ``` sh

  $ mamba env create -f env.yml


  $ mamba env update -n atyp --file env.yml
  ```



  ``` sh
  pip install -e .


  pip install atyp
  ```



  ``` sh

  $ conda activate atyp


  $ pip install -e .





  $ nbdev_prepare
  ```



  ``` sh

  $ nbdev_pypi


  $ nbdev_conda --build_args '-c conda-forge'
  $ nbdev_conda --mambabuild --build_args '-c conda-forge -c dsm-72'
  ```





  Install latest from the GitHub
  [repository](https://github.com/dsm-72/atyp):

  ``` sh
  $ pip install git+https://github.com/dsm-72/atyp.git
  ```

  or from [conda](https://anaconda.org/dsm-72/atyp)

  ``` sh
  $ conda install -c dsm-72 atyp
  ```

  or from [pypi](https://pypi.org/project/atyp/)

  ``` sh
  $ pip install atyp
  ```



  Documentation can be found hosted on GitHub
  [repository](https://github.com/dsm-72/atyp)
  [pages](https://dsm-72.github.io/atyp/). Additionally you can find
  package manager specific guidelines on
  [conda](https://anaconda.org/dsm-72/atyp) and
  [pypi](https://pypi.org/project/atyp/) respectively.


pkgId: 6c4c7aad2efd508d86be92b6ea21d281a5a865924f1bad9a62a896831ded4b3e
name: python-atypes
arch: src
version: 0.1.11
epoch: 0
release: 1
summary: Abstractions for signal machine learning.
url: https://github.com/otosense/atypes
rpm_license: apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-atypes-0.1.11-1.src.rpm
checksum_type: sha256
description:
  Abstractions for signal machine learning.

  To install:	```pip install atypes```

  [Documentation](https://i2mint.github.io/atypes/)


pkgId: e955fce63be015de9c925b48dfa5d24c7d15bf737c22e88fc390c41ed6aaf479
name: python-atzlib
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: My python codes.
url: https://pypi.org/project/atzlib/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-atzlib-0.1.3-1.src.rpm
checksum_type: sha256
description:
  Bunch of python codes.
  Test project to learn how to manage pypi library.

  LINK: <https://pypi.org/manage/project/atzlib/releases/>

  ```bash
  poetry config pypi-token.pypi your-pypi-token
  ```







  ```python
  def upload_csv(file_path, table_name, primary_keys, foreign_keys=None, reset=False):
      """
      CSV 파일에서 데이터를 로드하여 데이터베이스에 업로드합니다.

      Args:
          file_path (str): CSV 파일의 경로.
          table_name (str): 생성하거나 업서트할 테이블 이름.
          primary_keys (list of str): 기본 키 컬럼들.
          foreign_keys (dict, optional): 컬럼 이름과 외래 키 참조를 매핑하는 딕셔너리.
          reset (bool, optional): 업서트 전에 테이블을 초기화할지 여부. 기본값은 False.
      """
  ```





  ```yaml

  database:
    user: YOUR_NAME
    password: YOUR_PASSWORD
    host: YOUR_HOSTID
    port: 5432
    dbname: YOUR_DBNAME
  ```



  ```python
  from ezpsql import upload_csv
  upload_csv('test.csv', 'test', primary_keys=['SEQ_NO'])
  ```



  ```python
  from ezpsql import connect_db
  from sqlalchemy import text
  import pandas as pd

  engine = connect_db()
  query = text('SELECT * FROM public.tms_elite_temp WHERE "TR_ID" LIKE :tr_id')
  reg_map = pd.read_sql_query(query, engine, params={'tr_id': '%수원%'})
  reg_map
  ```





  ```python
  if __name__ == "__main__":
  ```

  구문을 사용하여 구동되는 .py로 변경



  ```python



  from ezpsql import upload_csv
  from ezpsql import connect_db

  from sqlalchemy import text
  import pandas as pd


  if __name__ == "__main__":
      upload_csv('test.csv', 'test', primary_keys=['DEV_ID'], option=['reset'])
      engine = connect_db()
      query = text('SELECT * FROM public.test')
      reg_map = pd.read_sql_query(query, engine)
  ```



  ```bash
  python main.py
  ```



  ``` bash

  while true
  do
      echo "Running Python script at $(date)"
      python /path/to/your/main.py
      sleep 86400  # 86400초 = 24시간
  done
  ```



  ```terminal
  chmod +x run_daily.sh
  ./run_daily.sh
  ```


pkgId: abd6ab8d1392f0a9cb4a01ed2bc7a5c44931b51cdf34c1cfccbfa7b24bd28aed
name: python-aucurriculum
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A Curriculum Learning Toolkit for Deep Learning Tasks built on top of autrainer.
url: https://github.com/autrainer/aucurriculum
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aucurriculum-0.1.1-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <img src="https://autrainer.github.io/aucurriculum/_images/logo_banner.png" alt="aucurriculum — A Curriculum Learning Toolkit for Deep Learning Tasks built on top of autrainer">
  </div>



  [![aucurriculum PyPI Version](https://img.shields.io/pypi/v/aucurriculum?logo=pypi&logoColor=b4befe&color=b4befe)](https://pypi.org/project/aucurriculum/)
  [![aucurriculum Python Versions](https://img.shields.io/pypi/pyversions/aucurriculum?logo=python&logoColor=b4befe&color=b4befe)](https://pypi.org/project/aucurriculum/)
  [![aucurriculum GitHub License](https://img.shields.io/badge/license-MIT-b4befe?logo=c)](https://github.com/autrainer/aucurriculum/blob/main/LICENSE)

  A Curriculum Learning Toolkit for Deep Learning Tasks built on top of [autrainer](https://github.com/autrainer/autrainer).



  To install _aucurriculum_, first ensure that PyTorch (along with torchvision and torchaudio) version 2.0 or higher is installed.
  For installation instructions, refer to the [PyTorch website](https://pytorch.org/get-started/locally/).

  It is recommended to install _aucurriculum_ within a virtual environment.
  To create a new virtual environment, refer to the [Python venv documentation](https://docs.python.org/3/library/venv.html).

  Next, install _aucurriculum_ using _pip_.

  ```bash
  pip install aucurriculum
  ```

  To install _aucurriculum_ from source, refer to the [contribution guide](https://autrainer.github.io/aucurriculum/development/contributing.html).



  To get started using _aucurriculum_, the [quickstart guide](https://autrainer.github.io/aucurriculum/usage/quickstart.html) outlines the creation of a simple training configuration
  and [tutorials](https://autrainer.github.io/aucurriculum/usage/tutorials.html) provide examples for implementing custom scoring and pacing functions including their configurations.

  For a complete list of available CLI commands, refer to the [CLI reference](https://autrainer.github.io/aucurriculum/usage/cli_reference.html) or the [CLI wrapper](https://autrainer.github.io/aucurriculum/usage/cli_wrapper.html).



  If you use _aucurriculum_ in your research, please consider citing the following [paper](https://doi.org/10.48550/arXiv.2411.00973):

  ```bibtex
  @misc{rampp2024sampledifficulty,
    doi = {10.48550/ARXIV.2411.00973},
    url = {https://arxiv.org/abs/2411.00973},
    author = {Rampp,  Simon and Milling,  Manuel and Triantafyllopoulos,  Andreas and Schuller,  Bj\"{o}rn W.},
    keywords = {Machine Learning (cs.LG),  FOS: Computer and information sciences,  FOS: Computer and information sciences},
    title = {Does the Definition of Difficulty Matter? Scoring Functions and their Role for Curriculum Learning},
    publisher = {arXiv},
    year = {2024},
    copyright = {Creative Commons Attribution Non Commercial Share Alike 4.0 International}
  }
  ```


pkgId: 44ab20c25bcd420ffab827cad9f4e0d6dbe10af588a46c79a946b072d0729402
name: python-audb
arch: src
version: 1.10.1
epoch: 0
release: 1
summary: Load and publish databases in audformat
url: https://pypi.org/project/audb/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audb-1.10.1-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2018-present audEERING GmbH and Contributors  Authors: Hagen Wierstorf Johannes Wagner Christian Geng  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: acbee152e61e5c154c607624bc3517294b4085d1dc8e7faa174dccaf34f22f77
name: python-audbackend
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Backends to access Artifactory and local file system
url: https://pypi.org/project/audbackend/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audbackend-2.1.0-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2021 audEERING GmbH and Contributors  Authors: Johannes Wagner Hagen Wierstorf  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: b092208d03583de06d01173bd6a71ae407112c1ef811d002aba541bc6e163f1f
name: python-audbackend
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Backends to access Artifactory and local file system
url: https://pypi.org/project/audbackend/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audbackend-2.2.0-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2021-present audEERING GmbH and Contributors  Authors: Johannes Wagner Hagen Wierstorf Christian Geng  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: 07d89777900500e8d18014b181b4bb97071aab7e816db71ce8dc2d1c8d51e292
name: python-audbcards
arch: src
version: 0.3.5
epoch: 0
release: 1
summary: Create data cards for audb databases
url: https://pypi.org/project/audbcards/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audbcards-0.3.5-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2023- audEERING GmbH and Contributors  Authors: Hagen Wierstorf Christian Geng  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: 6ce991c57ad3685c10c8b2929e1460222becbc0393eb78a9228abe15632bd4b2
name: python-audeer
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Helpful Python functions
url: https://pypi.org/project/audeer/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audeer-2.2.0-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2018-present audEERING GmbH and Contributors  Authors: Johannes Wagner Hagen Wierstorf  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: 55ca04f756d1def206bf0c2d18e479f3d093795b349558c012ad6c6215b85884
name: python-audfactory
arch: src
version: 1.0.15
epoch: 0
release: 1
summary: Communicate with Artifactory
url: https://pypi.org/project/audfactory/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audfactory-1.0.15-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2018-2021 audEERING GmbH and Contributors  Authors: Johannes Wagner Hagen Wierstorf  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: e7740127bb099a711633b2f0c7e01526bcbce99de76af62946f7afcd93769788
name: python-audformat
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: Python implementation of audformat
url: https://pypi.org/project/audformat/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audformat-1.3.1-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2018-present audEERING GmbH and Contributors  Authors: Hagen Wierstorf Johannes Wagner Christian Geng Baha Eddine Abrougui  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: a140c1d25ef14139d4ea27b0d688434eb589549eb027b08da35e662f383fc305
name: python-audible
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: A(Sync) Interface for internal Audible API written in pure Python.
url: https://github.com/mkb79/Audible
rpm_license: AGPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audible-0.10.0-1.src.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/pypi/v/audible.svg)](https://pypi.org/project/audible/)
  [![image](https://img.shields.io/pypi/l/audible.svg)](https://pypi.org/project/audible/)
  [![image](https://img.shields.io/pypi/pyversions/audible.svg)](https://pypi.org/project/audible/)
  [![image](https://img.shields.io/pypi/status/audible.svg)](https://pypi.org/project/audible/)
  [![image](https://img.shields.io/pypi/wheel/audible.svg)](https://pypi.org/project/audible/)
  [![Travis](https://img.shields.io/travis/mkb79/audible/master.svg?logo=travis)](https://travis-ci.org/mkb79/audible)
  [![CodeFactor](https://www.codefactor.io/repository/github/mkb79/audible/badge)](https://www.codefactor.io/repository/github/mkb79/audible)
  [![image](https://img.shields.io/pypi/dm/audible.svg)](https://pypi.org/project/audible/)

  **Audible is a Python low-level interface to communicate with the non-publicly
  [Audible](<https://en.wikipedia.org/wiki/Audible_(service)>) API.**

  It enables Python developers to create there own Audible services.
  Asynchronous communication with the Audible API is supported.

  For a basic command line interface take a look at my
  [audible-cli](https://github.com/mkb79/audible-cli) package. This package
  supports:

  - downloading audiobooks (aax/aaxc), cover, PDF and chapter files
  - export library to [csv](https://en.wikipedia.org/wiki/Comma-separated_values)
    files
  - get activation bytes
  - add own plugin commands



  Python >= 3.10



  `pip install audible`



  The documentation can be found at [Read the Docs](https://audible.readthedocs.io/en/latest)



  Contributions are very welcome.
  To learn more, see the [Contributor Guide].



  Distributed under the terms of the [AGPL-3.0][license],
  _Audible_ is free and open source software.



  If you encounter any problems,
  please [file an issue] along with a detailed description.



  Thanks a lot JetBrains for supporting me with a free [license](https://www.jetbrains.com/community/opensource/#support)
  This project was generated from [@cjolowicz]'s [Hypermodern Python Cookiecutter] template.

  [@cjolowicz]: https://github.com/cjolowicz
  [pypi]: https://pypi.org/
  [hypermodern python cookiecutter]: https://github.com/cjolowicz/cookiecutter-hypermodern-python
  [file an issue]: https://github.com/mkb79/Audible/issues
  [pip]: https://pip.pypa.io/
  [audible]: https://github.com/mkb79/Audible
  [pipx]: https://pypa.github.io/pipx/

  <!-- github-only -->

  [license]: https://github.com/mkb79/Audible/blob/main/LICENSE
  [contributor guide]: https://github.com/mkb79/Audible/blob/main/CONTRIBUTING.md


pkgId: 6c1e3c849f2193da509c681ec261e779905a78ec2247e70541a285505f17eafb
name: python-audiconnectpy
arch: src
version: 2.5.22
epoch: 0
release: 1
summary: Provides asynchronous authentication and access to Audi Connect
url: https://github.com/cyr-ius/audiconnectpy
rpm_license: GPL-3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audiconnectpy-2.5.22-1.src.rpm
checksum_type: sha256
description:
  [![GitHub sourcecode](https://img.shields.io/badge/Source-GitHub-green)](https://github.com/cyr-ius/audiconnectpy/)
  [![GitHub release (latest by date)](https://img.shields.io/github/v/release/cyr-ius/audiconnectpy)](https://github.com/cyr-ius/audiconnectpy/releases/latest)
  ![Code Style](https://img.shields.io/badge/code%20style-black-000000.svg?style=flat)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/audiconnectpy?label=PyPI%20Downloads)](https://pypi.org/project/audiconnectpy/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/weconnect)](https://pypi.org/project/audiconnectpy/)

  The audiconnect component provides an integration with the Audi Connect cloud service. It adds presence detection, sensors such as range, mileage, and fuel level, and provides car actions such as locking/unlocking and setting the pre-heater.

  Note: Certain functions require special permissions from Audi, such as position update via GPS.

  Credit for initial API discovery go to the guys at the ioBroker VW-Connect forum, who were able to figure out how the API and the PIN hashing works. Also some implementation credit to davidgiga1993 of the original AudiAPI Python package, on which some of this code is loosely based.



  Use this API with care. If you use it wrong (e.g. too many logins, repeated login attempts with wrong password, ...) your account may get blocked.



  Use the PIP package manager

  ```bash
  pip install audiconnectpy
  ```

  Or manually download and install the last version from github

  ```bash
  git clone https://github.com/cyr-ius/audiconnectpy.git
  python setup.py install
  ```



  ```python

  from audiconnectpy import AudiConnect

  async def main():
      async with ClientSession() as session:
          api = AudiConnect(session, VW_USERNAME, VW_PASSWORD, COUNTRY, SPIN)
          await api.async_update()
          print(api.vehicles)


  if __name__ == "__main__":
      loop = asyncio.get_event_loop()
      loop.run_until_complete(main())
  ```

  Have a look at the [example.py](https://github.com/cyr-ius/audiconnectpy/blob/master/example.py) for a more complete overview.



  Audiconectpy is based on the new Carnet ID API that was introduced with the new series of ID cars. If you use another car or hybrid you probably need to agree to the terms and conditions of the My Audi interface. Easiest to do so is by installing the My Audi app on your smartphone and login there. If necessary you will be asked to agree to the terms and conditions.



  Inspired by :

  - [arjenvrh/audi_connect_ha](https://github.com/arjenvrh/audi_connect_ha)
  - [tknaller/openhab-addons](https://github.com/tknaller/openhab-addons)
  - [davidgiga1993/AudiAPI](https://github.com/davidgiga1993/AudiAPI)


pkgId: 8c06b76506f59c05bcfd9b866bf249651c3a6b73e6c66d94e3cfeac99b817efa
name: python-audinterface
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: Generic interfaces for signal processing
url: https://pypi.org/project/audinterface/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audinterface-1.2.2-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2018- audEERING GmbH and Contributors  Authors: Hagen Wierstorf Johannes Wagner Maximilian Schmitt Andreas Triantafyllopoulos  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: f3623b3783b77cd9b98fc5397ac1d08ce618c003a21bcbcfec4d50f258da69f9
name: python-audio-augmentations
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: Audio augmentations library, for audio in the time-domain.
url: https://github.com/spijkervet/audio-augmentations
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audio-augmentations-0.1.3-1.src.rpm
checksum_type: sha256
description:
  Audio augmentations library for PyTorch for audio in the time-domain, with support for stochastic data augmentations as used often in self-supervised / contrastive learning.



  We can define several audio augmentations, which will be applied sequentially to a raw audio waveform:
  ```
  from audio_augmentations import *

  audio, sr = torchaudio.load("tests/classical.00002.wav")

  num_samples = sr * 5
  transforms = [
      RandomResizedCrop(n_samples=num_samples),
      RandomApply([PolarityInversion()], p=0.8),
      RandomApply([Noise(min_snr=0.3, max_snr=0.5)], p=0.3),
      RandomApply([Gain()], p=0.2),
      RandomApply([HighLowPass(sample_rate=sr)], p=0.8),
      RandomApply([Delay(sample_rate=sr)], p=0.5),
      RandomApply([PitchShift(
          n_samples=num_samples,
          sample_rate=sr
      )], p=0.4),
      RandomApply([Reverb(sample_rate=sr)], p=0.3)
  ]
  ```

  We can return either one or many versions of the same audio example:
  ```
  transform = Compose(transforms=transforms)
  transformed_audio =  transform(audio)
  >> transformed_audio.shape[0] = 1
  ```

  ```
  audio = torchaudio.load("testing/classical.00002.wav")
  transform = ComposeMany(transforms=transforms, num_augmented_samples=4)
  transformed_audio = transform(audio)
  >> transformed_audio.shape[0] = 4
  ```

  Similar to the `torchvision.datasets` interface, an instance of the `Compose` or `ComposeMany` class can be supplied to a torchaudio dataloaders that accept `transform=`.



  Install WavAugment for reverberation / pitch shifting:
  ```
  pip install git+https://github.com/facebookresearch/WavAugment
  ```


pkgId: 004f05c7708cce79c1231f14cef00f1f29c925a4169e0e6f1380b300fd5cd78b
name: python-audio-bible-tools
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Tools for use in building the audio-bible app
url: https://github.com/audio-bible/audio-bible-tools
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audio-bible-tools-0.1.5-1.src.rpm
checksum_type: sha256
description:
  This package is designed to download and process audio files from YouTube playlists, specifically tailored for Bible audio content. It provides functionality to download chapters from specified playlists, organize them into a structured directory format, and process them for further use.



  - Download audio from YouTube playlists matching specific patterns
  - Sanitize file names and organize downloads into a structured directory hierarchy
  - Process downloaded files, renaming and moving them to a specified output directory
  - Skip existing files to avoid redundant downloads
  - Remove temporary files created during the download process
  - Configurable options for version, voice, and output directory



  - Python 3.x
  - yt-dlp
  - requests



  ```bash
  pip install --upgrade audio_bible_tools
  ```



  Here's an example of how to use the YouTubeDownloader class:

  ```python
  from audio_bible_tools import YouTubeDownloader
  root_dir = '/content/drive/My Drive/'
  project_dir = 'kjv_audio'
  channel_handle = 'skiesaboveus'
  genesis_playlist = "01 Genesis Chapters 01-50 (KJV)"
  revelation_playlist = "66 Revelation Chapters 01-22 (KJV)"


  downloader = YouTubeDownloader(
      root_dir=root_dir,
      channel_handle=channel_handle,
      project_dir=project_dir,
      genesis_playlist=genesis_playlist,
      revelation_playlist=revelation_playlist
  )


  downloader.remove_tmp_files()




  downloader.list_and_process_playlists()


  downloader.remove_tmp_files()


  downloader.version("kjv") \
      .voice("kjv-audio-bible") \
      .result_dir("bible_audio_processed") \
      .chapterPattern("Chapter (\d+)") \
      .process()
  ```

  ```python
  from audio_bible_tools import YouTubeDownloader

  root_dir = '/content/drive/My Drive/'
  project_dir = 'kjv_audio_1'
  channel_handle = 'ScourbyYouBible'
  genesis_playlist = "1 ~ Book of Genesis by the Chapter"
  revelation_playlist = "66 ~ Book of Revelation by the Chapter"


  downloader = YouTubeDownloader(
      root_dir=root_dir,
      channel_handle=channel_handle,
      project_dir=project_dir,
      genesis_playlist=genesis_playlist,
      revelation_playlist=revelation_playlist
  )


  downloader.remove_tmp_files()




  downloader.list_and_process_playlists()


  downloader.remove_tmp_files()


  downloader.version("kjv") \
      .voice("scourby") \
      .result_dir("bible_audio_processed") \
      .chapterPattern("(\d+)\s+of\s+\d+\s+Chapters") \
      .process()
  ```



  - `__init__(self, root_dir, channel_handle, project_dir, genesis_playlist, revelation_playlist)`: Initializes the YouTubeDownloader with the specified parameters.
  - `remove_tmp_files(self, dir=None)`: Removes temporary files from the specified directory or the project directory.
  - `create_books_playlist_regular_expression(self, genesis_playlist, revelation_playlist)`: Creates a regular expression pattern to match playlist titles.
  - `sanitize_title(self, title)`: Sanitizes the playlist title for use as a directory name.
  - `download_video(self, url, download_dir)`: Downloads a single video from the given URL to the specified directory.
  - `count_files_in_directory(self, directory_path=None)`: Counts the total number of files in the specified directory.
  - `list_and_process_playlists(self)`: Lists and processes all playlists matching the specified pattern.
  - `version(self, version)`, `voice(self, voice)`, `result_dir(self, dir)`, `force(self, force)`, `chapterPattern(self, chapterPattern)`: Setter methods for various processing options.
  - `process(self)`: Processes the downloaded files, organizing them into the final directory structure.



  - This class is specifically designed for downloading and processing Bible audio content from YouTube playlists.
  - Make sure you have the necessary permissions to download and use the content.
  - The class uses a JSON file from 'https://audio-bible.github.io/info/books_mapping.json' to map book numbers to names. Ensure this resource is available and up-to-date.





  This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.


pkgId: ff6c031f0e8715abb3791673b361b47ad1f41a17efd5169977b0efb4f1ea7e50
name: python-audio-case-grade
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: library to score audio medical case studies
url: https://pypi.org/project/audio-case-grade/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audio-case-grade-0.1.0-1.src.rpm
checksum_type: sha256
description:
  ![PyPi][pypi-badge] ![Publish][publish-badge] ![Lint][lint-badge]

  A Python library (`audio-case-grade`) containing a score algorithm to score audio medical case studies.



  - Python
  - [uv][uv]
  - [Jupyter][jupyter]



  This project uses Python (see the `.python-version`). uv handles the virtual environment and the package is installed into the environment with `--editable` or `-e` flag.

  1. Install Python
  2. Install [uv][uv-install]
  3. Setup [virtual environment][uv-venv] `uv venv`
  4. Sync dev dependencies `uv sync --dev`
  5. Install package `uv pip install -e .`



  `uv build`



  `uv run pylint src`



  `uv run pytest`



  Existing files in the repostiory were placed in `/archived`

  <!-- Relative Links -->

  [pypi-badge]: https://img.shields.io/pypi/v/audio-case-grade
  [publish-badge]: https://github.com/audio-case-grade/Algorithms/actions/workflows/publish.yml/badge.svg
  [lint-badge]: https://github.com/audio-case-grade/Algorithms/actions/workflows/lint.yml/badge.svg
  [jupyter]: https://jupyter.org/
  [uv]: https://docs.astral.sh/uv/
  [uv-install]: https://docs.astral.sh/uv/getting-started/installation/
  [uv-venv]: https://docs.astral.sh/uv/pip/environments/


pkgId: 2c096d6f790686343e996049bc901cf6ea745c89de3f3ee160f9dd958b01d567
name: python-audio-cast
arch: src
version: 0.0.16
epoch: 0
release: 1
summary: A system to cast audio input to chromecast devices.
url: https://github.com/juancamilo87/linux-cast
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audio-cast-0.0.16-1.src.rpm
checksum_type: sha256
description:
  *Note: Designed to work with Rpi 4. Any installation process works for the Rpi4.*





  This requires to have `python3` installed and `pip` installed. Optionally also `venv`.

  1. (Optional) Create virtual environment to avoid dependency issues.
     - Example using venv:
       - Create: `python3 -m venv <DIR>`
       - Start: linux - `source <DIR>/bin/activate` - windows - `<DIR>/Scripts/activate`
       - Stop: `deactivate`
       - To clear delete the directory and create again `rm -r <DIR>`
  2. Install package from pip:
     - Linux/osX: `python3 -m pip install audio_cast`
     - Windows: `py -m pip install audio_cast`
  3. Install required applications:
     1. Install vlc:
        - Linux/osX has 2 alternatives:
           - Install required libraries:
              - `sudo apt install vlc-bin`
              - `sudo apt install vlc-plugin-base`
           - Install VLC `sudo apt install vlc`
        - Windows: Install vlc from their website.
     2. (Only Linux/osX) Install `libportaudio2`: `sudo apt install libportaudio2`
  4. Install a WSGI server.
     - Waitress: `pip install waitress`
  5. Run WSGI server.
     - Example: `waitress-serve --call --host=localhost --port=5000 'audio_cast:create_app'`





  - When using VS Code, just run the debugger.
  - Optional: Use a virtual environment.
  - When starting from termimal.
    1. Set environment variable for `FLASK_APP` to `audio_cast`.
       - Linux/osX: `export set FLASK_APP=audio_cast`
       - Windows cmd: `set FLASK_APP=audio_cast`
       - Windows powershell: `$Env:FLASK_APP = "audio_cast"`
    2. Launch the server with `python -m flask run`.



  - To upload to pypi:
    - Build: `py -m build`
    - Deploy: `py -m twine upload dist/*`
  - To run locally:
    - Set environment variable `FLASK_APP=audio_cast`
  - To run after installation from package:
    - Install waitress `python3 -m pip install waitress`
    - Run waitress `waitress-serve --call --host=localhost --port=5000 'audio_cast:create_app'`
  - Virtual environment:
    - Create: `python3 -m venv <DIR>`
    - Start: linux - `source <DIR>/bin/activate` - windows - `<DIR>/Scripts/activate`
    - Stop: `deactivate`
    - To clear delete the directory and create again `rm -r <DIR>`
  - Install packages from `requirements.txt` `pip install -r requirements.txt`.



  1. Install pip using apt `sudo apt install python3-pip`
  2. Install venv using apt `sudo apt install python3-venv`.
  3. Create virtual environment and activate it.
  4. Install waitress.
  5. Run waitress, run it without host so it is exposed.
  6. Install vlc `sudo apt install vlc`
     - Hopefully this can be changed to either incorporating the libvlc libraries or installing a part of vlc. Right now it's around 1 gb, which seems too much for the use needed.
     - Or install vlc-bin and vlc-plugin-base. `sudo apt install vlc-bin` and `sudo apt install vlc-plugin-base`. It's smaller but still big. Aroung 700MB.
     - Still there might be a better way.
  7. Install PortAudio using apt `sudo apt install libportaudio2`.


pkgId: 319926097f0e61d41b7958670ace2522892fd4c64f7001717a66edf52fa776b0
name: python-audio-degrader
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: Tool to introduce controlled degradations to audio
url: https://github.com/EliosMolina/audio_degrader
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audio-degrader-1.3.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/emilio-molina/audio_degrader.svg?branch=master)](https://travis-ci.com/emilio-molina/audio_degrader)


  Latest version: `1.3.1`

  Audio degradation toolbox in python, with a command-line tool. It is useful to apply controlled degradations to audio.




  `pip install audio_degrader`

  The program depends on `pysox`, so you might need to install `sox` (and `libsox-fmt-mp3` for mp3 encoding). Go to https://github.com/rabitt/pysox to have more details about it.



  ```
      convolution,impulse_response,level: Convolve input with specified impulse response
          parameters:
              impulse_response: Full path, URL (requires wget), or relative path (see -l option)
              level: Wet level (0.0=dry, 1.0=wet)
          example:
              convolution,impulse_responses/ir_classroom.wav,1.0
      dr_compression,degree: Apply dynamic range compression
          parameters:
              degree: Degree of compression. Presets from 0 (soft) to 3 (hard)
          example:
              dr_compression,0
      equalize,central_freq,bandwidth,gain: Apply a two-pole peaking equalisation (EQ) filter
          parameters:
              central_freq: Central frequency of filter in Hz
              bandwidth: Bandwith of filter in Hz
              gain: Gain of filter in dBs
          example:
              equalize,100,50,-10
      gain,value: Apply gain expressed in dBs
          parameters:
              value: Gain value [dB]
          example:
              gain,6
      mix,noise,snr: Mix input with a specified noise. The noise can be specified with its full path, URL (requires wget installed),  or relative to the resources directory (see -l option)
          parameters:
              noise: Full or relative path (to resources dir) of noise
              snr: Desired Signal-to-Noise-Ratio [dB]
          example:
              mix,sounds/ambience-pub.wav,6
      mp3,bitrate: Emulate mp3 transcoding
          parameters:
              bitrate: Quality [bps]
          example:
              mp3,320k
      normalize: Normalize amplitude of audio to range [-1.0, 1.0]
          parameters:
          example:
              normalize
      pitch_shift,pitch_shift_factor: Apply pitch shifting
          parameters:
              pitch_shift_factor: Pitch shift factor
          example:
              pitch_shift,0.9
      resample,sample_rate: Resample to given sample rate
          parameters:
              sample_rate: Desired sample rate [Hz]
          example:
              resample,8000
      speed,speed: Change playback speed
          parameters:
              speed: Playback speed factor
          example:
              speed,0.9
      time_stretch,time_stretch_factor: Apply time stretching
          parameters:
              time_stretch_factor: Time stretch factor
          example:
              time_stretch,0.9
      trim_from,start_time: Trim audio from a given start time
          parameters:
              start_time: Trim start [seconds]
          example:
              trim_from,0.1
  ```


  ```Python
  import audio_degrader as ad
  audio_file = ad.AudioFile('input.wav', './tmp_dir')
  for d in ad.ALL_DEGRADATIONS.values():
      print ad.DegradationUsageDocGenerator.get_degradation_help(d)
  degradations = ad.ParametersParser.parse_degradations_args([
      'normalize',
      'gain,6',
      'dr_compression,3',
      'equalize,500,10,30'])
  for d in degradations:
      audio_file.apply_degradation(d)
  audio_file.to_wav('output.wav')
  audio_file.delete_tmp_files()
  ```



  The script `audio_degrader` is installed along with the python package.

  ```

  $ audio_degrader -i input.mp3 -d mix,https://github.com/hagenw/audio-degradation-toolbox/raw/master/AudioDegradationToolbox/degradationData/PubSounds/restaurant08.wav,10 gain,6 dr_compression,3 -o out.wav


  $ audio_degrader --help
  ```

  A small set of sounds and impulse responses are installed along with the script, which can be listed with:
  ```
  $ audio_degrader -l


  $ audio_degrader -i input.mp3 -d mix,sounds/applause.wav,-3 gain,6 -o out.wav
  ```



  * Evaluate Music Information Retrieval systems under different degrees of degradations
  * Prepare augmented data for training of machine learning systems

  It is similar to the [Audio Degradation Toolbox in Matlab by Sebastian Ewert and Matthias Mauch][1] (for Matlab).




  ```

  $ audio_degrader -i input.wav -d mix,sounds/applause.wav,-3 -o out.wav



  $ audio_degrader -i input.wav -d mix,https://www.pacdv.com/sounds/ambience_sounds/airport-security-1.mp3,-3 -o out.wav



  $ audio_degrader -i input.wav -d gain,-15 mix,sounds/ambience-pub.wav,18 convolution,impulse_responses/ir_smartphone_mic_mono.wav,0.8 dr_compression,2 equalize,50,100,-6 normalize -o out.wav



  $ audio_degrader -i input.mp3 -d resample,8000 normalize -o out.wav



  $ audio_degrader -i input.wav -d convolution,impulse_responses/ir_classroom_mono.wav,0.7 -o out.wav
  $ audio_degrader -i input.wav -d convolution,http://www.cksde.com/sounds/month_ir/FLANGERSPACE%20E001%20M2S.wav,0.7 -o out.wav
  ```




  `audio_degrader` relies on ffmpeg for audio reading, so it can read any format (even video).


  `audio_degrader` output format is always wav stereo `pcm_f32le` (sample rate from original audio file).

  This output wav file can be easily coverted into another format with ffmpeg, e.g.:
  ```
  $ ffmpeg -i out.wav -b:a 320k out.mp3
  $ ffmpeg -i out.wav -ac 2 -ar 44100 -acodec pcm_s16le out_formatted.wav
  ```


  [1]: https://code.soundsoftware.ac.uk/projects/audio-degradation-toolbox


pkgId: a97f70e18fcdacb55a1de26cc5c4458f452fad32d5340fd02eca1fb02f9543c4
name: python-audio-dspy
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: A package for audio DSP tools
url: https://github.com/jatinchowdhury18/audio_dspy
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audio-dspy-0.0.4-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/jatinchowdhury18/audio_dspy.svg?style=svg)](https://circleci.com/gh/jatinchowdhury18/audio_dspy)
  [![codecov](https://codecov.io/gh/jatinchowdhury18/audio_dspy/branch/master/graph/badge.svg)](https://codecov.io/gh/jatinchowdhury18/audio_dspy)
  [![CodeFactor](https://www.codefactor.io/repository/github/jatinchowdhury18/audio_dspy/badge)](https://www.codefactor.io/repository/github/jatinchowdhury18/audio_dspy)
  [![Documentation Status](https://readthedocs.org/projects/audio-dspy/badge/?version=latest)](https://audio-dspy.readthedocs.io/en/latest/?badge=latest)


  audio_dspy is a Python package for audio signal processing tools.

  Current tools include:
  - EQ filter design
  - Nonlinear Processors
  - Sine Sweep Tools
  - Plotting Frequency Responses and Static Curves
  - Converting transfer functions to minimum or linear phase
  - Prony's method, and Prony's method with frequency warping
  - Modal modelling tools

  Install using `pip`:
  ```bash
  pip install audio-dspy
  ```



  ```python
  import audio_dspy as adsp
  import matplotlib.pyplot as plt


  adsp.plot_static_curve (lambda x : adsp.hard_clipper (x), range=2.5)
  adsp.plot_static_curve (lambda x : adsp.soft_clipper (x), range=2.5)
  plt.title ('Comparing Nonlinearities')
  plt.legend (['Hard Clipper', 'Soft Clipper'])
  ```

  ![Pic](docs/examples/nonlins.png)

  ```python

  fs = 44100
  b, a = adsp.design_lowshelf (800, 2.0, 2, fs)
  adsp.plot_magnitude_response (b, a, fs=fs)
  plt.title ('Low Shelf Filter')
  ```
  ![Pic](docs/examples/lowshelf.png)

  ```python

  from scipy.io import wavfile

  fs, x = wavfile.read('drums.wav')
  x = adsp.normalize(x[:,0]) # only take left channel, normalize
  plt.plot(x, label='input')

  for mode in ['peak', 'rms', 'analog']:
      y = adsp.level_detect(x, fs, mode=mode)
      plt.plot(y, label=mode)

  plt.title('Level Detection Example')
  plt.xlabel('Time [samples]')
  plt.legend()
  ```

  ![Pic](docs/examples/level_detect.png)


pkgId: 8ab5b13ec892e9abb77247a800ae6fe86091ae6169adc77109db7f03764236e6
name: python-audio-files-organizer-iphone
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A script to organize audio files and update metadata for syncing with Apple Music
url: https://github.com/David-Sandeep/audio-files-organizer-iphone
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audio-files-organizer-iphone-0.1.0-1.src.rpm
checksum_type: sha256
description:
  1. **Select Base Folder**:
      - The script prompts you to choose a folder containing your audio files. This is the source directory for processing.
  2. **Scan for Audio Files**:
      - The script recursively scans the base folder for supported audio file formats (.mp3, .wav, .flac, .m4a, etc.).
      - Files shorter than 1 minute in length are skipped.
  3. **Update Metadata**:
      - For each audio file, the script updates the Album and Artist metadata to match the name of the parent folder.
      - It uses the `mutagen` library to make these changes.
  4. **Retry Failed Files with Re-Encoding**:
      - If updating metadata fails, the script tries to re-encode the audio file using FFmpeg, ensuring compatibility.
  5. **Move Processed Files**:
      - Successfully processed files are moved to a folder named `audio songs`, preserving the folder structure.
  6. **Generate Logs**:
      - The script generates logs for:
          - Successfully processed files.
          - Files that failed metadata updates.
          - Files that failed even after re-encoding.
  7. **Sync to iTunes**:


pkgId: 1412fd769092cfc34468fc74910ff81f27d221d05f91a0a77f0f2102c8ee8cd6
name: python-audio-metadata
arch: src
version: 0.11.1
epoch: 0
release: 1
summary: A library for reading and, in the future, writing metadata from audio files.
url: https://github.com/thebigmunch/audio-metadata
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audio-metadata-0.11.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/audio-metadata.svg?label=PyPI)](https://pypi.org/project/audio-metadata/)
  ![](https://img.shields.io/badge/Python-3.6%2B-blue.svg)
  [![GitHub CI](https://img.shields.io/github/workflow/status/thebigmunch/audio-metadata/CI?label=GitHub%20CI)](https://github.com/thebigmunch/audio-metadata/actions?query=workflow%3ACI)
  [![Codecov](https://img.shields.io/codecov/c/github/thebigmunch/audio-metadata.svg?label=Codecov)](https://codecov.io/gh/thebigmunch/audio-metadata)
  [![Docs - Stable](https://img.shields.io/readthedocs/audio-metadata/stable.svg?label=Docs%20%28Stable%29)](https://audio-metadata.readthedocs.io/en/stable/)
  [![Docs - Latest](https://img.shields.io/readthedocs/audio-metadata/latest.svg?label=Docs%20%28Latest%29)](https://audio-metadata.readthedocs.io/en/latest/)

  [audio-metadata](https://github.com/thebigmunch/audio-metadata) is a library for reading and, in the future, writing audio metadata.



  Clean and understandable code, nice API, and good UX (user experience) are the focal points of audio-metadata.
  One or more of these things I feel are lacking from already existing alternatives
  enough to want to write something from scratch with them in mind.
  Also, there are certain features not present in other solutions that would be prohibitively painful to add.




  Features and functionality that set it apart:

  * Uses the Python standard load(s)/dump(s) API.
  	* Can load filepaths, os.PathLike objects, file-like objects, and bytes-like objects.
  * Metadata objects look like a dict **and** act like a dict.
  	* Some common libraries shadow the representation of a dict
  	  and/or dict methods but do not behave like a dict.
  	* Supports attribute-style access that can be mixed with dict key-subscription.
  * All metadata objects have user-friendly representations.
  	* This includes *humanized* representations of certain values
  	  like filesize, bitrate, duration, and sample rate.

  ```
  >>> import audio_metadata

  >>> metadata = audio_metadata.load('05 - Heart of Hearts.flac')

  >>> metadata
  <FLAC ({
  	'filepath': '05 - Heart of Hearts.flac',
  	'filesize': '44.23 MiB',
  	'pictures': [],
  	'seektable': <FLACSeekTable (37 seekpoints)>,
  	'streaminfo': <FLACStreamInfo ({
  		'bit_depth': 16,
  		'bitrate': '1022 Kbps',
  		'channels': 2,
  		'duration': '06:03',
  		'md5': '3ae700893d099a5d281a5d8db7847671',
  		'sample_rate': '44.1 KHz',
  	})>,
  	'tags': <VorbisComment ({
  		'album': ['Myth Takes'],
  		'artist': ['!!!'],
  		'bpm': ['119'],
  		'date': ['2007'],
  		'genre': ['Dance Punk'],
  		'title': ['Heart of Hearts'],
  		'tracknumber': ['05'],
  	})>,
  })>

  >>> metadata['streaminfo']
  <FLACStreamInfo ({
  	'bit_depth': 16,
  	'bitrate': '1022 Kbps',
  	'channels': 2,
  	'duration': '06:03',
  	'md5': '3ae700893d099a5d281a5d8db7847671',
  	'sample_rate': '44.1 KHz',
  })>

  >>> metadata.streaminfo.bitrate
  1022134.0362995076

  >>> metadata.streaminfo['duration']
  362.9066666666667

  >>> metadata['streaminfo'].sample_rate
  44100
  ```




  ``pip install -U audio-metadata``




  For the release version, see the [stable docs](https://audio-metadata.readthedocs.io/en/stable/).
  For the development version, see the [latest docs](https://audio-metadata.readthedocs.io/en/latest/).

  The high-level API and basic usage are covered, but more advanced features/functionality need documentation.




  If you're willing to [contribute](https://github.com/thebigmunch/audio-metadata/blob/master/.github/CONTRIBUTING.md)
  your time to work on [audio-metadata](https://github.com/thebigmunch/audio-metadata/), you can:

  * Post in the [Development](https://forum.thebigmunch.me/c/dev/) category on the [Discourse forum](https://forum.thebigmunch.me/).
  * Browse and comment on [issues](https://github.com/thebigmunch/audio-metadata/issues) or [pull requests](https://github.com/thebigmunch/audio-metadata/pulls).
  * [Open an issue](https://github.com/thebigmunch/audio-metadata/issues/new) with a bug report or feature request.
  * See current [projects](https://github.com/thebigmunch/audio-metadata/projects).
  * Contact me by email at mail@thebigmunch.me.




  Showing appreciation is always welcome.



  [![Say Thanks](https://img.shields.io/badge/thank-thebigmunch-blue.svg?style=flat-square)](https://saythanks.io/to/thebigmunch)

  Get your own thanks inbox at [SayThanks.io](https://saythanks.io/).



  [Contribute](https://github.com/thebigmunch/audio-metadata/blob/master/.github/CONTRIBUTING.md) by submitting bug reports, feature requests, or code.



  [Discourse forum](https://forum.thebigmunch.me/)



  [![Digital Ocean](https://img.shields.io/badge/Digital_Ocean-referral-orange.svg?style=flat-square)](https://bit.ly/DigitalOcean-tbm-referral) [![Namecheap](https://img.shields.io/badge/Namecheap-referral-orange.svg?style=flat-square)](http://bit.ly/Namecheap-tbm-referral) [![PayPal](https://img.shields.io/badge/PayPal-donate-brightgreen.svg?style=flat-square)](https://bit.ly/PayPal-thebigmunch)


pkgId: 9b3a4940a740582262628e91683c7f30defc84b052470e712f07c23ce234d2e8
name: python-audio-separator
arch: src
version: 0.21.2
epoch: 0
release: 1
summary: Easy to use audio stem separation, using various models from UVR trained primarily by @Anjok07
url: https://github.com/karaokenerds/python-audio-separator
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audio-separator-0.21.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/audio-separator.svg)](https://badge.fury.io/py/audio-separator)
  [![Conda Version](https://img.shields.io/conda/vn/conda-forge/audio-separator.svg)](https://anaconda.org/conda-forge/audio-separator)
  [![Docker pulls](https://img.shields.io/docker/pulls/beveradb/audio-separator.svg)](https://hub.docker.com/r/beveradb/audio-separator/tags)
  [![codecov](https://codecov.io/gh/karaokenerds/python-audio-separator/graph/badge.svg?token=N7YK4ET5JP)](https://codecov.io/gh/karaokenerds/python-audio-separator)
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/blane187gt/python-audio-separator/blob/main/audio_separator_Colab_work.ipynb)

  Summary: Easy to use audio stem separation from the command line or as a dependency in your own Python project, using the amazing MDX-Net, VR Arch, Demucs and MDXC models available in UVR by @Anjok07 & @aufr33.

  Audio Separator is a Python package that allows you to separate an audio file into various stems, using models trained by @Anjok07 for use with UVR (<https://github.com/Anjok07/ultimatevocalremovergui>).

  The simplest (and probably most used) use case for this package is to separate an audio file into two stems, Instrumental and Vocals, which can be very useful for producing karaoke videos! However, the models available in UVR can separate audio into many more stems, such as Drums, Bass, Piano, and Guitar, and perform other audio processing tasks, such as denoising or removing echo/reverb.



  - Separate audio into multiple stems, e.g. instrumental and vocals.
  - Supports all common audio formats (WAV, MP3, FLAC, M4A, etc.)
  - Ability to inference using a pre-trained model in PTH or ONNX format.
  - CLI support for easy use in scripts and batch processing.
  - Python API for integration into other projects.





  If you're able to use docker, you don't actually need to _install_ anything - there are [images published on Docker Hub](https://hub.docker.com/r/beveradb/audio-separator/tags) for GPU (CUDA) and CPU inferencing, for both `amd64` and `arm64` platforms.

  You probably want to volume-mount a folder containing whatever file you want to separate, which can then also be used as the output folder.

  For instance, if your current directory has the file `input.wav`, you could execute `audio-separator` as shown below (see [usage](#usage-) section for more details):

  ```sh
  docker run -it -v `pwd`:/workdir beveradb/audio-separator input.wav
  ```

  If you're using a machine with a GPU, you'll want to use the GPU specific image and pass in the GPU device to the container, like this:

  ```sh
  docker run -it --gpus all -v `pwd`:/workdir beveradb/audio-separator:gpu input.wav
  ```

  If the GPU isn't being detected, make sure your docker runtime environment is passing through the GPU correctly - there are [various guides](https://www.celantur.com/blog/run-cuda-in-docker-on-linux/) online to help with that.



  **Supported CUDA Versions:** 11.8 and 12.2

  💬 If successfully configured, you should see this log message when running `audio-separator --env_info`:
   `ONNXruntime has CUDAExecutionProvider available, enabling acceleration`

  Conda: `conda install pytorch=*=*cuda* onnxruntime=*=*cuda* audio-separator -c pytorch -c conda-forge`

  Pip: `pip install "audio-separator[gpu]"`

  Docker: `beveradb/audio-separator:gpu`



  💬 If successfully configured, you should see this log message when running `audio-separator --env_info`:
   `ONNXruntime has CoreMLExecutionProvider available, enabling acceleration`

  Pip: `pip install "audio-separator[cpu]"`



  Conda: `conda install audio-separator-c pytorch -c conda-forge`

  Pip: `pip install "audio-separator[cpu]"`

  Docker: `beveradb/audio-separator`



  💬 To test if `audio-separator` has been successfully configured to use FFmpeg, run `audio-separator --env_info`. The log will show `FFmpeg installed`.

  If you installed `audio-separator` using `conda` or `docker`, FFmpeg should already be avaialble in your environment.

  You may need to separately install FFmpeg. It should be easy to install on most platforms, e.g.:

  🐧 Debian/Ubuntu: `apt-get update; apt-get install -y ffmpeg`

   macOS:`brew update; brew install ffmpeg`



  In theory, all you should need to do to get `audio-separator` working with a GPU is install it with the `[gpu]` extra as above.

  However, sometimes getting both PyTorch and ONNX Runtime working with CUDA support can be a bit tricky so it may not work that easily.

  You may need to reinstall both packages directly, allowing pip to calculate the right versions for your platform, for example:

  - `pip uninstall torch onnxruntime`
  - `pip cache purge`
  - `pip install --force-reinstall torch torchvision torchaudio`
  - `pip install --force-reinstall onnxruntime-gpu`

  I generally recommend installing the latest version of PyTorch for your environment using the command recommended by the wizard here:
  <https://pytorch.org/get-started/locally/>



  Depending on your CUDA version and environment, you may need to install specific version(s) of CUDA libraries for ONNX Runtime to use your GPU.

  🧪 Google Colab, for example, now uses CUDA 12 by default, but ONNX Runtime still needs CUDA 11 libraries to work.

  If you see the error `Failed to load library` or `cannot open shared object file` when you run `audio-separator`, this is likely the issue.

  You can install the CUDA 11 libraries _alongside_ CUDA 12 like so:
  `apt update; apt install nvidia-cuda-toolkit`

  > Note: if anyone knows how to make this cleaner so we can support both different platform-specific dependencies for hardware acceleration without a separate installation process for each, please let me know or raise a PR!





  You can use Audio Separator via the command line, for example:

  ```sh
  audio-separator /path/to/your/input/audio.wav --model_filename UVR-MDX-NET-Inst_HQ_3.onnx
  ```

  This command will download the specified model file, process the `audio.wav` input audio and generate two new files in the current directory, one containing vocals and one containing instrumental.

  **Note:** You do not need to download any files yourself - audio-separator does that automatically for you!

  To see a list of supported models, run `audio-separator --list_models`

  Any file listed in the list models output can be specified (with file extension) with the model_filename parameter (e.g. `--model_filename UVR_MDXNET_KARA_2.onnx`) and it will be automatically downloaded to the `--model_file_dir` (default: `/tmp/audio-separator-models/`) folder on first usage.



  ```sh
  usage: audio-separator [-h] [-v] [-d] [-e] [-l] [--log_level LOG_LEVEL] [-m MODEL_FILENAME] [--output_format OUTPUT_FORMAT] [--output_dir OUTPUT_DIR] [--model_file_dir MODEL_FILE_DIR] [--invert_spect]
                         [--normalization NORMALIZATION] [--single_stem SINGLE_STEM] [--sample_rate SAMPLE_RATE] [--mdx_segment_size MDX_SEGMENT_SIZE] [--mdx_overlap MDX_OVERLAP] [--mdx_batch_size MDX_BATCH_SIZE]
                         [--mdx_hop_length MDX_HOP_LENGTH] [--mdx_enable_denoise] [--vr_batch_size VR_BATCH_SIZE] [--vr_window_size VR_WINDOW_SIZE] [--vr_aggression VR_AGGRESSION] [--vr_enable_tta]
                         [--vr_high_end_process] [--vr_enable_post_process] [--vr_post_process_threshold VR_POST_PROCESS_THRESHOLD] [--demucs_segment_size DEMUCS_SEGMENT_SIZE] [--demucs_shifts DEMUCS_SHIFTS]
                         [--demucs_overlap DEMUCS_OVERLAP] [--demucs_segments_enabled DEMUCS_SEGMENTS_ENABLED] [--mdxc_segment_size MDXC_SEGMENT_SIZE] [--mdxc_override_model_segment_size]
                         [--mdxc_overlap MDXC_OVERLAP] [--mdxc_batch_size MDXC_BATCH_SIZE] [--mdxc_pitch_shift MDXC_PITCH_SHIFT]
                         [audio_file]

  Separate audio file into different stems.

  positional arguments:
    audio_file                                             The audio file path to separate, in any common format.

  options:
    -h, --help                                             show this help message and exit

  Info and Debugging:
    -v, --version                                          Show the program's version number and exit.
    -d, --debug                                            Enable debug logging, equivalent to --log_level=debug
    -e, --env_info                                         Print environment information and exit.
    -l, --list_models                                      List all supported models and exit.
    --log_level LOG_LEVEL                                  Log level, e.g. info, debug, warning (default: info).

  Separation I/O Params:
    -m MODEL_FILENAME, --model_filename MODEL_FILENAME     model to use for separation (default: UVR-MDX-NET-Inst_HQ_3.onnx). Example: -m 2_HP-UVR.pth
    --output_format OUTPUT_FORMAT                          output format for separated files, any common format (default: FLAC). Example: --output_format=MP3
    --output_dir OUTPUT_DIR                                directory to write output files (default: <current dir>). Example: --output_dir=/app/separated
    --model_file_dir MODEL_FILE_DIR                        model files directory (default: /tmp/audio-separator-models/). Example: --model_file_dir=/app/models

  Common Separation Parameters:
    --invert_spect                                         invert secondary stem using spectogram (default: False). Example: --invert_spect
    --normalization NORMALIZATION                          value by which to multiply the amplitude of the output files (default: 0.9). Example: --normalization=0.7
    --single_stem SINGLE_STEM                              output only single stem, e.g. Instrumental, Vocals, Drums, Bass, Guitar, Piano, Other. Example: --single_stem=Instrumental
    --sample_rate SAMPLE_RATE                              set the sample rate of the output audio (default: 44100). Example: --sample_rate=44100

  MDX Architecture Parameters:
    --mdx_segment_size MDX_SEGMENT_SIZE                    larger consumes more resources, but may give better results (default: 256). Example: --mdx_segment_size=256
    --mdx_overlap MDX_OVERLAP                              amount of overlap between prediction windows, 0.001-0.999. higher is better but slower (default: 0.25). Example: --mdx_overlap=0.25
    --mdx_batch_size MDX_BATCH_SIZE                        larger consumes more RAM but may process slightly faster (default: 1). Example: --mdx_batch_size=4
    --mdx_hop_length MDX_HOP_LENGTH                        usually called stride in neural networks; only change if you know what you're doing (default: 1024). Example: --mdx_hop_length=1024
    --mdx_enable_denoise                                   enable denoising after separation (default: False). Example: --mdx_enable_denoise

  VR Architecture Parameters:
    --vr_batch_size VR_BATCH_SIZE                          number of "batches" to process at a time. higher = more RAM, slightly faster processing (default: 1). Example: --vr_batch_size=16
    --vr_window_size VR_WINDOW_SIZE                        balance quality and speed. 1024 = fast but lower, 320 = slower but better quality. (default: 512). Example: --vr_window_size=320
    --vr_aggression VR_AGGRESSION                          intensity of primary stem extraction, -100 - 100. typically 5 for vocals & instrumentals (default: 5). Example: --vr_aggression=2
    --vr_enable_tta                                        enable Test-Time-Augmentation; slow but improves quality (default: False). Example: --vr_enable_tta
    --vr_high_end_process                                  mirror the missing frequency range of the output (default: False). Example: --vr_high_end_process
    --vr_enable_post_process                               identify leftover artifacts within vocal output; may improve separation for some songs (default: False). Example: --vr_enable_post_process
    --vr_post_process_threshold VR_POST_PROCESS_THRESHOLD  threshold for post_process feature: 0.1-0.3 (default: 0.2). Example: --vr_post_process_threshold=0.1

  Demucs Architecture Parameters:
    --demucs_segment_size DEMUCS_SEGMENT_SIZE              size of segments into which the audio is split, 1-100. higher = slower but better quality (default: Default). Example: --demucs_segment_size=256
    --demucs_shifts DEMUCS_SHIFTS                          number of predictions with random shifts, higher = slower but better quality (default: 2). Example: --demucs_shifts=4
    --demucs_overlap DEMUCS_OVERLAP                        overlap between prediction windows, 0.001-0.999. higher = slower but better quality (default: 0.25). Example: --demucs_overlap=0.25
    --demucs_segments_enabled DEMUCS_SEGMENTS_ENABLED      enable segment-wise processing (default: True). Example: --demucs_segments_enabled=False

  MDXC Architecture Parameters:
    --mdxc_segment_size MDXC_SEGMENT_SIZE                  larger consumes more resources, but may give better results (default: 256). Example: --mdxc_segment_size=256
    --mdxc_override_model_segment_size                     override model default segment size instead of using the model default value. Example: --mdxc_override_model_segment_size
    --mdxc_overlap MDXC_OVERLAP                            amount of overlap between prediction windows, 2-50. higher is better but slower (default: 8). Example: --mdxc_overlap=8
    --mdxc_batch_size MDXC_BATCH_SIZE                      larger consumes more RAM but may process slightly faster (default: 1). Example: --mdxc_batch_size=4
    --mdxc_pitch_shift MDXC_PITCH_SHIFT                    shift audio pitch by a number of semitones while processing. may improve output for deep/high vocals. (default: 0). Example: --mdxc_pitch_shift=2
  ```



  You can use Audio Separator in your own Python project. Here's a minimal example using the default two stem (Instrumental and Vocals) model:

  ```python
  from audio_separator.separator import Separator


  separator = Separator()


  separator.load_model()


  output_files = separator.separate('audio1.wav')

  print(f"Separation complete! Output file(s): {' '.join(output_files)}")
  ```



  Here's an example of how you can process a single input file with multiple different models to get desired results.

  This example [came from a user]([url](https://github.com/nomadkaraoke/python-audio-separator/issues/111#issuecomment-2353780618)) who wanted the following outputs:

  - `Vocals.wav`
  - `Instrumental.wav`
  - `Vocals (Reverb).wav`
  - `Vocals (No Reverb).wav`
  - `Lead Vocals.wav`
  - `Backing Vocals.wav`

  To achieve this, they used the following code, leveraging three different models in sequence and renaming the output files:

  ```python
  import os
  from audio_separator.separator import Separator

  input = "/content/input.mp3"
  output = "/content/output"

  separator = Separator(output_dir=output)


  vocals = os.path.join(output, 'Vocals.wav')
  instrumental = os.path.join(output, 'Instrumental.wav')


  vocals_reverb = os.path.join(output, 'Vocals (Reverb).wav')
  vocals_no_reverb = os.path.join(output, 'Vocals (No Reverb).wav')


  lead_vocals = os.path.join(output, 'Lead Vocals.wav')
  backing_vocals = os.path.join(output, 'Backing Vocals.wav')


  separator.load_model(model_filename='model_bs_roformer_ep_317_sdr_12.9755.ckpt')
  voc_inst = separator.separate(input)
  os.rename(os.path.join(output, voc_inst[0]), instrumental) # Rename file to “Instrumental.wav”
  os.rename(os.path.join(output, voc_inst[1]), vocals) # Rename file to “Vocals.wav”


  separator.load_model(model_filename='UVR-DeEcho-DeReverb.pth')
  voc_no_reverb = separator.separate(vocals)
  os.rename(os.path.join(output, voc_no_reverb[0]), vocals_no_reverb) # Rename file to “Vocals (No Reverb).wav”
  os.rename(os.path.join(output, voc_no_reverb[1]), vocals_reverb) # Rename file to “Vocals (Reverb).wav”


  separator.load_model(model_filename='mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt')
  backing_voc = separator.separate(vocals_no_reverb)
  os.rename(os.path.join(output, backing_voc[0]), backing_vocals) # Rename file to “Backing Vocals.wav”
  os.rename(os.path.join(output, backing_voc[1]), lead_vocals) # Rename file to “Lead Vocals.wav”
  ```

  Thanks to @Bebra777228 for contributing this example!



  You can process multiple files without reloading the model to save time and memory.

  You only need to load a model when choosing or changing models. See example below:

  ```python
  from audio_separator.separator import Separator


  separator = Separator()


  separator.load_model(model_filename='UVR-MDX-NET-Inst_HQ_3.onnx')


  output_file_paths_1 = separator.separate('audio1.wav')
  output_file_paths_2 = separator.separate('audio2.wav')
  output_file_paths_3 = separator.separate('audio3.wav')


  separator.load_model(model_filename='UVR_MDXNET_KARA_2.onnx')


  output_file_paths_4 = separator.separate('audio1.wav')
  output_file_paths_5 = separator.separate('audio2.wav')
  output_file_paths_6 = separator.separate('audio3.wav')
  ```



  - log_level: (Optional) Logging level, e.g., INFO, DEBUG, WARNING. Default: logging.INFO
  - log_formatter: (Optional) The log format. Default: None, which falls back to 's - s - s - s'
  - model_file_dir: (Optional) Directory to cache model files in. Default: /tmp/audio-separator-models/
  - output_dir: (Optional) Directory where the separated files will be saved. If not specified, uses the current directory.
  - output_format: (Optional) Format to encode output files, any common format (WAV, MP3, FLAC, M4A, etc.). Default: WAV
  - normalization_threshold: (Optional) The amount by which the amplitude of the output audio will be multiplied. Default: 0.9
  - amplification_threshold: (Optional) The minimum amplitude level at which the waveform will be amplified. If the peak amplitude of the audio is below this threshold, the waveform will be scaled up to meet it. Default: 0.6
  - output_single_stem: (Optional) Output only a single stem, such as 'Instrumental' and 'Vocals'. Default: None
  - invert_using_spec: (Optional) Flag to invert using spectrogram. Default: False
  - sample_rate: (Optional) Set the sample rate of the output audio. Default: 44100
  - use_soundfile: (Optional) Use soundfile for output writing, can solve OOM issues, especially on longer audio.
  - mdx_params: (Optional) MDX Architecture Specific Attributes & Defaults. Default: {"hop_length": 1024, "segment_size": 256, "overlap": 0.25, "batch_size": 1}
  - vr_params: (Optional) VR Architecture Specific Attributes & Defaults. Default: {"batch_size": 1, "window_size": 512, "aggression": 5, "enable_tta": False, "enable_post_process": False, "post_process_threshold": 0.2, "high_end_process": False}
  - demucs_params: (Optional) VR Architecture Specific Attributes & Defaults. {"segment_size": "Default", "shifts": 2, "overlap": 0.25, "segments_enabled": True}



  Python >= 3.10

  Libraries: torch, onnx, onnxruntime, numpy, librosa, requests, six, tqdm, pydub



  This project uses Poetry for dependency management and packaging. Follow these steps to setup a local development environment:



  - Make sure you have Python 3.10 or newer installed on your machine.
  - Install Conda (I recommend Miniforge: <https://github.com/conda-forge/miniforge>) to manage your Python virtual environments



  Clone the repository to your local machine:

  ```sh
  git clone https://github.com/YOUR_USERNAME/audio-separator.git
  cd audio-separator
  ```

  Replace YOUR_USERNAME with your GitHub username if you've forked the repository, or use the main repository URL if you have the permissions.



  To create and activate the conda environment, use the following commands:

  ```sh
  conda env create
  conda activate audio-separator-dev
  ```



  Once you're inside the conda env, run the following command to install the project dependencies:

  ```sh
  poetry install
  ```

  Install extra dependencies depending if you're running with GPU or CPU.
  ```sh
  poetry install --extras "cpu"
  ```
  or
  ```sh
  poetry install --extras "gpu"
  ```



  You can run the CLI command directly within the virtual environment. For example:

  ```sh
  audio-separator path/to/your/audio-file.wav
  ```



  Once you are done with your development work, you can exit the virtual environment by simply typing:

  ```sh
  conda deactivate
  ```



  To build the package for distribution, use the following command:

  ```sh
  poetry build
  ```

  This will generate the distribution packages in the dist directory - but for now only @beveradb will be able to publish to PyPI.




  1. **Link Input**:

  ![step 1](https://github.com/user-attachments/assets/edb41e74-2082-43d8-9dde-30cc4eee3423)


     - **video_url**: This input is where you paste the URL of the audio or video you want to download. It can be from various platforms supported by yt-dlp. For a full list of supported websites, refer to [this link](https://github.com/yt-dlp/yt-dlp/blob/master/supportedsites.md).

     - Example:
       ```
       https://www.youtube.com/watch?v=exampleID
       ```

  2. **Input Audio File for Separation**:

  ![2 and 3](https://github.com/user-attachments/assets/a040a17f-dad1-447a-afef-39fbbe59e556)


     - **input**: This is the file path of the audio you want to separate. After downloading the audio file, you will need to specify this path to continue with separation.

     - Example:
       ```
       /content/ytdl/your_downloaded_audio.wav
       ```

  3. **Output Directory**:
     - **output**: This is the path where the separated files will be saved. It defaults to `/content/output` but can be changed to another directory if desired.

     - Example:
       ```
       /content/custom_output
       ```



  Contributions are very much welcome! Please fork the repository and submit a pull request with your changes, and I'll try to review, merge and publish promptly!

  - This project is 100% open-source and free for anyone to use and modify as they wish.
  - If the maintenance workload for this repo somehow becomes too much for me I'll ask for volunteers to share maintainership of the repo, though I don't think that is very likely
  - Development and support for the MDX-Net separation models is part of the main [UVR project](https://github.com/Anjok07/ultimatevocalremovergui), this repo is just a CLI/Python package wrapper to simplify running those models programmatically. So, if you want to try and improve the actual models, please get involved in the UVR project and look for guidance there!



  This project is licensed under the MIT [License](LICENSE).

  - **Please Note:** If you choose to integrate this project into some other project using the default model or any other model trained as part of the [UVR](https://github.com/Anjok07/ultimatevocalremovergui) project, please honor the MIT license by providing credit to UVR and its developers!



  - [Anjok07](https://github.com/Anjok07) - Author of [Ultimate Vocal Remover GUI](https://github.com/Anjok07/ultimatevocalremovergui), which almost all of the code in this repo was copied from! Definitely deserving of credit for anything good from this project. Thank you!
  - [DilanBoskan](https://github.com/DilanBoskan) - Your contributions at the start of this project were essential to the success of UVR. Thank you!
  - [Kuielab & Woosung Choi](https://github.com/kuielab) - Developed the original MDX-Net AI code.
  - [KimberleyJSN](https://github.com/KimberleyJensen) - Advised and aided the implementation of the training scripts for MDX-Net and Demucs. Thank you!
  - [Hv](https://github.com/NaJeongMo/Colab-for-MDX_B) - Helped implement chunks into the MDX-Net AI code. Thank you!
  - [zhzhongshi](https://github.com/zhzhongshi) - Helped add support for the MDXC models in `audio-separator`. Thank you!



  For questions or feedback, please raise an issue or reach out to @beveradb ([Andrew Beveridge](mailto:andrew@beveridge.uk)) directly.



  <!-- sponsors --><a href="https://github.com/empz"><img src="https:&#x2F;&#x2F;avatars.githubusercontent.com&#x2F;u&#x2F;412489?u&#x3D;c7bcf936f5d6b486dea8f26eb9453a59e4f522fa&amp;v&#x3D;4" width="60px" alt="Emiliano Parizzi" /></a><!-- sponsors -->


pkgId: 75a7836bee1d38c67d81aa58bd477930f844cccdf330c5e68f1f3086f6d6c3cf
name: python-audio-separator
arch: src
version: 0.24.1
epoch: 0
release: 1
summary: Easy to use audio stem separation, using various models from UVR trained primarily by @Anjok07
url: https://github.com/karaokenerds/python-audio-separator
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audio-separator-0.24.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/audio-separator.svg)](https://badge.fury.io/py/audio-separator)
  [![Conda Version](https://img.shields.io/conda/vn/conda-forge/audio-separator.svg)](https://anaconda.org/conda-forge/audio-separator)
  [![Docker pulls](https://img.shields.io/docker/pulls/beveradb/audio-separator.svg)](https://hub.docker.com/r/beveradb/audio-separator/tags)
  [![codecov](https://codecov.io/gh/karaokenerds/python-audio-separator/graph/badge.svg?token=N7YK4ET5JP)](https://codecov.io/gh/karaokenerds/python-audio-separator)
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/blane187gt/python-audio-separator/blob/main/audio_separator_Colab_work.ipynb)

  Summary: Easy to use audio stem separation from the command line or as a dependency in your own Python project, using the amazing MDX-Net, VR Arch, Demucs and MDXC models available in UVR by @Anjok07 & @aufr33.

  Audio Separator is a Python package that allows you to separate an audio file into various stems, using models trained by @Anjok07 for use with UVR (<https://github.com/Anjok07/ultimatevocalremovergui>).

  The simplest (and probably most used) use case for this package is to separate an audio file into two stems, Instrumental and Vocals, which can be very useful for producing karaoke videos! However, the models available in UVR can separate audio into many more stems, such as Drums, Bass, Piano, and Guitar, and perform other audio processing tasks, such as denoising or removing echo/reverb.



  - Separate audio into multiple stems, e.g. instrumental and vocals.
  - Supports all common audio formats (WAV, MP3, FLAC, M4A, etc.)
  - Ability to inference using a pre-trained model in PTH or ONNX format.
  - CLI support for easy use in scripts and batch processing.
  - Python API for integration into other projects.





  If you're able to use docker, you don't actually need to _install_ anything - there are [images published on Docker Hub](https://hub.docker.com/r/beveradb/audio-separator/tags) for GPU (CUDA) and CPU inferencing, for both `amd64` and `arm64` platforms.

  You probably want to volume-mount a folder containing whatever file you want to separate, which can then also be used as the output folder.

  For instance, if your current directory has the file `input.wav`, you could execute `audio-separator` as shown below (see [usage](#usage-) section for more details):

  ```sh
  docker run -it -v `pwd`:/workdir beveradb/audio-separator input.wav
  ```

  If you're using a machine with a GPU, you'll want to use the GPU specific image and pass in the GPU device to the container, like this:

  ```sh
  docker run -it --gpus all -v `pwd`:/workdir beveradb/audio-separator:gpu input.wav
  ```

  If the GPU isn't being detected, make sure your docker runtime environment is passing through the GPU correctly - there are [various guides](https://www.celantur.com/blog/run-cuda-in-docker-on-linux/) online to help with that.



  **Supported CUDA Versions:** 11.8 and 12.2

  💬 If successfully configured, you should see this log message when running `audio-separator --env_info`:
   `ONNXruntime has CUDAExecutionProvider available, enabling acceleration`

  Conda: `conda install pytorch=*=*cuda* onnxruntime=*=*cuda* audio-separator -c pytorch -c conda-forge`

  Pip: `pip install "audio-separator[gpu]"`

  Docker: `beveradb/audio-separator:gpu`



  💬 If successfully configured, you should see this log message when running `audio-separator --env_info`:
   `ONNXruntime has CoreMLExecutionProvider available, enabling acceleration`

  Pip: `pip install "audio-separator[cpu]"`



  Conda: `conda install audio-separator-c pytorch -c conda-forge`

  Pip: `pip install "audio-separator[cpu]"`

  Docker: `beveradb/audio-separator`



  💬 To test if `audio-separator` has been successfully configured to use FFmpeg, run `audio-separator --env_info`. The log will show `FFmpeg installed`.

  If you installed `audio-separator` using `conda` or `docker`, FFmpeg should already be avaialble in your environment.

  You may need to separately install FFmpeg. It should be easy to install on most platforms, e.g.:

  🐧 Debian/Ubuntu: `apt-get update; apt-get install -y ffmpeg`

   macOS:`brew update; brew install ffmpeg`



  In theory, all you should need to do to get `audio-separator` working with a GPU is install it with the `[gpu]` extra as above.

  However, sometimes getting both PyTorch and ONNX Runtime working with CUDA support can be a bit tricky so it may not work that easily.

  You may need to reinstall both packages directly, allowing pip to calculate the right versions for your platform, for example:

  - `pip uninstall torch onnxruntime`
  - `pip cache purge`
  - `pip install --force-reinstall torch torchvision torchaudio`
  - `pip install --force-reinstall onnxruntime-gpu`

  I generally recommend installing the latest version of PyTorch for your environment using the command recommended by the wizard here:
  <https://pytorch.org/get-started/locally/>



  Depending on your CUDA version and environment, you may need to install specific version(s) of CUDA libraries for ONNX Runtime to use your GPU.

  🧪 Google Colab, for example, now uses CUDA 12 by default, but ONNX Runtime still needs CUDA 11 libraries to work.

  If you see the error `Failed to load library` or `cannot open shared object file` when you run `audio-separator`, this is likely the issue.

  You can install the CUDA 11 libraries _alongside_ CUDA 12 like so:
  `apt update; apt install nvidia-cuda-toolkit`

  > Note: if anyone knows how to make this cleaner so we can support both different platform-specific dependencies for hardware acceleration without a separate installation process for each, please let me know or raise a PR!





  You can use Audio Separator via the command line, for example:

  ```sh
  audio-separator /path/to/your/input/audio.wav --model_filename UVR-MDX-NET-Inst_HQ_3.onnx
  ```

  This command will download the specified model file, process the `audio.wav` input audio and generate two new files in the current directory, one containing vocals and one containing instrumental.

  **Note:** You do not need to download any files yourself - audio-separator does that automatically for you!

  To see a list of supported models, run `audio-separator --list_models`

  Any file listed in the list models output can be specified (with file extension) with the model_filename parameter (e.g. `--model_filename UVR_MDXNET_KARA_2.onnx`) and it will be automatically downloaded to the `--model_file_dir` (default: `/tmp/audio-separator-models/`) folder on first usage.



  ```sh
  usage: audio-separator [-h] [-v] [-d] [-e] [-l] [--log_level LOG_LEVEL] [-m MODEL_FILENAME] [--output_format OUTPUT_FORMAT] [--output_dir OUTPUT_DIR] [--model_file_dir MODEL_FILE_DIR] [--invert_spect]
                         [--normalization NORMALIZATION] [--single_stem SINGLE_STEM] [--sample_rate SAMPLE_RATE] [--use_autocast] [--mdx_segment_size MDX_SEGMENT_SIZE] [--mdx_overlap MDX_OVERLAP] [--mdx_batch_size MDX_BATCH_SIZE]
                         [--mdx_hop_length MDX_HOP_LENGTH] [--mdx_enable_denoise] [--vr_batch_size VR_BATCH_SIZE] [--vr_window_size VR_WINDOW_SIZE] [--vr_aggression VR_AGGRESSION] [--vr_enable_tta]
                         [--vr_high_end_process] [--vr_enable_post_process] [--vr_post_process_threshold VR_POST_PROCESS_THRESHOLD] [--demucs_segment_size DEMUCS_SEGMENT_SIZE] [--demucs_shifts DEMUCS_SHIFTS]
                         [--demucs_overlap DEMUCS_OVERLAP] [--demucs_segments_enabled DEMUCS_SEGMENTS_ENABLED] [--mdxc_segment_size MDXC_SEGMENT_SIZE] [--mdxc_override_model_segment_size]
                         [--mdxc_overlap MDXC_OVERLAP] [--mdxc_batch_size MDXC_BATCH_SIZE] [--mdxc_pitch_shift MDXC_PITCH_SHIFT]
                         [audio_file]

  Separate audio file into different stems.

  positional arguments:
    audio_file                                             The audio file path to separate, in any common format.

  options:
    -h, --help                                             show this help message and exit

  Info and Debugging:
    -v, --version                                          Show the program's version number and exit.
    -d, --debug                                            Enable debug logging, equivalent to --log_level=debug
    -e, --env_info                                         Print environment information and exit.
    -l, --list_models                                      List all supported models and exit.
    --log_level LOG_LEVEL                                  Log level, e.g. info, debug, warning (default: info).

  Separation I/O Params:
    -m MODEL_FILENAME, --model_filename MODEL_FILENAME     model to use for separation (default: UVR-MDX-NET-Inst_HQ_3.onnx). Example: -m 2_HP-UVR.pth
    --output_format OUTPUT_FORMAT                          output format for separated files, any common format (default: FLAC). Example: --output_format=MP3
    --output_dir OUTPUT_DIR                                directory to write output files (default: <current dir>). Example: --output_dir=/app/separated
    --model_file_dir MODEL_FILE_DIR                        model files directory (default: /tmp/audio-separator-models/). Example: --model_file_dir=/app/models

  Common Separation Parameters:
    --invert_spect                                         invert secondary stem using spectogram (default: False). Example: --invert_spect
    --normalization NORMALIZATION                          value by which to multiply the amplitude of the output files (default: 0.9). Example: --normalization=0.7
    --single_stem SINGLE_STEM                              output only single stem, e.g. Instrumental, Vocals, Drums, Bass, Guitar, Piano, Other. Example: --single_stem=Instrumental
    --sample_rate SAMPLE_RATE                              set the sample rate of the output audio (default: 44100). Example: --sample_rate=44100
    --use_autocast                                         use PyTorch autocast for faster inference (default: False). Do not use for CPU inference. Example: --use_autocast

  MDX Architecture Parameters:
    --mdx_segment_size MDX_SEGMENT_SIZE                    larger consumes more resources, but may give better results (default: 256). Example: --mdx_segment_size=256
    --mdx_overlap MDX_OVERLAP                              amount of overlap between prediction windows, 0.001-0.999. higher is better but slower (default: 0.25). Example: --mdx_overlap=0.25
    --mdx_batch_size MDX_BATCH_SIZE                        larger consumes more RAM but may process slightly faster (default: 1). Example: --mdx_batch_size=4
    --mdx_hop_length MDX_HOP_LENGTH                        usually called stride in neural networks; only change if you know what you're doing (default: 1024). Example: --mdx_hop_length=1024
    --mdx_enable_denoise                                   enable denoising after separation (default: False). Example: --mdx_enable_denoise

  VR Architecture Parameters:
    --vr_batch_size VR_BATCH_SIZE                          number of "batches" to process at a time. higher = more RAM, slightly faster processing (default: 1). Example: --vr_batch_size=16
    --vr_window_size VR_WINDOW_SIZE                        balance quality and speed. 1024 = fast but lower, 320 = slower but better quality. (default: 512). Example: --vr_window_size=320
    --vr_aggression VR_AGGRESSION                          intensity of primary stem extraction, -100 - 100. typically 5 for vocals & instrumentals (default: 5). Example: --vr_aggression=2
    --vr_enable_tta                                        enable Test-Time-Augmentation; slow but improves quality (default: False). Example: --vr_enable_tta
    --vr_high_end_process                                  mirror the missing frequency range of the output (default: False). Example: --vr_high_end_process
    --vr_enable_post_process                               identify leftover artifacts within vocal output; may improve separation for some songs (default: False). Example: --vr_enable_post_process
    --vr_post_process_threshold VR_POST_PROCESS_THRESHOLD  threshold for post_process feature: 0.1-0.3 (default: 0.2). Example: --vr_post_process_threshold=0.1

  Demucs Architecture Parameters:
    --demucs_segment_size DEMUCS_SEGMENT_SIZE              size of segments into which the audio is split, 1-100. higher = slower but better quality (default: Default). Example: --demucs_segment_size=256
    --demucs_shifts DEMUCS_SHIFTS                          number of predictions with random shifts, higher = slower but better quality (default: 2). Example: --demucs_shifts=4
    --demucs_overlap DEMUCS_OVERLAP                        overlap between prediction windows, 0.001-0.999. higher = slower but better quality (default: 0.25). Example: --demucs_overlap=0.25
    --demucs_segments_enabled DEMUCS_SEGMENTS_ENABLED      enable segment-wise processing (default: True). Example: --demucs_segments_enabled=False

  MDXC Architecture Parameters:
    --mdxc_segment_size MDXC_SEGMENT_SIZE                  larger consumes more resources, but may give better results (default: 256). Example: --mdxc_segment_size=256
    --mdxc_override_model_segment_size                     override model default segment size instead of using the model default value. Example: --mdxc_override_model_segment_size
    --mdxc_overlap MDXC_OVERLAP                            amount of overlap between prediction windows, 2-50. higher is better but slower (default: 8). Example: --mdxc_overlap=8
    --mdxc_batch_size MDXC_BATCH_SIZE                      larger consumes more RAM but may process slightly faster (default: 1). Example: --mdxc_batch_size=4
    --mdxc_pitch_shift MDXC_PITCH_SHIFT                    shift audio pitch by a number of semitones while processing. may improve output for deep/high vocals. (default: 0). Example: --mdxc_pitch_shift=2
  ```



  You can use Audio Separator in your own Python project. Here's a minimal example using the default two stem (Instrumental and Vocals) model:

  ```python
  from audio_separator.separator import Separator


  separator = Separator()


  separator.load_model()


  output_files = separator.separate('audio1.wav')

  print(f"Separation complete! Output file(s): {' '.join(output_files)}")
  ```



  Here's an example of how you can process a single input file with multiple different models to get desired results.

  This example [came from a user]([url](https://github.com/nomadkaraoke/python-audio-separator/issues/111#issuecomment-2353780618)) who wanted the following outputs:

  - `Vocals.wav`
  - `Instrumental.wav`
  - `Vocals (Reverb).wav`
  - `Vocals (No Reverb).wav`
  - `Lead Vocals.wav`
  - `Backing Vocals.wav`

  To achieve this, they used the following code, leveraging three different models in sequence and renaming the output files:

  ```python
  import os
  from audio_separator.separator import Separator

  input = "/content/input.mp3"
  output = "/content/output"

  separator = Separator(output_dir=output)


  vocals = os.path.join(output, 'Vocals.wav')
  instrumental = os.path.join(output, 'Instrumental.wav')


  vocals_reverb = os.path.join(output, 'Vocals (Reverb).wav')
  vocals_no_reverb = os.path.join(output, 'Vocals (No Reverb).wav')


  lead_vocals = os.path.join(output, 'Lead Vocals.wav')
  backing_vocals = os.path.join(output, 'Backing Vocals.wav')


  separator.load_model(model_filename='model_bs_roformer_ep_317_sdr_12.9755.ckpt')
  voc_inst = separator.separate(input)
  os.rename(os.path.join(output, voc_inst[0]), instrumental) # Rename file to “Instrumental.wav”
  os.rename(os.path.join(output, voc_inst[1]), vocals) # Rename file to “Vocals.wav”


  separator.load_model(model_filename='UVR-DeEcho-DeReverb.pth')
  voc_no_reverb = separator.separate(vocals)
  os.rename(os.path.join(output, voc_no_reverb[0]), vocals_no_reverb) # Rename file to “Vocals (No Reverb).wav”
  os.rename(os.path.join(output, voc_no_reverb[1]), vocals_reverb) # Rename file to “Vocals (Reverb).wav”


  separator.load_model(model_filename='mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt')
  backing_voc = separator.separate(vocals_no_reverb)
  os.rename(os.path.join(output, backing_voc[0]), backing_vocals) # Rename file to “Backing Vocals.wav”
  os.rename(os.path.join(output, backing_voc[1]), lead_vocals) # Rename file to “Lead Vocals.wav”
  ```

  Thanks to @Bebra777228 for contributing this example!



  You can process multiple files without reloading the model to save time and memory.

  You only need to load a model when choosing or changing models. See example below:

  ```python
  from audio_separator.separator import Separator


  separator = Separator()


  separator.load_model(model_filename='UVR-MDX-NET-Inst_HQ_3.onnx')


  output_file_paths_1 = separator.separate('audio1.wav')
  output_file_paths_2 = separator.separate('audio2.wav')
  output_file_paths_3 = separator.separate('audio3.wav')


  separator.load_model(model_filename='UVR_MDXNET_KARA_2.onnx')


  output_file_paths_4 = separator.separate('audio1.wav')
  output_file_paths_5 = separator.separate('audio2.wav')
  output_file_paths_6 = separator.separate('audio3.wav')
  ```



  - log_level: (Optional) Logging level, e.g., INFO, DEBUG, WARNING. Default: logging.INFO
  - log_formatter: (Optional) The log format. Default: None, which falls back to 's - s - s - s'
  - model_file_dir: (Optional) Directory to cache model files in. Default: /tmp/audio-separator-models/
  - output_dir: (Optional) Directory where the separated files will be saved. If not specified, uses the current directory.
  - output_format: (Optional) Format to encode output files, any common format (WAV, MP3, FLAC, M4A, etc.). Default: WAV
  - normalization_threshold: (Optional) The amount by which the amplitude of the output audio will be multiplied. Default: 0.9
  - amplification_threshold: (Optional) The minimum amplitude level at which the waveform will be amplified. If the peak amplitude of the audio is below this threshold, the waveform will be scaled up to meet it. Default: 0.6
  - output_single_stem: (Optional) Output only a single stem, such as 'Instrumental' and 'Vocals'. Default: None
  - invert_using_spec: (Optional) Flag to invert using spectrogram. Default: False
  - sample_rate: (Optional) Set the sample rate of the output audio. Default: 44100
  - use_soundfile: (Optional) Use soundfile for output writing, can solve OOM issues, especially on longer audio.
  - use_autocast: (Optional) Flag to use PyTorch autocast for faster inference.　Do not use for CPU inference. Default: False
  - mdx_params: (Optional) MDX Architecture Specific Attributes & Defaults. Default: {"hop_length": 1024, "segment_size": 256, "overlap": 0.25, "batch_size": 1, "enable_denoise": False}
  - vr_params: (Optional) VR Architecture Specific Attributes & Defaults. Default: {"batch_size": 1, "window_size": 512, "aggression": 5, "enable_tta": False, "enable_post_process": False, "post_process_threshold": 0.2, "high_end_process": False}
  - demucs_params: (Optional) Demucs Architecture Specific Attributes & Defaults. {"segment_size": "Default", "shifts": 2, "overlap": 0.25, "segments_enabled": True}
  - mdxc_params: (Optional) MDXC Architecture Specific Attributes & Defaults. Default: {"segment_size": 256, "override_model_segment_size": False, "batch_size": 1, "overlap": 8, "pitch_shift": 0}



  Python >= 3.10

  Libraries: torch, onnx, onnxruntime, numpy, librosa, requests, six, tqdm, pydub



  This project uses Poetry for dependency management and packaging. Follow these steps to setup a local development environment:



  - Make sure you have Python 3.10 or newer installed on your machine.
  - Install Conda (I recommend Miniforge: <https://github.com/conda-forge/miniforge>) to manage your Python virtual environments



  Clone the repository to your local machine:

  ```sh
  git clone https://github.com/YOUR_USERNAME/audio-separator.git
  cd audio-separator
  ```

  Replace YOUR_USERNAME with your GitHub username if you've forked the repository, or use the main repository URL if you have the permissions.



  To create and activate the conda environment, use the following commands:

  ```sh
  conda env create
  conda activate audio-separator-dev
  ```



  Once you're inside the conda env, run the following command to install the project dependencies:

  ```sh
  poetry install
  ```

  Install extra dependencies depending if you're running with GPU or CPU.
  ```sh
  poetry install --extras "cpu"
  ```
  or
  ```sh
  poetry install --extras "gpu"
  ```



  You can run the CLI command directly within the virtual environment. For example:

  ```sh
  audio-separator path/to/your/audio-file.wav
  ```



  Once you are done with your development work, you can exit the virtual environment by simply typing:

  ```sh
  conda deactivate
  ```



  To build the package for distribution, use the following command:

  ```sh
  poetry build
  ```

  This will generate the distribution packages in the dist directory - but for now only @beveradb will be able to publish to PyPI.




  1. **Link Input**:

  ![step 1](https://github.com/user-attachments/assets/edb41e74-2082-43d8-9dde-30cc4eee3423)


     - **video_url**: This input is where you paste the URL of the audio or video you want to download. It can be from various platforms supported by yt-dlp. For a full list of supported websites, refer to [this link](https://github.com/yt-dlp/yt-dlp/blob/master/supportedsites.md).

     - Example:
       ```
       https://www.youtube.com/watch?v=exampleID
       ```

  2. **Input Audio File for Separation**:

  ![2 and 3](https://github.com/user-attachments/assets/a040a17f-dad1-447a-afef-39fbbe59e556)


     - **input**: This is the file path of the audio you want to separate. After downloading the audio file, you will need to specify this path to continue with separation.

     - Example:
       ```
       /content/ytdl/your_downloaded_audio.wav
       ```

  3. **Output Directory**:
     - **output**: This is the path where the separated files will be saved. It defaults to `/content/output` but can be changed to another directory if desired.

     - Example:
       ```
       /content/custom_output
       ```



  Contributions are very much welcome! Please fork the repository and submit a pull request with your changes, and I'll try to review, merge and publish promptly!

  - This project is 100% open-source and free for anyone to use and modify as they wish.
  - If the maintenance workload for this repo somehow becomes too much for me I'll ask for volunteers to share maintainership of the repo, though I don't think that is very likely
  - Development and support for the MDX-Net separation models is part of the main [UVR project](https://github.com/Anjok07/ultimatevocalremovergui), this repo is just a CLI/Python package wrapper to simplify running those models programmatically. So, if you want to try and improve the actual models, please get involved in the UVR project and look for guidance there!



  This project is licensed under the MIT [License](LICENSE).

  - **Please Note:** If you choose to integrate this project into some other project using the default model or any other model trained as part of the [UVR](https://github.com/Anjok07/ultimatevocalremovergui) project, please honor the MIT license by providing credit to UVR and its developers!



  - [Anjok07](https://github.com/Anjok07) - Author of [Ultimate Vocal Remover GUI](https://github.com/Anjok07/ultimatevocalremovergui), which almost all of the code in this repo was copied from! Definitely deserving of credit for anything good from this project. Thank you!
  - [DilanBoskan](https://github.com/DilanBoskan) - Your contributions at the start of this project were essential to the success of UVR. Thank you!
  - [Kuielab & Woosung Choi](https://github.com/kuielab) - Developed the original MDX-Net AI code.
  - [KimberleyJSN](https://github.com/KimberleyJensen) - Advised and aided the implementation of the training scripts for MDX-Net and Demucs. Thank you!
  - [Hv](https://github.com/NaJeongMo/Colab-for-MDX_B) - Helped implement chunks into the MDX-Net AI code. Thank you!
  - [zhzhongshi](https://github.com/zhzhongshi) - Helped add support for the MDXC models in `audio-separator`. Thank you!



  For questions or feedback, please raise an issue or reach out to @beveradb ([Andrew Beveridge](mailto:andrew@beveridge.uk)) directly.



  <!-- sponsors --><!-- sponsors -->


pkgId: 5cac269b1aeb361153be903161d4e809a018317613643e429ea86134fb15efa2
name: python-audio-separator
arch: src
version: 0.24.4
epoch: 0
release: 1
summary: Easy to use audio stem separation, using various models from UVR trained primarily by @Anjok07
url: https://github.com/karaokenerds/python-audio-separator
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audio-separator-0.24.4-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/audio-separator.svg)](https://badge.fury.io/py/audio-separator)
  [![Conda Version](https://img.shields.io/conda/vn/conda-forge/audio-separator.svg)](https://anaconda.org/conda-forge/audio-separator)
  [![Docker pulls](https://img.shields.io/docker/pulls/beveradb/audio-separator.svg)](https://hub.docker.com/r/beveradb/audio-separator/tags)
  [![codecov](https://codecov.io/gh/karaokenerds/python-audio-separator/graph/badge.svg?token=N7YK4ET5JP)](https://codecov.io/gh/karaokenerds/python-audio-separator)
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/blane187gt/python-audio-separator/blob/main/audio_separator_Colab_work.ipynb)
  [![Open In Huggingface](https://huggingface.co/datasets/huggingface/badges/resolve/main/open-in-hf-spaces-md.svg)](https://huggingface.co/spaces/theneos/audio-separator)



  Summary: Easy to use audio stem separation from the command line or as a dependency in your own Python project, using the amazing MDX-Net, VR Arch, Demucs and MDXC models available in UVR by @Anjok07 & @aufr33.

  Audio Separator is a Python package that allows you to separate an audio file into various stems, using models trained by @Anjok07 for use with UVR (<https://github.com/Anjok07/ultimatevocalremovergui>).

  The simplest (and probably most used) use case for this package is to separate an audio file into two stems, Instrumental and Vocals, which can be very useful for producing karaoke videos! However, the models available in UVR can separate audio into many more stems, such as Drums, Bass, Piano, and Guitar, and perform other audio processing tasks, such as denoising or removing echo/reverb.



  - Separate audio into multiple stems, e.g. instrumental and vocals.
  - Supports all common audio formats (WAV, MP3, FLAC, M4A, etc.)
  - Ability to inference using a pre-trained model in PTH or ONNX format.
  - CLI support for easy use in scripts and batch processing.
  - Python API for integration into other projects.





  If you're able to use docker, you don't actually need to _install_ anything - there are [images published on Docker Hub](https://hub.docker.com/r/beveradb/audio-separator/tags) for GPU (CUDA) and CPU inferencing, for both `amd64` and `arm64` platforms.

  You probably want to volume-mount a folder containing whatever file you want to separate, which can then also be used as the output folder.

  For instance, if your current directory has the file `input.wav`, you could execute `audio-separator` as shown below (see [usage](#usage-) section for more details):

  ```sh
  docker run -it -v `pwd`:/workdir beveradb/audio-separator input.wav
  ```

  If you're using a machine with a GPU, you'll want to use the GPU specific image and pass in the GPU device to the container, like this:

  ```sh
  docker run -it --gpus all -v `pwd`:/workdir beveradb/audio-separator:gpu input.wav
  ```

  If the GPU isn't being detected, make sure your docker runtime environment is passing through the GPU correctly - there are [various guides](https://www.celantur.com/blog/run-cuda-in-docker-on-linux/) online to help with that.



  **Supported CUDA Versions:** 11.8 and 12.2

  💬 If successfully configured, you should see this log message when running `audio-separator --env_info`:
   `ONNXruntime has CUDAExecutionProvider available, enabling acceleration`

  Conda: `conda install pytorch=*=*cuda* onnxruntime=*=*cuda* audio-separator -c pytorch -c conda-forge`

  Pip: `pip install "audio-separator[gpu]"`

  Docker: `beveradb/audio-separator:gpu`



  💬 If successfully configured, you should see this log message when running `audio-separator --env_info`:
   `ONNXruntime has CoreMLExecutionProvider available, enabling acceleration`

  Pip: `pip install "audio-separator[cpu]"`



  Conda: `conda install audio-separator-c pytorch -c conda-forge`

  Pip: `pip install "audio-separator[cpu]"`

  Docker: `beveradb/audio-separator`



  💬 To test if `audio-separator` has been successfully configured to use FFmpeg, run `audio-separator --env_info`. The log will show `FFmpeg installed`.

  If you installed `audio-separator` using `conda` or `docker`, FFmpeg should already be available in your environment.

  You may need to separately install FFmpeg. It should be easy to install on most platforms, e.g.:

  🐧 Debian/Ubuntu: `apt-get update; apt-get install -y ffmpeg`

   macOS:`brew update; brew install ffmpeg`



  In theory, all you should need to do to get `audio-separator` working with a GPU is install it with the `[gpu]` extra as above.

  However, sometimes getting both PyTorch and ONNX Runtime working with CUDA support can be a bit tricky so it may not work that easily.

  You may need to reinstall both packages directly, allowing pip to calculate the right versions for your platform, for example:

  - `pip uninstall torch onnxruntime`
  - `pip cache purge`
  - `pip install --force-reinstall torch torchvision torchaudio`
  - `pip install --force-reinstall onnxruntime-gpu`

  I generally recommend installing the latest version of PyTorch for your environment using the command recommended by the wizard here:
  <https://pytorch.org/get-started/locally/>



  Depending on your CUDA version and environment, you may need to install specific version(s) of CUDA libraries for ONNX Runtime to use your GPU.

  🧪 Google Colab, for example, now uses CUDA 12 by default, but ONNX Runtime still needs CUDA 11 libraries to work.

  If you see the error `Failed to load library` or `cannot open shared object file` when you run `audio-separator`, this is likely the issue.

  You can install the CUDA 11 libraries _alongside_ CUDA 12 like so:
  `apt update; apt install nvidia-cuda-toolkit`

  If you encounter the following messages when running on Google Colab or in another environment:
  ```
  [E:onnxruntime:Default, provider_bridge_ort.cc:1862 TryGetProviderInfo_CUDA] /onnxruntime_src/onnxruntime/core/session/provider_bridge_ort.cc:1539 onnxruntime::Provider& onnxruntime::ProviderLibrary::Get() [ONNXRuntimeError] : 1 : FAIL : Failed to load library libonnxruntime_providers_cuda.so with error: libcudnn_adv.so.9: cannot open shared object file: No such file or directory

  [W:onnxruntime:Default, onnxruntime_pybind_state.cc:993 CreateExecutionProviderInstance] Failed to create CUDAExecutionProvider. Require cuDNN 9.* and CUDA 12.*. Please install all dependencies as mentioned in the GPU requirements page (https://onnxruntime.ai/docs/execution-providers/CUDA-ExecutionProvider.html#requirements), make sure they're in the PATH, and that your GPU is supported.
  ```
  You can resolve this by running the following command:
  ```sh
  python -m pip install ort-nightly-gpu --index-url=https://aiinfra.pkgs.visualstudio.com/PublicPackages/_packaging/ort-cuda-12-nightly/pypi/simple/
  ```

  > Note: if anyone knows how to make this cleaner so we can support both different platform-specific dependencies for hardware acceleration without a separate installation process for each, please let me know or raise a PR!





  You can use Audio Separator via the command line, for example:

  ```sh
  audio-separator /path/to/your/input/audio.wav --model_filename UVR-MDX-NET-Inst_HQ_3.onnx
  ```

  This command will download the specified model file, process the `audio.wav` input audio and generate two new files in the current directory, one containing vocals and one containing instrumental.

  **Note:** You do not need to download any files yourself - audio-separator does that automatically for you!

  To see a list of supported models, run `audio-separator --list_models`

  Any file listed in the list models output can be specified (with file extension) with the model_filename parameter (e.g. `--model_filename UVR_MDXNET_KARA_2.onnx`) and it will be automatically downloaded to the `--model_file_dir` (default: `/tmp/audio-separator-models/`) folder on first usage.



  ```sh
  usage: audio-separator [-h] [-v] [-d] [-e] [-l] [--log_level LOG_LEVEL] [-m MODEL_FILENAME] [--output_format OUTPUT_FORMAT] [--output_dir OUTPUT_DIR] [--model_file_dir MODEL_FILE_DIR] [--invert_spect]
                         [--normalization NORMALIZATION] [--single_stem SINGLE_STEM] [--sample_rate SAMPLE_RATE] [--use_autocast] [--mdx_segment_size MDX_SEGMENT_SIZE] [--mdx_overlap MDX_OVERLAP] [--mdx_batch_size MDX_BATCH_SIZE]
                         [--mdx_hop_length MDX_HOP_LENGTH] [--mdx_enable_denoise] [--vr_batch_size VR_BATCH_SIZE] [--vr_window_size VR_WINDOW_SIZE] [--vr_aggression VR_AGGRESSION] [--vr_enable_tta]
                         [--vr_high_end_process] [--vr_enable_post_process] [--vr_post_process_threshold VR_POST_PROCESS_THRESHOLD] [--demucs_segment_size DEMUCS_SEGMENT_SIZE] [--demucs_shifts DEMUCS_SHIFTS]
                         [--demucs_overlap DEMUCS_OVERLAP] [--demucs_segments_enabled DEMUCS_SEGMENTS_ENABLED] [--mdxc_segment_size MDXC_SEGMENT_SIZE] [--mdxc_override_model_segment_size]
                         [--mdxc_overlap MDXC_OVERLAP] [--mdxc_batch_size MDXC_BATCH_SIZE] [--mdxc_pitch_shift MDXC_PITCH_SHIFT]
                         [audio_file]

  Separate audio file into different stems.

  positional arguments:
    audio_file                                             The audio file path to separate, in any common format.

  options:
    -h, --help                                             show this help message and exit

  Info and Debugging:
    -v, --version                                          Show the program's version number and exit.
    -d, --debug                                            Enable debug logging, equivalent to --log_level=debug
    -e, --env_info                                         Print environment information and exit.
    -l, --list_models                                      List all supported models and exit.
    --log_level LOG_LEVEL                                  Log level, e.g. info, debug, warning (default: info).

  Separation I/O Params:
    -m MODEL_FILENAME, --model_filename MODEL_FILENAME     model to use for separation (default: UVR-MDX-NET-Inst_HQ_3.onnx). Example: -m 2_HP-UVR.pth
    --output_format OUTPUT_FORMAT                          output format for separated files, any common format (default: FLAC). Example: --output_format=MP3
    --output_dir OUTPUT_DIR                                directory to write output files (default: <current dir>). Example: --output_dir=/app/separated
    --model_file_dir MODEL_FILE_DIR                        model files directory (default: /tmp/audio-separator-models/). Example: --model_file_dir=/app/models

  Common Separation Parameters:
    --invert_spect                                         invert secondary stem using spectogram (default: False). Example: --invert_spect
    --normalization NORMALIZATION                          value by which to multiply the amplitude of the output files (default: 0.9). Example: --normalization=0.7
    --single_stem SINGLE_STEM                              output only single stem, e.g. Instrumental, Vocals, Drums, Bass, Guitar, Piano, Other. Example: --single_stem=Instrumental
    --sample_rate SAMPLE_RATE                              set the sample rate of the output audio (default: 44100). Example: --sample_rate=44100
    --use_autocast                                         use PyTorch autocast for faster inference (default: False). Do not use for CPU inference. Example: --use_autocast

  MDX Architecture Parameters:
    --mdx_segment_size MDX_SEGMENT_SIZE                    larger consumes more resources, but may give better results (default: 256). Example: --mdx_segment_size=256
    --mdx_overlap MDX_OVERLAP                              amount of overlap between prediction windows, 0.001-0.999. higher is better but slower (default: 0.25). Example: --mdx_overlap=0.25
    --mdx_batch_size MDX_BATCH_SIZE                        larger consumes more RAM but may process slightly faster (default: 1). Example: --mdx_batch_size=4
    --mdx_hop_length MDX_HOP_LENGTH                        usually called stride in neural networks; only change if you know what you're doing (default: 1024). Example: --mdx_hop_length=1024
    --mdx_enable_denoise                                   enable denoising after separation (default: False). Example: --mdx_enable_denoise

  VR Architecture Parameters:
    --vr_batch_size VR_BATCH_SIZE                          number of "batches" to process at a time. higher = more RAM, slightly faster processing (default: 1). Example: --vr_batch_size=16
    --vr_window_size VR_WINDOW_SIZE                        balance quality and speed. 1024 = fast but lower, 320 = slower but better quality. (default: 512). Example: --vr_window_size=320
    --vr_aggression VR_AGGRESSION                          intensity of primary stem extraction, -100 - 100. typically 5 for vocals & instrumentals (default: 5). Example: --vr_aggression=2
    --vr_enable_tta                                        enable Test-Time-Augmentation; slow but improves quality (default: False). Example: --vr_enable_tta
    --vr_high_end_process                                  mirror the missing frequency range of the output (default: False). Example: --vr_high_end_process
    --vr_enable_post_process                               identify leftover artifacts within vocal output; may improve separation for some songs (default: False). Example: --vr_enable_post_process
    --vr_post_process_threshold VR_POST_PROCESS_THRESHOLD  threshold for post_process feature: 0.1-0.3 (default: 0.2). Example: --vr_post_process_threshold=0.1

  Demucs Architecture Parameters:
    --demucs_segment_size DEMUCS_SEGMENT_SIZE              size of segments into which the audio is split, 1-100. higher = slower but better quality (default: Default). Example: --demucs_segment_size=256
    --demucs_shifts DEMUCS_SHIFTS                          number of predictions with random shifts, higher = slower but better quality (default: 2). Example: --demucs_shifts=4
    --demucs_overlap DEMUCS_OVERLAP                        overlap between prediction windows, 0.001-0.999. higher = slower but better quality (default: 0.25). Example: --demucs_overlap=0.25
    --demucs_segments_enabled DEMUCS_SEGMENTS_ENABLED      enable segment-wise processing (default: True). Example: --demucs_segments_enabled=False

  MDXC Architecture Parameters:
    --mdxc_segment_size MDXC_SEGMENT_SIZE                  larger consumes more resources, but may give better results (default: 256). Example: --mdxc_segment_size=256
    --mdxc_override_model_segment_size                     override model default segment size instead of using the model default value. Example: --mdxc_override_model_segment_size
    --mdxc_overlap MDXC_OVERLAP                            amount of overlap between prediction windows, 2-50. higher is better but slower (default: 8). Example: --mdxc_overlap=8
    --mdxc_batch_size MDXC_BATCH_SIZE                      larger consumes more RAM but may process slightly faster (default: 1). Example: --mdxc_batch_size=4
    --mdxc_pitch_shift MDXC_PITCH_SHIFT                    shift audio pitch by a number of semitones while processing. may improve output for deep/high vocals. (default: 0). Example: --mdxc_pitch_shift=2
  ```



  You can use Audio Separator in your own Python project. Here's a minimal example using the default two stem (Instrumental and Vocals) model:

  ```python
  from audio_separator.separator import Separator


  separator = Separator()


  separator.load_model()


  output_files = separator.separate('audio1.wav')

  print(f"Separation complete! Output file(s): {' '.join(output_files)}")
  ```



  You can process multiple files without reloading the model to save time and memory.

  You only need to load a model when choosing or changing models. See example below:

  ```python
  from audio_separator.separator import Separator


  separator = Separator()


  separator.load_model(model_filename='UVR-MDX-NET-Inst_HQ_3.onnx')


  output_file_paths_1 = separator.separate('audio1.wav')
  output_file_paths_2 = separator.separate('audio2.wav')
  output_file_paths_3 = separator.separate('audio3.wav')


  separator.load_model(model_filename='UVR_MDXNET_KARA_2.onnx')


  output_file_paths_4 = separator.separate('audio1.wav')
  output_file_paths_5 = separator.separate('audio2.wav')
  output_file_paths_6 = separator.separate('audio3.wav')
  ```



  You can rename the output files by specifying the desired names. For example:
  ```python
  output_files = separator.separate('audio1.wav', 'stem1', 'stem2')
  ```
  In this case, the output file names will be: `stem1.wav` and `stem2.wav`.

  You can also rename specific stems:

  - To rename the primary stem:
    ```python
    output_files = separator.separate('audio1.wav', primary_output_name='stem1')
    ```
    > The output files will be named: `stem1.wav` and `audio1_(Instrumental)_model_mel_band_roformer_ep_3005_sdr_11.wav`
  - To rename the secondary stem:
    ```python
    output_files = separator.separate('audio1.wav', secondary_output_name='stem2')
    ```
    > The output files will be named: `audio1_(Vocals)_model_mel_band_roformer_ep_3005_sdr_11.wav` and `stem2.wav`



  - log_level: (Optional) Logging level, e.g., INFO, DEBUG, WARNING. Default: logging.INFO
  - log_formatter: (Optional) The log format. Default: None, which falls back to 's - s - s - s'
  - model_file_dir: (Optional) Directory to cache model files in. Default: /tmp/audio-separator-models/
  - output_dir: (Optional) Directory where the separated files will be saved. If not specified, uses the current directory.
  - output_format: (Optional) Format to encode output files, any common format (WAV, MP3, FLAC, M4A, etc.). Default: WAV
  - normalization_threshold: (Optional) The amount by which the amplitude of the output audio will be multiplied. Default: 0.9
  - amplification_threshold: (Optional) The minimum amplitude level at which the waveform will be amplified. If the peak amplitude of the audio is below this threshold, the waveform will be scaled up to meet it. Default: 0.0
  - output_single_stem: (Optional) Output only a single stem, such as 'Instrumental' and 'Vocals'. Default: None
  - invert_using_spec: (Optional) Flag to invert using spectrogram. Default: False
  - sample_rate: (Optional) Set the sample rate of the output audio. Default: 44100
  - use_soundfile: (Optional) Use soundfile for output writing, can solve OOM issues, especially on longer audio.
  - use_autocast: (Optional) Flag to use PyTorch autocast for faster inference. Do not use for CPU inference. Default: False
  - mdx_params: (Optional) MDX Architecture Specific Attributes & Defaults. Default: {"hop_length": 1024, "segment_size": 256, "overlap": 0.25, "batch_size": 1, "enable_denoise": False}
  - vr_params: (Optional) VR Architecture Specific Attributes & Defaults. Default: {"batch_size": 1, "window_size": 512, "aggression": 5, "enable_tta": False, "enable_post_process": False, "post_process_threshold": 0.2, "high_end_process": False}
  - demucs_params: (Optional) Demucs Architecture Specific Attributes & Defaults. {"segment_size": "Default", "shifts": 2, "overlap": 0.25, "segments_enabled": True}
  - mdxc_params: (Optional) MDXC Architecture Specific Attributes & Defaults. Default: {"segment_size": 256, "override_model_segment_size": False, "batch_size": 1, "overlap": 8, "pitch_shift": 0}



  Python >= 3.10

  Libraries: torch, onnx, onnxruntime, numpy, librosa, requests, six, tqdm, pydub



  This project uses Poetry for dependency management and packaging. Follow these steps to setup a local development environment:



  - Make sure you have Python 3.10 or newer installed on your machine.
  - Install Conda (I recommend Miniforge: <https://github.com/conda-forge/miniforge>) to manage your Python virtual environments



  Clone the repository to your local machine:

  ```sh
  git clone https://github.com/YOUR_USERNAME/audio-separator.git
  cd audio-separator
  ```

  Replace YOUR_USERNAME with your GitHub username if you've forked the repository, or use the main repository URL if you have the permissions.



  To create and activate the conda environment, use the following commands:

  ```sh
  conda env create
  conda activate audio-separator-dev
  ```



  Once you're inside the conda env, run the following command to install the project dependencies:

  ```sh
  poetry install
  ```

  Install extra dependencies depending if you're running with GPU or CPU.
  ```sh
  poetry install --extras "cpu"
  ```
  or
  ```sh
  poetry install --extras "gpu"
  ```



  You can run the CLI command directly within the virtual environment. For example:

  ```sh
  audio-separator path/to/your/audio-file.wav
  ```



  Once you are done with your development work, you can exit the virtual environment by simply typing:

  ```sh
  conda deactivate
  ```



  To build the package for distribution, use the following command:

  ```sh
  poetry build
  ```

  This will generate the distribution packages in the dist directory - but for now only @beveradb will be able to publish to PyPI.




  1. **Link Input**:

  ![step 1](https://github.com/user-attachments/assets/edb41e74-2082-43d8-9dde-30cc4eee3423)


     - **video_url**: This input is where you paste the URL of the audio or video you want to download. It can be from various platforms supported by yt-dlp. For a full list of supported websites, refer to [this link](https://github.com/yt-dlp/yt-dlp/blob/master/supportedsites.md).

     - Example:
       ```
       https://www.youtube.com/watch?v=exampleID
       ```

  2. **Input Audio File for Separation**:

  ![2 and 3](https://github.com/user-attachments/assets/a040a17f-dad1-447a-afef-39fbbe59e556)


     - **input**: This is the file path of the audio you want to separate. After downloading the audio file, you will need to specify this path to continue with separation.

     - Example:
       ```
       /content/ytdl/your_downloaded_audio.wav
       ```

  3. **Output Directory**:
     - **output**: This is the path where the separated files will be saved. It defaults to `/content/output` but can be changed to another directory if desired.

     - Example:
       ```
       /content/custom_output
       ```



  Contributions are very much welcome! Please fork the repository and submit a pull request with your changes, and I'll try to review, merge and publish promptly!

  - This project is 100% open-source and free for anyone to use and modify as they wish.
  - If the maintenance workload for this repo somehow becomes too much for me I'll ask for volunteers to share maintainership of the repo, though I don't think that is very likely
  - Development and support for the MDX-Net separation models is part of the main [UVR project](https://github.com/Anjok07/ultimatevocalremovergui), this repo is just a CLI/Python package wrapper to simplify running those models programmatically. So, if you want to try and improve the actual models, please get involved in the UVR project and look for guidance there!



  This project is licensed under the MIT [License](LICENSE).

  - **Please Note:** If you choose to integrate this project into some other project using the default model or any other model trained as part of the [UVR](https://github.com/Anjok07/ultimatevocalremovergui) project, please honor the MIT license by providing credit to UVR and its developers!



  - [Anjok07](https://github.com/Anjok07) - Author of [Ultimate Vocal Remover GUI](https://github.com/Anjok07/ultimatevocalremovergui), which almost all of the code in this repo was copied from! Definitely deserving of credit for anything good from this project. Thank you!
  - [DilanBoskan](https://github.com/DilanBoskan) - Your contributions at the start of this project were essential to the success of UVR. Thank you!
  - [Kuielab & Woosung Choi](https://github.com/kuielab) - Developed the original MDX-Net AI code.
  - [KimberleyJSN](https://github.com/KimberleyJensen) - Advised and aided the implementation of the training scripts for MDX-Net and Demucs. Thank you!
  - [Hv](https://github.com/NaJeongMo/Colab-for-MDX_B) - Helped implement chunks into the MDX-Net AI code. Thank you!
  - [zhzhongshi](https://github.com/zhzhongshi) - Helped add support for the MDXC models in `audio-separator`. Thank you!



  For questions or feedback, please raise an issue or reach out to @beveradb ([Andrew Beveridge](mailto:andrew@beveridge.uk)) directly.



  <!-- sponsors --><!-- sponsors -->


pkgId: e42fe18e4d561d94a388db3ff23ceba1d367b422fe28e815d6ab136bd6ddef31
name: python-audio-transformers
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Audio data transformations library with a command-line interface.
url: https://github.com/stepan-anokhin/audio-transformers
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audio-transformers-1.0.0-1.src.rpm
checksum_type: sha256
description:
  BandPass           Apply band-pass filter.
  BandStop           Apply band-stop filter.
  GaussianNoise      Add gaussian noise to the signal.
  HighPass           Apply high-pass filter.
  Inversion          Inverse waveform polarity by multiplying it by -1.
  LowPass            Apply low-pass filter.
  PitchShift         Pitch shift transformation.
  SpeedPerturbation  Speed perturbation transformer.
  ```

  Run:
  ```shell
  audio transform params TRANSFORMATION
  ```
  For example:
  ```shell
  audio transform params PitchShift
  ```
  Output:
  ```


pkgId: c76b718ce6f5512a029fab95ab8ee0fc4a3915edcf62448b15a2f2693549466e
name: python-audio-upscaler
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: This package is written for text-to-audio/music generation.
url: https://github.com/IAHispano/Audio-Upscaler
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audio-upscaler-0.1.4-1.src.rpm
checksum_type: sha256
description:
  [![arXiv](https://img.shields.io/badge/arXiv-2309.07314-brightgreen.svg?style=flat-square)](https://arxiv.org/abs/2309.07314)  [![githubio](https://img.shields.io/badge/GitHub.io-Audio_Samples-blue?logo=Github&style=flat-square)](https://audioldm.github.io/audiosr)



  AudioSR is a powerful tool designed to enhance the fidelity of your audio files, regardless of their type (e.g., music, speech, ambient sounds) or sampling rates. It leverages cutting-edge super-resolution techniques to upscale audio signals, resulting in superior quality output.



  - **Versatility**: Works seamlessly with all types of audio content, including music, speech, environmental sounds, and more.
  - **Scale**: Handles audio files of various sampling rates, ensuring compatibility with a wide range of sources.
  - **High Fidelity**: Produces high-quality output with enhanced clarity and detail.
  - **Ease of Use**: Simple and intuitive interface makes it easy to enhance your audio files with just a few clicks.


  Based on the work of https://github.com/haoheliu/versatile_audio_super_resolution/

  ```bibtex
  @article{liu2023audiosr,
    title={{AudioSR}: Versatile Audio Super-resolution at Scale},
    author={Liu, Haohe and Chen, Ke and Tian, Qiao and Wang, Wenwu and Plumbley, Mark D},
    journal={arXiv preprint arXiv:2309.07314},
    year={2023}
  }
  ```


pkgId: 2b85e5279ab55df89ec2c3f1b3f7570e2be4adc3aab7cf72a780142a83c67468
name: python-audio2numpy
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Load audio file to numpy array
url: https://github.com/wiccy46/audio2numpy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audio2numpy-0.1.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/wiccy46/audio2numpy.svg?branch=master)](https://travis-ci.com/wiccy46/audio2numpy)



  audio2numpy load an audio file and directly ouputs the audio data as a numpy array and its sampling rate. Supports .wav, .aiff via python's standard library, and .mp3 via ffmpeg.



  Using pip:

      pip install audio2numpy


  audio2numpy requires ffmpeg to decode mp3 files. You would need to install ffmpeg in order to have mp3 support.


      homebrew install ffmpeg


      sudo apt-get install ffmpeg
  [Check here](https://www.ostechnix.com/install-ffmpeg-linux/) for other installation methods for different Linux distributions.


  - Download the latest distribution from https://ffmpeg.zeranoe.com/builds/
  - Unzip the folder, preferably to `C:\`
  - Append the FFmpeg binary folder (e.g. `C:\ffmpeg\bin`) to the PATH system variable ([How do I set or change the PATH system variable?](https://www.java.com/en/download/help/path.xml))



      from audio2numpy import open_audio
      fp = "./examples/word.mp3"  # change to the correct path to your file accordingly
      signal, sampling_rate = open_audio(fp)



  **0.1.2 (20.08.2019)**

  Add instructions to install ffmpeg if load mp3 failed with ffmpeg backend not available.

  **0.1.1 (14.08.2019)**

  Initial release.


pkgId: 48fb63e5926292865918c66cfec6dd0d69787f8aad03a4680741dfc182b62ead
name: python-audiobook-dl
arch: src
version: 0.7.3
epoch: 0
release: 1
summary: CLI tool for downloading audiobooks from online sources
url: https://github.com/jo1gi/audiobook-dl
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audiobook-dl-0.7.3-1.src.rpm
checksum_type: sha256
description:
  ![GitHub release](https://img.shields.io/github/v/release/jo1gi/audiobook-dl)
  ![GitHub top language](https://img.shields.io/github/languages/top/jo1gi/audiobook-dl)
  ![License](https://img.shields.io/github/license/jo1gi/audiobook-dl)
  [![Donate using Ko-Fi](https://img.shields.io/badge/donate-kofi-00b9fe?logo=ko-fi&logoColor=00b9fe)](https://ko-fi.com/jo1gi)

  CLI tool for downloading audiobooks from online sources.


  audiobook-dl currently supports downloading from the following sources:
  - [audiobooks.com](https://audiobooks.com)
  - [Blinkist](https://www.blinkist.com)
  - [Chirp](https://www.chirpbooks.com/)
  - [eReolen](https://ereolen.dk)
  - [Everand (previously Scribd)](https://everand.com)
  - [Librivox](https://librivox.org)
  - [Nextory](https://nextory.com)
  - [Overdrive / Libby](https://www.overdrive.com/)
  - [Podimo](https://podimo.com)
  - [Saxo](https://saxo.com)
  - [Storytel](https://www.storytel.com/) / [Mofibo](https://mofibo.com)
  - [YourCloudLibrary](https://www.yourcloudlibrary.com/)

  [More info](./supported_sites.md)


  audiobook-dl can be installed from the repo itself or through pip.

  To get the newest stable version with pip run:
  ```shell
  pip install audiobook-dl
  ```

  If you want to use the newest version (can be unstable) run:
  ```shell
  pip install "git+https://github.com/jo1gi/audiobook-dl.git"
  ```
  or
  ```shell
  git clone https://github.com/jo1gi/audiobook-dl.git
  cd audiobook-dl
  python3 setup.py install
  ```

  Some features require [ffmpeg](https://ffmpeg.org/) which can be installed
  through most package managers or from [ffmpeg.org/download.html](https://ffmpeg.org/download.html).




  audiobook-dl uses Netscape cookie files for authentication in most cases. I use
  [this](https://github.com/rotemdan/ExportCookies) extension to export my cookies
  from the browser.

  Cookies can be placed in current dir as `cookies.txt` or be given with the
  `--cookie` argument.


  [Some sources](./supported_sites.md) support authentication through login with
  username and password (and sometimes library). Use the `--username` and
  `--password` arguments or enter them through an interactive prompt.


  ```shell
  audiobook-dl -c <cookie file> <url>
  ```
  **Most sites require you to provide the listening page not not just the
  information page**



  | Argument          | Value                                                             |
  |-------------------|-------------------------------------------------------------------|
  | url               | The url of the page where you listen to the audiobook             |
  | -c/--cookie       | Path to a Netscape cookie file                                    |
  | --combine         | Combine all output files into a single file (requires ffmpeg)     |
  | --cover           | Only download cover                                               |
  | -d/--debug        | Print debug information                                           |
  | -o/--output       | Output location                                                   |
  | --remove-chars    | List of characters that will be removed from output path          |
  | --no-chapters     | Don't include chapters in output file                             |
  | --output-format   | Output file format                                                |
  | --verbose--ffmpeg | Show ffmpeg output in terminal                                    |
  | --username        | Username to source (Required when using login)                    |
  | --password        | Password to source (Required when using login)                    |
  | --library         | Specific library on service (Sometimes required when using login) |


  By default, audiobook-dl saves all audiobooks to `{title}` relative to the
  current path. This can be changed with the `--output` argument. Path can be
  customized by audiobook with the following fields:
  - `title`
  - `author`
  - `series`
  - `narrator`

  Not all fields are available for all audiobooks.

  The file extension can be changed with the `--output-format` argument.


  Issues, bug-reports, pull requests or ideas for features and improvements are
  **very welcome**.


  If you like the project, please consider donating:
  - [Ko-fi](https://ko-fi.com/jo1gi)
  - [Buy me a Coffee](https://www.buymeacoffee.com/joakimholm)
  <details>
  <summary>Cryptocurrencies</summary>

  - Bitcoin: bc1qrh8hcnw0fd22y7rmljlmrztwrz2nd5tqckrt44
  - Bitcoin Cash: qp6rt9zx7tfyu9e4alxcn5yf4re5pfztvu8yx0rywh
  - Dash: XfgopGkj4BBpuzsUvrbj9jenXUZ6dXsr3J
  - Etherium: 0x8f5d2eb6d2a4d4615d2b9b1cfa28b4c5b9d18f9f
  - Litecoin: ltc1qfz2936a04m2h7t0srxftygjrq759auav7ndfd3
  - Monero: 853tLAbK5wQ93mdj884C31JGKBUEJCpM25gEjGGLnuVDc8PEDMJi6uC5Vcz9g37K2PeT8FY1bjEveUWqJXNPotFRLwLnn9a

  </details>


pkgId: e773caf299fbc3ccc023273cd8bd1cd6019c519720c604faba02a471400ffe71
name: python-audioconverter
arch: src
version: 2.0.3
epoch: 0
release: 1
summary: CLI for converting audio files from one format to another
url: https://github.com/lamdav/AudioConverter
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audioconverter-2.0.3-1.src.rpm
checksum_type: sha256
description:
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  A simple CLI to convert a directory of audio files from  one format
  to another. This CLI sits ontop of `pydub` and `ffmpeg`


  I have some old music in a lossless format. Now that I am constantly
  jumping between computers, I wanted it to be converted in
  a more universal format such as `mp3` so that I can play it with
  the simplest of players. I also wanted to avoid having
  to stream my music on cloud platforms. Upon a cursory and naive scan
  on the web, I found that existing scripts are defunct (again cursory)
  or was not as simple as I would like it to be. I did not want to download
  a GUI for a one time use or upload a directory of music online to have it
  be converted on some server and download it again either. Instead, I wrote
  this quick CLI to do it for me.



  Go follow the `pydub`
  [tutorial](https://github.com/jiaaro/pydub#getting-ffmpeg-set-up)
  on how to set up `ffmpeg` on the various platforms.


  ```shell
  pip install --upgrade AudioConverter
  ```


  ```shell
  audioconvert [--verbose/-v] convert INPUT_DIRECTORY OUTPUT_DIRECTORY [--output-format/-o TARGET_FORMAT]
  ```
  This will recursively search the `INPUT_DIRECTORY` for files with music
  extensions. Each file found will then be converted to the `TARGET_FORMAT` and
  placed in the `OUTPUT_DIRECTORY` with the same name but updated extension.

  The `--verbose/-v` flag must be provided before the `convert` command. This
  will enable debugging logs and allow you to monitor progress.

  For example - to convert the contents of the directory `input/`, containing
  files of type `.m4a` and `.flac`, outputting to directory `output/`, converting
  to type `.mp3` run:

  ```shell
  audioconvert convert input/ output/ --output-format .mp3
  ```


  Audio can be passed to be converted to specific codecs. This is an experimental now feature
  as it has no error checking that certain codecs are compatible with your desired output
  audio format. Depending on `ffmpeg` and/or `pydub`, there may or may not be error logging.

  To use the new experimental feature:
  ```shell
  audioconvert convert input/ output/ --output-format .wav --codec pcm_mulaw
  ```


  Due to not being super savvy with audio formats, I hard coded the extensions
  that are searched for in the `INPUT_DIRECTORY` and acceptable `TARGET_FORMAT`.
  Here is a list of formats I thought were popular:
  - .mp3
  - .flac
  - .aiff
  - .mp4
  - .m4a
  - .wav
  - .ogg


  - pcm_mulaw


pkgId: 8ba143cc3b3baac89c160ae212ccc07bab886438787d2645cd4f640f37857206
name: python-audiocraft
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Audio generation research library for PyTorch
url: https://github.com/facebookresearch/audiocraft
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audiocraft-1.3.0-1.src.rpm
checksum_type: sha256
description:
  ![docs badge](https://github.com/facebookresearch/audiocraft/workflows/audiocraft_docs/badge.svg)
  ![linter badge](https://github.com/facebookresearch/audiocraft/workflows/audiocraft_linter/badge.svg)
  ![tests badge](https://github.com/facebookresearch/audiocraft/workflows/audiocraft_tests/badge.svg)

  AudioCraft is a PyTorch library for deep learning research on audio generation. AudioCraft contains inference and training code
  for two state-of-the-art AI generative models producing high-quality audio: AudioGen and MusicGen.



  AudioCraft requires Python 3.9, PyTorch 2.1.0. To install AudioCraft, you can run the following:

  ```shell


  python -m pip install 'torch==2.1.0'

  python -m pip install setuptools wheel

  python -m pip install -U audiocraft  # stable release
  python -m pip install -U git+https://git@github.com/facebookresearch/audiocraft#egg=audiocraft  # bleeding edge
  python -m pip install -e .  # or if you cloned the repo locally (mandatory if you want to train).
  ```

  We also recommend having `ffmpeg` installed, either through your system or Anaconda:
  ```bash
  sudo apt-get install ffmpeg

  conda install "ffmpeg<5" -c conda-forge
  ```



  At the moment, AudioCraft contains the training code and inference code for:
  * [MusicGen](./docs/MUSICGEN.md): A state-of-the-art controllable text-to-music model.
  * [AudioGen](./docs/AUDIOGEN.md): A state-of-the-art text-to-sound model.
  * [EnCodec](./docs/ENCODEC.md): A state-of-the-art high fidelity neural audio codec.
  * [Multi Band Diffusion](./docs/MBD.md): An EnCodec compatible decoder using diffusion.
  * [MAGNeT](./docs/MAGNET.md): A state-of-the-art non-autoregressive model for text-to-music and text-to-sound.



  AudioCraft contains PyTorch components for deep learning research in audio and training pipelines for the developed models.
  For a general introduction of AudioCraft design principles and instructions to develop your own training pipeline, refer to
  the [AudioCraft training documentation](./docs/TRAINING.md).

  For reproducing existing work and using the developed training pipelines, refer to the instructions for each specific model
  that provides pointers to configuration, example grids and model/task-specific information and FAQ.




  We provide some [API documentation](https://facebookresearch.github.io/audiocraft/api_docs/audiocraft/index.html) for AudioCraft.






  Yes! We provide the training code for [EnCodec](./docs/ENCODEC.md), [MusicGen](./docs/MUSICGEN.md) and [Multi Band Diffusion](./docs/MBD.md).



  Hugging Face stored the model in a specific location, which can be overridden by setting the `AUDIOCRAFT_CACHE_DIR` environment variable for the AudioCraft models.
  In order to change the cache location of the other Hugging Face models, please check out the [Hugging Face Transformers documentation for the cache setup](https://huggingface.co/docs/transformers/installation#cache-setup).
  Finally, if you use a model that relies on Demucs (e.g. `musicgen-melody`) and want to change the download location for Demucs, refer to the [Torch Hub documentation](https://pytorch.org/docs/stable/hub.html#where-are-my-downloaded-models-saved).



  * The code in this repository is released under the MIT license as found in the [LICENSE file](LICENSE).
  * The models weights in this repository are released under the CC-BY-NC 4.0 license as found in the [LICENSE_weights file](LICENSE_weights).




  For the general framework of AudioCraft, please cite the following.
  ```
  @inproceedings{copet2023simple,
      title={Simple and Controllable Music Generation},
      author={Jade Copet and Felix Kreuk and Itai Gat and Tal Remez and David Kant and Gabriel Synnaeve and Yossi Adi and Alexandre Défossez},
      booktitle={Thirty-seventh Conference on Neural Information Processing Systems},
      year={2023},
  }
  ```

  When referring to a specific model, please cite as mentioned in the model specific README, e.g
  [./docs/MUSICGEN.md](./docs/MUSICGEN.md), [./docs/AUDIOGEN.md](./docs/AUDIOGEN.md), etc.


pkgId: 24a9867d1003b5ae51259ffe1779740bdc91a01f64f4d071fa87f5db81599016
name: python-audiodiffusion
arch: src
version: 1.5.7
epoch: 0
release: 1
summary: Generate Mel spectrogram dataset from directory of audio files.
url: https://pypi.org/project/audiodiffusion/
rpm_license: GPL3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audiodiffusion-1.5.7-1.src.rpm
checksum_type: sha256
description:
  title: Audio Diffusion
  emoji: 🎵
  colorFrom: pink
  colorTo: blue
  sdk: gradio
  sdk_version: 3.1.4
  app_file: app.py
  pinned: false


pkgId: 90761cd66bd25a093852df206e09d9d411bbc83de5d571a89d0c0045a4a2c6d7
name: python-audiofile
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: Fast reading of all kind of audio files
url: https://pypi.org/project/audiofile/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audiofile-1.5.0-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2018-present audEERING GmbH and Contributors  Author: Hagen Wierstorf Johannes Wagner Christian Geng  Contributors: Fabian-Robert Stöter (code for benchmarks)  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: fb24c2958567782f8a270d9535ec22aa4e65850f20cfdb98da6c23cb79664144
name: python-audioio
arch: src
version: 2.2.0
epoch: 0
release: 1
url: https://pypi.org/project/audioio/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audioio-2.2.0-1.src.rpm
checksum_type: sha256
summary:
  Platform independent interfacing of numpy arrays of floats with audio files and devices for scientific data analysis.

description:
  wave              is  installed (F)
  ewave             not installed (F)
  scipy.io.wavfile  is  installed (F)
  soundfile         is  installed (F)
  wavefile          not installed (F)
  audioread         is  installed (F)
  pydub             is  installed (F)
  pyaudio           not installed (D)
  sounddevice       not installed (D)
  simpleaudio       NOT installed (D)
  soundcard         not installed (D)
  ossaudiodev       is  installed (D)
  winsound          not installed (D)
  F: file I/O, D: audio device
  For better performance you should install the following modules:

rpm_license:
[cell repeats an earlier one in this file: 34478 characters]


pkgId: f1547011ea3db4659374fc04f6ce000e84a54d7792c46c6be8ed6baee530461f
name: python-audioldm
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: This package is written for text-to-audio generation.
url: https://github.com/haoheliu/audioldm
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audioldm-0.1.1-1.src.rpm
checksum_type: sha256
description:
  [![arXiv](https://img.shields.io/badge/arXiv-2301.12503-brightgreen.svg?style=flat-square)](https://arxiv.org/abs/2301.12503)  [![githubio](https://img.shields.io/badge/GitHub.io-Audio_Samples-blue?logo=Github&style=flat-square)](https://audioldm.github.io/)  [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/haoheliu/audioldm-text-to-audio-generation)  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/olaviinha/NeuralTextToAudio/blob/main/AudioLDM_pub.ipynb?force_theme=dark)  [![Replicate](https://replicate.com/jagilley/audio-ldm/badge)](https://replicate.com/jagilley/audio-ldm)

  <!-- # [![PyPI version](https://badge.fury.io/py/voicefixer.svg)](https://badge.fury.io/py/voicefixer) -->

  **Generate speech, sound effects, music and beyond.**

  This repo currently support:

  - **Text-to-Audio Generation**: Generate audio given text input.
  - **Audio-to-Audio Generation**: Given an audio, generate another audio that contain the same type of sound.
  - **Text-guided Audio-to-Audio Style Transfer**: Transfer the sound of an audio into another one using the text description.

  <hr>


  1. Try to provide more hints to AudioLDM, such as using more adjectives to describe your sound (e.g., clearly, high quality) or make your target more specific (e.g., "water stream in a forest" instead of "stream"). This can make sure AudioLDM understand what you want.
  2. Try to use different random seeds, which can affect the generation quality significantly sometimes.
  3. It's best to use general terms like 'man' or 'woman' instead of specific names for individuals or abstract objects that humans may not be familiar with.



  **2023-04-10**: Try to finetune AudioLDM with MusicCaps and AudioCaps datasets. Add three more checkpoints, including audioldm-m-text-ft, audioldm-s-text-ft, and audioldm-m-full.

  **2023-03-04**: Add two more checkpoints, one is small model with more training steps, another is a large model. Add model selection in the Gradio APP.

  **2023-02-24**: Add audio-to-audio generation. Add test cases. Add a pipeline (python function) for audio super-resolution and inpainting.

  **2023-02-15**: Add audio style transfer. Add more options on generation.



  The web APP currently only support Text-to-Audio generation. For full functionality please refer to the [Commandline Usage](https://github.com/haoheliu/AudioLDM#commandline-usage).

  1. Prepare running environment
  ```shell
  conda create -n audioldm python=3.8; conda activate audioldm
  pip3 install audioldm
  git clone https://github.com/haoheliu/AudioLDM; cd AudioLDM
  ```
  2. Start the web application (powered by Gradio)
  ```shell
  python3 app.py
  ```
  3. A link will be printed out. Click the link to open the browser and play.


  Prepare running environment
  ```shell

  conda create -n audioldm python=3.8; conda activate audioldm

  pip3 install audioldm
  ```

  :star2: **Text-to-Audio Generation**: generate an audio guided by a text
  ```shell

  audioldm -t "A hammer is hitting a wooden surface"

  ```

  :star2: **Audio-to-Audio Generation**: generate an audio guided by an audio (output will have similar audio events as the input audio file).
  ```shell
  audioldm --file_path trumpet.wav

  ```

  :star2: **Text-guided Audio-to-Audio Style Transfer**
  ```shell




  audioldm --mode "transfer" --file_path trumpet.wav -t "Children Singing"




  audioldm --mode "transfer" --file_path trumpet.wav -t "Children Singing" --transfer_strength 0.25
  ```

  :gear: How to choose between different model checkpoints?
  ```

  audioldm --model_name audioldm-s-full
  ```

  - :star: audioldm-m-full (default, **recommend**): the medium AudioLDM without finetuning and trained with audio embeddings as condition *(added 2023-04-10)*.
  - :star: audioldm-s-full (**recommend**): the original open-sourced version *(added 2023-02-01)*.
  - :star: audioldm-s-full-v2 (**recommend**): more training steps comparing with audioldm-s-full *(added 2023-03-04)*.
  - audioldm-s-text-ft: the small AudioLDM finetuned with AudioCaps and MusicCaps audio-text pairs *(added 2023-04-10)*.
  - audioldm-m-text-ft: the medium large AudioLDM finetuned with AudioCaps and MusicCaps audio-text pairs *(added 2023-04-10)*.
  - audioldm-l-full: larger model comparing with audioldm-s-full *(added 2023-03-04)*.

  > @haoheliu personally did a evaluation regarding the overall quality of the checkpoint, which gives audioldm-m-full (6.85/10), audioldm-s-full (6.62/10), audioldm-s-text-ft (6/10), audioldm-m-text-ft (5.46/10). These score are only for reference and may not reflect the true performance of the checkpoint. Checkpoint performance also varying with different text input as well.

  :grey_question: For more options on guidance scale, batchsize, seed, ddim steps, etc., please run
  ```shell
  audioldm -h
  ```
  ```console
  usage: audioldm [-h] [--mode {generation,transfer}] [-t TEXT] [-f FILE_PATH] [--transfer_strength TRANSFER_STRENGTH] [-s SAVE_PATH] [--model_name {audioldm-s-full,audioldm-l-full,audioldm-s-full-v2}] [-ckpt CKPT_PATH]
                  [-b BATCHSIZE] [--ddim_steps DDIM_STEPS] [-gs GUIDANCE_SCALE] [-dur DURATION] [-n N_CANDIDATE_GEN_PER_TEXT] [--seed SEED]

  optional arguments:
    -h, --help            show this help message and exit
    --mode {generation,transfer}
                          generation: text-to-audio generation; transfer: style transfer
    -t TEXT, --text TEXT  Text prompt to the model for audio generation, DEFAULT ""
    -f FILE_PATH, --file_path FILE_PATH
                          (--mode transfer): Original audio file for style transfer; Or (--mode generation): the guidance audio file for generating simialr audio, DEFAULT None
    --transfer_strength TRANSFER_STRENGTH
                          A value between 0 and 1. 0 means original audio without transfer, 1 means completely transfer to the audio indicated by text, DEFAULT 0.5
    -s SAVE_PATH, --save_path SAVE_PATH
                          The path to save model output, DEFAULT "./output"
    --model_name {audioldm-s-full,audioldm-l-full,audioldm-s-full-v2}
                          The checkpoint you gonna use, DEFAULT "audioldm-s-full"
    -ckpt CKPT_PATH, --ckpt_path CKPT_PATH
                          (deprecated) The path to the pretrained .ckpt model, DEFAULT None
    -b BATCHSIZE, --batchsize BATCHSIZE
                          Generate how many samples at the same time, DEFAULT 1
    --ddim_steps DDIM_STEPS
                          The sampling step for DDIM, DEFAULT 200
    -gs GUIDANCE_SCALE, --guidance_scale GUIDANCE_SCALE
                          Guidance scale (Large => better quality and relavancy to text; Small => better diversity), DEFAULT 2.5
    -dur DURATION, --duration DURATION
                          The duration of the samples, DEFAULT 10
    -n N_CANDIDATE_GEN_PER_TEXT, --n_candidate_gen_per_text N_CANDIDATE_GEN_PER_TEXT
                          Automatic quality control. This number control the number of candidates (e.g., generate three audios and choose the best to show you). A Larger value usually lead to better quality with heavier computation, DEFAULT 3
    --seed SEED           Change this value (any integer number) will lead to a different generation result. DEFAULT 42
  ```

  For the evaluation of audio generative model, please refer to [audioldm_eval](https://github.com/haoheliu/audioldm_eval).



  Integrated into [Hugging Face Spaces 🤗](https://huggingface.co/spaces) using [Gradio](https://github.com/gradio-app/gradio). Try out the Web Demo [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/haoheliu/audioldm-text-to-audio-generation)



  Try out AudioLDM as a [TuneFlow](https://tuneflow.com) plugin [![TuneFlow x AudioLDM](https://img.shields.io/badge/TuneFlow-AudioLDM-%23C563E6%20)](https://github.com/tuneflow/AudioLDM). See how it can work in a real DAW (Digital Audio Workstation).



  [!["Buy Me A Coffee"](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://www.buymeacoffee.com/haoheliuP)

  - [x] Update the checkpoint with more training steps.
  - [x] Update the checkpoint with more parameters (audioldm-l).
  - [ ] Add AudioCaps finetuned AudioLDM-S model
  - [x] Build pip installable package for commandline use
  - [x] Build Gradio web application
  - [ ] Add super-resolution, inpainting into Gradio web application
  - [ ] Add style-transfer into Gradio web application
  - [x] Add text-guided style transfer
  - [x] Add audio-to-audio generation
  - [x] Add audio super-resolution
  - [x] Add audio inpainting



  If you found this tool useful, please consider citing
  ```bibtex
  @article{liu2023audioldm,
    title={AudioLDM: Text-to-Audio Generation with Latent Diffusion Models},
    author={Liu, Haohe and Chen, Zehua and Yuan, Yi and Mei, Xinhao and Liu, Xubo and Mandic, Danilo and Wang, Wenwu and Plumbley, Mark D},
    journal={arXiv preprint arXiv:2301.12503},
    year={2023}
  }
  ```


  - GPU with 8GB of dedicated VRAM
  - A system with a 64-bit operating system (Windows 7, 8.1 or 10, Ubuntu 16.04 or later, or macOS 10.13 or later) 16GB or more of system RAM


  Part of the code is borrowed from the following repos. We would like to thank the authors of these repos for their contribution.

  > https://github.com/LAION-AI/CLAP

  > https://github.com/CompVis/stable-diffusion

  > https://github.com/v-iashin/SpecVQGAN

  > https://github.com/toshas/torch-fidelity


  We build the model with data from AudioSet, Freesound and BBC Sound Effect library. We share this demo based on the UK copyright exception of data for academic research.

  <!-- This code repo is strictly for research demo purpose only. For commercial use please contact us. -->


pkgId: 726d411b552d4b71aead287a55c8d186c2f8f0738598f761a74d0c4c2a6d3c8e
name: python-audiomatic-python
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Official Python client for the Audiomatic API
url: https://pypi.org/project/audiomatic-python/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audiomatic-python-0.1.0-1.src.rpm
checksum_type: sha256
description:
  The official Python library for the Audiomatic API



  ```bash
  pip install audiomatic-python
  ```



  ```python
  from audiomatic import Audiomatic


  client = Audiomatic(api_key="your_api_key")


  project_id = client.translate(
      source="path/to/video.mp4",
      target_lang="es",
      project_name="Spanish Translation"
  )


  status, result_url = client.get_status(project_id)
  ```





  ```python

  project_id = client.translate(
      source="https://youtube.com/watch?v=example",
      target_lang="fr",
      project_name="French Translation"
  )
  ```



  ```python

  project_id = client.translate(
      source="path/to/video.mp4",
      target_lang="de",
      project_name="German Translation",
      opt_params={
          "accent_level": 0.75,
          "num_speakers": 2,
          "remove_background_audio": True,
          "start_time": 30000,  # Start at 30 seconds
          "end_time": 120000,   # End at 2 minutes
          "captions_path": "path/to/captions.vtt"
      }
  )
  ```







  Initialize the Audiomatic client.

  **Parameters:**
  - `api_key` (str): Your Audiomatic API key





  Translate a video file or YouTube URL.

  **Parameters:**
  - `source` (str): Path to local video file or YouTube URL
  - `target_lang` (str): Target language code (e.g., "es", "fr", "de")
  - `project_name` (str, optional): Custom project name (defaults to filename)
  - `opt_params` (Dict, optional): Additional parameters:
    - `accent_level` (float): Voice accent level (0, 0.25, 0.5, 0.75, or 1)
    - `num_speakers` (int): Number of speakers in video (defaults to auto-detect)
    - `remove_background_audio` (bool): Whether to remove background audio
    - `start_time` (int): Start time of video clip in milliseconds
    - `end_time` (int): End time of video clip in milliseconds
    - `captions_path` (str): Path to custom captions file

  **Returns:** Project ID string



  Check the status of a translation project.

  **Parameters:**
  - `project_id` (str): Project ID returned from translate()

  **Returns:** Tuple of (status, result_url)



  - Maximum file size: 500MB
  - Maximum video duration: 15 minutes
  - Supported accent levels: 0, 0.25, 0.5, 0.75, 1



  The client includes a custom `AudiomaticError` exception class that provides detailed error information:

  ```python
  try:
      project_id = client.translate(...)
  except AudiomaticError as e:
      print(f"Error: {e}")
      print(f"Status Code: {e.status_code}")
      print(f"Error Code: {e.error_code}")
  ```


pkgId: 8a47decf3cadc701b6ff8272a5c1003ae2a14f0fa53db5dae2c2ef93cfecb0c6
name: python-audiomentations
arch: src
version: 0.37.0
epoch: 0
release: 1
url: https://github.com/iver56/audiomentations
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audiomentations-0.37.0-1.src.rpm
checksum_type: sha256
summary:
  A Python library for audio data augmentation. Inspired by albumentations. Useful for machine learning.

description:
  [![Build status](https://img.shields.io/circleci/project/github/iver56/audiomentations/main.svg)](https://circleci.com/gh/iver56/audiomentations)
  [![Code coverage](https://img.shields.io/codecov/c/github/iver56/audiomentations/main.svg)](https://codecov.io/gh/iver56/audiomentations)
  [![Code Style: Black](https://img.shields.io/badge/code%20style-black-black.svg)](https://github.com/ambv/black)
  [![Licence: MIT](https://img.shields.io/pypi/l/audiomentations)](https://github.com/iver56/audiomentations/blob/main/LICENSE)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.13639627.svg)](https://doi.org/10.5281/zenodo.13639627)

  A Python library for audio data augmentation. Inspired by
  [albumentations](https://github.com/albu/albumentations). Useful for deep learning. Runs on
  CPU. Supports mono audio and multichannel audio. Can be
  integrated in training pipelines in e.g. Tensorflow/Keras or Pytorch. Has helped people get
  world-class results in Kaggle competitions. Is used by companies making next-generation audio
  products.

  Need a Pytorch-specific alternative with GPU support? Check out [torch-audiomentations](https://github.com/asteroid-team/torch-audiomentations)!



  ![Python version support](https://img.shields.io/pypi/pyversions/audiomentations)
  [![PyPI version](https://img.shields.io/pypi/v/audiomentations.svg?style=flat)](https://pypi.org/project/audiomentations/)
  [![Number of downloads from PyPI per month](https://img.shields.io/pypi/dm/audiomentations.svg?style=flat)](https://pypi.org/project/audiomentations/)
  ![os: Linux, macOS, Windows](https://img.shields.io/badge/OS-Linux%20%28arm%20%26%20x86%29%20|%20macOS%20%28arm%20|%20Windows%20%28x86%29-blue)

  `pip install audiomentations`



  ```python
  from audiomentations import Compose, AddGaussianNoise, TimeStretch, PitchShift, Shift
  import numpy as np

  augment = Compose([
      AddGaussianNoise(min_amplitude=0.001, max_amplitude=0.015, p=0.5),
      TimeStretch(min_rate=0.8, max_rate=1.25, p=0.5),
      PitchShift(min_semitones=-4, max_semitones=4, p=0.5),
      Shift(p=0.5),
  ])


  samples = np.random.uniform(low=-0.2, high=0.2, size=(32000,)).astype(np.float32)


  augmented_samples = augment(samples=samples, sample_rate=16000)
  ```



  The API documentation, along with guides, example code, illustrations and example sounds, is available at [https://iver56.github.io/audiomentations/](https://iver56.github.io/audiomentations/)



  * [AddBackgroundNoise](https://iver56.github.io/audiomentations/waveform_transforms/add_background_noise/): Mixes in another sound to add background noise
  * [AddColorNoise](https://iver56.github.io/audiomentations/waveform_transforms/add_color_noise/): Adds noise with specific color
  * [AddGaussianNoise](https://iver56.github.io/audiomentations/waveform_transforms/add_gaussian_noise/): Adds gaussian noise to the audio samples
  * [AddGaussianSNR](https://iver56.github.io/audiomentations/waveform_transforms/add_gaussian_snr/): Injects gaussian noise using a randomly chosen signal-to-noise ratio
  * [AddShortNoises](https://iver56.github.io/audiomentations/waveform_transforms/add_short_noises/): Mixes in various short noise sounds
  * [AdjustDuration](https://iver56.github.io/audiomentations/waveform_transforms/adjust_duration/): Trims or pads the audio to fit a target duration
  * [AirAbsorption](https://iver56.github.io/audiomentations/waveform_transforms/air_absorption/): Applies frequency-dependent attenuation simulating air absorption
  * [Aliasing](https://iver56.github.io/audiomentations/waveform_transforms/aliasing/): Produces aliasing artifacts by downsampling without low-pass filtering and then upsampling
  * [ApplyImpulseResponse](https://iver56.github.io/audiomentations/waveform_transforms/apply_impulse_response/): Convolves the audio with a randomly chosen impulse response
  * [BandPassFilter](https://iver56.github.io/audiomentations/waveform_transforms/band_pass_filter/): Applies band-pass filtering within randomized parameters
  * [BandStopFilter](https://iver56.github.io/audiomentations/waveform_transforms/band_stop_filter/): Applies band-stop (notch) filtering within randomized parameters
  * [BitCrush](https://iver56.github.io/audiomentations/waveform_transforms/bit_crush/): Applies bit reduction without dithering
  * [Clip](https://iver56.github.io/audiomentations/waveform_transforms/clip/): Clips audio samples to specified minimum and maximum values
  * [ClippingDistortion](https://iver56.github.io/audiomentations/waveform_transforms/clipping_distortion/): Distorts the signal by clipping a random percentage of samples
  * [Gain](https://iver56.github.io/audiomentations/waveform_transforms/gain/): Multiplies the audio by a random gain factor
  * [GainTransition](https://iver56.github.io/audiomentations/waveform_transforms/gain_transition/): Gradually changes the gain over a random time span
  * [HighPassFilter](https://iver56.github.io/audiomentations/waveform_transforms/high_pass_filter/): Applies high-pass filtering within randomized parameters
  * [HighShelfFilter](https://iver56.github.io/audiomentations/waveform_transforms/high_shelf_filter/): Applies a high shelf filter with randomized parameters
  * [Lambda](https://iver56.github.io/audiomentations/waveform_transforms/lambda/): Applies a user-defined transform
  * [Limiter](https://iver56.github.io/audiomentations/waveform_transforms/limiter/): Applies dynamic range compression limiting the audio signal
  * [LoudnessNormalization](https://iver56.github.io/audiomentations/waveform_transforms/loudness_normalization/): Applies gain to match a target loudness
  * [LowPassFilter](https://iver56.github.io/audiomentations/waveform_transforms/low_pass_filter/): Applies low-pass filtering within randomized parameters
  * [LowShelfFilter](https://iver56.github.io/audiomentations/waveform_transforms/low_shelf_filter/): Applies a low shelf filter with randomized parameters
  * [Mp3Compression](https://iver56.github.io/audiomentations/waveform_transforms/mp3_compression/): Compresses the audio to lower the quality
  * [Normalize](https://iver56.github.io/audiomentations/waveform_transforms/normalize/): Applies gain so that the highest signal level becomes 0 dBFS
  * [Padding](https://iver56.github.io/audiomentations/waveform_transforms/padding/): Replaces a random part of the beginning or end with padding
  * [PeakingFilter](https://iver56.github.io/audiomentations/waveform_transforms/peaking_filter/): Applies a peaking filter with randomized parameters
  * [PitchShift](https://iver56.github.io/audiomentations/waveform_transforms/pitch_shift/): Shifts the pitch up or down without changing the tempo
  * [PolarityInversion](https://iver56.github.io/audiomentations/waveform_transforms/polarity_inversion/): Flips the audio samples upside down, reversing their polarity
  * [RepeatPart](https://iver56.github.io/audiomentations/waveform_transforms/repeat_part/): Repeats a subsection of the audio a number of times
  * [Resample](https://iver56.github.io/audiomentations/waveform_transforms/resample/): Resamples the signal to a randomly chosen sampling rate
  * [Reverse](https://iver56.github.io/audiomentations/waveform_transforms/reverse/): Reverses the audio along its time axis
  * [RoomSimulator](https://iver56.github.io/audiomentations/waveform_transforms/room_simulator/): Simulates the effect of a room on an audio source
  * [SevenBandParametricEQ](https://iver56.github.io/audiomentations/waveform_transforms/seven_band_parametric_eq/): Adjusts the volume of 7 frequency bands
  * [Shift](https://iver56.github.io/audiomentations/waveform_transforms/shift/): Shifts the samples forwards or backwards
  * [SpecChannelShuffle](https://iver56.github.io/audiomentations/spectrogram_transforms/): Shuffles channels in the spectrogram
  * [SpecFrequencyMask](https://iver56.github.io/audiomentations/spectrogram_transforms/): Applies a frequency mask to the spectrogram
  * [TanhDistortion](https://iver56.github.io/audiomentations/waveform_transforms/tanh_distortion/): Applies tanh distortion to distort the signal
  * [TimeMask](https://iver56.github.io/audiomentations/waveform_transforms/time_mask/): Makes a random part of the audio silent
  * [TimeStretch](https://iver56.github.io/audiomentations/waveform_transforms/time_stretch/): Changes the speed without changing the pitch
  * [Trim](https://iver56.github.io/audiomentations/waveform_transforms/trim/): Trims leading and trailing silence from the audio







  * Leverage the SIMD-accelerated [numpy-minmax](https://github.com/nomonosound/numpy-minmax) package for speed improvements. These transforms are faster now: `Limiter`, `Mp3Compression` and `Normalize`. Unfortunately, this removes support for Intel-based Macs. Intel Mac users have the following options: A) use audiomentations 0.36.1, B) Create a fork of audiomentations C) submit a patch to numpy-minmax, D) run Linux or Windows.
  * Limit numpy dependency to >=1.21,<2 for now, since numpy v2 is not officially supported yet.

  For the full changelog, including older versions, see [https://iver56.github.io/audiomentations/changelog/](https://iver56.github.io/audiomentations/changelog/)



  Thanks to [Nomono](https://nomono.co/) for backing audiomentations.

  Thanks to [all contributors](https://github.com/iver56/audiomentations/graphs/contributors) who help improving audiomentations.


pkgId: 8a4a45621c853ede4f5c7f4385a860a5438d1635b5542c98f5563095de106cb8
name: python-audiometry-trainer
arch: src
version: 0.1.16
epoch: 0
release: 1
summary: Clinical audiometry simulator
url: https://gitlab.com/sam81/audiometry_trainer
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audiometry-trainer-0.1.16-1.src.rpm
checksum_type: sha256
description:
  Audiometry simulator which can be used for training clinical audiometry and clinical masking. Homepage: https://samcarcagno.altervista.org/audiometry_trainer/audiometry_trainer.html

rpm_license:
  GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007  Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The GNU General Public License is a free, copyleft license for software and other kinds of works.  The licenses for most software and other practical works are designed to take away your freedom to share and change the works.  By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users.  We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors.  You can apply it to your programs, too.  When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.  To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights.  Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others.  For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received.  You must make sure that they, too, receive or can get the source code.  And you must show them these terms so they know their rights.  Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it.  For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software.  For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions.  Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so.  This is fundamentally incompatible with the aim of protecting users' freedom to change the software.  The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable.  Therefore, we have designed this version of the GPL to prohibit the practice for those products.  If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users.  Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary.  To prevent this, the GPL assures that patents cannot be used to render the program non-free.  The precise terms and conditions for copying, distribution and modification follow.  TERMS AND CONDITIONS  0. Definitions.  "This License" refers to version 3 of the GNU General Public License.  "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.  "The Program" refers to any copyrightable work licensed under this License.  Each licensee is addressed as "you".  "Licensees" and "recipients" may be individuals or organizations.  To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy.  The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.  A "covered work" means either the unmodified Program or a work based on the Program.  To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy.  Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.  To "convey" a work means any kind of propagation that enables other parties to make or receive copies.  Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.  An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License.  If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.  1. Source Code.  The "source code" for a work means the preferred form of the work for making modifications to it.  "Object code" means any non-source form of a work.  A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.  The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form.  A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.  The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities.  However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.  For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.  The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.  The Corresponding Source for a work in source code form is that same work.  2. Basic Permissions.  All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met.  This License explicitly affirms your unlimited permission to run the unmodified Program.  The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work.  This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.  You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force.  You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright.  Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.  Conveying under any other circumstances is permitted solely under the conditions stated below.  Sublicensing is not allowed; section 10 makes it unnecessary.  3. Protecting Users' Legal Rights From Anti-Circumvention Law.  No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.  When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.  4. Conveying Verbatim Copies.  You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.  You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.  5. Conveying Modified Source Versions.  You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:  a) The work must carry prominent notices stating that you modified it, and giving a relevant date.  b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7.  This requirement modifies the requirement in section 4 to "keep intact all notices".  c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy.  This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged.  This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.  d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.  A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit.  Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.  6. Conveying Non-Source Forms.  You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:  a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.  b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.  c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source.  This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.  d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge.  You need not require recipients to copy the Corresponding Source along with the object code.  If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source.  Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.  e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.  A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.  A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling.  In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage.  For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product.  A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.  "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source.  The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.  If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information.  But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).  The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed.  Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.  Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.  7. Additional Terms.  "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law.  If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.  When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it.  (Additional permissions may be written to require their own removal in certain cases when you modify the work.)  You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.  Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:  a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or  b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or  c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or  d) Limiting the use for publicity purposes of names of licensors or authors of the material; or  e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or  f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.  All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10.  If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term.  If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.  If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.  Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.  8. Termination.  You may not propagate or modify a covered work except as expressly provided under this License.  Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).  However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.  Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.  Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License.  If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.  9. Acceptance Not Required for Having Copies.  You are not required to accept this License in order to receive or run a copy of the Program.  Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance.  However, nothing other than this License grants you permission to propagate or modify any covered work.  These actions infringe copyright if you do not accept this License.  Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.  10. Automatic Licensing of Downstream Recipients.  Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License.  You are not responsible for enforcing compliance by third parties with this License.  An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations.  If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.  You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.  For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.  11. Patents.  A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based.  The work thus licensed is called the contributor's "contributor version".  A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version.  For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.  Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.  In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement).  To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.  If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients.  "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.  If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.  A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License.  You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.  Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.  12. No Surrender of Others' Freedom.  If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all.  For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.  13. Use with the GNU Affero General Public License.  Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work.  The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such.  14. Revised Versions of this License.  The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation.  If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.  Later license versions may give you additional or different permissions.  However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.  15. Disclaimer of Warranty.  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. Limitation of Liability.  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  17. Interpretation of Sections 15 and 16.  If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Programs  If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.  To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  <one line to give the program's name and a brief idea of what it does.> Copyright (C) <year>  <name of author>  This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.  Also add information on how to contact you by electronic and paper mail.  If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode:  <program>  Copyright (C) <year>  <name of author> This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.  The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License.  Of course, your program's commands might be different; for a GUI interface, you would use an "about box".  You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see <http://www.gnu.org/licenses/>.  The GNU General Public License does not permit incorporating your program into proprietary programs.  If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library.  If this is what you want to do, use the GNU Lesser General Public License instead of this License.  But first, please read <http://www.gnu.org/philosophy/why-not-lgpl.html>.


pkgId: 44a0bfc345546b57bfdb84e711370cb53372aee719e5ca965e3c1f742522abce
name: python-audiopython
arch: src
version: 0.0.22
epoch: 0
release: 1
summary: A package with functionality for offline audio processing
url: https://fleximeter.github.io/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audiopython-0.0.22-1.src.rpm
checksum_type: sha256
description:
  This is a Python library for working with audio. It comes in two flavors - a regular Python version called `pyaudiopython`, contained in the `pyaudiopython` directory, and a Cython version called `caudiopython`, contained in the `caudiopython` directory. There is a separate directory called `audiopython` that is set up for building a package - at the moment, this directory contains a copy of the Cython version.

  You can install this library from PyPi by running the command `pip install audiopython`. This will install the Cython version, which is only compiled for Windows at the moment. You can also build the package yourself on your own computer if you wish. Or you can use individual modules in the `pyaudiopython` or `caudiopython` directories.

  The package is divided into 8 modules:


  Tools for spectral analysis and analysis of audio waveforms. Many of these tools are based on formulas from Florian Eyben's "Real-Time Speech and Music Classification," published by Springer in 2016. Among other things, this module computes spectral centroid, entropy, slope, and flatness.


  This module is for reading and writing audio files, using either the `pedalboard` library or using (slower) code provided here.


  Funtionality for grain extraction


  This module has various operations that can be performed on audio, such as spectral frame swapping, equal energy forcing, dc bias removal, and beat envelope generation.


  Plotting functionality for audio and spectrum


  Tools for extracting samples from audio


  Tools for spectral analysis


  Tools for generating simple waveforms


  You will need the following Python libraries: `matplotlib`, `numpy`, `pedalboard`, `regex`, `scipy`. You will also need `Cython` if you want to build the Cython version.


  To build this package, run `python -m build`.


pkgId: ffb35d47b636305a144b36930c6e15bb828594210075c1facddacfec583791ec
name: python-audioread
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: Multi-library, cross-platform audio decoding.
url: https://pypi.org/project/audioread/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audioread-3.0.1-1.src.rpm
checksum_type: sha256
description:
  Decode audio files using whichever backend is available. The library
  currently supports:
  - `Gstreamer`_ via `PyGObject`_.
  - `Core Audio`_ on Mac OS X via `ctypes`_. (PyObjC not required.)
  - `MAD`_ via the `pymad`_ bindings.
  - `FFmpeg`_ or `Libav`_ via its command-line interface.
  - The standard library `wave`_, `aifc`_, and `sunau`_ modules (for
    uncompressed audio formats).
  Use the library like so::
      with audioread.audio_open(filename) as f:
          print(f.channels, f.samplerate, f.duration)
          for buf in f:
              do_something(buf)
  Buffers in the file can be accessed by iterating over the object returned from
  ``audio_open``. Each buffer is a bytes-like object (``buffer``, ``bytes``, or
  ``bytearray``) containing raw **16-bit little-endian signed integer PCM
  data**. (Currently, these PCM format parameters are not configurable, but this
  could be added to most of the backends.)
  Additional values are available as fields on the audio file object:
  - ``channels`` is the number of audio channels (an integer).
  - ``samplerate`` is given in Hz (an integer).
  - ``duration`` is the length of the audio in seconds (a float).
  The ``audio_open`` function transparently selects a backend that can read the
  file. (Each backend is implemented in a module inside the ``audioread``
  package.) If no backends succeed in opening the file, a ``DecodeError``
  exception is raised. This exception is only used when the file type is
  unsupported by the backends; if the file doesn't exist, a standard ``IOError``
  will be raised.
  A second optional parameter to ``audio_open`` specifies which backends to try
  (instead of trying them all, which is the default). You can use the
  ``available_backends`` function to get a list backends that are usable on the
  current system.
  Audioread supports Python 3 (3.8+).


pkgId: 6a5e78f6be88cadc0f02eb5283387e005e1cd96c2b79eac119d89649b3ac65aa
name: python-audiosample
arch: src
version: 2.1.14
epoch: 0
release: 1
url: https://deepdub.ai
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audiosample-2.1.14-1.src.rpm
checksum_type: sha256
summary:
  AudioSample is an optimized numpy-like audio manipulation library, created for researchers, used by developers.

description:
  AudioSample is an optimized numpy-like audio manipulation library, created for researchers, used by developers.

  It is an advanced audio manipulation library designed to provide researchers and developers with efficient, numpy-like tools for audio processing. It supports complex audio operations with ease and offers a familiar syntax for those accustomed to numpy.

  AudioSample is perfect for data loading and ETLs, because its fast and has a low memory footprint due to lazy actions.



  - **Seamless Audio Operations:** Perform a wide range of audio manipulations, including mixing, filtering, and transformations.
  - **Integration with Numpy:** Leverage numpy's syntax and capabilities for intuitive audio handling.
  - **Integration with Torch:** Export audio directly to and from torch tensors.
  - **High Performance:** Optimized for speed and efficiency, suitable for research and production environments. Most actions are lazy, so no operation done until absolutely necessary.
  - **Extensive I/O Support:** Easily read from and write to various audio formats. Utilizes PyAv - to support multiple ranges.



  To install AudioSample, use pip:

  to install all prerequisites:
  ```bash
  pip install audiosample[all]

  pip install audiosample[all]


  [av] - only av
  [torch] - add torch
  [tests] - include everything for tests.
  [noui] - install without jupyter support.


  brew install portaudio

  apt-get install portaudio19-dev
  [play] - bare, with ability to play audio in console. (uses pyaudio)
  ```





  Here's a quick example of how to load, process, and save audio using AudioSample:

  ```python
  import audiosample as ap
  import numpy as np


  au = ap.AudioSample.from_numpy(np.random.rand(2, 48000), rate=48000)
  beep = ap.AudioSample().beep(1).to_stereo()
  out = au.gain(-12) * beep
  out.write("beep_with_overlayed_noise.mp3")
  out = au.gain(-10) + au.silence(1) + beep
  out.write("noise_then_silence_then_beep.mp3")

  ```


  - **Resampling:** Fast resampling of audio.
  - **Normalization:** Easily normalize audio levels.
  - **Mixing:** Easily mix multiple audio sources together. Using * sign
  - **Concat** Easily concat audio sources. Using + sign
  - **Playback:** Play audio directly in Jupyter notebooks or from the command line.







  - longbeep is a 100s long wav file of beep.

  ```python
  import pydub
  from audiosample import AudioSample
  def test_audiosample():
      au = AudioSample()
      for i in range(0, 100):
          au += AudioSample("longbeep.wav")[50:51]
      au.write("out.wav")

  def test_pydub():
      au = pydub.AudioSegment.empty()
      for i in range(0, 100):
          au += pydub.AudioSegment.from_file("longbeep.wav")[50:51]
      au.export("out.wav")

  %timeit test_audiosample()


  %timeit test_pydub()

  ```


  ```python
  def test_audiosample():
      au = AudioSample().silence(1)
      for i in range(0, 100):
          au *= AudioSample("longbeep.wav")[50:51]
      au.write("out.wav")
  def test_pydub():
      au = pydub.AudioSegment.silent(1)
      for i in range(0, 100):
          au = au.overlay(pydub.AudioSegment.from_file("longbeep.wav")[50:51], 0)
      au.export("out.wav")

  In [3]: %timeit test_audiosample()
  12.7 ms ± 265 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)
  In [4]: %timeit test_pydub()
  398 ms ± 26.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
  ```



  verylongbeep.wav - is a 3200s file. (293M)
  ```python
  import soundfile as sf
  from audiosample import AudioSample

  def test_audiosample():
      out = AudioSample("verylongbeep.wav")[1500:1501].as_numpy()

  def test_soundfile():
      with sf.SoundFile("verylongbeep.wav") as f:
          f.seek(48000*1500)
          out = f.read(48000)

  In [5]: %timeit test_audiosample()
  35.8 μs ± 1.69 μs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
  In [6]: %timeit test_soundfile()
  140 μs ± 8.89 μs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
  ```


  For detailed instructions and API references, type help(AudioSample)



  Explore the [examples notebook](examples.ipynb) to see practical applications of AudioSample in action.



  AudioSample is released under the [MIT License](LICENSE).



  Contributions are welcome! Please follow the [contributing guidelines](CONTRIBUTING.md) to submit changes.



  AudioSample is developed by [Deepdub](https://deepdub.ai/), a company specializing in AI-driven audio solutions. Deepdub focuses on enhancing media experiences through cutting-edge technology, enabling content creators to reach global audiences with high-quality, localized audio.



  If you have questions or need help, please open an issue on GitHub.


pkgId: 63ef3ed3ee171b332443d5d7f71486d70c754164de8e8f35639233e70ef1ccf8
name: python-audioseal
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Watermarking and detection for speech audios
url: https://pypi.org/project/audioseal/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audioseal-0.1.4-1.src.rpm
checksum_type: sha256
description:
  <a href="https://www.python.org/"><img alt="Python" src="https://img.shields.io/badge/-Python 3.8+-blue?style=for-the-badge&logo=python&logoColor=white"></a>
  <a href="https://black.readthedocs.io/en/stable/"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-black.svg?style=for-the-badge&labelColor=gray"></a>

  Inference code for AudioSeal, a method for speech localized watermarking, with state-of-the-art robustness and detector speed (training code coming soon).
  More details can be found in the [paper](https://arxiv.org/abs/2401.17264).

  [[`arXiv`](https://arxiv.org/abs/2401.17264)]
  [[`Colab notebook`](https://colab.research.google.com/github/facebookresearch/audioseal/blob/master/examples/colab.ipynb)][[🤗`Hugging Face`](https://huggingface.co/facebook/audioseal)]

  ![fig](https://github.com/facebookresearch/audioseal/assets/1453243/5d8cd96f-47b5-4c34-a3fa-7af386ed59f2)



  - 2024-06-17: Training code is now available. Check the [instruction](./docs/TRAINING.md) !!!
  - 2024-05-31: Our paper gets accepted at ICML'24 :)
  - 2024-04-02: We have updated our license to full MIT license (including the license for the model weights) ! Now you can use AudioSeal in commercial application too !
  - 2024-02-29: AudioSeal 0.1.2 is out, with more bug fixes for resampled audios and updated notebooks



  We introduce AudioSeal, a method for speech localized watermarking, with state-of-the-art robustness and detector speed. It jointly trains a generator that embeds a watermark in the audio, and a detector that detects the watermarked fragments in longer audios, even in the presence of editing.
  Audioseal achieves state-of-the-art detection performance of both natural and synthetic speech at the sample level (1/16k second resolution), it generates limited alteration of signal quality and is robust to many types of audio editing.
  Audioseal is designed with a fast, single-pass detector, that significantly surpasses existing models in speed — achieving detection up to two orders of magnitude faster, making it ideal for large-scale and real-time applications.



  AudioSeal requires Python >=3.8, Pytorch >= 1.13.0, [omegaconf](https://omegaconf.readthedocs.io/), [julius](https://pypi.org/project/julius/), and numpy. To install from PyPI:

  ```
  pip install audioseal
  ```

  To install from source: Clone this repo and install in editable mode:

  ```
  git clone https://github.com/facebookresearch/audioseal
  cd audioseal
  pip install -e .
  ```



  You can find all the model checkpoints on the [Hugging Face Hub](https://huggingface.co/facebook/audioseal). We provide the checkpoints for the following models:

  - [AudioSeal Generator](src/audioseal/cards/audioseal_wm_16bits.yaml).
    It takes as input an audio signal (as a waveform), and outputs a watermark of the same size as the input, that can be added to the input to watermark it.
    Optionally, it can also take as input a secret message of 16-bits that will be encoded in the watermark.
  - [AudioSeal Detector](src/audioseal/cards/audioseal_detector_16bits.yaml).
    It takes as input an audio signal (as a waveform), and outputs a probability that the input contains a watermark at each sample of the audio (every 1/16k s).
    Optionally, it may also output the secret message encoded in the watermark.

  Note that the message is optional and has no influence on the detection output. It may be used to identify a model version for instance (up to $2**16=65536$ possible choices).

  **Note**: We are working to release the training code for anyone wants to build their own watermarker. Stay tuned !



  Audioseal provides a simple API to watermark and detect the watermarks from an audio sample. Example usage:

  ```python

  from audioseal import AudioSeal


  model = AudioSeal.load_generator("audioseal_wm_16bits")







  wav, sr = ..., 16000

  watermark = model.get_watermark(wav, sr)





  watermarked_audio = wav + watermark

  detector = AudioSeal.load_detector("audioseal_detector_16bits")


  result, message = detector.detect_watermark(watermarked_audio, sr)

  print(result) # result is a float number indicating the probability of the audio being watermarked,
  print(message)  # message is a binary vector of 16 bits



  result, message = detector(watermarked_audio, sr)



  print(result[:, 1 , :])



  print(message)
  ```



  See [here](./docs/TRAINING.md) for details on how to train your own Watermarking model.



   We welcome Pull Requests with improvements or suggestions.
   If you want to flag an issue or propose an improvement, but dont' know how to realize it, create a GitHub Issue.



  - If you encounter the error `ValueError: not enough values to unpack (expected 3, got 2)`, this is because we expect a batch of audio  tensors as inputs. Add one
  dummy batch dimension to your input (e.g. `wav.unsqueeze(0)`, see [example notebook for getting started](examples/Getting_started.ipynb)).

  - In Windows machines, if you encounter the error `KeyError raised while resolving interpolation: "Environmen variable 'USER' not found"`: This is due to an old checkpoint
  uploaded to the model hub, which is not compatible in Windows. Try to invalidate the cache by removing the files in `C:\Users\<USER>\.cache\audioseal`
  and re-run again.

  - If you use torchaudio to handle your audios and encounter the error `Couldn't find appropriate backend to handle uri ...`, this is due to newer version of
  torchaudio does not handle the default backend well. Either downgrade your torchaudio to `2.1.0` or earlier, or install `soundfile` as your audio backend.



  - The code in this repository is released under the MIT license as found in the [LICENSE file](LICENSE).


  - [Tuan Tran](https://github.com/antoine-tran)
  - [Hady Elsahar](https://github.com/hadyelsahar)
  - [Pierre Fernandez](https://github.com/pierrefdz)
  - [Robin San Roman](https://github.com/robinsrm)



  If you find this repository useful, please consider giving a star :star: and please cite as:

  ```
  @article{sanroman2024proactive,
    title={Proactive Detection of Voice Cloning with Localized Watermarking},
    author={San Roman, Robin and Fernandez, Pierre and Elsahar, Hady and D´efossez, Alexandre and Furon, Teddy and Tran, Tuan},
    journal={ICML},
    year={2024}
  }
  ```


pkgId: 853ed79e246f32fd2301d563ff44605ef6a97b492a1025abf3df7613895ece1c
name: python-audiosegment
arch: src
version: 0.23.0
epoch: 0
release: 1
summary: Wrapper for pydub.AudioSegment for additional methods.
url: https://github.com/MaxStrange/AudioSegment
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audiosegment-0.23.0-1.src.rpm
checksum_type: sha256
description:
  Wrapper for pydub.AudioSegment for additional high level methods.

  See the github README for documentation.


pkgId: 3f12b2f72e2f5ef2c2911e1675e58b437d74360dbc7ff1aab616a24760d15598
name: python-audiosr
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: This package is written for text-to-audio/music generation.
url: https://github.com/haoheliu/audiosr
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audiosr-0.0.7-1.src.rpm
checksum_type: sha256
description:
  [![arXiv](https://img.shields.io/badge/arXiv-2309.07314-brightgreen.svg?style=flat-square)](https://arxiv.org/abs/2309.07314)  [![githubio](https://img.shields.io/badge/GitHub.io-Audio_Samples-blue?logo=Github&style=flat-square)](https://audioldm.github.io/audiosr) [![Replicate](https://replicate.com/nateraw/audio-super-resolution/badge)](https://replicate.com/nateraw/audio-super-resolution)

  Pass your audio in, AudioSR will make it high fidelity!

  Work on all types of audio (e.g., music, speech, dog, raining, ...) & all sampling rates.

  Share your thoughts/samples/issues in our discord channel: https://discord.gg/HWeBsJryaf

  ![Image Description](https://github.com/haoheliu/versatile_audio_super_resolution/blob/main/visualization.png?raw=true)


  - 2023-09-24: Add replicate demo (@nateraw); Fix error on windows, librosa warning etc (@ORI-Muchim).
  - 2023-09-16: Fix DC shift issue. Fix duration padding bug. Update default DDIM steps to 50.




  ```shell

  conda create -n audiosr python=3.9; conda activate audiosr

  pip3 install audiosr==0.0.7
  ```



  Process a list of files. The result will be saved at ./output by default.

  ```shell
  audiosr -il batch.lst
  ```

  Process a single audio file.
  ```shell
  audiosr -i example/music.wav
  ```

  Full usage instruction

  ```shell
  > audiosr -h

  > usage: audiosr [-h] -i INPUT_AUDIO_FILE [-il INPUT_FILE_LIST] [-s SAVE_PATH] [--model_name {basic,speech}] [-d DEVICE] [--ddim_steps DDIM_STEPS] [-gs GUIDANCE_SCALE] [--seed SEED]

  optional arguments:
    -h, --help            show this help message and exit
    -i INPUT_AUDIO_FILE, --input_audio_file INPUT_AUDIO_FILE
                          Input audio file for audio super resolution
    -il INPUT_FILE_LIST, --input_file_list INPUT_FILE_LIST
                          A file that contains all audio files that need to perform audio super resolution
    -s SAVE_PATH, --save_path SAVE_PATH
                          The path to save model output
    --model_name {basic,speech}
                          The checkpoint you gonna use
    -d DEVICE, --device DEVICE
                          The device for computation. If not specified, the script will automatically choose the device based on your environment.
    --ddim_steps DDIM_STEPS
                          The sampling step for DDIM
    -gs GUIDANCE_SCALE, --guidance_scale GUIDANCE_SCALE
                          Guidance scale (Large => better quality and relavancy to text; Small => better diversity)
    --seed SEED           Change this value (any integer number) will lead to a different generation result.
    --suffix SUFFIX       Suffix for the output file
  ```



  [!["Buy Me A Coffee"](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://www.buymeacoffee.com/haoheliuP)

  - [ ] Add gradio demo.
  - [ ] Optimize the inference speed.


  If you find this repo useful, please consider citing:
  ```bibtex
  @article{liu2023audiosr,
    title={{AudioSR}: Versatile Audio Super-resolution at Scale},
    author={Liu, Haohe and Chen, Ke and Tian, Qiao and Wang, Wenwu and Plumbley, Mark D},
    journal={arXiv preprint arXiv:2309.07314},
    year={2023}
  }
  ```


pkgId: ccdaa8f195a4b2661b3c7fd3a5abc5a162110a6d892385fc940ab4e5e6914bec
name: python-audiostack
arch: src
version: 2.5.0
epoch: 0
release: 1
summary: Python SDK for Audiostack API
url: https://github.com/aflorithmic/audiostack-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audiostack-2.5.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center"> This is the official <a href="https://audiostack.ai/" rel="noopener">audiostack</a> Python 3 SDK. This SDK provides easy access to the Audiostack API for applications written in Python.
      <br>
  </p>

  This repository is actively maintained by [Audiostack](https://audiostack.ai/). For examples, recipes and api reference see the [api.audio docs](https://docs.audiostack.ai/reference/quick-start). Feel free to get in touch with any questions or feedback!

  You can view [here](https://docs.audiostack.ai/changelog) our updated Changelog.


  You don't need this source code unless you want to modify it. If you want to use the package, just run:
  ```sh
  pip install audiostack -U
  ```

  Python `^3.8.1`

  This library needs to be configured with your account's API key which is available in your [Audiostack platform](https://platform.audiostack.ai/audiostackapi). Import the audiostack package and set `audiostack.api_key` with the API key you got from the console:
  ```python
  import audiostack
  audiostack.api_key = "your-key"
  ```
  If you belong to multiple organizations, by default the API will use the first organization you had access to. You can specify the organization by setting the `assume_org_id` attribute:
  ```python
  audiostack.assume_org_id = "your-org-id"
  ```


  Audiostack Scripts are the first step in creating audio assets. Not only do they contain the text to be spoken, but also determine the final structure of our audio asset using the [Script Syntax](https://docs.audiostack.ai/docs/script-syntax).
  It also supports a [unified SSML syntax](https://docs.audiostack.ai/docs/ssml-tags), which is a standard way to control speech synthesis.
  ```python
  script = audiostack.Content.Script.create(scriptText="""
  <as:section name="intro" soundsegment="intro">
  Hey there, <as:placeholder id="username">friend</as:placeholder>! Welcome to Audiostack - the audio creation platform that allows you to create high quality audio assets using just a few lines of code.
  </as:section>
  <as:section name="main" soundsegment="main">
  Whether it's a podcast, a video, a game, or an app, Audiostack has you covered. You can create voiceovers, sound effects, music, and more.
  </as:section>
  <as:section name="outro" soundsegment="outro">
  We are excited to see what you'll create with our product!
  </as:section>
  """)
  ```

  We integrate all the major TTS voices in the market. You can browse them in our [voice library](https://library.audiostack.ai/).
  Let's use the voice "Isaac", substitute the `username` placeholder with `mate` and download the produced files. Each section results in a seperate audio file.
  ```python
  tts = audiostack.Speech.TTS.create(scriptItem=script, voice="isaac", audience={"username": "mate"})
  tts.download(fileName="example")
  ```
  When you listen to these files, you'll notice each of them has a certain silence padding at the end. This might be useful for some use cases, but for this example, let's remove it.
  ```python
  tts = audiostack.Speech.TTS.remove_padding(speechId=tts.speechId)
  ```

  ```python
  mix = audiostack.Production.Mix.create(speechItem=tts, soundTemplate="chill_vibes")
  ```
  Various sound templates consist of various segments. In our example, we're using three segments: intro, main and outro.
  You can list all the sound templates to see what segments are available or even [create your own](https://docs.audiostack.ai/docs/custom-sound-design-templates)!
  Mixing comes with a lot of options to tune your audio to sound just right.
  [More on this here.](https://docs.audiostack.ai/docs/advance-timing-parameters)

  ```python
  enc = audiostack.Delivery.Encoder.encode_mix(productionItem=mix, preset="mp3_high")
  enc.download(fileName="example")
  ```
  Easy right? 🔮 This is the final result:
  https://github.com/aflorithmic/audiostack-python/assets/64603095/6948cddb-4132-40a7-b84d-457f3fc0803d

  Get started with our [quickstart recipes](https://docs.audiostack.ai/docs/introduction).

  - https://github.com/Sjhunt93

  This project is licensed under the terms of the MIT license.


pkgId: a59d6aba7764dd65d98919e6bc139bccdebb1a07b405344f5421e63df05c0434
name: python-audiotag
arch: src
version: 0.7.3
epoch: 0
release: 1
summary: A simple CLI audio tagger
url: https://pypi.org/project/audiotag/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audiotag-0.7.3-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/Popkornium18/audiotag/actions/workflows/tests.yml/badge.svg)](https://github.com/Popkornium18/audiotag/actions/workflows/tests.yml)
  [![CodeQL](https://github.com/Popkornium18/audiotag/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/Popkornium18/audiotag/actions/workflows/codeql-analysis.yml)
  [![PyPI](https://github.com/Popkornium18/audiotag/actions/workflows/python-publish.yml/badge.svg)](https://github.com/Popkornium18/audiotag/actions/workflows/python-publish.yml)

  Audiotag is a command line audio tagger written in python3.
  It uses [TagLib](http://taglib.org/) to write the metadata.
  It features a very simple to use interactive mode which lets you tag a single album as fast as possible.



  You can install audiotag directly from PyPI.

  ```
  pip install audiotag
  ```

  If you are running **Arch Linux** you can install it from the **AUR**. The package is called [`audiotag`](https://aur.archlinux.org/packages/audiotag/).



  Audiotags functionality is split into different subcommands.

  ```
  usage: audiotag [-h] [-v] {clean,copy,interactive,print,rename,set} ...

  positional arguments:
    {clean,copy,interactive,print,rename,set}
      clean               delete all tags except 'ENCODER'
      copy                copy the tags from files in one folder to those in another folder
      interactive         tag a single album interactively. Treats files in subdirectories as different discs.
      print               print all tags
      rename              rename files based on their tags
      set                 set or delete tags

  optional arguments:
    -h, --help            show this help message and exit
    -v, --version         show program's version number and exit
  ```



  The `print` subcommand prints all tags.
  Multiple values per tag will be printed as a list.

  ```
  $ audiotag print *.flac
  Filename: 1 - Nova.flac
  ALBUM: Nova/Moth
  ALBUMARTIST: Burial & Four Tet
  ARTIST: Burial, Four Tet
  DATE: 2022
  DISCNUMBER: 1
  DISCTOTAL: 1
  ENCODER: Lavf58.76.100
  GENRE: Electronic, UK Garage, Future Garage
  TITLE: Nova
  TRACKNUMBER: 1
  TRACKTOTAL: 2

  Filename: 2 - Moth.flac
  ALBUM: Nova/Moth
  ALBUMARTIST: Burial & Four Tet
  ARTIST: Burial, Four Tet
  DATE: 2022
  DISCNUMBER: 1
  DISCTOTAL: 1
  ENCODER: Lavf58.76.100
  GENRE: Electronic, UK Garage, Future Garage
  TITLE: Moth
  TRACKNUMBER: 2
  TRACKTOTAL: 2
  ```



  The `interactive` subcommand interprets all given files as a single album and asks for all the necessary information.
  If the the files are in different directories, audiotag assumes that each directory is a disk of a multi-disc release.
  The `TRACKTOTAL` and `DISCTOTAL` tags are set automatically.
  Multiple values have to be seperated by `//`.

  ```
  $ audiotag interactive *.flac
  Artist: Burial//Four Tet
  Album Artist: Burial & Four Tet
  Albumtitle: Nova/Moth
  Genre: Electronic//UK Garage//Future Garage
  Year: 2022
  File: 1 - Nova.flac
  Track 1: Nova
  File: 2 - Moth.flac
  Track 2: Moth
  ```

  If you pass the `--compilation` flag, audiotag will ask the artist of each track.



  If you want to set the tags in a non-interactive way you can use the `set` command.
  You can choose from these options:

  *  `--artist="Example"`
  *  `--albumartist="Example"`
  *  `--title="Example"`
  *  `--album="Example"`
  *  `--date=2000`
  *  `--genre="Example"`
  *  `--tracknumber=1`
  *  `--discnumber=2`
  *  `--tracktotal=10`
  *  `--disctotal=2`

  Multiple artists and genres have to be separated by `//`.
  If you want to add a literal `//` you have to escape it like this `\/\/`.

  If you want to remove tags you can choose these options:

  *  `--noartist`
  *  `--noalbumartist`
  *  `--notitle`
  *  `--noalbum`
  *  `--nodate`
  *  `--nogenre`
  *  `--notracknumber`
  *  `--nodiscnumber`
  *  `--notracktotal`
  *  `--nodisctotal`

  You can combine these options as you like.
  Here is an example:

  ```
  $ audiotag set --artist="Burial & Four Tet" --album="Nova/Moth" --nodiscnumber 01-nova.flac
  ```



  The `clean` subcommand removes all tags from the given files.
  If you want to keep certain tags, you can specify them using the `--keep` parameter.
  If none are specified, audiotag defaults to keeping the `ENCODER` tag.



  The `rename` subcommand lets you rename files based on the audio tags.
  You have to provide a pattern for renaming.
  The pattern may contain a combination of these placeholders:

  * **{A}**:  Artist
  * **{T}**:  Title
  * **{L}**:  Album
  * **{Y}**:  Date
  * **{G}**:  Genre
  * **{N}**:  Tracknumber
  * **{D}**:  Discnumber
  * **{NT}**:  Tracktotal
  * **{DT}**:  Disctotal

  If you don't specify a pattern, audiotag will use `{N} - {T}` if the _Disctotal_ tag is set to `1` or `{D}-{N} - {T}` if the _Disctotal_ tag is set to something else or missing.
  You do _not_ have to add the extension to the pattern.
  Audiotag adds the extension to the output file name for you.

  ```
  $ ls
  01-nova.flac  02-moth.flac

  $ audiotag rename *.flac

  $ ls
  '1 - Nova.flac'  '2 - Moth.flac'
  ```

  If the new filename already exists Audiotag will ask if you want to overwrite the existing file. This check can be disabled with the `-f` or `--force` option.


  The `copy` subcommand copies the tags from all the files in the sourcefolder to corresponding files in the destination folder.
  The filenames are sorted alphabetically before they are matched.
  You may also specify a _single_ file as source and destination.
  Note that the `ENCODER` tag ist _not_ copied.



  The config file is located here:

  * **Linux**: `~/.config/audiotag/config.ini` or in `$XDG_CONFIG_HOME`, if defined
  * **MacOS**: `~/Library/Preferences/audiotag/config.ini`
  * **Win**: `C:\Users\<username>\AppData\Local\audiotag\audiotag\config.ini`

  These are the default values:

  ```ini
  [global]
  ; Input key bindings. 'emacs' or 'vi'
  editing_mode = emacs
  ; Character for separating multiple tags
  value_separator = /
  ; Rename pattern for single disc releases
  pattern_single_disc = {N} - {T}
  ; Rename pattern for multi disc releases
  pattern_multi_disc = {D}-{N} - {T}
  ```



  The following dependencies are needed to run audiotag:
  * [appdirs](https://pypi.org/project/appdirs/): Standard file locations for multiple platforms
  * [prompt-toolkit](https://pypi.org/project/prompt-toolkit/): Better console I/O
  * [pytaglib](https://pypi.org/project/pytaglib/): Python wrapper for accessing TagLib


pkgId: e1b51cec9f0764eaa30dcd23db56a5387435cf8d91a5931f4fca1079c328f4a5
name: python-audiotsm
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: A real-time audio time-scale modification library
url: https://github.com/Muges/audiotsm
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audiotsm-0.1.2-1.src.rpm
checksum_type: sha256
description:
  AudioTSM is a python library for real-time audio time-scale modification
  procedures, i.e. algorithms that change the speed of an audio signal without
  changing its pitch.
  Documentation:
     https://audiotsm.readthedocs.io/
  Examples:
      https://muges.github.io/audiotsm/
  Source code repository and issue tracker:
     https://github.com/Muges/audiotsm/
  Python Package Index:
      https://pypi.python.org/pypi/audiotsm/
  License:
     MIT -- see the file ``LICENSE`` for details.


pkgId: 286a7c9adbdfa080104645c240a162532d8d7179ef4a4ed650c4aefb7d69df3a
name: python-audioviz
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: An user-friendly music information retrieval tools interfacing with Google Colab
url: https://github.com/TrangDuLam/audioviz
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audioviz-0.3.1-1.src.rpm
checksum_type: sha256
description:
  * An user-friendly music information retrieval visualization API interfacing with Google Colab
  * Coordinated by Prof. [Li Su](https://homepage.iis.sinica.edu.tw/pages/lisu/index_en.html), Prof. [Yu-Fen Huang](https://yfhuang.info/) from the [Music and Culture Technology Lab](https://sites.google.com/view/mctl/), Academia Sinica, Taipei, Taiwan
  * A collaration project with graduate students from National Tsing Hua University, Hsinchu, Taiwan



  * Custom visualization wrappers for open source module [librosa](https://librosa.org/doc/latest/index.html)
  * Using open source graphing library [Plotly](https://plotly.com/python/) to enhance visualization capabilities
  * Direcctly integrated with Google Colab functions to provide platform-free user experience
  * Please refer to [official page](https://grace1287986s-organization.gitbook.io/musicai-ui-space-v2/) for more details





  * PyPi installation

    ```bash
    pip install audioviz
    ```

  * setup.py


  ![alt text](panel.png "Title")



  * Colab upload solution
    * Direct instruction
  * Programming Copilot


pkgId: ae9aad689ce5c670c7e528656da7fedb88f86ba604f2d656de73bdc326499803
name: python-audiowalkman
arch: src
version: 0.21.0
epoch: 0
release: 1
summary: play audio files in performance contexts
url: https://pypi.org/project/audiowalkman/
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audiowalkman-0.21.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://circleci.com/gh/audiowalkman/walkman.svg?style=shield)](https://circleci.com/gh/audiowalkman/walkman)
  [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
  [![PyPI version](https://badge.fury.io/py/audiowalkman.svg)](https://badge.fury.io/py/audiowalkman)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  Walkman is a minimalistic, robust software to trigger (audio) cues in performance contexts.
  It uses [pyo](http://ajaxsoundstudio.com/software/pyo/) as its backend and [pysimplegui](https://pypi.org/project/PySimpleGUI/) as its frontend.
  It can be configured by [toml](https://toml.io/en/) files.

  ![walkman screenshot](screenshot.png)



  Live-electronic setups tend to be messy, difficult to maintain and difficult to test.
  Furthermore many compositions with live-electronics make use of cue-based pattern, but in most of electronic music frameworks (Pd, Max/MSP, ...) no default implementation exists.
  `walkman` aims to improve the situation by providing a simple, declarative configuration language to setup programs based on cues.
  The actual software is implemented in Python3, can be extended in python3 and can be tested with unit tests.



  walkman is available on pip:

  ```bash
  pip3 install audiowalkman
  ```

  Alternatively you can use [Nix](https://nixos.org/) to install walkman.



  ```


  [configure]
  name            = string                                              (default to "Project")
  logging_level   = "info" | "error" | "warning" | "debug" | "notset"   (default to "info")

  [configure.audio]
  audio           = string                                              (default to "jack")
  midi            = string                                              (default to "jack")
  sampling_rate   = integer                                             (default to 44100)
  buffer_size     = integer                                             (default to 1024)
  channel_count   = integer                                             (default to 2)

  [configure.module.MODULE_NAME.REPLICATION_KEY]

  [cue.CUE_NAME.MODULE_NAME.REPLICATION_KEY]
  ```



  ```bash
  walkman my_composition.toml.j2
  ```



  With nix tests can be run with a newly compiled isolated setup:


  ```bash
  nix-build default.nix
  ```


pkgId: ba501e6575bffcd12937082726aa376b35bd88df0a92552c8ba1b3f5a701a0e5
name: python-audit-tools
arch: src
version: 0.1.14
epoch: 0
release: 1
summary: Auditing tools for Cova POS files
url: https://github.com/JakePIXL/audit-tools
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audit-tools-0.1.14-1.src.rpm
checksum_type: sha256
description:
  ```bash
  $ pypi install audit-tools
  ```
  ```python
  from audit_tools.sessionmanager import SessionManager
  with SessionManager() as session:  # invokes the session manager
    session.import_data("/path/to/file.xlsx")  # imports data from an excel, json or csv file
    session.count_product('F7X6A7', 20)  # Counts 20 F7X6A7's to the inventory
    session.increase_product('F7X6A7', 10)  # Increases F7X6A7 to 30 in the inventory
    session.reduce_product('F7X6A7', 3)  # Reduces F7X6A7 to 27 in the inventory
    print(session.get_product('F7X6A7'))  # Returns the row of product with SKU 'F7X6A7'
    session.parse_session_data()  # Updates session dataframes with accurate content
  ```


pkgId: e617aed743ba0c44ca591eda5e20ddba81a9c9730605f43e8a3b96a45bbe0b01
name: python-audit-trail-logger
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: A Django package for logging actions with user and object details
url: https://github.com/sardareurvashi05/audit-trail-logger
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audit-trail-logger-0.1.3-1.src.rpm
checksum_type: sha256
description:
  A simple Django package for logging user actions on objects within the application.



  Install via pip:

  pip install audit-trail-logger

  1. Add auditlog to INSTALLED_APPS in your Django settings.
  2. Use the audit_log decorator on your views or model methods.
      from auditlog.decorators import audit_log
      @audit_log(action_type='create', object_type='Product')
      def create_product(request):


pkgId: 6e25b9ea7ceb993742f600137c007653840d44865c05940965bfddd4912f942d
name: python-auditlog3
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: django-auditlog for Django 3.0
url: https://github.com/jjkester/django-auditlog/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auditlog3-1.0.1-1.src.rpm
checksum_type: sha256
description:
  This is a simple auditlog package for Django 3.0. You can use
  [Github-flavored Markdown](https://guides.github.com/features/mastering-markdown/)
  to write your content.


pkgId: 40ce3feccb05a892a443b9a5b36434c0c60c67396a445b8cdc41f7b30f4cbf94
name: python-auditok
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: A module for Audio/Acoustic Activity Detection
url: http://github.com/amsehili/auditok/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auditok-0.2.0-1.src.rpm
checksum_type: sha256
description:
  ``auditok`` is an **Audio Activity Detection** tool that can process online data
  (read from an audio device or from standard input) as well as audio files.
  It can be used as a command-line program or by calling its API.
  The documentation for this version can be found on
  `readthedocs. <https://auditok.readthedocs.io/en/v0.2.0/>`_


pkgId: 4bf5817de0a95daa4e0ab95662d43c08fe50d96a01efcac0ba22d482e8e0a58b
name: python-auditok
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: A module for Audio/Acoustic Activity Detection
url: http://github.com/amsehili/auditok/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auditok-0.3.0-1.src.rpm
checksum_type: sha256
description:
  ``auditok`` requires Python 3.7 or higher.
  To install the latest stable version, use pip:
      sudo pip install auditok
  To install the latest development version from GitHub:
      pip install git+https://github.com/amsehili/auditok
  Alternatively, clone the repository and install it manually:
      git clone https://github.com/amsehili/auditok.git
      cd auditok
      python setup.py install


pkgId: ac897496f06c2156b67f391b9690ab01f0ec6158705379666b724e1755188ef9
name: python-auditorium
arch: src
version: 20.2.1
epoch: 0
release: 1
summary: A Python-powered slideshow maker with steroids.
url: https://pypi.org/project/auditorium/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auditorium-20.2.1-1.src.rpm
checksum_type: sha256
description:
  [<img alt="PyPI - License" src="https://img.shields.io/pypi/l/auditorium.svg">](https://github.com/apiad/auditorium/blob/master/LICENSE)
  [<img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/auditorium.svg">](https://pypi.org/project/auditorium/)
  [<img alt="PyPI" src="https://img.shields.io/pypi/v/auditorium.svg">](https://pypi.org/project/auditorium/)
  [<img alt="Travis (.org)" src="https://img.shields.io/travis/apiad/auditorium/master.svg">](https://travis-ci.org/apiad/auditorium)
  [<img alt="Codecov" src="https://img.shields.io/codecov/c/github/apiad/auditorium.svg">](https://codecov.io/gh/apiad/auditorium)
  [<img alt="Gitter" src="https://img.shields.io/gitter/room/apiad/auditorium">](https://gitter.im/auditorium-slides/community)
  [<img alt="Demo" src="https://img.shields.io/badge/demo-browse-blueviolet"></img>](https://auditorium-demo.apiad.net)

  <!-- <img src="https://apiad.net/auditorium/assets/logo.png"></img> -->

  > A Python-powered slideshow creator with steroids.

  See the demo at [auditorium-demo.apiad.net](https://auditorium-demo.apiad.net).



  Auditorium is a Python-powered slideshow generator.
  You write pure Python code, and obtain an HTML+JavaScript slideshow (using the amazing [reveal.js](https://revealjs.com) library).
  The awesomeness comes from the fact that your Python backend is connected to the slideshow frontend, which allows your slideshow to dynamically change according to user input or automatically.

  This opens the door to a few interesting use cases:

  *  The slides content itself can be generated by code. For example, long and repetitive sets of slides can be automatically generated, or tables and graphs embedded in slides can be generated on-the-fly with `matplotlib`, `bokeh`, `altair`, `plotly`, or any visualization package that produces HTML output.
  *  You can insert components in the slides that respond to user input, and execute a Python code in response. For example, you can generate an interactive graph that can be modified by moving sliders in a slideshow.
  *  You can create beautiful animations with simple Python code, that automatically play on a slide, using visualization libraries or simple HTML markup.

  > **And all of this without writing a single line of HTML or JavaScript.**

  Alternatively, if you need little to no Python code, you can author your slideshow in pure Markdown and add some Python sprinkless here and there when necessary.



  Simply run:

      pip install auditorium[server]

  To see a quick demo run:

      auditorium demo

  And point your browser at [localhost:6789](http://localhost:6789).



  If you want to quickly grok `auditorium`, the best option is to [look at the demo online](https://auditorium-demo.apiad.net) and then
  [read the source code](https://github.com/apiad/auditorium/blob/master/auditorium/demo.py). This way you will both see the end result and what effort it takes to get there.

  * [Authoring a slideshow with Python](https://apiad.net/auditorium/quickstart/#python-first)
  * [Authoring a slideshow with Markdown](https://apiad.net/auditorium/quickstart/#markdown-first)
  * [Rendering a slideshow as purely static HTML](https://apiad.net/auditorium/quickstart/#going-full-static)
  * [Hosting a slideshow online for free](https://apiad.net/auditorium/hosting/#hosting-freely-with-auditorium-publish)



  * [Auditorium Demo](https://auditorium-demo.apiad.net) - a slideshow showcasing the most important features from `auditorium`.



  If you have a slideshow to showcase here, feel free to [edit this Readme](https://github.com/apiad/auditorium/edit/master/README.md) and send a pull request. Add your website, Github repository, and any other information.

  If you feel like sending some support please consider adding a badge somewhere in your website or repository:

  ```html
  <a href="https://apiad.net/auditorium">
      <img alt="Made with Auditorium"
           src="https://img.shields.io/badge/made--with-auditorium-blue">
      </img>
  </a>
  ```

  It looks like this:

  <a href="https://apiad.net/auditorium"><img alt="Made with Auditorium" src="https://img.shields.io/badge/made--with-auditorium-blue"></img></a>



  See [the docs](https://apiad.net/auditorium/history).



  License is MIT, so you know the drill: fork, develop, add tests, pull request, rinse and repeat.
  See collaboration details [in the docs](https://apiad.net/auditorium/contributing).


pkgId: f125265f709b9c066409e883e0950f4e197f0a5b5a6c8f547a2cc2f9640e6240
name: python-auditree-framework
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Tool to run compliance control checks as unit tests
url: https://auditree.github.io/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auditree-framework-2.0.0-1.src.rpm
checksum_type: sha256
description:
  [![OS Compatibility][platform-badge]](#prerequisites)
  [![Python Compatibility][python-badge]][python]
  [![pre-commit][pre-commit-badge]][pre-commit]
  [![Code validation](https://github.com/ComplianceAsCode/auditree-framework/workflows/format%20%7C%20lint%20%7C%20security%20%7C%20test/badge.svg)][lint-test]
  [![Upload Python Package](https://github.com/ComplianceAsCode/auditree-framework/workflows/PyPI%20upload/badge.svg)][pypi-upload]



  Tool to run compliance control checks as unit tests and build up a body of evidence.

  This framework gives you the tools you need to create an auditable body of evidence, and is designed to be "DevSecOps" friendly. Collection & validation of evidence is modelled as python unit tests, evidence is stored & versioned in a git repository, notifications can be configured to send to Slack, create issues, contact PagerDuty, or just write files into git. The goal is to enable the digital transformation of compliance activities, and make these everyday operational tasks for the team managing the system.





  - Supported for execution on OSX and LINUX.
  - Supported for execution with Python 3.6 and above.

  If you haven't already you need to generate a new ssh key for your Github account as per [this guide](https://help.github.com/articles/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent/)



  ```shell
  git clone git@github.com:ComplianceAsCode/auditree-framework
  cd auditree-framework
  ```



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



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



  This repository uses [black][black] for code formatting and [flake8][flake8] for code styling.  It also
  uses [pre-commit][pre-commit] hooks that are integrated into the development process and the CI.  When
  you run `make develop` you are ensuring that the pre-commit hooks are installed and updated to their
  latest versions for this repository.  This ensures that all delivered code has been properly formatted
  and passes the linter rules.  See the [pre-commit configuration file][pre-commit-config] for details on
  `black` and `flake8` configurations.

  Since `black` and `flake8` are installed as part of the `pre-commit` hooks, running `black` and `flake8`
  manually must be done through `pre-commit`.  See examples below:

  ```shell
  make code-format
  make code-lint
  ```

  ...will run `black` and `flake8` on the entire repo and is equivalent to:

  ```shell
  pre-commit run black --all-files
  pre-commit run flake8 --all-files
  ```

  ...and when looking to limit execution to a subset of files do similar to:

  ```shell
  pre-commit run black --files compliance/*
  pre-commit run flake8 --files compliance/*
  ```



  To run the frameworks test suite, use:

  ```shell
  make test
  ```



  Documentation sources live in `doc-source`, and are also auto-generated from the source codes doc strings. The auto-generated documentation (`compliance*rst, modules.rst`) is ignored by git & should not be modified directly - make changes in the python code.

  To build the documentation locally run:

  ```shell
  make docs
  ```

  This will update the files in `doc` with the latest documentation. These files should not be modified by hand.



  Successfully complete the steps below and you should be able to find your local
  evidence locker in your `$TMPDIR/compliance` folder.  There you will find a `raw`
  folder that contains all of the raw evidence fetched by the fetchers found in the
  `demo/demo_examples/fetchers` folder along with a `reports` folder that contains
  the reports generated by the checks found in the `demo/demo_examples/checks` folder.

  - Create an empty [credentials][] file:

  ```shell
  $ touch ~/.credentials
  ```

  - Set up your environment:

  ```shell
  cd demo
  python -m venv
  . ./venv/bin/activate
  pip install -r requirements.txt
  ```

  - Run the fetchers:

  ```shell
  compliance --fetch --evidence local -C auditree_demo.json -v
  ```

  - Run the checks:

  ```shell
  compliance --check demo.arboretum.accred,demo.custom.accred --evidence local -C auditree_demo.json -v
  ```



  Help us to improve the Auditree framework. See [CONTRIBUTING][].



  We are building a set of common fetchers/checks in [Arboretum](https://github.com/ComplianceAsCode/auditree-arboretum). If you have a library of checks, please let us know & we'll link here.

  We have a data gathering and reporting tool called [Harvest](https://github.com/ComplianceAsCode/auditree-harvest) which lets you process your evidence locker and generate reports over the data held.

  We have a tool called [Prune](https://github.com/ComplianceAsCode/auditree-prune) which lets you mark evidence as no longer being collected, in a suitably tracked manner.

  We have a tool called [Plant](https://github.com/ComplianceAsCode/auditree-plant) which lets you add evidence to evidence lockers without the use of fetchers or checks.

  [CONTRIBUTING]: https://github.com/ComplianceAsCode/auditree-framework/blob/master/CONTRIBUTING.md
  [credentials file]: https://github.com/ComplianceAsCode/auditree-framework/blob/master/doc/design-principles.rst#credentials
  [flake8]: https://gitlab.com/pycqa/flake8
  [platform-badge]: https://img.shields.io/badge/platform-osx%20|%20linux-orange.svg
  [pre-commit-badge]: https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white
  [pre-commit]: https://github.com/pre-commit/pre-commit
  [pre-commit-config]: https://github.com/ComplianceAsCode/auditree-framework/blob/master/.pre-commit-config.yaml
  [python-badge]: https://img.shields.io/badge/python-v3.6+-blue.svg
  [python]: https://www.python.org/downloads/
  [quick start guide]: https://github.com/ComplianceAsCode/auditree-framework/blob/master/doc-source/quick-start.rst
  [black]: https://github.com/psf/black
  [lint-test]: https://github.com/ComplianceAsCode/auditree-framework/actions?query=workflow%3A%22format+%7C+lint+%7C+test%22
  [pypi-upload]: https://github.com/ComplianceAsCode/auditree-framework/actions?query=workflow%3A%22PyPI+upload%22
  [credentials]: https://complianceascode.github.io/auditree-framework/design-principles.html#credentials


pkgId: 3c1dc85276ccc173c160a34f696fab22b6c8b460160b1e2fc658b03545c28017
name: python-auditree-harvest
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: The Auditree data gathering and reporting tool
url: https://auditree.github.io/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auditree-harvest-1.3.0-1.src.rpm
checksum_type: sha256
description:
  [![OS Compatibility][platform-badge]](#prerequisites)
  [![Python Compatibility][python-badge]][python-dl]
  [![pre-commit][pre-commit-badge]][pre-commit]
  [![Code validation](https://github.com/ComplianceAsCode/auditree-harvest/workflows/format%20%7C%20lint%20%7C%20test/badge.svg)][lint-test]
  [![Upload Python Package](https://github.com/ComplianceAsCode/auditree-harvest/workflows/PyPI%20upload/badge.svg)][pypi-upload]



  The Auditree data gathering and reporting tool.



  Auditree `harvest` is a command line tool that assists with the gathering and
  formatting of data into human readable reports.  Auditree `harvest` allows
  a user to easily retrieve historical raw data, in bulk, from a Git repository
  and optionally format that raw data to meet reporting needs.  Auditree
  `harvest` is meant to retrieve and report on historical evidence from an
  evidence locker.  It is, however, not limited to just processing evidence.  Any
  file found in a Git repository hosting service can be processed by Auditree `harvest`.



  - Supported for execution on OSX and LINUX.
  - Supported for execution with Python 3.6 and above.

  Python 3 must be installed, it can be downloaded from the [Python][python-dl]
  site or installed using your package manager.

  Python version can be checked with:

  ```sh
  python --version
  ```

  or

  ```sh
  python3 --version
  ```

  The `harvest` tool is available for download from [PyPI](https://pypi.org/project/auditree-harvest/).



  It is best practice, but not mandatory, to run `harvest` from a dedicated Python
  virtual environment.  Assuming that you have the Python [virtualenv][virtual-env]
  package already installed, you can create a virtual environment named `venv` by
  executing `virtualenv venv` which will create a `venv` folder at the location of
  where you executed the command.  Alternatively you can use the python `venv` module
  to do the same.

  ```sh
  python3 -m venv venv
  ```

  Assuming that you have a virtual environment and that virtual environment is in
  the current directory then to install a new instance of `harvest`, activate
  your virtual environment and use `pip` to install `harvest` like so:

  ```sh
  . ./venv/bin/activate
  pip install auditree-harvest
  ```

  As we add functionality to `harvest` users will want to upgrade their `harvest`
  package regularly.  To upgrade `harvest` to the most recent version do:

  ```sh
  . ./venv/bin/activate
  pip install auditree-harvest --upgrade
  ```

  See [pip documentation][pip-docs] for additional options for using `pip`.



  Since Auditree `harvest` interacts with Git repositories, it requires Git remote
  hosting service credentials in order to do its thing.  Auditree `harvest` will by
  default look for a `username` and `token` in a `~/.credentials` file.  You can
  override the credentials file location by using the `--creds` option on a `harvest`
  CLI execution. Valid section headings include `github`, `github_enterprise`, `bitbucket`,
  and `gitlab`.  Below is an example of the expected credentials entry.

  ```ini
  [github]
  username=your-gh-username
  token=your-gh-token
  ```





  To collate historical versions of a file from a Git repository hosting service
  like Github, provide the repository URL (`repo` positional argument), the
  relative path to the file within the remote repository including the file name
  (`filepath` positional argument) and an optional date range (`--start` and `--end`
  arguments).  You can also, optionally, provide the local Git repository path
  (`--repo-path` argument), if the repository already exists locally and you wish
  to override the remote repository download behavior.

  ```sh
  harvest collate https://github.com/org-foo/repo-bar /raw/baz/baz.json --start 20191201 --end 20191212 --repo-path ./bar-repo
  ```

  - File versions are written to the current local directory where `harvest` was
  executed from.
  - File versions are prefixed by the commit date in `YYYYMMDD` format.
  - File versions are gathered with daily granularity.
     - Only the latest version of a file for a given day is retrieved.
     - If a file did not change on a date then no file version is written for that
     date.  Instead the latest version prior to that date serves as the version of
     that file for that date.
  - If you don't provide a `--start` and an `--end` then the latest version of a
  file is retrieved.
  - If you only provide a `--start` date file versions from the start date to the
  current date are retrieved.
  - If you only provide an `--end` date the latest version of a file for the end
  date is retrieved.



  To run a report using content contained in a Git repository hosting service
  like Github, provide the repository URL (`repo` positional argument), the report
  package (`package`), the report name (`name` positional argument) and include
  any configuration that the report requires (`--config`) as a JSON string.  You
  can also, optionally, provide the local Git repository path (`--repo-path`
  argument), if the repository already exists locally and you wish to override
  the remote repository download behavior.

  ```sh
  harvest report https://github.com/org-foo/repo-bar auditree_arboretum check_results_summary --config '{"start":"20191212","end":"20191221"}'
  ```



  To see a full summary of available reports within any package (like `auditree-arboretum`) do:

  ```sh
  harvest reports auditree_arboretum --list
  ```

  To see details on a specific report that include usage example do something like:

  ```sh
  harvest reports auditree_arboretum --detail check_results_summary
  ```



  Reports should be hosted with the fetchers/checks that collect the evidence for
  the reports process. Within `auditree-arboretum` this means the code lives in the
  appropriate provider directory.  Contributing common harvest reports are as follows:

  1.  Adhere to the auditree-arboretum contribution guidelines - **TODO add link**.
  2.  Reports go in the "reports" folder by provider.
  3.  Create a python module with a class that extends the [BaseReporter][base-reporter]
  class.
      - The `harvest` CLI will use the report module name as the name of the
      report (_sans the .py extention)._
      - **Only one report class per report module is permitted.**
  4.  In the new report class the expectations are as follows:
      - Provide a module level docstring that contains:
         - A single line summary
         - A detailed description of the report that includes evidence/files being
         processed and expected configuration
         - At least one usage example
         - Use the [check results summary report docstring][crs-rpt] as an example/template.
         - `harvest` uses this docstring to display available reports and their
         details to the user.
      - Provide/Override the `report_filename` property to return the name of the
      report (including extension).  `harvest` uses this property to apply a report
      template (if desired) and to determine which writer function to use when writing
      the report to a file.  Use the [check results summary report report_filename property][crs-rpt]
      and the [Python packages summary report report_filename property][pps-rpt] as examples.
      - Provide/Override the `generate_report` method.  This is where you put your
      evidence processing and report formatting logic.  Use the
      [check results summary report generate_report][crs-rpt] method as an example.
         - `harvest` takes the optional `--config` command line argument as a JSON
         string when executing a report, converts it to a dictionary and attaches
         it as the `config` attribute to your report object.  Use the report object's
         `config` attribute in the `generate_report` method if you plan to have report
         specific configuration options.
         - Your report object also has a method that retrieves an evidence file for
         a given date. Use the report object's `get_file_content` method when
         retrieving evidence from an evidence locker.
         - Generating CSV reports:
            - `harvest` uses the Python [CSV writer][python-csv] to write out the
            report file. So be sure that your `generate_report` method returns a
            list of dictionaries that adheres to the expectations of the Python
            [CSV writer][python-csv].
         - Generating reports from a Jinja2 template:
            - Add a report template named the same as your `report_filename`
            property with a `.tmpl` extension.  `harvest` will start to look for
            the template in the same directory as the report module.  So as long as
            it exists within that directory structure, `harvest` will find it.
            Use [python_packages_summary.md.tmpl][pps-rpt-tmpl] as an example.
            - `harvest` will look for this template file as part of your report
            processing and, if found, will pass your `generate_report` returned
            content through the template logic.
            - Your `generate_report` returned content should be a dictionary with
            everything necessary for your report template to render the desired
            report appropriately.
            - The report template can access the "raw" content generated by
            `generate_report` through a dictionary named `data` and also has
            access to the report's attributes through the `report` object.
            Use [python_packages_summary.md.tmpl][pps-rpt-tmpl] as an example.
         - Generating reports without templates:
            - You just want to generate report content directly from `generate_report`?
            No problem.  Just generate a string as the report content or a list of
            strings as the rows of the report content and `harvest` will do the rest.



  If you find that you have a specific reporting need that does not fit in as a common
  `harvest` report, no problem.  Just develop the report in a separate repo/project
  following the same guidelines as above.  As long as the package is importable by
  python and you tell `harvest` what package to look for your report(s) in via the CLI,
  it will handle the rest.


  [changes]: https://github.com/ComplianceAsCode/auditree-harvest/blob/main/CHANGES.md
  [platform-badge]: https://img.shields.io/badge/platform-osx%20|%20linux-orange.svg
  [python-badge]: https://img.shields.io/badge/python-v3.6+-blue.svg
  [python-dl]: https://www.python.org/downloads/
  [pip-docs]: https://pip.pypa.io/en/stable/reference/pip/
  [virtual-env]: https://pypi.org/project/virtualenv/
  [contributing]: https://github.com/ComplianceAsCode/auditree-harvest/blob/main/CONTRIBUTING.md
  [base-reporter]: https://github.com/ComplianceAsCode/auditree-harvest/blob/main/harvest/reporter.py
  [crs-rpt]: https://github.com/ComplianceAsCode/auditree-harvest/blob/main/auditree_arboretum/provider/auditree/reports/check_results_summary.py
  [pps-rpt]: https://github.com/ComplianceAsCode/auditree-harvest/blob/main/auditree_arboretum/provider/auditree/reports/python_packages_summary.py
  [python-csv]: https://docs.python.org/3/library/csv.html#csv.writer
  [python-io]: https://docs.python.org/3/tutorial/inputoutput.html
  [pps-rpt-tmpl]: https://github.com/ComplianceAsCode/auditree-harvest/blob/main/auditree_arboretum/provider/auditree/reports/report_templates/python_packages_summary.md.tmpl
  [pre-commit-badge]: https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white
  [pre-commit]: https://github.com/pre-commit/pre-commit
  [lint-test]: https://github.com/ComplianceAsCode/auditree-harvest/actions?query=workflow%3A%22format+%7C+lint+%7C+test%22
  [pypi-upload]: https://github.com/ComplianceAsCode/auditree-harvest/actions?query=workflow%3A%22PyPI+upload%22


pkgId: 92d284c844f094a9670fe7af9ad1ab4254176d9ec856b78a5ebca92dc4af5921
name: python-auditwheel
arch: src
version: 6.1.0
epoch: 0
release: 1
summary: Cross-distribution Linux wheels
url: https://github.com/pypa/auditwheel
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auditwheel-6.1.0-1.src.rpm
checksum_type: sha256
description:
  Auditing and relabeling of `PEP 600 manylinux_x_y
  <https://www.python.org/dev/peps/pep-0600/>`_, `PEP 513 manylinux1
  <https://www.python.org/dev/peps/pep-0513/>`_, `PEP 571 manylinux2010
  <https://www.python.org/dev/peps/pep-0571/>`_ and `PEP 599 manylinux2014
  <https://www.python.org/dev/peps/pep-0599/>`_ Linux wheels.


pkgId: b92ec4cb935df79b1d7c95625db6bf4670b23e76b7063f38785b7f7391db0ad7
name: python-auditwheel-emscripten
arch: src
version: 0.0.16
epoch: 0
release: 1
summary: auditwheel-like tool for Pyodide
url: https://pypi.org/project/auditwheel-emscripten/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auditwheel-emscripten-0.0.16-1.src.rpm
checksum_type: sha256
description:
  [![PyPI Latest Release](https://img.shields.io/pypi/v/auditwheel-emscripten.svg)](https://pypi.org/project/auditwheel-emscripten/)
  ![Test Status](https://github.com/ryanking13/auditwheel-emscripten/actions/workflows/test.yml/badge.svg)

  auditwheel-like tool for wheels targeting Emscripten platform

  ```sh
  $ pip install auditwheel-emscripten
  ```



  auditwheel-emscripten is a tiny tool to facilitate the creation of Python wheel packages for
  [Emscripten](https://emscripten.org/). auditwheel-emscripten is originally created for
  [Pyodide](https://pyodide.org/en/stable/), but it can be used in any other projects that target
  Python-in-the-browser using Emscripten.

  - `pyodide auditwheel show`: shows external shared libraries that the wheel depends on.
  - `pyodide auditwheel repair`: copies these external shared libraries into the wheel itself.



  ```sh
   Usage: pyodide auditwheel [OPTIONS] COMMAND [ARGS]...

   Auditwheel-like tool for emscripten wheels and shared libraries.

  ╭─ Options ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
  │ --help          Show this message and exit.                                                                                         │
  ╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
  ╭─ Commands ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
  │ copy      [Deprecated] Copy shared libraries to the wheel directory. Works same as repair. Use repair instead.          │
  │ exports   Show exports of a wheel or a shared library file.                                                                         │
  │ imports   Show imports of a wheel or a shared library file.                                                                         │
  │ repair    Repair a wheel file: copy shared libraries to the wheel directory.   │
  │ show      Show shared library dependencies of a wheel or a shared library file.                                                     │
  ╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
  ```

  ```sh

  $ pyodide auditwheel show Shapely-1.8.2-cp310-cp310-emscripten_3_1_14_wasm32.whl

  The following external shared libraries are required:
  {
  │   'shapely/speedups/_speedups.cpython-310-wasm32-emscripten.so': ['libgeos_c.so'],
  │   'shapely/vectorized/_vectorized.cpython-310-wasm32-emscripten.so': ['libgeos_c.so']
  }
  ```

  ```sh
  $ pyodide auditwheel repair --libdir <directory which contains libgeos_c.so> Shapely-1.8.2-cp310-cp310-emscripten_3_1_14_wasm32.whl

  Repaired wheel has following external shared libraries:
  {
  │   'Shapely.libs/libgeos.so.3.10.3': [],
  │   'Shapely.libs/libgeos_c.so': ['libgeos.so.3.10.3'],
  │   'shapely/speedups/_speedups.cpython-310-wasm32-emscripten.so': ['libgeos_c.so'],
  │   'shapely/vectorized/_vectorized.cpython-310-wasm32-emscripten.so': ['libgeos_c.so']
  }
  ```




  Listing shared library dependencies of a wheel file:

  ```py
  from auditwheel_emscripten import show
  libs = show("Shapely-1.8.2-cp310-cp310-emscripten_3_1_14_wasm32.whl")
  print(libs)

  ```

  Copying shared libraries to the wheel:

  ```py
  from auditwheel_emscripten import repair, show
  repaired_wheel = repair(
      "Shapely-1.8.2-cp310-cp310-emscripten_3_1_14_wasm32.whl",
      libdir="/path/where/shared/libraries/are/located",
      outdir="/path/to/output/directory",
  )
  libs = show(repaired_wheel)
  print(libs)

  ```





  Dynamic linking is not in the WebAssembly specification,
  but Emscripten has its own dynamic linking support,
  which is required for building Python wheels targeting Emscripten platform.

  This tool is based on:

  - Loosely documented Emscripten dynamic linking specification: https://github.com/WebAssembly/tool-conventions/blob/main/DynamicLinking.md
  - Emscripten's internal utility for inspecting WASM module: https://github.com/emscripten-core/emscripten/blob/main/tools/webassembly.py
  - Emscripten dylink implementation: https://github.com/emscripten-core/emscripten/blob/main/src/library_dylink.js



  `auditwheel` is a tool that helps repair and modify Python wheels (pre-compiled packages)
  to be compatible with a wide range of Linux distributions.
  It does this by copying external shared libraries into the wheel and
  repairing the RPATH (a file path that is used to locate shared libraries at runtime)
  of the ELF binary so that the Linux operating system can locate the library when the program is run.

  `auditwheel-emscripten` is a variation of auditwheel that is specifically designed
  to work with Emscripten-generated WebAssembly (WASM) modules.
  It does not perform an audit on the wheel, as Emscripten does not guarantee compatibility between versions.
  Instead, it simply copies the required libraries into the wheel without modifying the module itself.
  It is up to the user to manually implement a way to locate these libraries at runtime.

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


pkgId: c0ebfa48f3276b888aff84ec494f3a46bb5d98a048f2c4cad5316be258a20980
name: python-audl
arch: src
version: 0.0.15
epoch: 0
release: 1
summary: Unofficial audl api
url: https://github.com/yukikongju/audl
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audl-0.0.15-1.src.rpm
checksum_type: sha256
description:
  Unofficial AUDL api for python users

  What it does:
  - [X] Fetch Data directly from [audl website](https://theaudl.com)
  - [ ] Update database from Web Scrapping using workflow
  - [ ] Generate pdf reports for player, team and games

  [See Documentation](https://htmlpreview.github.io/?https://github.com/yukikongju/audl/blob/master/docs/audl/index.html)

  To download the package: `pip install audl`







  ```python
  from audl.stats.endpoints.playerprofile import PlayerProfile


  player = PlayerProfile('cbrock')
  career = player.get_career_stats()
  reg = player.get_regular_seasons_career()
  playoffs = player.get_playoffs_career()
  season = player.get_season_games_stats(2019)
  games_stats = player.get_career_games_stats()
  ```



  ![image](https://user-images.githubusercontent.com/34996954/172069063-9499e31a-aab3-4a58-9345-106555f41b7a.png)

  Season=['career', 2022, ..., 2012]
  Per=['total', 'game']
  Team=['team', 'opponent']


  ```python
  from audl.stats.endpoints.teamstats import TeamStats


  team_stats = TeamStats('career', 'game', 'opponent') # TeamStats(season, per, team)
  df = team_stats.get_table()
  ```



  ![image](https://user-images.githubusercontent.com/34996954/172069041-48e55c45-717c-4e99-a7aa-777658833ac6.png)

  Season=['career', 2022, ..., 2012]
  Per=['total', 'game', 'points', 'possessions', 'minutes']

  ```python
  from audl.stats.endpoints.playerstats import PlayerStats


  playerstats = PlayerStats('career', 'total', 'breeze').fetch_table()  # PlayerStats(season, per, team)
  ```



  ![image](https://user-images.githubusercontent.com/34996954/178094543-d6c57f95-6f1f-4aae-a7a4-a6687ab46afb.png)


  ```python

  from audl.stats.endpoints.seasonschedule import SeasonSchedule, TeamSeasonSchedule, AllSchedule, TeamSeasonAgainstOpponentSchedule



  from audl.stats.endpoints.seasonschedule import SeasonSchedule, TeamSeasonSchedule, AllSchedule, TeamSeasonAgainstOpponentSchedule



  season_schedule = SeasonSchedule(2022).get_schedule()
  team_season_schedule = TeamSeasonSchedule(2022, 'royal').get_schedule()
  all_schedule = AllSchedule().get_schedule()
  team_season_against_opponent = TeamSeasonAgainstOpponentSchedule(2022, 'royal', 'rush').get_schedule()

  ```



  ```python

  from audl.stats.endpoints.gamestats import GameStats


  game = GameStats("2021-06-05-RAL-ATL")
  teams = game.get_teams_metadata()
  players = game.get_players_metadata()
  game_metadata = game.get_game_metadata()
  team_stats = game.get_team_stats()
  roster = game.get_roster_stats()
  scoring_time = game._get_scoring_time()
  boxscores = game.get_boxscores()
  events = game.get_events()
  throw_selection = game.get_throw_selection()
  thrower_receiver_count = game.get_thrower_receiver_count(True)
  lineup = game.get_lineup_frequency(True)
  teamates = game.get_teamates_selection('ataylor', True)
  df_throws = game.get_throws_dataframe()


  game.print_team_events(True)
  game.print_team_events(False)
  ```



  ![image](https://user-images.githubusercontent.com/34996954/178094574-43272b29-8d47-4d15-8207-0536dd2ca30c.png)


  ```python
  from audl.stats.endpoints.teamgamestats import AllTeamGameStats, SeasonGameStats, TeamSeasonGameStats

  team_season = TeamSeasonGameStats(2022, 'royal').get_game_stats()
  all_games = AllTeamGameStats().get_game_stats()
  season_games = SeasonGameStats(2022).get_game_stats()

  ```


pkgId: 3928c1ee9d74caab0fee03ee24cbea933732d2c4ddc3ee2b073a8ed1c1f61a55
name: python-audlib
arch: src
version: 0.0.3.5
epoch: 0
release: 1
summary: A speech signal processing library with emphasis on deep learning.
url: https://github.com/raymondxyy/pyaudlib
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audlib-0.0.3.5-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/audlib.svg)](https://badge.fury.io/py/audlib)
  [![Build Status](https://travis-ci.com/raymondxyy/pyaudlib.svg?token=xNuzdfgseSXz1yHDnh9L&branch=master)](https://travis-ci.org/raymondxyy/pyaudlib)
  [![Coverage](https://codecov.io/gh/raymondxyy/pyaudlib/branch/master/graph/badge.svg?token=vMLw7Y9H5m)](https://codecov.io/gh/raymondxyy/pyaudlib)

  > A speech signal processing library in Python with emphasis on deep learning.

  audlib provides a collection of utilities for developing speech-related applications using both signal processing and deep learning. The package offers the following high-level features:

  - Speech signal processing utilities with ready-to-use applications
  - Deep learning architectures for speech processing tasks in [PyTorch][pytorch]
  - PyTorch-compatible interface (similar to torchvision) for batch processing
  - A command-line interface with a unix-pipe-like syntax

  Some use cases of audlib are:

  - Extracting common speech features for your backend
  - Developing your own deep-learning-based tools for speech tasks
  - Quickly try out speech processors and visualize the spectrogram in command line

  audlib focuses on correctness, efficiency, and simplicity. Signal processing functionalities are mathematically checked whenever possible (e.g. constant overlap-add, `istft(stft(X))==X`). Deep neural networks follow the [PyTorch][pytorch]'s convention.



  - 0.0.3
    - `sig.util.freqz` becomes `sig.util.fftfreqz`
    - `nn.strfnet` is removed. See the official repository [here](https://github.com/raymondxyy/strfnet-IS2020).
    - `transform.stlogm` is removed
  - 0.0.2
    - `audioread` follows the interface of `soundfile.read`
    - `audiowrite` follows the interface of `soundfile.write`
    - The argument `sr` is removed from all short-time transforms



  ```sh
  pip install audlib
  ```



  In the source directory, install the library with test dependencies:

  ```sh
  pip install ".[tests]"
  ```

  Run test:

  ```sh
  python -m pytest tests
  ```



  1. Bump version in setup.py.
  2. Package release: `python setup.py sdist bdist_wheel`
  3. Upload release: `twine upload --repository-url https://upload.pypi.org/legacy/ dist/*`



  More extensive examples can be found in `examples/`.



  - 0.0.3
    - First release of the command-line tool *audpipe*
  - 0.0.2
    - Streamlines optional installation
    - Improves API (**see breaking changes**)
    - Adds coverage test
  - 0.0.1
    - First release on PyPI



  Please reach out to Raymond Xia (raymondxia@cmu.edu) for comments.

  More information about our research groups can be found on at

  - [CMU Robust Speech Recognition Group](http://www.cs.cmu.edu/~robust/)
  - [Machine Learning for Signal Processing Group](http://mlsp.cs.cmu.edu/)



  Distributed under the MIT license. See ``LICENSE`` for more information.

  [pytorch]: https://pytorch.org/


pkgId: d741ac23d1270145d59ddd2b3ef9048c95f4d04e975dc824edd739c20e497dfe
name: python-audmath
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: Math function implemented using numpy
url: https://pypi.org/project/audmath/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audmath-1.4.1-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2021-present audEERING GmbH and Contributors  Authors: Hagen Wierstorf  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: 62a150589c94fb8d3aec3b5b63cf9f7bb19c4ea2a94d2bba85d2c8e6c736b6cc
name: python-audobject
arch: src
version: 0.7.11
epoch: 0
release: 1
summary: Generic object interface
url: https://pypi.org/project/audobject/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audobject-0.7.11-1.src.rpm
checksum_type: sha256
rpm_license:
  Copyright (c) 2019-2020 audEERING GmbH. All rights reserved.  Unauthorized copying of this file, via any medium is strictly prohibited. Proprietary and confidential.


pkgId: 58c11944d5133a9c11b699035acf2aa5688ec4de2ada7bf823e5dbe197ba5784
name: python-audp
arch: src
version: 0.9
epoch: 0
release: 1
summary: Analog Unicast Data Protocol (AUDP)
url: https://github.com/logandhillon/audp
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-audp-0.9-1.src.rpm
checksum_type: sha256
description:
  AUDP transfers analog data in a unicast manner between two TCP/IP-compliant machines.





  Encodes each bit using PCM. This results in larger, longer packets, but has practically no chance of data loss.
  There can be up to **~0.98 kHz** of interference, and PCM/AUDP will still be able to get a clean signal.



  Encodes each byte using DAC. This results in much smaller (about 8x smaller than PCM/AUDP) packets, but the chance of data loss is slightly higher.
  Not to be used in highly noisy areas, where sonic data may be lost. The tolerance for DAC/AUDP is ~35 Hz.



  Each unique frame of data should be 20 ms, or 882 Hz (samples) long at the AUDP-compliant sample rate (44.1 kHz).

  AUDP sonic data may be transfered in any medium, as long as the frequencies remain. For mediums that may endure compression, noise, or other forms of potential data loss, PCM/AUDP-based modems are recommended.



  The `LOW` (0) signal is represented by a frequency of **6 kHz**.

  The `HIGH` (1) signal is represented by a frequency of **4 kHz**.

  The `END CHUNK` signal is represented by a frequency of **2 kHz**.

  Acceptable tolerance is **± 975 Hz** for any signal.



  The factor to mulitply the byte by is **70 Hz**.



  Mulitply the decimal value of the byte (65) by the DAC factor (70 Hz) to get the frequency of 4.55 kHz.


pkgId: ceca0d838b952b90b8b23895470b9cd1ee3a561c9812ee6735b5e8b44298027c
name: python-auger-python
arch: src
version: 0.1.35
epoch: 0
release: 1
summary: Automatically generate unit tests for Python code
url: https://github.com/laffra/auger
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-auger-python-0.1.35-1.src.rpm
checksum_type: sha256
description:
  Auger is a project to automatically generate unit tests for Python code.

  See
  [these slides](http://goo.gl/PuZsgX)
  or
  [this blog](http://chrislaffra.blogspot.com/2016/12/auger-automatic-unit-test-generation.html)
  entry for more information.



  Install auger with:

      pip install auger-python



  To generate a unit test for any class or module, for Python 2 or 3, do this:

      import auger

      with auger.magic([ <any list of modules or classes> ]):
          <any code that exercises your application>



  Here is a simple example that does not rely on Auger at all:

      class Foo:                # Declare a class with a method
          def bar(self, x):
              return 2 * x .    # Duplicate x and return it

      def main():
          foo = Foo()           # Create an instance of Foo
          print(foo.bar(32))    # Call the bar method and print the result

      main()

  Inside the `main` function we call the `bar` method and it will print 64.



  To generate a unit test for this class, we run the code again, but this time in the context of Auger:

      import auger

      with auger.magic([Foo]):
          main()

  This will print out the following:

      64
      Auger: generated test: tests/test_Foo.py

  The test that is generated looks like this, with some imports and test for main removed:

      import unittest

      class FooTest(unittest.TestCase):
          def test_bar(self):
              foo_instance = Foo()
              self.assertEquals(
                  foo_instance.bar(x=32),
                  64
              )

      if __name__ == "__main__":
          unittest.main()



  Rather than emit tests in the file system, Auger can also print out the test to the console,
  by using the `verbose` parameter:

      import auger

      with auger.magic([Foo], verbose=True):
          main()

  In that case, Auger will not generate any tests, but just print them out.



  Consider the following example, `pet.py`, included in the `sample` folder, that lets us create a `Pet` with a name and a species:

      from animal import Animal

      class Pet(Animal):
        def __init__(self, name, species):
          Animal.__init__(self, species)
          self.name = name

        def getName(self):
          return self.name

        def __str__(self):
          return "%s is a %s" % (self.getName(), self.getSpecies())

      def createPet(name, species):
        return Pet(name, species)

  A `Pet` is really a special kind of `Animal`, with a name, which is defined in `animal.py`:

      class Animal(object):
        def __init__(self, species):
          self.species = species

        def getSpecies(self):
          return self.species

  With those two definitions, we can create a `Pet` instance and print out some details:

      import animal
      import pet

      def main():
        p = pet.createPet("Polly", "Parrot")
        print(p, p.getName(), p.getSpecies())

      main()

  This produces:

      Polly is a Parrot Polly Parrot



  With Auger, we can record all calls to all functions and methods defined in `pet.py`,
  while also remembering the details for all calls going out from `pet.py` to other modules,
  so they can be mocked out.

  Instead of saying:

      if __name__ == "__main__":
        main()

  We would say:

      import auger

      if __name__ == "__main__":
        with auger.magic([pet]):   # this is the new line and invokes Auger
          main()

  This produces the following automatically generated unit test for `pet.py`:

      from mock import patch
      from sample.animal import Animal
      import sample.pet
      from sample.pet import Pet
      import unittest


      class PetTest(unittest.TestCase):
          @patch.object(Animal, 'get_species')
          @patch.object(Animal, 'get_age')
          def test___str__(self, mock_get_age, mock_get_species):
              mock_get_age.return_value = 12
              mock_get_species.return_value = 'Dog'
              pet_instance = Pet('Clifford', 'Dog', 12)
              self.assertEquals(pet_instance.__str__(), 'Clifford is a dog aged 12')

          def test_create_pet(self):
              self.assertIsInstance(sample.pet.create_pet(age=12,species='Dog',name='Clifford'), Pet)

          def test_get_name(self):
              pet_instance = Pet('Clifford', 'Dog', 12)
              self.assertEquals(pet_instance.get_name(), 'Clifford')

          def test_lower(self):
              self.assertEquals(Pet.lower(s='Dog'), 'dog')

      if __name__ == "__main__":
          unittest.main()

  Note that auger detects object creation, method invocation, and static methods. It automatically
  generate mocks for `Animal`. The mock for `get_species` returns 'Dog' and `get_age` returns 12.
  Namely, those were the values Auger recorded when we ran our sample code the last time.



  By automatically generating unit tests, we dramatically cut down the cost of software
  development. The tests themselves are intended to help developers get going on their unit testing
  and lower the learning curve for how to write tests.



  Auger does not do try to substitue parameters with synthetic values such as `-1`, `None`, or `[]`.
  Auger also does not act well when code uses exceptions. Auger also does not like methods that have a decorator.

  Auger only records a given execution run and saves the run as a test. Auger does not know if the code actually
  works as intended. If the code contains a bug, Auger will simply record the buggy behavior. There is no free
  lunch here. It is up to the developer to verify the code actually works.


pkgId: 56e38ed0d7c64ec0d147c321d62741aff84029831a6c519e6512b6280f7c31e4
name: python-augflow
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: A versatile augmentation library for computer vision projects.
url: https://github.com/ConnectedMotion/augflow
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-augflow-1.0.1-1.src.rpm
checksum_type: sha256
description:
  <div style="margin-left: 40px;">
    **Discover What Makes AugFlow Unique and So Powerful 🌟**
  - **🌊 Innovative Flow Concept**
      AugFlow introduces the entirely novel concept of flows, a groundbreaking approach not yet implemented in any existing theory or solutions. Our initial evaluations demonstrate the impact and advantages this unique methodology brings to data augmentation.
  - **🛠️ Configurable Parameters**: Every augmentation is fully configurable through simple and intuitive parameters.
  - **🖍️ Comprehensive Polygon Clipping Control**
      Unlike existing open and closed-source solutions that inadequately manage polygon clipping, AugFlow offers comprehensive, per-class control over clipped polygons, enhancing dataset diversity especially for those with high intra-class variability.
  - **✂️ Enhanced CutOut Functionality**
      AugFlow's CutOut feature provides superior control, enabling precise targeting of large or small polygons along with customizable parameters. This flexibility ensures more effective and tailored data augmentation strategies.
  - **🧩 Advanced Mosaic Augmentation**
      AugFlow's Mosaic augmentation offers exceptional control with dynamic grid configurations, including larger grids for high-resolution images. This adaptability significantly improves detection accuracy for small objects within complex scenes.
  - **🔄 Precise Transformation Controls**
      AugFlow enhances fundamental augmentations like Crop, Rotate, Shear, and Translate, allowing precise customization to better suit diverse dataset requirements and improve model robustness.
  - **🎯 Targeted Category Focusing**
      AugFlow enables targeted augmentation by focusing on images containing specific categories while excluding others, effectively balancing datasets. Future enhancements aim to handle edge cases per class using advanced unsupervised techniques.
  - **📄 Format-Agnostic**: Supports multiple annotation formats including **COCO** and **YOLO** seamlessly, for both detection and segmentation.
  - **📊 Logging & Visualization**: Track augmentation processes with detailed logs and visualize annotations to ensure quality.
  - **🔧 Extensible Architecture**: Designed to easily incorporate new augmentations and extend existing functionalities.


pkgId: 50e9de3c2e9470029f72bca6701e0faffd2ebbd5ec101eeb384334a4eb4725e8
name: python-augint-tools
arch: src
version: 1.42.0
epoch: 0
release: 1
summary: Standard tools for Augmenting Integrations
url: https://github.com/svange/openbrain
rpm_license: AGPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-augint-tools-1.42.0-1.src.rpm
checksum_type: sha256
description:
  The `LeadmoApiV1` class is a Python client designed to facilitate interactions with the Lead Momentum API. This client provides an easy-to-use interface for managing contacts and appointments within the Lead Momentum platform. It abstracts away the complexities of making HTTP requests and handling authentication, allowing developers to focus on their application's core functionality.

  The `LeadmoApiV1` class offers the following capabilities:

  - **Create Contact**: Add a new contact to your Lead Momentum account.
  - **Lookup Contact**: Retrieve contact details using contact identifiers.
  - **Update Contact**: Modify existing contact information, such as address and phone number.
  - **Delete Contact**: Remove a contact from your account.
  - **Get Contact by ID**: Fetch detailed information about a contact using their unique identifier.

  - **Get Available Appointment Slots**: Retrieve available time slots for scheduling appointments.
  - **Create Appointment**: Schedule a new appointment using available slots.
  - **Get Appointment by ID**: Retrieve detailed information about a specific appointment.
  - **Update Appointment**: Change the details of an existing appointment.
  - **Update Appointment Status**: Modify the status of an appointment (e.g., confirmed, canceled).
  - **Delete Appointment**: Cancel and remove an appointment from the schedule.


  To use the `LeadmoApiV1` client, instantiate it with your API key:
  ```python
  from augint_tools.leadmo_api.v1.client import LeadmoApiV1

  api_key = "your_api_key_here"
  leadmo = LeadmoApiV1(api_key=api_key)
  ```
  Alternatively, you can set the API key as an environment variable and initialize the client without passing the key explicitly:
  ```python
  from augint_tools.leadmo_api.v1.client import LeadmoApiV1
  os.environ["LEADMO_BEARER_TOKEN"] = "your_api_key_here"

  leadmo = LeadmoApiV1()
  ```


  ```python

  contact_data = {
      "first_name": "John",
      "last_name": "Doe",
      "email": "john.doe@example.com",
      "phone": "+1234567890"
  }

  response = leadmo.create_contact(**contact_data)
  print(response)
  ```

  ```python

  slots_response = leadmo.get_available_appointment_slots(calendar_id="your_calendar_id", timezone="US/Pacific")
  next_slot = list(slots_response.values())[0]["slots"][0]

  appointment_response = leadmo.create_appointment(
      phone=contact_data.get("phone"),
      calendar_id="your_calendar_id",
      selected_slot=next_slot,
      selected_timezone="US/Pacific"
  )
  print(appointment_response)
  ```

  ```python

  update_response = leadmo.update_contact(contact_id=contact_id, address1="1234 Main St.")
  print(update_response)
  ```

  ```python

  leadmo.delete_appointment(appointment_id=appointment_id)
  ```

  The `LeadmoApiV1` class streamlines the process of integrating with the Lead Momentum API, providing a simple and efficient way to manage contacts and appointments programmatically. By utilizing this client, developers can focus on building robust applications while leveraging the powerful features offered by the Lead Momentum platform.
  examples as needed for your project's documentation!


