# packages

pkgId: 3e4086764d7085c9c64220cc4767ae6745f1da3a5c1c032a6d051fd2247ad195
name: python-appier
arch: src
version: 1.34.5
epoch: 0
release: 1
summary: Appier Framework
url: http://appier.hive.pt
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-appier-1.34.5-1.src.rpm
checksum_type: sha256
description:
  Joyful Python Web App development
  Appier is an object-oriented Python web framework built for super fast app development.
  It's as lightweight as possible, but not too lightweight.
  It gives you the power of bigger frameworks, without their complexity.


pkgId: 526df520528bdffd1bec153544b477c56c22922e030271ef93e4abdb62420e13
name: python-appimage-builder
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Recipe based AppImage creation meta-tool
url: https://github.com/AppImageCrafters/appimage-builder
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-appimage-builder-1.1.0-1.src.rpm
checksum_type: sha256
description:
  *GNU/Linux packaging made easy!* ™



  It's a tool for packing applications along with all of its dependencies using the
  system package manager to obtain binaries and resolve dependencies. It creates a
  **self-sufficient** and **portable** bundle using the [AppImage](https://appimage.org)
  format.

  Features:
  - Real GNU/Linux packaging (no more distro packaging)
  - Simple recipes
  - Simple workflow
  - Backward and forward compatibility
  - One binary, many target systems.




  - [Installation](https://appimage-builder.readthedocs.io/en/latest/intro/install.html)
  - [Getting help](https://appimage-builder.readthedocs.io/en/latest/index.html#getting-help)
  - [Tutorial](https://appimage-builder.readthedocs.io/en/latest/intro/tutorial.html)
  - [Documentation](https://appimage-builder.readthedocs.io)




  [![Zeal](https://raw.githubusercontent.com/zealdocs/zeal/master/assets/freedesktop/128-apps-zeal.png)](https://github.com/zealdocs/zeal/)
  [![Kstars](https://invent.kde.org/education/kstars/-/raw/master/logo.png)](https://invent.kde.org/education/kstars)
  [![Glimpse](https://raw.githubusercontent.com/glimpse-editor/Glimpse/dev-g210/icons/Color/128/glimpse-icon.png)](https://github.com/glimpse-editor/Glimpse)
  [![MystiQ](https://raw.githubusercontent.com/swl-x/MystiQ/master/icons/mystiq_128x128.png)](https://github.com/swl-x/MystiQ)
  [![MAUI](https://invent.kde.org/uploads/-/system/group/avatar/1557/avatar.png?width=64)](https://invent.kde.org/maui)


pkgId: 3c66e288e2a3616f70ed13a033b3c1590df5a26b46268c76f21595797cd0c58f
name: python-appinsights
arch: src
version: 0.13.0
epoch: 0
release: 1
summary: This project extends the Application Insights API surface to support Python.
url: https://github.com/brennerm/python-appinsights
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-appinsights-0.13.0-1.src.rpm
checksum_type: sha256
description:
  This project extends the Application Insights API surface to support Python.
  `Application Insights
  <http://azure.microsoft.com/services/application-insights/>`_ is a service that
  allows developers to keep their application available, performing and
  succeeding. This Python module will allow you to send telemetry of various kinds
  (event, trace, exception, etc.) to the Application Insights service where they
  can be visualized in the Azure Portal. A link to the Application Insights API
  documentation can be found `here
  <https://brennerm.github.io/python-appinsights/>`_.
  This project is not officially supported and not recommended for high load
  production use. The project is open source and welcomes contributions.


pkgId: f2c53d488e05aee86294837b9f6fb88bb91dcf64a343cd5dbd2035f5ce301197
name: python-appium_selector
arch: src
version: 1.3.2
epoch: 0
release: 1
url: https://github.com/Mattwhooo/appium_selector.git
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-appium_selector-1.3.2-1.src.rpm
checksum_type: sha256
summary:
  Creates a Tcl/Tk window to read connected Appium devices from Selenium Grid and display them for selection


pkgId: e0572d33fee5374c2fe2cfb4441ec7f4ac64314d6c0f613b56f407544098b255
name: python-applaud
arch: src
version: 0.9.4
epoch: 0
release: 1
summary: The Python SDK to work with the App Store Connect API from Apple.
url: https://github.com/codinn/applaud
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-applaud-0.9.4-1.src.rpm
checksum_type: sha256
description:
  `Applaud` is a Python client library for accessing [App Store Connect API](https://developer.apple.com/documentation/appstoreconnectapi), generated by [Applaudgen](https://github.com/codinn/applaudgen).

  [![PyPI version](https://badge.fury.io/py/applaud.svg)](https://badge.fury.io/py/applaud)



  - [x] Support App Store Connect API latest version 1.6
  - [x] Support `filter`, `fileds`, `include`, `limit`, `sort`, `exists` and other query parameters
  - [x] All endpoints / paths are implemented, include, but not limited to: App Information, TestFlight, Users and Roles, Sales and Finances
  - [x] Pythonic, all `camelCase` schema fields are represented as `snake_case` class attributes
  - [x] Embrace [Python type hints](https://www.python.org/dev/peps/pep-0483/)
  - [x] Use [Python Requests](https://docs.python-requests.org/en/latest/) to hanlde HTTP sessions
  - [x] [ErrorResponse](https://developer.apple.com/documentation/appstoreconnectapi/errorresponse) can be catched as exception



  Install with `pip`:

  ```
  pip install applaud
  ```

  Install with [Poetry](https://python-poetry.org/):
  ```
  poetry add applaud
  ```

  Install with [Pipenv](https://pipenv.pypa.io/en/latest/):
  ```
  pipenv install applaud
  ```



  Calls to the API require authorization, so before we get started, you obtain keys to create the tokens from your organization’s App Store Connect account. See [Creating API Keys for App Store Connect API](https://developer.apple.com/documentation/appstoreconnectapi/creating_api_keys_for_app_store_connect_api) to create your keys and tokens.




  `Connection` is the core class of `Applaud`, it holds a connection between client and remote service, [generate a new token](https://developer.apple.com/documentation/appstoreconnectapi/generating_tokens_for_api_requests#3878467) before it expires.

  ```python
  from applaud.connection import Connection


  connection = Connection(APPSTORE_ISSUER_ID, APPSTORE_KEY_ID, APPSTORE_PRIVATE_KEY)
  ```

  In most of cases, all tasks you'd like to perform on remote service should be initiated from a `Connection` object. `Connection` has a bunch of functions help you create `…Endpoint` objects:

  ```python

  connection.apps()
  ```



  A `…Endpoint` class encapsulates all operations you can perform on a specific resource. For example, this snippet fetches first two (sort by app name) apps that "ready for sale" and have game center enabled versions:

  ```python

  connection.apps().filter(
      app_store_versions_app_store_state=AppStoreVersionState.READY_FOR_SALE
  ).exists(
      game_center_enabled_versions=True
  ).limit(
      2
  ).sort(
      name: SortOrder.ASC
  ).get()
  ```



  The `get()` operation initiates a HTTP `GET` request on the endpoint's path. For example, the URL of [List Apps](https://developer.apple.com/documentation/appstoreconnectapi/list_apps) service endpoint is:
  ```
  GET https://api.appstoreconnect.apple.com/v1/apps
  ```

  The corresponding code in `Applaud`:
  ```python

  response = connection.apps().get()

  for app in response.data:
      print(f'{app.attributes.name}: {app.attributes.bundle_id}')
  ```

  Unlike other operations (`create()`, `update()` and `delete()`), `get()` operation can be chained by query parameters functions:

  **`filter()`**

  You use `filter()` function to extract matching resources. For example:
  ```
  filter[bundleId]  Attributes, relationships, and IDs by which to filter.
          [string]
  ```

  The corresponding code in `Applaud`:
  ```python
  response = connection.apps().filter(
      bundle_id="com.exmaple.app1"
  ).get()

  connection.apps().filter(
      bundle_id=["com.exmaple.app1", "com.exmaple.app2"]
  ).get()

  for app in response.data:
      print(f'{app.attributes.name}: {app.attributes.bundle_id}')
  ```

  **`include()`**

  You use `include()` function to ask relationship data to include in the response. For example:
  ```
   include  Relationship data to include in the response.
  [string]  Possible values: appClips, appInfos, appStoreVersions,
            availableTerritories, betaAppLocalizations,
            betaAppReviewDetail, betaGroups, betaLicenseAgreement,
            builds, ciProduct, endUserLicenseAgreement,
            gameCenterEnabledVersions, inAppPurchases, preOrder,
            preReleaseVersions, prices
  ```

  The corresponding code in `Applaud`:
  ```python
  response = connection.apps().include(
      AppListEndpoint.Include.BETA_LICENSE_AGREEMENT
  ).get()

  response = connection.apps().include(
      [AppListEndpoint.Include.BETA_LICENSE_AGREEMENT, AppListEndpoint.Include.PRICES]
  ).get()
  ```

  **`fields()`**

  You use `fields()` function to ask fields data to return for included related resources in a `get()` operation. Related resources specified in `fields()` function *MUST* be included explicitly in `include()` function, otherwise, the remote service may not return the fields data that you expect. For example:
  ```
  fields[betaLicenseAgreements]  Fields to return for included related types.
                       [string]  Possible values: agreementText, app
  ```

  The corresponding code in `Applaud`:
  ```python
  connection.apps().include(
      AppListEndpoint.Include.BETA_LICENSE_AGREEMENT
  ).fields(
      beta_license_agreement=[BetaLicenseAgreementField.AGREEMENT_TEXT, BetaLicenseAgreementField.APP]
  ).get()
  ```

  **`limit()`**

  You use `limit()` function to restrict the maximum number of resources to return in a `get()` operation. For example:
  ```
    limit  Number of resources to return.
  integer  Maximum Value: 200
  ```

  The corresponding code in `Applaud`:
  ```python

  connection.apps().limit(10).get()


  connection.apps().limit(400).get()
  ```

  You can also included limit the number of related resources to return, as in `fields()` function, you *MUST* also specify the related resources explicitly in `include()` function. For example:
  ```
  limit[appStoreVersions]  integer
                           Maximum Value: 50
  ```

  The corresponding code in `Applaud`:
  ```python

  connection.apps().include(
      AppListEndpoint.Include.APP_STORE_VERSIONS
  ).limit(app_store_versions=5).get()


  connection.apps().include(
      AppListEndpoint.Include.APP_STORE_VERSIONS
  ).limit(app_store_versions=100).get()
  ```

  By leverage `limit()` function with `sort()` function, your script can be more responsive.

  **`sort()`**

  You use `sort()` function to sort the returned resources by attributes in ascending or descending order. For example:
  ```
      sort  Attributes by which to sort.
  [string]  Possible values: bundleId, -bundleId, name, -name, sku, -sku
  ```

  The corresponding code in `Applaud`:
  ```python
  connection.apps().sort(name=SortOrder.ASC, bundleId=SortOrder.DESC).get()
  ```

  **`exists()`**

  `exists()` is a special type of filter – filter by existence or non-existence of related resource. For example:
  ```
  exists[gameCenterEnabledVersions]  [string]
  ```

  The corresponding code in `Applaud`:
  ```python
  connection.apps().exists(game_center_enabled_versions=True).get()
  ```



  The `create()` operation initiates a HTTP `POST` request on the endpoint's path. For example, the URL of [Create an App Store Version](https://developer.apple.com/documentation/appstoreconnectapi/create_an_app_store_version) service endpoint is:
  ```
  POST https://api.appstoreconnect.apple.com/v1/appStoreVersions
  ```

  The corresponding code in `Applaud`:
  ```python
  request = AppStoreVersionCreateRequest(
              data = AppStoreVersionCreateRequest.Data(
                  relationships = AppStoreVersionCreateRequest.Data.Relationships(
                      app = AppStoreVersionCreateRequest.Data.Relationships.App(
                          data = AppStoreVersionCreateRequest.Data.Relationships.App.Data(
                              id = 'com.exmaple.app1'
                          )
                      )
                  ),
                  attributes = AppStoreVersionCreateRequest.Data.Attributes(
                      version_string = '1.6',
                      platform = Platform.IOS,
                      copyright = f'Copyright © 2021 Codinn Technologies. All rights reserved.',
                      release_type = AppStoreVersionReleaseType.AFTER_APPROVAL
                  )
              )
          )


  reponse = connection.app_store_versions().create(request)

  version = response.data
  print(f'{version.version_string}: {version.created_date}, {version.app_store_state}')
  ```



  The `update()` operation initiates a HTTP `PATCH` request on the endpoint's path. For example, the URL of [Modify an App Store Version](https://developer.apple.com/documentation/appstoreconnectapi/modify_an_app_store_version) service endpoint is:
  ```
  PATCH https://api.appstoreconnect.apple.com/v1/appStoreVersions/{id}
  ```

  The corresponding code in `Applaud`:
  ```python

  version_id = version.data.id


  request = AppStoreVersionUpdateRequest(
              data = AppStoreVersionUpdateRequest.Data(
                  id = version.data.id,

                  attributes = AppStoreVersionUpdateRequest.Data.Attributes(
                      version_string = '1.6.1',
                      platform = Platform.IOS,
                      copyright = f'Copyright © 2022 Codinn Technologies. All rights reserved.',
                      release_type = AppStoreVersionReleaseType.AFTER_APPROVAL
                  )
              )
          )


  reponse = connection.app_store_version(version_id).update(request)

  version = response.data
  print(f'{version.version_string}: {version.copyright}, {version.app_store_state}')
  ```



  The `delete()` operation initiates a HTTP `DELETE` request on the endpoint's path. For example, the URL of [Delete an App Store Version](https://developer.apple.com/documentation/appstoreconnectapi/delete_an_app_store_version) service endpoint is:
  ```
  DELETE https://api.appstoreconnect.apple.com/v1/appStoreVersions/{id}
  ```

  The corresponding code in `Applaud`:
  ```python

  version_id = version.data.id

  connection.app_store_version(version_id).delete()
  ```



  `…Endpoint.get()`, `…Endpoint.create()`, `…Endpoint.update()` and `…Endpoint.delete()` may raise two types of exceptions:

  1. HTTP request exceptions raised by [Python Requests](https://docs.python-requests.org/en/latest/api/#exceptions)
  2. Remote service returns an [ErrorResponse](https://developer.apple.com/documentation/appstoreconnectapi/errorresponse)

  For the second case, `Applaud` raises an `EndpointException` exception, and attaches all [`ErrorResponse.Error`](https://developer.apple.com/documentation/appstoreconnectapi/errorresponse/errors) objects in `EndpointException.errors` attribute.

  Some errors are harmless, for example, App Store Connect has no API for you to tell whether a tester has accepted beta test invitation or not. When you trying to resend invitations to testers, you may encounter an `ALREADY_ACCEPTED` error, it's safe to just ignore such error:

  ```python
  try:
      
      response = connection.beta_tester_invitations().create(…)
  except EndpointException as err:
      already_accepted_error = False
      for e in err.errors:
          if e.code == 'STATE_ERROR.TESTER_INVITE.ALREADY_ACCEPTED':
              
              already_accepted_error = True
              break

      if not already_accepted_error:
          raise err
  ```



  - Query parameters functions (`filter()`, `include`, `fields` …) play a role only when using with `…Endpoint.get()`. Though there is no side effects if chain it with `…Endpoint.create()`, `…Endpoint.update()` and `…Endpoint.delete()` operations, it is not adviced.


pkgId: 938cc7f0d804ee2cabd518b3374e2fd81443435a14f5318397cccff7d05a93c2
name: python-applaunchservices
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Simple package for registering an app with apple Launch Services to handle UTI and URL
url: https://github.com/impact27/applaunchservices
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-applaunchservices-0.3.0-1.src.rpm
checksum_type: sha256
description:
  Simple package for registering an app with apple Launch Services to handle UTI and URL. See Apple documentations for details.


  Launch Services allows a GUI app to register a URL scheme.
  This means the app can be called when the user types a URL like `<scheme>://<something>`.

   - `set_URL_scheme_handler`: Sets the given bundleid as the default handler for a given url scheme.
   - `get_URL_scheme_handler`: Gets the default bundleid for a given url scheme.
   - `open_URL`: Opens the given URL with launch services


  Launch Services allows a GUI app to register a uniform type identifier (UTI).
  This means the app can be called when the user double click on a file in the finder that matches this scheme.
  Or if the user types an url like `<file:///path/to/file.ext>`.

  - `set_UTI_handler`: Sets the given bundleid as the default handler for a given uniform type identifier and role.
  - `get_UTI_handler`: Gets the default bundleid for a given uniform type identifier and role.
  - `open_path`: Opens the given path with launch services

  The roles are:
   - 'none'
   - 'viewer'
   - 'editor'
   - 'shell'
   - 'all'



  The bundle identifier is used to identify an app. Two functions are supplied:

   - `get_bundle_identifier()`: Gets the current bundle identifier if it exists (The app is a GUI app)
   - `get_bundle_identifier(pid)`: Gets the bundle identifier for the given process id if it exists (The app is a GUI app)
   - `get_bundle_identifier_for_path(path)`: Gets the bundle identifier if the path points to a bundle


  ```python
  import applaunchservices as als
  from PyQt5.QtWidgets import QApplication, QWidget
  from PyQt5.QtCore import QEvent, Qt


  uniform_type_identifier = "public.python-script"
  role = 'editor'


  class MacApplication(QApplication):
      """Application that process fileopen events."""
      def event(self, event):
          if event.type() == QEvent.FileOpen:
              widget.setWindowTitle(str(event.file()))
          return QApplication.event(self, event)


  app = MacApplication([''])
  widget = QWidget()


  old_handler = als.get_UTI_handler(uniform_type_identifier, role)
  app.aboutToQuit.connect(
      lambda: als.set_UTI_handler(
          uniform_type_identifier, role, old_handler))



  def handle_applicationStateChanged(state):
      if state == Qt.ApplicationActive and app._starting:
          app._starting = False
          bundle_identifier = als.get_bundle_identifier()
          als.set_UTI_handler(
              uniform_type_identifier, role, bundle_identifier)


  app._starting = True
  app.applicationStateChanged.connect(handle_applicationStateChanged)


  widget.setWindowTitle('test')
  widget.show()
  app.exec_()

  ```


pkgId: 6a56f2f574f4092deda31a5240caeeb87e47b67c1729805cf9e9421c3a3c285f
name: python-apple-compress
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: Python bindings for Apple's libcompression.
url: https://pypi.org/project/apple-compress/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apple-compress-0.2.3-1.src.rpm
checksum_type: sha256
description:
  Python bindings for Apple's libcompression.

  Based on bindings from [Asahi Linux](https://github.com/AsahiLinux/asahi-installer/blob/8bbbb8ca5a347d99b243e10f24358573f1587df0/asahi_firmware/img4.py#L17-L27).


  - Python 3.8 or higher
  - An *OS system



  Read the [API usage](https://github.com/m1stadev/apple-compress/wiki/API-Usage).


  ```
  Usage: acompress [OPTIONS]

    A Python CLI tool for compression using Apple's libcompression.

  Options:
    --version              Show the version and exit.
    -i, --input FILENAME   Input file.  [required]
    -o, --output FILENAME  Output file.  [required]
    -c, --compress         Compress the data.
    -d, --decompress       Decompress the data.
    -l, --lzfse            LZFSE compress the data.
    -b, --lzfse-iboot      LZFSE compress the data (iBoot compatible).
    -z, --zlib             zlib compress the data.
    -v, --verbose          Increase verbosity.
    -h, --help             Show this message and exit.
  ```


  - Install from [PyPI](https://pypi.org/project/apple-compress/):
      - ```python3 -m pip install apple-compress```
  - Local installation:
      - `./install.sh`
      - Requires [Poetry](https://python-poetry.org)


  For any questions/issues you have, [open an issue](https://github.com/m1stadev/apple-compress/issues).


pkgId: 4ff161147bef707990b394747fc7c7e2036578b80cfb3c2a50d003c8a5367c60
name: python-apple-hdr-heic
arch: src
version: 0.0.3
epoch: 0
release: 1
url: https://github.com/johncf/apple-hdr-heic
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apple-hdr-heic-0.0.3-1.src.rpm
checksum_type: sha256
summary:
  A library/tool to decode images in HEIC/HEIF format taken on Apple devices that contain HDR gain map.

description:
  A library/tool to decode photos (HEIC files) taken on an iPhone that contain HDR gain map, and convert it to a 48-bit (16-bit per channel) HDR representation as per [Rec. 2100](https://en.wikipedia.org/wiki/Rec._2100) with PQ transfer function.

  **Disclaimer:** This project is _not_ affiliated with, or endorsed by, Apple Inc. or any of its subsidiaries.



  * Python 3.10+
  * [`exiftool`](https://exiftool.org/) 12.54+
    - For Ubuntu or Debian, do `sudo apt install libimage-exiftool-perl`
    - For other Linux distros, search `exiftool` using your package manager
    - For Mac or Windows, follow the instructions in website
    - For Windows, it is also available via [Scoop](https://scoop.sh/)



  To install the latest published version, do (preferrably in a [virtual environment](https://docs.python.org/3/library/venv.html)):

  ```
  pip install apple-hdr-heic
  ```

  Or if you want the latest development version, install using a Github archive link:

  ```
  pip install https://github.com/johncf/apple-hdr-heic/archive/master.tar.gz
  ```





  ```
  apple-hdr-heic-decode input.heic output.png
  apple-hdr-heic-decode input.heic output.heic -q 95
  ```

  Lossless conversion:

  ```
  apple-hdr-heic-decode input.heic output.avif -b 12 -y 444
  ```

  Note: With 12-bit channels (in AVIF or HEIC), it's not truly lossless compared to 16-bit channels in PNG, but it's close enough.



  ```py
  from apple_hdr_heic import load_as_bt2100_pq, quantize_to_uint16

  bt2100_pq = load_as_bt2100_pq("input.heic")
  bt2100_pq_u16 = quantize_to_uint16(bt2100_pq)
  cv2.imwrite("output.png", bt2100_pq_u16[:, :, ::-1])
  ```

  Note: The output file `output.png` (in examples above) does not contain the necessary [cICP](https://en.wikipedia.org/wiki/Coding-independent_code_points) metadata that denotes it to have `bt2020` (9) color primaries and `smpte2084` (16) transfer characteristics. Therefore, all image viewers will display them incorrectly.





  Install [`uv`](https://github.com/astral-sh/uv).

  Install `nox` using `uv`:

  ```
  uv tool install nox
  ```



  ```
  nox -s test
  ```



  ```
  nox -s typeck
  ```



  ```
  nox -s lint
  ```



  ```
  nox -s style
  ```



  ```
  uv tool install flit
  flit build --no-use-vcs
  ```





  Although this tool supports 12-bit HEIC output, it doesn't seem to be widely supported, even in Apple softwares.



  If you want to use a different AVIF encoder, first use this tool to produce a PNG file, then use [libavif](https://github.com/AOMediaCodec/libavif) with `--cicp` set to `9/16/9` to convert the PNG to AVIF:

  ```
  avifenc -s 4 -j 4 --min 1 --max 56 -a end-usage=q -a cq-level=10 -a tune=ssim -a color:enable-qm=1 \
      -a color:enable-chroma-deltaq=1 -d 12 --cicp 9/16/9 output.png output.avif
  ```


pkgId: e938fe52f704dadd0ad65560f54a738b9301bac018421e97e9bbe88c29d8df65
name: python-apple_weatherkit
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: Python client for Apple WeatherKit API
url: https://github.com/tjhorner/python-weatherkit
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apple_weatherkit-1.1.3-1.src.rpm
checksum_type: sha256
description:
  This is a Python client for Apple's WeatherKit API. It is primarily written for use with the [Home Assistant](https://www.home-assistant.io/) integration, but can be used for other purposes as well.


pkgId: e0f69d47e4ee9e0f27168ccff8296c49f45587efac762074a2ebcfb1f9af0c52
name: python-applecatalog
arch: src
version: 2.0.5
epoch: 0
release: 1
summary: AppleCatalog download agent
url: https://github.com/doronz88/applecatalog
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-applecatalog-2.0.5-1.src.rpm
checksum_type: sha256
description:
  [![Python application](https://github.com/doronz88/applecatalog/workflows/Python%20application/badge.svg)](https://github.com/doronz88/applecatalog/actions/workflows/python-app.yml "Python application action")
  [![Pypi version](https://img.shields.io/pypi/v/applecatalog.svg)](https://pypi.org/project/applecatalog/ "PyPi package")



  Simple library for automating downloads of updates from Apple's servers. Use this simply tool for downloads macOS
  images, CommandLineTools, XProtect database and just everything you can think of :).



  You can either install using `pip`:

  ```shell
  python3 -m pip install -U applecatalog
  ```

  Or install locally from git:

  ```shell
  git clone git@github.com:doronz88/applecatalog.git
  cd applecatalog
  python3 -m pip install -U -e .
  ```



  ```
  Usage: applecatalog [OPTIONS] {macos|rosetta} COMMAND [ARGS]...

    CLI util for downloading updates from either macos/rosetta seeds

  Options:
    --help  Show this message and exit.

  Commands:
    date      last update date
    download  download a single product packages
    info      query info for a single product
    list      list all products
  ```



  ```shell

  python3 -m applecatalog macos list -q | grep CLTools


  python3 -m applecatalog macos list --macos


  python3 -m applecatalog macos download PRODUCT_ID /tmp

  ```



  ```
  ➜  dev applecatalog macos products list
  Product(id='031-17335', version='11.0.0.0', title='Photo Content Catalogs', date=datetime.datetime(2015, 2, 23, 18, 1, 41), basename='PhotoContentCatalogs.smd')
  Product(id='031-17334', version='11.0.0.0', title='Photo Content Themes', date=datetime.datetime(2015, 2, 23, 18, 1, 41), basename='PhotoContentThemes.smd')
  Product(id='031-18981', version='17.0.0.0', title='Photo Content Catalogs', date=datetime.datetime(2015, 3, 25, 17, 12, 1), basename='PhotoContentCatalogs.smd')
  Product(id='091-76740', version='1.0.0.0', title='Noticeboard Removal Tool', date=datetime.datetime(2018, 4, 5, 17, 17, 49), basename='NRT.smd')
  Product(id='041-91737', version='1.0', title='BootCamp', date=datetime.datetime(2019, 10, 9, 19, 40, 56), basename='BootCampESD.smd')
  Product(id='041-91736', version='1.0', title='BootCamp', date=datetime.datetime(2019, 10, 9, 19, 43, 9), basename='BootCampESD.smd')
  Product(id='041-88235', version='31.0.0.0', title='Photo Content Catalogs', date=datetime.datetime(2019, 10, 9, 21, 33, 35), basename='PhotoContentCatalogs.smd')
  Product(id='041-88237', version='31.0.0.0', title='Photo Content Themes', date=datetime.datetime(2019, 10, 9, 21, 34, 21), basename='PhotoContentThemes.smd')
  Product(id='041-88232', version='1.8', title='Mac mini EFI Firmware Update', date=datetime.datetime(2019, 10, 9, 21, 35, 34), basename='MacminiEFIUpdate1.8.smd')
  Product(id='041-88233', version='3.7.2', title='Remote Desktop Admin Update', date=datetime.datetime(2019, 10, 9, 21, 37, 47), basename='RemoteDesktopAdmin372.smd')
  Product(id='041-88177', version='2.0.1', title='Dictation Language Update - Italian (Italy)', date=datetime.datetime(2019, 10, 9, 23, 10, 48), basename='SRCLUpdate_it_IT.smd')
  Product(id='041-94866', version='2.0.1', title='Dictation Language Update - English (Australia)', date=datetime.datetime(2019, 10, 9, 23, 11, 3), basename='SRCLUpdate_en_AU.smd')
  Product(id='041-88170', version='2.0.3', title='Dictation Language Update - French (France)', date=datetime.datetime(2019, 10, 9, 23, 12, 27), basename='SRCLUpdate_fr_FR.smd')
  Product(id='041-88171', version='2.0.1', title='Dictation Language Update - Spanish (United States)', date=datetime.datetime(2019, 10, 9, 23, 12, 28), basename='SRCLUpdate_es_US.smd')
  Product(id='041-88172', version='2.0.1', title='Dictation Language Update - Chinese (China)', date=datetime.datetime(2019, 10, 9, 23, 12, 28), basename='SRCLUpdate_zh_CN.smd')
  ...
  ```



  Listing macOS images can be done as follows:

  ```
  ➜  apple-catalog git:(master) ✗ applecatalog macos products list --macos
  MacOsProduct(product='061-26578', name=None, build='18F2059', version='10.14.5')
  MacOsProduct(product='061-26589', name=None, build='18G103', version='10.14.6')
  MacOsProduct(product='041-91758', name=None, build='17G66', version='10.13.6')
  MacOsProduct(product='041-88800', name=None, build='18E2034', version='10.14.4')
  MacOsProduct(product='041-90855', name=None, build='17F66a', version='10.13.5')
  MacOsProduct(product='061-86291', name=None, build='19D2064', version='10.15.3')
  MacOsProduct(product='001-04366', name=None, build='19E2269', version='10.15.4')
  MacOsProduct(product='001-15219', name=None, build='19F2200', version='10.15.5')
  MacOsProduct(product='001-36735', name=None, build='19G2006', version='10.15.6')
  MacOsProduct(product='001-36801', name=None, build='19G2021', version='10.15.6')
  MacOsProduct(product='001-51042', name=None, build='19H2', version='10.15.7')
  MacOsProduct(product='001-57224', name=None, build='19H4', version='10.15.7')
  MacOsProduct(product='001-68446', name=None, build='19H15', version='10.15.7')
  MacOsProduct(product='071-14766', name='macOS Big Sur', build='20D91', version='11.2.3')
  MacOsProduct(product='071-29172', name='macOS Big Sur', build='20E232', version='11.3')
  MacOsProduct(product='071-32414', name='macOS Big Sur', build='20E241', version='11.3.1')
  MacOsProduct(product='071-00696', name='macOS Big Sur', build='20F71', version='11.4')
  MacOsProduct(product='071-52235', name='macOS Big Sur Beta', build='20G5042c', version='11.5')
  MacOsProduct(product='071-59953', name='macOS Monterey beta', build='21A5268h', version='12.0')
  ```

  For Downloading each one you just download their packages as you would for any other product:

  ```
  ➜  apple-catalog git:(master) ✗ applecatalog macos products download 071-59953 ~/Downloads/macos
  2021-07-08 10:48:27 DoronZ.local root[21530] DEBUG downloading: UpdateBrain.zip
  100%|██████████████████████████████████████████████████████████████████████████████████████████| 2.75M/2.75M [00:00<00:00, 44.7MiB/s]
  2021-07-08 10:48:27 DoronZ.local root[21530] DEBUG downloading: Info.plist
  ...
  ```

  For creating an installation from these files you can now simply:

  ```shell
  sudo installer -pkg /path/to/InstallAssistant.pkg -target /
  ```

  This should create an `Install macOS XXXXXX.app` application at your `/Applications` folder. If you wish to make a
  bootable device from this installation you can use the following official guidelines:

  https://support.apple.com/en-us/HT201372


pkgId: 12f42a41e5b663f489a1f60cdf1d091e51f4e0b4d96aa5bc9547a012a29c900b
name: python-applepassgenerator
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Python package to create passes compatible with Apple Wallet.
url: https://primedigitalglobal.github.io/applepassgenerator
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-applepassgenerator-0.0.2-1.src.rpm
checksum_type: sha256
description:
  Python library to generate passes i.e (.pkpass) files compatible with Apple Wallet (former Passbook).



  - [💾 Installation](#-installation)
  - [🍎 Apple docs](#-apple-docs)
  - [📝 Configuration](#-configuration)
  - [🚀 Usage](#-usage)
  - [📜 Code Of Conduct](#code-of-conduct)



  To easily install or upgrade to the latest release, use pip.

  ```
  $ pip install applepassgenerator
  ```



  From now on, some stuff is much better explained on the Apple docs, so when in doubt just check (if you haven't done so) the following documents:

  - [Wallet Portal](https://developer.apple.com/wallet/)
  - [Wallet Developer Guide](https://developer.apple.com/library/ios/documentation/UserExperience/Conceptual/PassKit_PG/index.html#//apple_ref/doc/uid/TP40012195)
  - [Crypto Signatures](https://developer.apple.com/library/ios/documentation/UserExperience/Conceptual/PassKit_PG/Creating.html#//apple_ref/doc/uid/TP40012195-CH4-SW55)
  - [PassKit Package Format Reference](https://developer.apple.com/library/ios/documentation/UserExperience/Reference/PassKit_Bundle/Chapters/Introduction.html#//apple_ref/doc/uid/TP40012026)



  To start using the lib, some Apple files are needed, as well as some action in order to convert them to more friendly formats:

  - Get Pass Type ID
      - Go to the [Apple Developer page ➵ Identifiers ➵ Pass Type IDs](https://developer.apple.com/account/ios/identifiers/passTypeId/passTypeIdList.action).
      - Next, you need to create a pass type ID. This is similar to the bundle ID for apps. It will uniquely identify a specific kind of pass. It should be of the form of a reverse-domain name style string (i.e., pass.com.example.appname).

  - Generate the necessary certificate
      - After creating the pass type ID, click on Edit and follow the instructions to create a new Certificate.
      - Once the process is finished, the pass certificate can be downloaded. That's not it though, the certificate is downloaded as `.cer` file, which need to be converted to `.p12` in order to work. If you are using a Mac you can import it into Keychain Access and export it as `.p12`from there.
      - if now you have `certificate.p12` file follow the steps below to convert it to `certifictate.pem`

          ```markdown
          $ openssl pkcs12 -in certificate.p12 -clcerts -nokeys -out certificate.pem
          ```

  - Generate the key.pem

      ```markdown
      >$ openssl pkcs12 -in certificate.p12 -nocerts -out private.key
      ```

      Note: While generating this `private.key` file you will be asked for a PEM pass phrase which will be used as the `CERTIFICATE_PASSWORD` attribute throughout the Package.

  - Getting WWDR Certificate

      - If you have made iOS development, you probably have already the Apple Worldwide Developer Relations Intermediate Certificate in your Mac’s keychain.
      - If not, it can be downloaded from the [Apple Website](https://www.apple.com/certificateauthority/) (on `.cer` format). This one needs to be exported as `.pem`, It can be exported from KeyChain into a `.pem` (e.g. wwdr.pem).



  ```python
  from applepassgenerator import ApplePassGeneratorClient
  from applepassgenerator.models import EventTicket

  card_info = EventTicket()
  card_info.add_primary_field('name', 'Tony Stark', 'Name')
  card_info.add_secondary_field('loc', 'USA', 'Country')

  team_identifier = "1234ABCDEF"
  pass_type_identifier = "pass.com.project.example"
  organization_name = "Primedigital Global"

  applepassgenerator_client = ApplePassGeneratorClient(team_identifier, pass_type_identifier, organization_name)
  apple_pass = applepassgenerator_client.get_pass(card_info)


  apple_pass.add_file("logo.png", open("<path>/logo.png", "rb"))
  apple_pass.add_file("icon.png", open("<path>/icon.png", "rb"))

  CERTIFICATE_PATH = "<path-to-file>/certificate.pem"
  PASSWORD_KEY = "<path-to-file>/password.key"
  WWDR_CERTIFICATE_PATH = "<path-to-file>/wwdr.pem"
  CERTIFICATE_PASSWORD = "<password>"
  OUTPUT_PASS_NAME = "mypass.pkpass"

  apple_pass.create(CERTIFICATE_PATH, PASSWORD_KEY, WWDR_CERTIFICATE_PATH, CERTIFICATE_PASSWORD, OUTPUT_PASS_NAME)
  ```



  In order to foster a kind, inclusive, and harassment-free community, we have a code of conduct, which can be found [here](CODE_OF_CONDUCT.md). We ask you to treat everyone as a smart human programmer that shares an interest in Python and Apple Pass Generator with you.


pkgId: faa1fd32455af1ece2e91fa50a04468cfccd5bf28a67ffb53b6d3c1c2509f913
name: python-applescript
arch: src
version: 2021.2.9
epoch: 0
release: 1
summary: run applescript
url: https://github.com/andrewp-as-is/applescript.py
rpm_license: Unlicense
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-applescript-2021.2.9-1.src.rpm
checksum_type: sha256
description:
  <!--
  https://readme42.com
  -->


  [![](https://img.shields.io/pypi/v/applescript.svg?maxAge=3600)](https://pypi.org/project/applescript/)
  [![](https://img.shields.io/badge/License-Unlicense-blue.svg?longCache=True)](https://unlicense.org/)


  ```bash
  $ [sudo] pip install applescript
  ```


  ```python
  >>> import applescript
  >>> r = applescript.run('return 1')
  >>> r = applescript.run('path/to/file.applescript')

  >>> r.code
  0
  >>> r.out
  'hello world'
  >>> r.err
  ''
  ```

  `tell application "appname"`
  ```python
  >>> applescript.tell.app("Terminal",'do script "ls"')
  >>> applescript.tell.app("Terminal",'do script "ls"',background=True)
  ```

  javascript (JXA)
  ```python
  >>> applescript.run('...',javascript=True)
  ```

  <p align="center">
      <a href="https://readme42.com/">readme42.com</a>
  </p>


pkgId: e48c29fa315af122e81ae623ea02b726f83ebf57c994bc129ae845a84992a46c
name: python-appletree
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: A high-Performance Program simuLatEs and fiTs REsponse of xEnon.
url: https://github.com/XENONnT/appletree
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-appletree-0.5.2-1.src.rpm
checksum_type: sha256
description:
  A high-Performance Program simuLatEs and fiTs REsponse of xEnon.

  [![DOI](https://zenodo.org/badge/534803881.svg)](https://zenodo.org/badge/latestdoi/534803881)
  [![Test package](https://github.com/XENONnT/appletree/actions/workflows/pytest.yml/badge.svg?branch=master)](https://github.com/XENONnT/appletree/actions/workflows/pytest.yml)
  [![Coverage Status](https://coveralls.io/repos/github/XENONnT/appletree/badge.svg?branch=master&kill_cache=1)](https://coveralls.io/github/XENONnT/appletree?branch=master&kill_cache=1)
  [![PyPI version shields.io](https://img.shields.io/pypi/v/appletree.svg)](https://pypi.python.org/pypi/appletree/)
  [![Readthedocs Badge](https://readthedocs.org/projects/appletree/badge/?version=latest)](https://appletree.readthedocs.io/en/latest/?badge=latest)
  [![CodeFactor](https://www.codefactor.io/repository/github/xenonnt/appletree/badge)](https://www.codefactor.io/repository/github/xenonnt/appletree)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/XENONnT/appletree/master.svg)](https://results.pre-commit.ci/latest/github/XENONnT/appletree/master)





  With cpu support:

  ```
  pip install appletree jax[cpu]
  ```

  With CUDA Toolkit 11.2 support:

  ```
  pip install appletree jax[cuda]==0.3.15 -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
  ```

  With CUDA Toolkit 12.1 support:

  ```
  pip install appletree jax[cuda12_pip] -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
  ```



  Clone the repository:

  ```
  git clone https://github.com/XENONnT/appletree
  cd appletree
  ```

  To install the package and requirements in your environment, add `--user` in the above commands.

  To install appletree in editable mode, insert `--editable` argument after `install` in the above `pip install` commands.

  For example, to install in your environment and in editable mode with CUDA Toolkit 12.1 support:

  ```
  pip install --editable . jax[cuda]==0.3.15 -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html --user
  ```

  Then you are now good to go!



  The best way to start with the `appletree` package is to have a look at the tutorial `notebooks`.



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

  Please make sure to update tests as appropriate.


pkgId: 6cfb294bd9497c8e6500229ce5e89d7e1905a530646acad790a6b004402182bd
name: python-application-properties
arch: src
version: 0.8.2
epoch: 0
release: 1
summary: A simple, easy to use, unified manner of accessing program properties.
url: https://github.com/jackdewinter/application_properties
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-application-properties-0.8.2-1.src.rpm
checksum_type: sha256
description:
  |   |   |
  |---|---|
  |Project|[![Version](https://img.shields.io/pypi/v/application_properties.svg)](https://pypi.org/project/application_properties)  [![Python Versions](https://img.shields.io/pypi/pyversions/application_properties.svg)](https://pypi.org/project/application_properties)  ![platforms](https://img.shields.io/badge/platform-windows%20%7C%20macos%20%7C%20linux-lightgrey)  [![License](https://img.shields.io/github/license/jackdewinter/application_properties.svg)](https://github.com/jackdewinter/application_properties/blob/main/LICENSE.txt)  [![GitHub top language](https://img.shields.io/github/languages/top/jackdewinter/application_properties)](https://github.com/jackdewinter/application_properties)|
  |Quality|[![GitHub Workflow Status (event)](https://img.shields.io/github/actions/workflow/status/jackdewinter/application_properties/main.yml?branch=main)](https://github.com/jackdewinter/application_properties/actions/workflows/main.yml)  [![Issues](https://img.shields.io/github/issues/jackdewinter/application_properties.svg)](https://github.com/jackdewinter/application_properties/issues)  [![codecov](https://codecov.io/gh/jackdewinter/application_properties/branch/main/graph/badge.svg?token=PD5TKS8NQQ)](https://codecov.io/gh/jackdewinter/application_properties)  [![Sourcery](https://img.shields.io/badge/Sourcery-enabled-brightgreen)](https://sourcery.ai)  ![snyk](https://img.shields.io/snyk/vulnerabilities/github/jackdewinter/application_properties) |
  |  |![GitHub Pipenv locked dependency version (branch)](https://img.shields.io/github/pipenv/locked/dependency-version/jackdewinter/application_properties/dev/black/main)  ![GitHub Pipenv locked dependency version (branch)](https://img.shields.io/github/pipenv/locked/dependency-version/jackdewinter/application_properties/dev/flake8/main)  ![GitHub Pipenv locked dependency version (branch)](https://img.shields.io/github/pipenv/locked/dependency-version/jackdewinter/application_properties/dev/pylint/main)  ![GitHub Pipenv locked dependency version (branch)](https://img.shields.io/github/pipenv/locked/dependency-version/jackdewinter/application_properties/dev/mypy/main)  ![GitHub Pipenv locked dependency version (branch)](https://img.shields.io/github/pipenv/locked/dependency-version/jackdewinter/application_properties/dev/pyroma/main)  ![GitHub Pipenv locked dependency version (branch)](https://img.shields.io/github/pipenv/locked/dependency-version/jackdewinter/application_properties/dev/pre-commit/main) ![GitHub Pipenv locked dependency version (branch)](https://img.shields.io/github/pipenv/locked/dependency-version/jackdewinter/application_properties/dev/sourcery/main)|
  |Community|[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://github.com/jackdewinter/application_properties/graphs/commit-activity) [![Stars](https://img.shields.io/github/stars/jackdewinter/application_properties.svg)](https://github.com/jackdewinter/application_properties/stargazers)  [![Forks](https://img.shields.io/github/forks/jackdewinter/application_properties.svg)](https://github.com/jackdewinter/application_properties/network/members)  [![Contributors](https://img.shields.io/github/contributors/jackdewinter/application_properties.svg)](https://github.com/jackdewinter/application_properties/graphs/contributors)  [![Downloads](https://img.shields.io/pypi/dm/application_properties.svg)](https://pypistats.org/packages/application_properties)|
  |Maintainers|[![LinkedIn](https://img.shields.io/badge/-LinkedIn-black.svg?logo=linkedin&colorB=555)](https://www.linkedin.com/in/jackdewinter/)|

  The `application_properties` package was born out of necessity.
  During the creation of the [PyMarkdown](https://github.com/jackdewinter/pymarkdown) project,
  there was a distinct need for a configuration subsystem that was able to handle more
  complex configuration scenarios.

  The `application_properties` library has the following advnatages:

  - Thoroughly tested
    - The project currently has over 65 tests and coverage percentages over 99%.
  - Simple... With Examples
    - The package was created with the intention of being as easy to use as possbile.
    - To that extent, there are 4 basic usage examples and over 10 advanced usage examples.
  - Complex When Required
    - The default is simplicity, but the package can step up when required to do so.
    - Any actions outside of the simple scenario of getting an optional string value should
      be relatively easy to request of the package API.
  - Hierarchically Aware
    - By default, uses the `.` character in the property names to define levels of hierarchy.
    - Hierarchy levels can be used to find only those properties that exist under a
      given hierarchy.
    - If desired, the `ApplicationPropertiesFacade` object can be used to restrict access
      to only those properties that exist under a given hierarchy.
  - Command Line Aware
    - The `set_manual_property` function allows for one or more individual properties to be
      supplied by the command line.
  - Extensible
    - The loading of the properties is separate from access to the values for those properties.
    - Due to the separation of the loading and accessing parts of the library, custom loading
      classes can be added with ease.
      - Current loading classes include loaders for Json files, with Simple Property files right
        around the corner



  This project required Python 3.8 or later to function.



  ```sh
  pip install application_properties
  ```



  The primary goal of this package is to provide a simple, easy to use interface
  to access properties within a Python script or program.  It is our contention
  that 80% or more of general usage of such a package will be focused on two
  elements:

  - loading a group of properties from a file that is properly formatted
    for a given format
  - accessing a specific string property, possibly with a default, from the that
    property store



  For concrete examples that show the power of this library package, please consult
  the [Examples Document](./docs/examples.md).  If you come up with a normal example
  of how to use our package that we have missed, or come up with a novel example of
  how to use our package, please file an issue using the process below and let us
  know. From our experience, one example can often paint a picture of how to use our
  project that is difficult to explain clearly with just words.



  If you would like to report an issue with the library or the documentation, please
  file an issue [using GitHub](https://github.com/jackdewinter/application_properties/issues).
  Please remember to fill in as much information as possible including a good, repeatable
  pattern for reproducing the issue.  Do not overflow us with too much information,
  but provide us with enough information to make the problem evident to us.

  If you would like to us to implement a feature that you believe is important, please
  file an issue [using GitHub](https://github.com/jackdewinter/application_properties/issues)
  that includes what you want to add, why you want to add it, and why it is important
  to you, and how you think it will help others.  We truly want to listen to what
  you see as a good feature, so please do not be upset if we say "no" or "let me
  think about it".

  Please note that the issue you file will usually be the start of a conversation,
  so be ready for more questions.  If you have any Python developer skills, please
  mention that as well.  The conversations about "hey, can you..." is a lot different
  than "if I do... can I add it to the project?".



  The changelog for this project is maintained [at this location](/changelog.md).



  If you still have questions, please consult our
  [Frequently Asked Questions](/docs/faq.md) document.



  Developer notes on various topics are kept in the the
  [Developer Notes](/docs/developer.md) document.

  If you attempting to contribute something to this project,
  please follow the steps outlined in the
  [CONTRIBUTING.md](/CONTRIBUTING.md) file.


pkgId: 9b775fa32e1f99e763da1f8ca1fa634e9c25b73b300330763f00f1a26c96f310
name: python-applicationinsights
arch: src
version: 0.11.10
epoch: 0
release: 1
summary: This project extends the Application Insights API surface to support Python.
url: https://github.com/Microsoft/ApplicationInsights-Python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-applicationinsights-0.11.10-1.src.rpm
checksum_type: sha256
description:
  This SDK is no longer maintained or supported by Microsoft. Check out the `Python OpenCensus SDK <https://docs.microsoft.com/azure/azure-monitor/app/opencensus-python>`_ for Azure Monitor's latest Python investments. Azure Monitor only provides support when using the `supported SDKs <https://docs.microsoft.com/en-us/azure/azure-monitor/app/platforms#unsupported-community-sdks>`_. We’re constantly assessing opportunities to expand our support for other languages, so follow our `GitHub Announcements <https://github.com/microsoft/ApplicationInsights-Announcements/issues>`_ page to receive the latest SDK news.


pkgId: ea8d69c8bceb6b40dc0dcc49766d9f59b7cfdea927e9e7e93097cdbb71e4cdad
name: python-applique
arch: src
version: 0.1.12
epoch: 0
release: 1
summary: Chemical drawing with Python
url: https://www.codeberg.org/cap_jmk/applique.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-applique-0.1.12-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](https://static.pepy.tech/personalized-badge/applique?period=total&units=international_system&left_color=orange&right_color=blue&left_text=Downloads)](https://pepy.tech/project/applique)
  [![License: GPL v3](https://img.shields.io/badge/License-GPL_v3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
  ![Python Versions](https://img.shields.io/badge/python-3.8%20%7C%203.9%20%7C%203.10%20%7C%203.11%20%7C-blue)
  <a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>
  [![PyPI - Version](https://img.shields.io/pypi/v/applique.svg)](https://pypi.org/project/applique)

  `applique` is a simple program that can write .xyz file from .mol files. It really is just a missing puzzle piece in the quantum chemistry world, as some molecular editors went corrupt. Now one can use common Quantum Chemistry software again. It mimics Avogadros behaviour.

  Nothing special.

  Okay by now it is an understatement. It is infact a molecular model suitable for generating simulations. It can also convert fileformats.



  Simple as always

  ```bash
  pip install applique
  ```





  In your venv
  ```bash
  applique --i in_file.mol --o out_file.xyz
  ```
  Easy peasy


  Within programs for example you load a molfile like this


  ```bash
  from applique.molecule import Molecule as Mol

  mol_file_benzene = "tests/molecules/benzene.mol"
  benzene = Mol().from_mol(mol_file_benzene)
  ```
  Then write the `.xyz` like this

  ```bash
  from applique.writer import write_xyz
  from applique.molecule import Molecule as Mol

  mol_file_benzene = "tests/molecules/benzene.mol"
  benzene = Mol().from_mol(mol_file_benzene)
  file_name_benzene = "./tests/molecules/benzene.xyz"
  coordinates = benzene.struct3D() #you can omit if you don't want to preoptimize the structure.
  write_xyz(self.benzene, file_name_benzene)
  ```



  This is wanted (don't want to impose bonds at this stage)
  ```bash
  E       RuntimeError: Pre-condition Violation
  E               getNumImplicitHs() called without preceding call to calcImplicitValence()
  E               Violation occurred on line 287 in file Code/GraphMol/Atom.cpp
  E               Failed Expression: d_implicitValence > -1
  E               RDKIT: 2024.03.5
  E               BOOST: 1_85
  ```


pkgId: 2670b5815e0e16be2b52ae55dd2b10daf645171e1e7bd2c33b7200b59b71bdf6
name: python-applm
arch: src
version: 0.0.51
epoch: 0
release: 1
summary: Language Model Tools for Apple Silicon
url: https://github.com/Jonathan-Dobson/applm
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-applm-0.0.51-1.src.rpm
checksum_type: sha256
description:
  AppLM brings Language Model Tools to Apple Silicon.

  This project aiming to refactor the [mlx-lm](https://pypi.org/project/mlx-lm/) package with a goal to reorganize it making the features less opinionated and more flexible for developer customization. For example, we are removing the CLI components, and exposing more of the package parts as an developer API.

  Warning: This package is still incomplete.

  Please do not use it yet in production.

  This package was created August 13, 2024



  ```shell
  pip install transformers mlx applm
  ```



  This is just the first test. We have only tested this one code example so far.

  ```python
  from applm.utils.load import load
  from applm.utils.generate import generate
  import applm.models.qwen2 as qwen2

  model_name = "mlx-community/Qwen2-0.5B"

  model, tokenizer = load(
      model_name,
      tokenizer_config={"eos_token": "<|im_end|>"},
      mx_prototype=qwen2,
  )

  prompt = "Give me a short introduction to large language model."
  messages = [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": prompt},
  ]
  input_text = ""
  for message in messages:
      if message["role"] == "user":
          input_text = message["content"]
          break

  response = generate(
      model,
      tokenizer,
      prompt=input_text,
      verbose=True,
      top_p=0.8,
      temp=0.7,
      repetition_penalty=1.05,
      max_tokens=512,
      mx_prototype=qwen2,
  )

  ```

  This example will soon change.

  It is only meant to showcase the direction we are working toward. The next change to the `applm` package will probably break it.

  If you like what we are doing, want to watch our progress, or want to contribute, please feel free to engage with the repo on github.

  We are looking for contributors to help further develop this package.

  The refactor is not complete, but we will make regular updates as we progress.

  If you are the Apple developer in charge of leading the mlx-lm package development, and you also have the goal to refactor the mlx-lm package to be less opinionated and more developer customizable, feel free to use this package as inspiration, fork it, merge it, or collaborate either on this package or the mlx-lm package.


pkgId: 06afa44c166f6a4410a357f2dfe8b12187c981bb1de245dc6d6efbaca3cd2306
name: python-apply-subs
arch: src
version: 0.5.5
epoch: 0
release: 1
summary: A command line tool to apply substitutions to a text file
url: https://github.com/neutrinoceros/apply_subs
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apply-subs-0.5.5-1.src.rpm
checksum_type: sha256
description:
  +++ mytext.txt (patched)
  @@ -1 +1 @@
  -Lorem ipsum dolor sit amet, consectetur adipiscing elit
  +Hello dolor sit amet, consectetur goodbye
  ```
  Use `-cp/--cdiff/--colored-diff` for a colored output (when supported).

  `-i/--inplace`
  ```shell
  apply-subs --inplace mytext.txt -s mysubs.json
  ```
  is equivalent to
  ```shell
  apply-subs mytext.txt -s mysubs.json > mytext.txt
  ```

  The `target` positional argument can consist of a single file (as illustrated above),
  or many. This is useful for instance if you need to apply a set of subtitutions to
  all files in a project whose name match a regexp.
  ```shell
  git ls-files | egrep "(.md|.py)$" | xargs apply-subs -s subsubs.json -i
  ```


pkgId: 7a942504f30fe5e0f5edfbc31d0f9c3232312b617a31e841be2c01192b690f65
name: python-applyaf
arch: src
version: 1.5.3
epoch: 0
release: 1
summary: Apply antenna factor and cable loss to spectrum analyzer measurements
url: https://github.com/questrail/applyaf
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-applyaf-1.5.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPi Version][pypi ver image]][pypi ver link]
  [![Build Status][travis image]][travis link]
  [![Coverage Status][coveralls image]][coveralls link]
  [![License Badge][license image]][LICENSE.txt]

  [applyaf][] is a Python 3.8+ module that applies frequency dependent
  antenna factors and cable losses to spectrum analyzer readings in order
  to calculate the incident field. Any duplicate frequency entries in the
  antenna factors or cable losses data are removed before interpolating
  the frequencies to match those of the spectrum analyzer readings.



  Three csv files containing the following are required inputs:

  1. Spectrum analyzer measurements
  2. Antenna factor data
  3. Cable loss data

  Each CSV file should contain data in two columns:

  1. Frequency
  2. Amplitude

  The amplitude is expected to be in dB.



  - [numpy][]



  Some thoughts for future improvements include:

  1. Allowing CSV data files that contain non-dB amplitudes and then
     convert as needed. Should this be a per-file setting?
  2. Generalize the code to handle a variable number (>3) of data to be
     interpolated and applied to the given data set.
  3. If the code is generalized, should this be wrapped into the
     [siganalysis][] project or left on its own?



  Contributions are welcome! To contribute please:

  1. Fork the repository
  2. Create a feature branch
  3. Add code and tests
  4. Pass lint and tests
  5. Submit a [pull request][]





  Use the following commands to create a Python 3.12 virtualenv using [pyenv][]
  and [pyenv-virtualenv][], install the requirements in the virtualenv named
  `applyaf`, and list the available [Invoke][] tasks.

  ```bash
  $ pyenv install 3.13
  $ pyenv virtualenv 3.13 applyaf
  $ pyenv activate applyaf
  $ pip install -r requirements.txt
  $ inv -l
  ```



  [applyaf][] is released under the MIT license. Please see the
  [LICENSE.txt][] file for more information.

  [applyaf]: https://github.com/questrail/applyaf
  [coveralls image]: http://img.shields.io/coveralls/questrail/applyaf/master.svg
  [coveralls link]: https://coveralls.io/r/questrail/applyaf
  [invoke]: https://www.pyinvoke.org/
  [LICENSE.txt]: https://github.com/questrail/applyaf/blob/develop/LICENSE.txt
  [license image]: http://img.shields.io/pypi/l/applyaf.svg
  [numpy]: http://www.numpy.org
  [pull request]: https://help.github.com/articles/using-pull-requests
  [pyenv]: https://github.com/pyenv/pyenv
  [pyenv-virtualenv]: https://github.com/pyenv/pyenv-virtualenv
  [pypi ver image]: http://img.shields.io/pypi/v/applyaf.svg
  [pypi ver link]: https://pypi.python.org/pypi/applyaf
  [siganalysis]: https://github.com/questrail/siganalysis
  [travis image]: http://img.shields.io/travis/questrail/applyaf/master.svg
  [travis link]: https://travis-ci.org/questrail/applyaf


pkgId: 61946a85c8d83ad31697dc2c72290c71eae7f2130436e3d629f850c974aec011
name: python-appman
arch: src
version: 0.4.5
epoch: 0
release: 1
summary: Cross-platform application management aggregator
url: https://github.com/basiliskus/appman
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-appman-0.4.5-1.src.rpm
checksum_type: sha256
description:
  appman is cross-platform application management aggregator

  [![Build Status](https://app.travis-ci.com/basiliskus/appman.svg?branch=main)](https://app.travis-ci.com/basiliskus/appman)

  <p align="center"><img src="https://raw.githubusercontent.com/basiliskus/appman/main/docs/demo.gif"/></p>



  - Python 3.8
  - Git



  You can install appman from [PyPI](https://pypi.org/project/appman/):

  ```bash
  > pip install appman
  ```



  While working on my [dotfiles](https://wiki.archlinux.org/title/Dotfiles) repository, I realized that I also wanted to have a way to handle not just configuration files but also my installed applications. That way I'd be able to define which applications I want to have installed on any new environment, have those under version control, and run a script to install/uninstall applications on any new personal or work computer, server, etc.



  The main goal for appman is to be flexible and extensible. In that context the goals are:

  - Cross-platform: handle multiple OS and devices. Currently appman handles Ubuntu and Windows (desktop).
  - Multi-profile: define different profiles with a unique list of applications for different environments (e.g., work and personal computers).
  - Supported Packages: aside from desktop and command line applications, support software like: device drivers, software plugins and extensions (e.g., vscode extensions), backend libraries (e.g., python libraries), fonts, etc.
  - Package Management: support any package manager (e.g., apt, brew, scoop) or custom formulas to define how to install, uninstall and upgrade packages.
  - Package definitions source: the source for package definitions is a [git repository](https://github.com/basiliskus/appman-main), which allows you to fork and use your own repository.





  - Add a package to your user packages list

    Using interactive mode:

    ```console
    $ appman add

    [?] Select the package type: (Use arrow keys)
    >app
     font
     driver
     provisioned
     backend
     extension

    [?] Select app packages to add: (<up>, <down> to move, <space> to select, <a> to toggle, <i> to invert)
     ○ curl
     ○ fzf
    >● git
     ○ jq
     ○ python
     ○ ...

    Added git package
    ```

    or directly passing parameters:

    ```console
    $ appman add -pt app -id git
    ```

  - Remove a previously added package

    Using interactive mode:

    ```console
    $ appman remove

    [?] Select the package type: (Use arrow keys)
    >app
     font
     driver
     provisioned
     backend
     extension

    [?] Select app packages to remove: (<up>, <down> to move, <space> to select, <a> to toggle, <i> to invert)
     ○ 7zip
     ○ curl
    >● git
     ○ ...

    Removed git package
    ```

    Directly passing parameters:

    ```console
    $ appman remove -pt app -id git
    ```

  - Show your user packages list

    Using interactive mode:

    ```console
    $ appman list

    [?] Select the package type: (Use arrow keys)
    >app

     • 7zip (cli, utils)
     • curl (cli, utils)
    ```

    Directly passing parameters:

    ```console
    $ appman list -pt app
    ```

  - Search all available packages to add

    Using interactive mode:

    ```console
    $ appman search

    [?] Select the package type: (Use arrow keys)
    >app

     • 7zip
     • ack
     • apache2
     • aria2
     • bottom
     • broot
     • cookiecutter
     • curl
    ...
    ```

    Directly passing parameters:

    ```console
    $ appman search -pt app -id 7zip
    ```



  Using interactive mode:

  ```console
  $ appman install

  [?] Select the package type: (Use arrow keys)
  >app

  Installing 7zip...
  Installing ack...
  ...
  ```

  Directly passing parameters:

  ```console
  $ appman install -pt app -id 7zip
  ```



  ```console
  $ appman repo https://github.com/basiliskus/appman-main
  ```



  ```console
  $ appman update
  ```



  All packages have pre-defined labels (e.g. for apps: 'cli' & 'gui'), but you can also add your own labels by passing the --labels/-l parameter to the 'add' command.

  ```console
  $ appman add -pt app -id 7zip -l server
  ```

  You can also filter by labels when using the 'list', 'search', 'remove', 'install' or 'uninstall' commands

  ```console
  $ appman list -pt app -l server
  ```



  © Basilio Bogado. Distributed under the [MIT License](LICENSE).


pkgId: 626af026b1ef8bbd006b6d57ca8df9dbfc582e72694fde94b11979318435200d
name: python-appmap
arch: src
version: 2.1.7
epoch: 0
release: 1
summary: Create AppMap files by recording a Python application.
url: https://github.com/applandinc/appmap-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-appmap-2.1.7-1.src.rpm
checksum_type: sha256
description:
  Your code has been rated at 10.00/10 (previous run: 10.00/10, +0.00)
  ```
  [Note that the current configuration has a threshold set which must be met for the Travis build to
  pass. To make this easier to achieve, a number of checks have both been disabled. They should be
  reenabled as soon as possible.]


  Note that you must install the dependencies contained in
  [requirements-dev.txt](requirements-dev.txt) before running tests. See the explanation in
  [pyproject.toml](pyproject.toml) for details.
  Additionally, the tests currently require that you set `APPMAP=true` and
  `APPMAP_DISPLAY_PARAMS=true`.
  [pytest](https://docs.pytest.org/en/stable/) for testing:
  ```
  % cd appmap-python
  % pip install -r requirements-test.txt
  % APPMAP=true APPMAP_DISPLAY_PARAMS=true poetry run pytest
  ```

  Additionally, the `tox` configuration provides the ability to run the tests for all
  supported versions of Python and Django.
  `tox` requires that all the correct versions of Python to be available to create
  the test environments. [pyenv](https://github.com/pyenv/pyenv) is an easy way to manage
  multiple versions of Python, and the [xxenv-latest
  plugin](https://github.com/momo-lab/xxenv-latest) can help get all the latest versions.
  ```sh
  % brew install pyenv
  % git clone https://github.com/momo-lab/xxenv-latest.git "$(pyenv root)"/plugins/xxenv-latest
  % cd appmap-python
  % pyenv latest local 3.{9,6,7,8}
  % for v in 3.{9,6,7,8}; do pyenv latest install $v; done
  % poetry run tox
  ```

  [coverage](https://coverage.readthedocs.io/) for coverage:
  ```
  % cd appmap-python
  % poetry run coverage run -m pytest
  % poetry run coverage html
  % open htmlcov/index.html
  ```


pkgId: c8b444c0f4f606260f1936e5a78bdf39c6aedd309dbe86bf0e0cc03f449ad05a
name: python-appmesh
arch: src
version: 1.3.9
epoch: 0
release: 1
summary: Client SDK for App Mesh
url: https://github.com/laoshanxi/app-mesh
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-appmesh-1.3.9-1.src.rpm
checksum_type: sha256
description:
  Application management | 1. Manage independent applications with flexible process control (long/short running, periodic, cron schedule, custom timings, error handling) and comprehensive monitoring (start counts, return codes, error messages, health checks) for both native and Docker applications. <br> 2. Run applications on remote hosts using SDK/CLI with sync/async modes and fetch results to the client. <br> 3. Full control over application lifecycle (cgroup resource limitation, specific OS user for execution). <br> 4. Support interactive application start with specific input data via pipe and environment variables. <br> 5. Access all functionalities via [CLI](https://app-mesh.readthedocs.io/en/latest/CLI.html), [REST](https://app-mesh.readthedocs.io/en/latest/Development.html#rest-apis), [SDK](https://github.com/laoshanxi/app-mesh/tree/main/src/sdk) and [WebGUI](https://github.com/laoshanxi/app-mesh-ui) interface.<br>
  Security |  ⚡️ [JWT authentication](https://app-mesh.readthedocs.io/en/latest/JWT.html) for CLI and REST interface <br> ⚡️ [LDAP support](https://app-mesh.readthedocs.io/en/latest/LDAP.html) <br> ⚡️ [Role based permission control](https://app-mesh.readthedocs.io/en/latest/USER_ROLE.html) <br> ⚡️ [Multi-factor authentication](https://app-mesh.readthedocs.io/en/latest/MFA.html)<br> SSL support (ECDH and secure ciphers) for REST http connection  <br> Multi-tenant support
  Cloud native | Schedule cloud-level applications to run on multiple hosts with resource size requests. <br> ⚡️ [Prometheus Exporter (build-in)](https://app-mesh.readthedocs.io/en/latest/PROMETHEUS.html) <br> ⚡️ [Grafana SimpleJson datasource](https://app-mesh.readthedocs.io/en/latest/GrafanaDataSource.html) <br> ⚡️ [Grafana Loki](https://app-mesh.readthedocs.io/en/latest/Loki.html) <br>⚡️ [Dockerfile](https://github.com/laoshanxi/app-mesh/blob/main/Dockerfile)
  Micro service application | ⚡️ [Consul micro-service cluster management](https://app-mesh.readthedocs.io/en/latest/CONSUL.html)
  Extra Features | Collect host/app resource usage <br> Remote shell command execution <br> File upload/download interface <br> Hot-update support `systemctl reload appmesh` <br> Bash completion <br> Reverse proxy <br> [Web GUI](https://github.com/laoshanxi/app-mesh-ui)
  Platform support | X86_64 <br> ARM32 <br> ARM64
  SDK | [Python](https://app-mesh.readthedocs.io/en/latest/api/appmesh_client.html) <br> [Golang](https://github.com/laoshanxi/app-mesh/blob/main/src/sdk/go/appmesh_client.go) <br> [JavaScript](https://www.npmjs.com/package/appmesh) <br> [Java](https://github.com/laoshanxi/app-mesh/packages/2227502) <br> [Swagger OpenAPI Specification](https://petstore.swagger.io/?url=https://raw.githubusercontent.com/laoshanxi/app-mesh/main/src/daemon/rest/openapi.yaml)

  Refer to the [Installation doc](https://app-mesh.readthedocs.io/en/latest/Install.html) to learn how to install App Mesh via Docker Compose or natively and set up an App Mesh cluster.

  - [Read the Docs](https://app-mesh.readthedocs.io/)
  - [REST API](https://app-mesh.readthedocs.io/en/latest/Development.html#rest-apis)
  - [Command lines](https://app-mesh.readthedocs.io/en/latest/CLI.html)
  - [Security](https://app-mesh.readthedocs.io/en/latest/JWT.html)


  | Feature                  | App Mesh | [Supervisor](http://supervisord.org/) | [crontab](https://crontab.guru/) |
  | ------------------------ | -------- | ------------------------------------- | -------------------------------- |
  | Accuracy                 | Seconds  | Seconds                               | Minutes                          |
  | Language                 | C++11    | Python                                | C                                |
  | Web GUI                  | √        | √                                     |
  | Command lines            | √        | √                                     | √                                |
  | SDK                      | √        |                                       |
  | Cron schedule expression | √        |                                       | √                                |
  | Manage daemon process    |          |                                       | √                                |
  | Manage docker app        | √        |                                       |
  | Start check (avoid leak) | √        | √                                     |
  | Session login            |          |                                       |
  | Manage stdout/stderr     | √        | √                                     |
  | Health check             | √        |                                       |
  | Rich control options     | √        |                                       |
  | Authentication           | √        | √                                     |
  | Multi-tenant             | √        |                                       | √                                |

  | Feature           | App Mesh | Kubernetes |
  | ----------------- | -------- | ---------- |
  | Easy deploy       | √        |
  | More features     |          | √          |
  | Non-container app | √        |
  | Service expose    | √        | √          |
  | Scheduler         | √        | √          |
  | Definition file   | YAML     | YAML       |
  | GUI               | √        | √          |
  | Virtual Network   |          | √          |


pkgId: dc422185c4a631785a664f1ac41c9fae9b7f07592f4ed939240ed3105dc7b3bb
name: python-appnope
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Disable App Nap on macOS >= 10.9
url: http://github.com/minrk/appnope
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-appnope-0.1.4-1.src.rpm
checksum_type: sha256
description:
  Simple package for disabling App Nap on macOS >= 10.9,
  which can be problematic.

  To disable App Nap:

  ```python
  import appnope
  appnope.nope()
  ```

  To reenable, for some reason:

  ```python
  appnope.nap()
  ```

  or to only disable App Nap for a particular block:

  ```
  with appnope.nope_scope():
      do_important_stuff()
  ```

  It uses ctypes to wrap a `[NSProcessInfo beginActivityWithOptions]` call to disable App Nap.

  To install:

      pip install appnope


pkgId: 90a8ea34d9f35ea19a12f5dd14cb40a80f35a57a4dbfcfa966209342d01e5c99
name: python-appointment-workflow-manager
arch: src
version: 0.2.1
epoch: 0
release: 1
url: https://github.com/yourusername/appointment-workflow-manager
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-appointment-workflow-manager-0.2.1-1.src.rpm
checksum_type: sha256
summary:
  Utilities to manage appointment workflows including approval, rejection, cancellation, audit logging, and conflict detection.

description:
  - **Workflow Management**:
    - Approve, reject, or cancel appointments.
    - Automatically update appointment status and manage notifications.
  - **Audit Logging**:
    - Log status changes of appointments with timestamps.
    - Helps maintain a historical record of changes for reporting and debugging.
  - **Conflict Detection**:
    - Detect overlapping or conflicting appointments for the same user.
    - Prevent scheduling conflicts during appointment creation.
  - **Reusable Logic**:


pkgId: d4306fd94eea4cf91dce1658b949ffc0db154013ec7d69fb8c7b9899fcfbbeb2
name: python-apportionpy
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: A Python package for apportionment.
url: https://pypi.org/project/apportionpy/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apportionpy-0.3.1-1.src.rpm
checksum_type: sha256
description:
  A package that allows users to apportion seats to states based on population figures.

  This apportionment package calculates results for the following methods:
   - Hamilton's method
   - Jefferson's method
   - Adam's method
   - Webster's method
   - Huntington Hill's method
   - Method of equal proportions

  Hamilton's method calculations:
   - fair shares
   - initial fair shares
   - initial quotas
   - final quotas
   - initial divisor
   - modified divisor

  Jefferson's method calculations:
   - fair shares
   - initial fair shares
   - initial quotas
   - final quotas
   - initial divisor
   - modified divisor
   - divisor history

  Adam's method calculations:
   - fair shares
   - initial fair shares
   - initial quotas
   - final quotas
   - initial divisor
   - modified divisor
   - divisor history

  Webster's method calculations:
   - fair shares
   - initial fair shares
   - initial quotas
   - final quotas
   - initial divisor
   - modified divisor
   - divisor history

  Huntington Hill's method calculations:
   - fair shares
   - initial fair shares
   - initial quotas
   - final quotas
   - initial geometric means
   - final geometric means
   - initial divisor
   - modified divisor

  Method of equal proportions calculations:
   - fair shares

  Experimental features:
   - estimate the lowest possible divisor possible
   - estimate the highest possible divisor possible


pkgId: 7cb112b6742eb759154168f7065ccaf21bad298e3c1351b26351de1e742967b7
name: python-apprise
arch: src
version: 1.9.0
epoch: 0
release: 1
summary: Push Notifications that work with just about every platform!
url: https://github.com/caronc/apprise
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apprise-1.9.0-1.src.rpm
checksum_type: sha256
description:
  ![Apprise Logo](https://raw.githubusercontent.com/caronc/apprise/master/apprise/assets/themes/default/apprise-logo.png)

  <hr/>

  **ap·prise** / *verb*<br/>
  To inform or tell (someone). To make one aware of something.
  <hr/>

  *Apprise* allows you to send a notification to *almost* all of the most popular *notification* services available to us today such as: Telegram, Discord, Slack, Amazon SNS, Gotify, etc.

  * One notification library to rule them all.
  * A common and intuitive notification syntax.
  * Supports the handling of images and attachments (_to the notification services that will accept them_).
  * It's incredibly lightweight.
  * Amazing response times because all messages sent asynchronously.

  Developers who wish to provide a notification service no longer need to research each and every one out there. They no longer need to try to adapt to the new ones that comeout thereafter. They just need to include this one library and then they can immediately gain access to almost all of the notifications services available to us today.

  System Administrators and DevOps who wish to send a notification now no longer need to find the right tool for the job. Everything is already wrapped and supported within the `apprise` command line tool (CLI) that ships with this product.

  [![Paypal](https://img.shields.io/badge/paypal-donate-green.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=MHANV39UZNQ5E)
  [![Follow](https://img.shields.io/twitter/follow/l2gnux)](https://twitter.com/l2gnux/)<br/>
  [![Discord](https://img.shields.io/discord/558793703356104724.svg?colorB=7289DA&label=Discord&logo=Discord&logoColor=7289DA&style=flat-square)](https://discord.gg/MMPeN2D)
  [![Python](https://img.shields.io/pypi/pyversions/apprise.svg?style=flat-square)](https://pypi.org/project/apprise/)
  [![Build Status](https://github.com/caronc/apprise/actions/workflows/tests.yml/badge.svg)](https://github.com/caronc/apprise/actions/workflows/tests.yml)
  [![CodeCov Status](https://codecov.io/github/caronc/apprise/branch/master/graph/badge.svg)](https://codecov.io/github/caronc/apprise)
  [![PyPi](https://img.shields.io/pypi/dm/apprise.svg?style=flat-square)](https://pypi.org/project/apprise/)


  <!--ts-->
  * [Supported Notifications](#supported-notifications)
    * [Productivity Based Notifications](#productivity-based-notifications)
    * [SMS Notifications](#sms-notifications)
    * [Desktop Notifications](#desktop-notifications)
    * [Email Notifications](#email-notifications)
    * [Custom Notifications](#custom-notifications)
  * [Installation](#installation)
  * [Command Line Usage](#command-line-usage)
    * [Configuration Files](#cli-configuration-files)
    * [File Attachments](#cli-file-attachments)
    * [Loading Custom Notifications/Hooks](#cli-loading-custom-notificationshooks)
  * [Developer API Usage](#developer-api-usage)
    * [Configuration Files](#api-configuration-files)
    * [File Attachments](#api-file-attachments)
    * [Loading Custom Notifications/Hooks](#api-loading-custom-notificationshooks)
  * [Persistent Storage](#persistent-storage)
  * [More Supported Links and Documentation](#want-to-learn-more)
  <!--te-->



  The section identifies all of the services supported by this library. [Check out the wiki for more information on the supported modules here](https://github.com/caronc/apprise/wiki).



  The table below identifies the services this tool supports and some example service urls you need to use in order to take advantage of it. Click on any of the services listed below to get more details on how you can configure Apprise to access them.

  | Notification Service | Service ID | Default Port | Example Syntax |
  | -------------------- | ---------- | ------------ | -------------- |
  | [Apprise API](https://github.com/caronc/apprise/wiki/Notify_apprise_api)  | apprise:// or apprises:// | (TCP) 80 or 443 | apprise://hostname/Token
  | [AWS SES](https://github.com/caronc/apprise/wiki/Notify_ses)  | ses://   | (TCP) 443   | ses://user@domain/AccessKeyID/AccessSecretKey/RegionName<br/>ses://user@domain/AccessKeyID/AccessSecretKey/RegionName/email1/email2/emailN
  | [Bark](https://github.com/caronc/apprise/wiki/Notify_bark)  | bark://   | (TCP) 80 or 443   | bark://hostname<br />bark://hostname/device_key<br />bark://hostname/device_key1/device_key2/device_keyN<br/>barks://hostname<br />barks://hostname/device_key<br />barks://hostname/device_key1/device_key2/device_keyN
  | [Boxcar](https://github.com/caronc/apprise/wiki/Notify_boxcar)  | boxcar://   | (TCP) 443   | boxcar://hostname<br />boxcar://hostname/@tag<br/>boxcar://hostname/device_token<br />boxcar://hostname/device_token1/device_token2/device_tokenN<br />boxcar://hostname/@tag/@tag2/device_token
  | [Chantify](https://github.com/caronc/apprise/wiki/Notify_chantify) | chantify://    | (TCP) 443    | chantify://token
  | [Discord](https://github.com/caronc/apprise/wiki/Notify_discord)  | discord://   | (TCP) 443   | discord://webhook_id/webhook_token<br />discord://avatar@webhook_id/webhook_token
  | [Emby](https://github.com/caronc/apprise/wiki/Notify_emby)  | emby:// or embys:// | (TCP) 8096 | emby://user@hostname/<br />emby://user:password@hostname
  | [Enigma2](https://github.com/caronc/apprise/wiki/Notify_enigma2)  | enigma2:// or enigma2s:// | (TCP) 80 or 443 | enigma2://hostname
  | [FCM](https://github.com/caronc/apprise/wiki/Notify_fcm) | fcm://    | (TCP) 443    | fcm://project@apikey/DEVICE_ID<br />fcm://project@apikey/#TOPIC<br/>fcm://project@apikey/DEVICE_ID1/#topic1/#topic2/DEVICE_ID2/
  | [Feishu](https://github.com/caronc/apprise/wiki/Notify_feishu) | feishu://    | (TCP) 443    | feishu://token
  | [Flock](https://github.com/caronc/apprise/wiki/Notify_flock) | flock://    | (TCP) 443    | flock://token<br/>flock://botname@token<br/>flock://app_token/u:userid<br/>flock://app_token/g:channel_id<br/>flock://app_token/u:userid/g:channel_id
  | [Google Chat](https://github.com/caronc/apprise/wiki/Notify_googlechat) | gchat://    | (TCP) 443    | gchat://workspace/key/token
  | [Gotify](https://github.com/caronc/apprise/wiki/Notify_gotify) | gotify:// or gotifys://   | (TCP) 80 or 443    | gotify://hostname/token<br />gotifys://hostname/token?priority=high
  | [Growl](https://github.com/caronc/apprise/wiki/Notify_growl)  | growl://   | (UDP) 23053   | growl://hostname<br />growl://hostname:portno<br />growl://password@hostname<br />growl://password@hostname:port</br>**Note**: you can also use the get parameter _version_ which can allow the growl request to behave using the older v1.x protocol. An example would look like: growl://hostname?version=1
  | [Guilded](https://github.com/caronc/apprise/wiki/Notify_guilded)  | guilded://   | (TCP) 443   | guilded://webhook_id/webhook_token<br />guilded://avatar@webhook_id/webhook_token
  | [Home Assistant](https://github.com/caronc/apprise/wiki/Notify_homeassistant)       | hassio:// or hassios://   | (TCP) 8123 or 443 | hassio://hostname/accesstoken<br />hassio://user@hostname/accesstoken<br />hassio://user:password@hostname:port/accesstoken<br />hassio://hostname/optional/path/accesstoken
  | [IFTTT](https://github.com/caronc/apprise/wiki/Notify_ifttt) | ifttt://    | (TCP) 443    | ifttt://webhooksID/Event<br />ifttt://webhooksID/Event1/Event2/EventN<br/>ifttt://webhooksID/Event1/?+Key=Value<br/>ifttt://webhooksID/Event1/?-Key=value1
  | [Join](https://github.com/caronc/apprise/wiki/Notify_join) | join://   | (TCP) 443    | join://apikey/device<br />join://apikey/device1/device2/deviceN/<br />join://apikey/group<br />join://apikey/groupA/groupB/groupN<br />join://apikey/DeviceA/groupA/groupN/DeviceN/
  | [KODI](https://github.com/caronc/apprise/wiki/Notify_kodi) | kodi:// or kodis://    | (TCP) 8080 or 443   | kodi://hostname<br />kodi://user@hostname<br />kodi://user:password@hostname:port
  | [Kumulos](https://github.com/caronc/apprise/wiki/Notify_kumulos) | kumulos:// | (TCP) 443 | kumulos://apikey/serverkey
  | [LaMetric Time](https://github.com/caronc/apprise/wiki/Notify_lametric) | lametric:// | (TCP) 443 | lametric://apikey@device_ipaddr<br/>lametric://apikey@hostname:port<br/>lametric://client_id@client_secret
  | [Line](https://github.com/caronc/apprise/wiki/Notify_line) | line:// | (TCP) 443 | line://Token@User<br/>line://Token/User1/User2/UserN
  | [LunaSea](https://github.com/caronc/apprise/wiki/Notify_lunasea) | lunasea://  | (TCP) 80 or 443   | lunasea://user:pass@+FireBaseDevice/<br/>lunasea://user:pass@FireBaseUser/<br/>lunasea://user:pass@hostname/+FireBaseDevice/<br/>lunasea://user:pass@hostname/@FireBaseUser/
  | [Mailgun](https://github.com/caronc/apprise/wiki/Notify_mailgun) | mailgun:// | (TCP) 443 | mailgun://user@hostname/apikey<br />mailgun://user@hostname/apikey/email<br />mailgun://user@hostname/apikey/email1/email2/emailN<br />mailgun://user@hostname/apikey/?name="From%20User"
  | [Mastodon](https://github.com/caronc/apprise/wiki/Notify_mastodon) | mastodon:// or mastodons://| (TCP) 80 or 443  | mastodon://access_key@hostname<br />mastodon://access_key@hostname/@user<br />mastodon://access_key@hostname/@user1/@user2/@userN
  | [Matrix](https://github.com/caronc/apprise/wiki/Notify_matrix) | matrix:// or matrixs://  | (TCP) 80 or 443 | matrix://hostname<br />matrix://user@hostname<br />matrixs://user:pass@hostname:port/#room_alias<br />matrixs://user:pass@hostname:port/!room_id<br />matrixs://user:pass@hostname:port/#room_alias/!room_id/#room2<br />matrixs://token@hostname:port/?webhook=matrix<br />matrix://user:token@hostname/?webhook=slack&format=markdown
  | [Mattermost](https://github.com/caronc/apprise/wiki/Notify_mattermost) | mmost:// or mmosts:// | (TCP) 8065 | mmost://hostname/authkey<br />mmost://hostname:80/authkey<br />mmost://user@hostname:80/authkey<br />mmost://hostname/authkey?channel=channel<br />mmosts://hostname/authkey<br />mmosts://user@hostname/authkey<br />
  | [Microsoft Power Automate / Workflows (MSTeams)](https://github.com/caronc/apprise/wiki/Notify_workflows) | workflows://  | (TCP) 443   | workflows://WorkflowID/Signature/
  | [Microsoft Teams](https://github.com/caronc/apprise/wiki/Notify_msteams) | msteams://  | (TCP) 443   | msteams://TokenA/TokenB/TokenC/
  | [Misskey](https://github.com/caronc/apprise/wiki/Notify_misskey) | misskey:// or misskeys://| (TCP) 80 or 443  | misskey://access_token@hostname
  | [MQTT](https://github.com/caronc/apprise/wiki/Notify_mqtt) | mqtt://  or mqtts:// | (TCP) 1883 or 8883   | mqtt://hostname/topic<br />mqtt://user@hostname/topic<br />mqtts://user:pass@hostname:9883/topic
  | [Nextcloud](https://github.com/caronc/apprise/wiki/Notify_nextcloud) | ncloud:// or nclouds:// | (TCP) 80 or 443 | ncloud://adminuser:pass@host/User<br/>nclouds://adminuser:pass@host/User1/User2/UserN
  | [NextcloudTalk](https://github.com/caronc/apprise/wiki/Notify_nextcloudtalk) | nctalk:// or nctalks:// | (TCP) 80 or 443 | nctalk://user:pass@host/RoomId<br/>nctalks://user:pass@host/RoomId1/RoomId2/RoomIdN
  | [Notica](https://github.com/caronc/apprise/wiki/Notify_notica) | notica://  | (TCP) 443   | notica://Token/
  | [Notifiarr](https://github.com/caronc/apprise/wiki/Notify_notifiarr) | notifiarr:// | (TCP) 443 | notifiarr://apikey/#channel<br />notifiarr://apikey/#channel1/#channel2/#channeln
  | [Notifico](https://github.com/caronc/apprise/wiki/Notify_notifico) | notifico://  | (TCP) 443   | notifico://ProjectID/MessageHook/
  | [ntfy](https://github.com/caronc/apprise/wiki/Notify_ntfy) | ntfy://  | (TCP) 80 or 443   | ntfy://topic/<br/>ntfys://topic/
  | [Office 365](https://github.com/caronc/apprise/wiki/Notify_office365) | o365://  | (TCP) 443   | o365://TenantID:AccountEmail/ClientID/ClientSecret<br />o365://TenantID:AccountEmail/ClientID/ClientSecret/TargetEmail<br />o365://TenantID:AccountEmail/ClientID/ClientSecret/TargetEmail1/TargetEmail2/TargetEmailN
  | [OneSignal](https://github.com/caronc/apprise/wiki/Notify_onesignal) | onesignal:// | (TCP) 443 | onesignal://AppID@APIKey/PlayerID<br/>onesignal://TemplateID:AppID@APIKey/UserID<br/>onesignal://AppID@APIKey/#IncludeSegment<br/>onesignal://AppID@APIKey/Email
  | [Opsgenie](https://github.com/caronc/apprise/wiki/Notify_opsgenie) | opsgenie:// | (TCP) 443 | opsgenie://APIKey<br/>opsgenie://APIKey/UserID<br/>opsgenie://APIKey/#Team<br/>opsgenie://APIKey/\*Schedule<br/>opsgenie://APIKey/^Escalation
  | [PagerDuty](https://github.com/caronc/apprise/wiki/Notify_pagerduty) | pagerduty:// | (TCP) 443 | pagerduty://IntegrationKey@ApiKey<br/>pagerduty://IntegrationKey@ApiKey/Source/Component
  | [PagerTree](https://github.com/caronc/apprise/wiki/Notify_pagertree) | pagertree:// | (TCP) 443 | pagertree://integration_id
  | [ParsePlatform](https://github.com/caronc/apprise/wiki/Notify_parseplatform) | parsep:// or parseps:// | (TCP) 80 or 443 | parsep://AppID:MasterKey@Hostname<br/>parseps://AppID:MasterKey@Hostname
  | [PopcornNotify](https://github.com/caronc/apprise/wiki/Notify_popcornnotify) | popcorn://  | (TCP) 443   | popcorn://ApiKey/ToPhoneNo<br/>popcorn://ApiKey/ToPhoneNo1/ToPhoneNo2/ToPhoneNoN/<br/>popcorn://ApiKey/ToEmail<br/>popcorn://ApiKey/ToEmail1/ToEmail2/ToEmailN/<br/>popcorn://ApiKey/ToPhoneNo1/ToEmail1/ToPhoneNoN/ToEmailN
  | [Prowl](https://github.com/caronc/apprise/wiki/Notify_prowl) | prowl://   | (TCP) 443    | prowl://apikey<br />prowl://apikey/providerkey
  | [PushBullet](https://github.com/caronc/apprise/wiki/Notify_pushbullet) | pbul://    | (TCP) 443    | pbul://accesstoken<br />pbul://accesstoken/#channel<br/>pbul://accesstoken/A_DEVICE_ID<br />pbul://accesstoken/email@address.com<br />pbul://accesstoken/#channel/#channel2/email@address.net/DEVICE
  | [Pushjet](https://github.com/caronc/apprise/wiki/Notify_pushjet) | pjet:// or pjets:// | (TCP) 80 or 443 | pjet://hostname/secret<br />pjet://hostname:port/secret<br />pjets://secret@hostname/secret<br />pjets://hostname:port/secret
  | [Push (Techulus)](https://github.com/caronc/apprise/wiki/Notify_techulus) | push://    | (TCP) 443    | push://apikey/
  | [Pushed](https://github.com/caronc/apprise/wiki/Notify_pushed) | pushed://    | (TCP) 443    | pushed://appkey/appsecret/<br/>pushed://appkey/appsecret/#ChannelAlias<br/>pushed://appkey/appsecret/#ChannelAlias1/#ChannelAlias2/#ChannelAliasN<br/>pushed://appkey/appsecret/@UserPushedID<br/>pushed://appkey/appsecret/@UserPushedID1/@UserPushedID2/@UserPushedIDN
  | [PushMe](https://github.com/caronc/apprise/wiki/Notify_pushme) | pushme://  | (TCP) 443   | pushme://Token/
  | [Pushover](https://github.com/caronc/apprise/wiki/Notify_pushover)  | pover://   | (TCP) 443   | pover://user@token<br />pover://user@token/DEVICE<br />pover://user@token/DEVICE1/DEVICE2/DEVICEN<br />**Note**: you must specify both your user_id and token
  | [PushSafer](https://github.com/caronc/apprise/wiki/Notify_pushsafer)  | psafer:// or psafers://  | (TCP) 80 or 443  | psafer://privatekey<br />psafers://privatekey/DEVICE<br />psafer://privatekey/DEVICE1/DEVICE2/DEVICEN
  | [Pushy](https://github.com/caronc/apprise/wiki/Notify_pushy)  | pushy://  | (TCP) 443  | pushy://apikey/DEVICE<br />pushy://apikey/DEVICE1/DEVICE2/DEVICEN<br />pushy://apikey/TOPIC<br />pushy://apikey/TOPIC1/TOPIC2/TOPICN
  | [PushDeer](https://github.com/caronc/apprise/wiki/Notify_pushdeer) | pushdeer:// or pushdeers:// | (TCP) 80 or 443 | pushdeer://pushKey<br />pushdeer://hostname/pushKey<br />pushdeer://hostname:port/pushKey
  | [Reddit](https://github.com/caronc/apprise/wiki/Notify_reddit) | reddit:// | (TCP) 443   | reddit://user:password@app_id/app_secret/subreddit<br />reddit://user:password@app_id/app_secret/sub1/sub2/subN
  | [Revolt](https://github.com/caronc/apprise/wiki/Notify_Revolt) | revolt:// | (TCP) 443   |  revolt://bottoken/ChannelID<br />revolt://bottoken/ChannelID1/ChannelID2/ChannelIDN |
  | [Rocket.Chat](https://github.com/caronc/apprise/wiki/Notify_rocketchat) | rocket:// or rockets://  | (TCP) 80 or 443   | rocket://user:password@hostname/RoomID/Channel<br />rockets://user:password@hostname:443/#Channel1/#Channel1/RoomID<br />rocket://user:password@hostname/#Channel<br />rocket://webhook@hostname<br />rockets://webhook@hostname/@User/#Channel
  | [RSyslog](https://github.com/caronc/apprise/wiki/Notify_rsyslog) | rsyslog://  | (UDP) 514 | rsyslog://hostname<br />rsyslog://hostname/Facility
  | [Ryver](https://github.com/caronc/apprise/wiki/Notify_ryver) | ryver://  | (TCP) 443   | ryver://Organization/Token<br />ryver://botname@Organization/Token
  | [SendGrid](https://github.com/caronc/apprise/wiki/Notify_sendgrid) | sendgrid://  | (TCP) 443   | sendgrid://APIToken:FromEmail/<br />sendgrid://APIToken:FromEmail/ToEmail<br />sendgrid://APIToken:FromEmail/ToEmail1/ToEmail2/ToEmailN/
  | [ServerChan](https://github.com/caronc/apprise/wiki/Notify_serverchan) | schan://   | (TCP) 443    | schan://sendkey/
  | [Signal API](https://github.com/caronc/apprise/wiki/Notify_signal) | signal://  or signals:// | (TCP) 80 or 443  | signal://hostname:port/FromPhoneNo<br/>signal://hostname:port/FromPhoneNo/ToPhoneNo<br/>signal://hostname:port/FromPhoneNo/ToPhoneNo1/ToPhoneNo2/ToPhoneNoN/
  | [SimplePush](https://github.com/caronc/apprise/wiki/Notify_simplepush) | spush://   | (TCP) 443    | spush://apikey<br />spush://salt:password@apikey<br />spush://apikey?event=Apprise
  | [Slack](https://github.com/caronc/apprise/wiki/Notify_slack) | slack://  | (TCP) 443   | slack://TokenA/TokenB/TokenC/<br />slack://TokenA/TokenB/TokenC/Channel<br />slack://botname@TokenA/TokenB/TokenC/Channel<br />slack://user@TokenA/TokenB/TokenC/Channel1/Channel2/ChannelN
  | [SMTP2Go](https://github.com/caronc/apprise/wiki/Notify_smtp2go) | smtp2go:// | (TCP) 443 | smtp2go://user@hostname/apikey<br />smtp2go://user@hostname/apikey/email<br />smtp2go://user@hostname/apikey/email1/email2/emailN<br />smtp2go://user@hostname/apikey/?name="From%20User"
  | [SparkPost](https://github.com/caronc/apprise/wiki/Notify_sparkpost) | sparkpost:// | (TCP) 443 | sparkpost://user@hostname/apikey<br />sparkpost://user@hostname/apikey/email<br />sparkpost://user@hostname/apikey/email1/email2/emailN<br />sparkpost://user@hostname/apikey/?name="From%20User"
  | [Splunk](https://github.com/caronc/apprise/wiki/Notify_splunk) | splunk:// or victorops:/ | (TCP) 443 | splunk://route_key@apikey<br />splunk://route_key@apikey/entity_id
  | [Streamlabs](https://github.com/caronc/apprise/wiki/Notify_streamlabs) | strmlabs:// | (TCP) 443 | strmlabs://AccessToken/<br/>strmlabs://AccessToken/?name=name&identifier=identifier&amount=0&currency=USD
  | [Synology Chat](https://github.com/caronc/apprise/wiki/Notify_synology_chat) | synology:// or synologys:// |  (TCP) 80 or 443 | synology://hostname/token<br />synology://hostname:port/token
  | [Syslog](https://github.com/caronc/apprise/wiki/Notify_syslog) | syslog://  | n/a | syslog://<br />syslog://Facility
  | [Telegram](https://github.com/caronc/apprise/wiki/Notify_telegram) | tgram://  | (TCP) 443   | tgram://bottoken/ChatID<br />tgram://bottoken/ChatID1/ChatID2/ChatIDN
  | [Twitter](https://github.com/caronc/apprise/wiki/Notify_twitter) | twitter://  | (TCP) 443   | twitter://CKey/CSecret/AKey/ASecret<br/>twitter://user@CKey/CSecret/AKey/ASecret<br/>twitter://CKey/CSecret/AKey/ASecret/User1/User2/User2<br/>twitter://CKey/CSecret/AKey/ASecret?mode=tweet
  | [Twist](https://github.com/caronc/apprise/wiki/Notify_twist) | twist://  | (TCP) 443   | twist://pasword:login<br/>twist://password:login/#channel<br/>twist://password:login/#team:channel<br/>twist://password:login/#team:channel1/channel2/#team3:channel
  | [Webex Teams (Cisco)](https://github.com/caronc/apprise/wiki/Notify_wxteams) | wxteams://  | (TCP) 443   | wxteams://Token
  | [WeCom Bot](https://github.com/caronc/apprise/wiki/Notify_wecombot) | wecombot://  | (TCP) 443   | wecombot://BotKey
  | [WhatsApp](https://github.com/caronc/apprise/wiki/Notify_whatsapp) | whatsapp://  | (TCP) 443   | whatsapp://AccessToken@FromPhoneID/ToPhoneNo<br/>whatsapp://Template:AccessToken@FromPhoneID/ToPhoneNo
  | [WxPusher](https://github.com/caronc/apprise/wiki/Notify_wxpusher) | wxpusher://  | (TCP) 443   | wxpusher://AppToken@UserID1/UserID2/UserIDN<br/>wxpusher://AppToken@Topic1/Topic2/Topic3<br/>wxpusher://AppToken@UserID1/Topic1/
  | [XBMC](https://github.com/caronc/apprise/wiki/Notify_xbmc) | xbmc:// or xbmcs://    | (TCP) 8080 or 443   | xbmc://hostname<br />xbmc://user@hostname<br />xbmc://user:password@hostname:port
  | [Zulip Chat](https://github.com/caronc/apprise/wiki/Notify_zulip) | zulip://  | (TCP) 443   | zulip://botname@Organization/Token<br />zulip://botname@Organization/Token/Stream<br />zulip://botname@Organization/Token/Email



  | Notification Service | Service ID | Default Port | Example Syntax |
  | -------------------- | ---------- | ------------ | -------------- |
  | [Africas Talking](https://github.com/caronc/apprise/wiki/Notify_africas_talking) | atalk://  | (TCP) 443   | atalk://AppUser@ApiKey/ToPhoneNo<br/>atalk://AppUser@ApiKey/ToPhoneNo1/ToPhoneNo2/ToPhoneNoN/
  | [Automated Packet Reporting System (ARPS)](https://github.com/caronc/apprise/wiki/Notify_aprs)  | aprs:// | (TCP) 10152 | aprs://user:pass@callsign<br/>aprs://user:pass@callsign1/callsign2/callsignN
  | [AWS SNS](https://github.com/caronc/apprise/wiki/Notify_sns)  | sns://   | (TCP) 443   | sns://AccessKeyID/AccessSecretKey/RegionName/+PhoneNo<br/>sns://AccessKeyID/AccessSecretKey/RegionName/+PhoneNo1/+PhoneNo2/+PhoneNoN<br/>sns://AccessKeyID/AccessSecretKey/RegionName/Topic<br/>sns://AccessKeyID/AccessSecretKey/RegionName/Topic1/Topic2/TopicN
  | [BulkSMS](https://github.com/caronc/apprise/wiki/Notify_bulksms) | bulksms://  | (TCP) 443   | bulksms://user:password@ToPhoneNo<br/>bulksms://User:Password@ToPhoneNo1/ToPhoneNo2/ToPhoneNoN/
  | [BulkVS](https://github.com/caronc/apprise/wiki/Notify_bulkvs) | bulkvs://  | (TCP) 443   | bulkvs://user:password@FromPhoneNo<br/>bulkvs://user:password@FromPhoneNo/ToPhoneNo<br/>bulkvs://user:password@FromPhoneNo/ToPhoneNo1/ToPhoneNo2/ToPhoneNoN/
  | [Burst SMS](https://github.com/caronc/apprise/wiki/Notify_burst_sms) | burstsms://  | (TCP) 443   | burstsms://ApiKey:ApiSecret@FromPhoneNo/ToPhoneNo<br/>burstsms://ApiKey:ApiSecret@FromPhoneNo/ToPhoneNo1/ToPhoneNo2/ToPhoneNoN/
  | [Burst SMS](https://github.com/caronc/apprise/wiki/Notify_burst_sms) | burstsms://  | (TCP) 443   | burstsms://ApiKey:ApiSecret@FromPhoneNo/ToPhoneNo<br/>burstsms://ApiKey:ApiSecret@FromPhoneNo/ToPhoneNo1/ToPhoneNo2/ToPhoneNoN/
  | [ClickSend](https://github.com/caronc/apprise/wiki/Notify_clicksend) | clicksend://  | (TCP) 443   | clicksend://user:pass@PhoneNo<br/>clicksend://user:pass@ToPhoneNo1/ToPhoneNo2/ToPhoneNoN
  | [DAPNET](https://github.com/caronc/apprise/wiki/Notify_dapnet) | dapnet://  | (TCP) 80   | dapnet://user:pass@callsign<br/>dapnet://user:pass@callsign1/callsign2/callsignN
  | [D7 Networks](https://github.com/caronc/apprise/wiki/Notify_d7networks) | d7sms://  | (TCP) 443   | d7sms://token@PhoneNo<br/>d7sms://token@ToPhoneNo1/ToPhoneNo2/ToPhoneNoN
  | [DingTalk](https://github.com/caronc/apprise/wiki/Notify_dingtalk)  | dingtalk://   | (TCP) 443   | dingtalk://token/<br />dingtalk://token/ToPhoneNo<br />dingtalk://token/ToPhoneNo1/ToPhoneNo2/ToPhoneNo1/
  | [Free-Mobile](https://github.com/caronc/apprise/wiki/Notify_freemobile)  | freemobile://   | (TCP) 443   | freemobile://user@password/
  | [httpSMS](https://github.com/caronc/apprise/wiki/Notify_httpsms) | httpsms://  | (TCP) 443   | httpsms://ApiKey@FromPhoneNo<br/>httpsms://ApiKey@FromPhoneNo/ToPhoneNo<br/>httpsms://ApiKey@FromPhoneNo/ToPhoneNo1/ToPhoneNo2/ToPhoneNoN/
  | [Kavenegar](https://github.com/caronc/apprise/wiki/Notify_kavenegar) | kavenegar://  | (TCP) 443   | kavenegar://ApiKey/ToPhoneNo<br/>kavenegar://FromPhoneNo@ApiKey/ToPhoneNo<br/>kavenegar://ApiKey/ToPhoneNo1/ToPhoneNo2/ToPhoneNoN
  | [MessageBird](https://github.com/caronc/apprise/wiki/Notify_messagebird) | msgbird://  | (TCP) 443   | msgbird://ApiKey/FromPhoneNo<br/>msgbird://ApiKey/FromPhoneNo/ToPhoneNo<br/>msgbird://ApiKey/FromPhoneNo/ToPhoneNo1/ToPhoneNo2/ToPhoneNoN/
  | [MSG91](https://github.com/caronc/apprise/wiki/Notify_msg91) | msg91://  | (TCP) 443   | msg91://TemplateID@AuthKey/ToPhoneNo<br/>msg91://TemplateID@AuthKey/ToPhoneNo1/ToPhoneNo2/ToPhoneNoN/
  | [Société Française du Radiotéléphone (SFR)](https://github.com/caronc/apprise/wiki/Notify_sfr) | sfr://   | (TCP) 443    | sfr://user:password>@spaceId/ToPhoneNo<br/>sfr://user:password>@spaceId/ToPhoneNo1/ToPhoneNo2/ToPhoneNoN/
  | [Signal API](https://github.com/caronc/apprise/wiki/Notify_signal) | signal://  or signals:// | (TCP) 80 or 443  | signal://hostname:port/FromPhoneNo<br/>signal://hostname:port/FromPhoneNo/ToPhoneNo<br/>signal://hostname:port/FromPhoneNo/ToPhoneNo1/ToPhoneNo2/ToPhoneNoN/
  | [Sinch](https://github.com/caronc/apprise/wiki/Notify_sinch) | sinch://  | (TCP) 443   | sinch://ServicePlanId:ApiToken@FromPhoneNo<br/>sinch://ServicePlanId:ApiToken@FromPhoneNo/ToPhoneNo<br/>sinch://ServicePlanId:ApiToken@FromPhoneNo/ToPhoneNo1/ToPhoneNo2/ToPhoneNoN/<br/>sinch://ServicePlanId:ApiToken@ShortCode/ToPhoneNo<br/>sinch://ServicePlanId:ApiToken@ShortCode/ToPhoneNo1/ToPhoneNo2/ToPhoneNoN/
  | [SMSEagle](https://github.com/caronc/apprise/wiki/Notify_smseagle) | smseagle:// or smseagles:// | (TCP) 80 or 443  | smseagles://hostname:port/ToPhoneNo<br/>smseagles://hostname:port/@ToContact<br/>smseagles://hostname:port/#ToGroup<br/>smseagles://hostname:port/ToPhoneNo1/#ToGroup/@ToContact/
  | [SMS Manager](https://github.com/caronc/apprise/wiki/Notify_sms_manager) | smsmgr://  | (TCP) 443   | smsmgr://ApiKey@ToPhoneNo<br/>smsmgr://ApiKey@ToPhoneNo1/ToPhoneNo2/ToPhoneNoN/
  | [Threema Gateway](https://github.com/caronc/apprise/wiki/Notify_threema) | threema://  | (TCP) 443   | threema://GatewayID@secret/ToPhoneNo<br/>threema://GatewayID@secret/ToEmail<br/>threema://GatewayID@secret/ToThreemaID/<br/>threema://GatewayID@secret/ToEmail/ToThreemaID/ToPhoneNo/...
  | [Twilio](https://github.com/caronc/apprise/wiki/Notify_twilio) | twilio://  | (TCP) 443   | twilio://AccountSid:AuthToken@FromPhoneNo<br/>twilio://AccountSid:AuthToken@FromPhoneNo/ToPhoneNo<br/>twilio://AccountSid:AuthToken@FromPhoneNo/ToPhoneNo1/ToPhoneNo2/ToPhoneNoN/<br/>twilio://AccountSid:AuthToken@FromPhoneNo/ToPhoneNo?apikey=Key<br/>twilio://AccountSid:AuthToken@ShortCode/ToPhoneNo<br/>twilio://AccountSid:AuthToken@ShortCode/ToPhoneNo1/ToPhoneNo2/ToPhoneNoN/
  | [Voipms](https://github.com/caronc/apprise/wiki/Notify_voipms) | voipms://  | (TCP) 443   | voipms://password:email/FromPhoneNo<br/>voipms://password:email/FromPhoneNo/ToPhoneNo<br/>voipms://password:email/FromPhoneNo/ToPhoneNo1/ToPhoneNo2/ToPhoneNoN/
  | [Vonage](https://github.com/caronc/apprise/wiki/Notify_nexmo) (formerly Nexmo) | nexmo://  | (TCP) 443   | nexmo://ApiKey:ApiSecret@FromPhoneNo<br/>nexmo://ApiKey:ApiSecret@FromPhoneNo/ToPhoneNo<br/>nexmo://ApiKey:ApiSecret@FromPhoneNo/ToPhoneNo1/ToPhoneNo2/ToPhoneNoN/



  | Notification Service | Service ID | Default Port | Example Syntax |
  | -------------------- | ---------- | ------------ | -------------- |
  | [Linux DBus Notifications](https://github.com/caronc/apprise/wiki/Notify_dbus)  | dbus://<br />qt://<br />glib://<br />kde://  | n/a  | dbus://<br />qt://<br />glib://<br />kde://
  | [Linux Gnome Notifications](https://github.com/caronc/apprise/wiki/Notify_gnome) | gnome://    |        n/a          | gnome://
  | [MacOS X Notifications](https://github.com/caronc/apprise/wiki/Notify_macosx) | macosx://    |        n/a          | macosx://
  | [Windows Notifications](https://github.com/caronc/apprise/wiki/Notify_windows) | windows://    |        n/a          | windows://



  | Service ID | Default Port | Example Syntax |
  | ---------- | ------------ | -------------- |
  | [mailto://](https://github.com/caronc/apprise/wiki/Notify_email)  |  (TCP) 25    | mailto://userid:pass@domain.com<br />mailto://domain.com?user=userid&pass=password<br/>mailto://domain.com:2525?user=userid&pass=password<br />mailto://user@gmail.com&pass=password<br />mailto://mySendingUsername:mySendingPassword@example.com?to=receivingAddress@example.com<br />mailto://userid:password@example.com?smtp=mail.example.com&from=noreply@example.com&name=no%20reply
  | [mailtos://](https://github.com/caronc/apprise/wiki/Notify_email) |  (TCP) 587   | mailtos://userid:pass@domain.com<br />mailtos://domain.com?user=userid&pass=password<br/>mailtos://domain.com:465?user=userid&pass=password<br />mailtos://user@hotmail.com&pass=password<br />mailtos://mySendingUsername:mySendingPassword@example.com?to=receivingAddress@example.com<br />mailtos://userid:password@example.com?smtp=mail.example.com&from=noreply@example.com&name=no%20reply

  Apprise have some email services built right into it (such as yahoo, fastmail, hotmail, gmail, etc) that greatly simplify the mailto:// service.  See more details [here](https://github.com/caronc/apprise/wiki/Notify_email).



  | Post Method          | Service ID | Default Port | Example Syntax |
  | -------------------- | ---------- | ------------ | -------------- |
  | [Form](https://github.com/caronc/apprise/wiki/Notify_Custom_Form)       | form:// or forms://   | (TCP) 80 or 443 | form://hostname<br />form://user@hostname<br />form://user:password@hostname:port<br />form://hostname/a/path/to/post/to
  | [JSON](https://github.com/caronc/apprise/wiki/Notify_Custom_JSON)       | json:// or jsons://   | (TCP) 80 or 443 | json://hostname<br />json://user@hostname<br />json://user:password@hostname:port<br />json://hostname/a/path/to/post/to
  | [XML](https://github.com/caronc/apprise/wiki/Notify_Custom_XML)         | xml:// or xmls://   | (TCP) 80 or 443 | xml://hostname<br />xml://user@hostname<br />xml://user:password@hostname:port<br />xml://hostname/a/path/to/post/to



  The easiest way is to install this package is from pypi:
  ```bash
  pip install apprise
  ```

  Apprise is also packaged as an RPM and available through [EPEL](https://docs.fedoraproject.org/en-US/epel/) supporting CentOS, Redhat, Rocky, Oracle Linux, etc.
  ```bash



  yum install apprise


  dnf install apprise
  ```

  You can also check out the [Graphical version of Apprise](https://github.com/caronc/apprise-api) to centralize your configuration and notifications through a managable webpage.



  A small command line interface (CLI) tool is also provided with this package called *apprise*. If you know the server urls you wish to notify, you can simply provide them all on the command line and send your notifications that way:
  ```bash



  apprise -vv -t 'my title' -b 'my notification body' \
     'mailto://myemail:mypass@gmail.com' \
     'pbul://o.gn5kj6nfhv736I7jC3cj3QLRiyhgl98b'



  cat /proc/cpuinfo | apprise -vv -t 'cpu info' \
     'mailto://myemail:mypass@gmail.com'


  uptime | apprise -vv \
     'discord:///4174216298/JHMHI8qBe7bk2ZwO5U711o3dV_js'
  ```



  No one wants to put their credentials out for everyone to see on the command line.  No problem *apprise* also supports configuration files.  It can handle both a specific [YAML format](https://github.com/caronc/apprise/wiki/config_yaml) or a very simple [TEXT format](https://github.com/caronc/apprise/wiki/config_text). You can also pull these configuration files via an HTTP query too! You can read more about the expected structure of the configuration files [here](https://github.com/caronc/apprise/wiki/config).
  ```bash

































  apprise -vv -t 'my title' -b 'my notification body'



  apprise -vv -t 'my title' -b 'my notification body' \
     --config=/path/to/my/config.yml



  apprise -vv -t 'my title' -b 'my notification body' \
     --config=/path/to/my/config.yml \
     --config=https://localhost/my/apprise/config
  ```



  Apprise also supports file attachments too! Specify as many attachments to a notification as you want.
  ```bash

  apprise -vv --title 'Agile Joke' \
          --body 'Did you see this one yet?' \
          --attach https://i.redd.it/my2t4d2fx0u31.jpg \
          'mailto://myemail:mypass@gmail.com'


  apprise -vv --title 'system crash' \
          --body 'I do not think Jim fixed the bug; see attached...' \
          --attach /var/log/myprogram.log \
          --attach /var/debug/core.2345 \
          --tag devteam
  ```



  To create your own custom `schema://` hook so that you can trigger your own custom code,
  simply include the `@notify` decorator to wrap your function.
  ```python
  from apprise.decorators import notify



  @notify(on="foobar", name="My Custom Foobar Plugin")
  def my_custom_notification_wrapper(body, title, notify_type, *args, **kwargs):
      """My custom notification function that triggers on all foobar:// calls
      """
      
      print("{}: {} - {}".format(notify_type.upper(), title, body))

      
      
  ```

  Once you've defined your custom hook, you just need to tell Apprise where it is at runtime.
  ```bash















  apprise -vv --title 'custom override' \
          --body 'the body of my message' \
          foobar:\\


  apprise -vv --title 'custom override' \
          --body 'the body of my message' \
          --plugin-path /path/to/my/plugin.py \
          foobar:\\
  ```

  You can read more about creating your own custom notifications and/or hooks [here](https://github.com/caronc/apprise/wiki/decorator_notify).



  To send a notification from within your python application, just do the following:
  ```python
  import apprise


  apobj = apprise.Apprise()



  apobj.add('mailto://myuserid:mypass@gmail.com')


  apobj.add('pbul://o.gn5kj6nfhv736I7jC3cj3QLRiyhgl98b')



  apobj.notify(
      body='what a great notification service!',
      title='my notification title',
  )
  ```



  Developers need access to configuration files too. The good news is their use just involves declaring another object (called *AppriseConfig*) that the *Apprise* object can ingest.  You can also freely mix and match config and notification entries as often as you wish! You can read more about the expected structure of the configuration files [here](https://github.com/caronc/apprise/wiki/config).
  ```python
  import apprise


  apobj = apprise.Apprise()


  config = apprise.AppriseConfig()


  config.add('/path/to/my/config.yml')


  config.add('https://myserver:8080/path/to/config')


  apobj.add(config)



  apobj.add('mailto://myuser:mypass@hotmail.com', tag='admin')




  apobj.notify(
      body='what a great notification service!',
      title='my notification title',
  )



  apobj.notify(
      body='send a notification to our admin group',
      title='Attention Admins',
      
      tag='admin',
  )



  apobj.notify(
      body='send a notification to our admin group',
      title='Attention Admins',
      
      
      tag='all',
  )
  ```



  Attachments are very easy to send using the Apprise API:
  ```python
  import apprise


  apobj = apprise.Apprise()


  apobj.add('mailto://myuser:mypass@hotmail.com')


  apobj.notify(
      title='A great photo of our family',
      body='The flash caused Jane to close her eyes! hah! :)',
      attach='/local/path/to/my/DSC_003.jpg',
  )






  apobj.notify(
      title='Latest security image',
      attach='http://admin:password@hikvision-cam01/ISAPI/Streaming/channels/101/picture?cache=3'
  )
  ```

  To send more than one attachment, just use a list, set, or tuple instead:
  ```python
  import apprise


  apobj = apprise.Apprise()


  apobj.add('mailto://myuser:mypass@hotmail.com')


  attach = (
      
      
      'https://i.redd.it/my2t4d2fx0u31.jpg?name=FlyingToMars.jpg',

      
      '/path/to/funny/joke.gif',
  )


  apobj.notify(
      title='Some good jokes.',
      body='Hey guys, check out these!',
      attach=attach,
  )
  ```



  By default, no custom plugins are loaded at all for those building from within the Apprise API.
  It's at the developers discretion to load custom modules. But should you choose to do so, it's as easy
  as including the path reference in the `AppriseAsset()` object prior to the initialization of your `Apprise()`
  instance.

  For example:
  ```python
  from apprise import Apprise
  from apprise import AppriseAsset



  asset = AppriseAsset(plugin_paths="/path/to/scan")


  asset = AppriseAsset(
      plugin_paths=[
          
          
          
          
          "/dir/containing/many/python/libraries",

          
          "/path/to/plugin.py",

          
          
          
          
          "/path/to/dir/library"
      ]
  )



  aobj = Apprise(asset=asset)




  aobj.add('foobar://')


  aobj.notify("test")
  ```

  You can read more about creating your own custom notifications and/or hooks [here](https://github.com/caronc/apprise/wiki/decorator_notify).



  Persistent storage allows Apprise to cache re-occurring actions optionaly to disk. This can greatly reduce the overhead used to send a notification.

  There are 3 Persistent Storage operational states Apprise can operate using:
  1. `auto`:  Flush gathered cache information to the filesystem on demand.  This option is incredibly light weight.  This is the default behavior for all CLI usage.
     * Developers who choose to use this operational mode can also force cached information manually if they choose.
     * The CLI will use this operational mode by default.
  1. `flush`: Flushes any cache information to the filesystem during every transaction.
  1. `memory`: Effectively disable Persistent Storage.  Any caching of data required by each plugin used is done in memory.  Apprise effectively operates as it always did before peristent storage was available. This setting ensures no content is every written to disk.
     * By default this is the mode Apprise will operate under for those developing with it unless they configure it to otherwise operate as `auto` or `flush`.  This is done through the `AppriseAsset()` object and is explained further on in this documentation.



  You can provide the keyword `storage` on your CLI call to see the persistent storage options available to you.
  ```bash

  apprise storage list


  apprise storage



  apprise storage prune


  apprise storage clean

  ```

  You can also filter your results by adding tags and/or URL Identifiers.  When you get a listing (`apprise storage list`), you may see:
  ```
     
     1. f7077a65                                             0.00B    unused
        - matrixs://abcdef:****@synapse.example12.com/%23general?image=no&mode=off&version=3&msgtype...
        tags: team

     2. 0e873a46                                            81.10B    active
        - tgram://W...U//?image=False&detect=yes&silent=no&preview=no&content=before&mdv=v1&format=m...
        tags: personal

     3. abcd123                                             12.00B    stale

  ```
  The (persistent storage) cache states are:
   - `unused`: This plugin has not commited anything to disk for reuse/cache purposes
   - `active`: This plugin has written content to disk.  Or at the very least, it has prepared a persistent storage location it can write into.
   - `stale`: The system detected a location where a URL may have possibly written to in the past, but there is nothing linking to it using the URLs provided.  It is likely wasting space or is no longer of any use.

  You can use this information to filter your results by specifying _URL ID_ (UID) values after your command.  For example:
  ```bash



  apprise storage list ab




  apprise storage clean ab


  apprise storage list --tag=team



  apprise storage list f 0
  ```
  When using the CLI, Persistent storage is set to the operational mode of `auto` by default, you can change this by providing `--storage-mode=` (`-SM`) during your calls.  If you want to ensure it's always set to a value of your choice.

  For more information on persistent storage, [visit here](https://github.com/caronc/apprise/wiki/persistent_storage).


  For developers, persistent storage is set in the operational mode of `memory` by default.

  It's at the developers discretion to enable it (by switching it to either `auto` or `flush`). Should you choose to do so: it's as easy as including the information in the `AppriseAsset()` object prior to the initialization of your `Apprise()` instance.

  For example:
  ```python
  from apprise import Apprise
  from apprise import AppriseAsset
  from apprise import PersistentStoreMode




  asset = AppriseAsset(storage_path="/path/to/save/data")



  asset = AppriseAsset(
      
      storage_path="/path/to/save/data",

      
      
      
      
      
      
      
      storage_mode=PersistentStoreMode.FLUSH

      
      
      
      storage_idlen=8,
  )



  aobj = Apprise(asset=asset)
  ```

  For more information on persistent storage, [visit here](https://github.com/caronc/apprise/wiki/persistent_storage).



  If you're interested in reading more about this and other methods on how to customize your own notifications, please check out the following links:
  * 📣 [Using the CLI](https://github.com/caronc/apprise/wiki/CLI_Usage)
  * 🛠️ [Development API](https://github.com/caronc/apprise/wiki/Development_API)
  * 🔧 [Troubleshooting](https://github.com/caronc/apprise/wiki/Troubleshooting)
  * ⚙️ [Configuration File Help](https://github.com/caronc/apprise/wiki/config)
  * ⚡ [Create Your Own Custom Notifications](https://github.com/caronc/apprise/wiki/decorator_notify)
  * 💾 [Persistent Storage](https://github.com/caronc/apprise/wiki/persistent_storage)
  * 🌎 [Apprise API/Web Interface](https://github.com/caronc/apprise-api)
  * 🎉 [Showcase](https://github.com/caronc/apprise/wiki/showcase)

  Want to help make Apprise better?
  * 💡 [Contribute to the Apprise Code Base](https://github.com/caronc/apprise/wiki/Development_Contribution)
  * ❤️ [Sponsorship and Donations](https://github.com/caronc/apprise/wiki/Sponsors)


pkgId: d4bdb9906d4d884975a0f9dcf706026f389183ec06bea3dac18c9867b847cbef
name: python-approvaltests
arch: src
version: 14.0.0
epoch: 0
release: 1
summary: Assertion/verification library to aid testing
url: https://github.com/approvals/ApprovalTests.Python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-approvaltests-14.0.0-1.src.rpm
checksum_type: sha256
description:
  <!-- toc -->


    * [What can I use ApprovalTests for?](#what-can-i-use-approvaltests-for)
    * [Getting Started](#getting-started)
      * [What Are Approvals](#what-are-approvals)
      * [New Projects](#new-projects)
        * [Minimal Example Tutorial](#minimal-example-tutorial)
      * [Adding to Existing Projects](#adding-to-existing-projects)
    * [Overview](#overview)
      * [Example using pytest](#example-using-pytest)
      * [Example using unittest](#example-using-unittest)
      * [Example using CLI](#example-using-cli)
        * [Usage](#usage)
        * [Argument Definitions](#argument-definitions)
    * [Reporters](#reporters)
      * [Selecting a Reporter](#selecting-a-reporter)
      * [JSON file for collection of reporters](#json-file-for-collection-of-reporters)
    * [Support and Documentation](#support-and-documentation)
      * [Missing Documentation?](#missing-documentation)
      * [Dependencies](#dependencies)
        * [Required dependencies](#required-dependencies)
        * [Extra dependencies](#extra-dependencies)
    * [For developers](#for-developers)
      * [Weekly Ensemble](#weekly-ensemble)
      * [Pull Requests](#pull-requests)<!-- endToc -->

  Capturing Human Intelligence - ApprovalTests is an open source assertion/verification library to aid testing.
  `approvaltests` is the ApprovalTests port for Python.

  For more information see: [www.approvaltests.com](http://approvaltests.com/).

  [![PyPI version](https://img.shields.io/pypi/v/approvaltests.svg)](https://pypi.org/project/approvaltests)
  [![Python versions](https://img.shields.io/pypi/pyversions/approvaltests.svg)](https://pypi.org/project/approvaltests)
  [![Build Status](https://github.com/approvals/ApprovalTests.Python/workflows/Test/badge.svg?branch=master)](https://github.com/approvals/ApprovalTests.Python/actions)
  [![Build Status](https://github.com/approvals/ApprovalTests.Python/workflows/on-push-do-doco/badge.svg)](https://github.com/approvals/ApprovalTests.Python/actions?query=workflow%3Aon-push-do-doco)
  [![Build Status](https://github.com/approvals/ApprovalTests.Python/workflows/Upload%20Python%20Package/badge.svg)](https://github.com/approvals/ApprovalTests.Python/actions?query=workflow%3A%22Upload+Python+Package%22)



  You can use ApprovalTests to verify objects that require more than a simple assert including long strings, large arrays,
  and complex hash structures and objects. ApprovalTests really shines when you need a more granular look at the test
  failure. Sometimes, trying to find a small difference in a long string printed to STDOUT is just too hard!
  ApprovalTests solves this problem by providing reporters which let you view the test results in one of many popular diff
  utilities.





  If you need to gain a better understanding or are new to this concept, start [here](https://github.com/approvals/ApprovalTests.Documentation/blob/main/explanations/what_are_approvals.md).



  If you are starting a new project, we suggest you use the [Starter Project](https://github.com/approvals/ApprovalTests.Python.StarterProject).
  You can just clone this and go. It's great for exercises, katas, and green field projects.



  If this is first time approvaltesting in python, consider starting here: [Minimal Example Tutorial](docs/tutorial/minimal-example.md)



  From [pypi](https://pypi.org/project/approvaltests/):

      pip install approvaltests



  Approvals work by comparing the test results to a golden master. If no golden master exists you can create a snapshot
  of the current test results and use that as the golden master. The reporter helps you manage the golden master.
  Whenever your current results differ from the golden master, Approvals will launch an external application for you to
  examine the differences. Either you will update the master because you expected the changes and they are good,
  or you will go back to your code and update or roll back your changes to get your results back in line with the
  golden master.



  <!-- snippet: getting_started_with_pytest.py -->
  <a id='snippet-getting_started_with_pytest.py'></a>
  ```py
  from approvaltests.approvals import verify


  def test_simple():
      result = "Hello ApprovalTests"
      verify(result)
  ```
  <sup><a href='/tests/examples/getting_started_with_pytest.py#L1-L6' title='Snippet source file'>snippet source</a> | <a href='#snippet-getting_started_with_pytest.py' title='Start of snippet'>anchor</a></sup>
  <!-- endSnippet -->

  Install the plugin pytest-approvaltests and use it to select a reporter:

      pip install pytest-approvaltests
      pytest --approvaltests-use-reporter='PythonNative'

  The reporter is used both to alert you to changes in your test output, and to provide a tool to update the golden
  master. In this snippet, we chose the 'PythonNative' reporter when we ran the tests. For more information about selecting
  reporters see [the documentation](https://github.com/approvals/ApprovalTests.Python.PytestPlugin)



  <!-- snippet: getting_started_with_unittest.py -->
  <a id='snippet-getting_started_with_unittest.py'></a>
  ```py
  import unittest

  from approvaltests.approvals import verify


  class GettingStartedTest(unittest.TestCase):
      def test_simple(self):
          verify("Hello ApprovalTests")


  if __name__ == "__main__":
      unittest.main()
  ```
  <sup><a href='/tests/examples/getting_started_with_unittest.py#L1-L12' title='Snippet source file'>snippet source</a> | <a href='#snippet-getting_started_with_unittest.py' title='Start of snippet'>anchor</a></sup>
  <!-- endSnippet -->

  This example has the same behaviour as the pytest version, but uses the built-in test framework `unittest` instead.



  You can invoke a verify() call from the command line. This allows invoking python approvals from any other stack via subprocesses.



  ```
  python -m approvaltests --test-id hello --received "hello world!"
  ```

  or

  ```
  python -m approvaltests -t hello -r "hello world!"
  ```

  or

  ```
  echo "hello world!" | python -m approvaltests -t hello
  ```



  -   **`--test-id`** or **`-t`**: Test identifier used to name the `approved.txt` and `received.txt` files for the test.

  -   **`--received`** or **`-r`**: The output of the program under test (a string) that is passed to the verify method.

      -   **`stdin`**: Instead of providing a `received` argument, you may use `stdin`.





  All verify functions take an optional `options` parameter that can configure reporters (as well as many other aspects).

  ApprovalTests.Python comes with a few reporters configured, supporting Linux, Mac OSX, and Windows.

  In the example shown below, we pass in an options with a reporter we're selecting directly:

  <!-- snippet: select_reporter_from_class -->
  <a id='snippet-select_reporter_from_class'></a>
  ```py
  class TestSelectReporterFromClass(unittest.TestCase):
      def test_simple(self):
          verify("Hello", options=Options().with_reporter(report_with_beyond_compare()))
  ```
  <sup><a href='/tests/samples/test_getting_started.py#L25-L31' title='Snippet source file'>snippet source</a> | <a href='#snippet-select_reporter_from_class' title='Start of snippet'>anchor</a></sup>
  <!-- endSnippet -->

  You can also use the `GenericDiffReporterFactory` to find and select the first diff utility that exists on our system.

  An advantage of this method is you can modify the reporters.json file directly to handle your unique system.

  <!-- snippet: select_reporter_from_factory -->
  <a id='snippet-select_reporter_from_factory'></a>
  ```py
  class TestSelectReporter(unittest.TestCase):
      def setUp(self):
          self.factory = GenericDiffReporterFactory()

      def test_simple(self):
          verify(
              "Hello", options=Options().with_reporter(self.factory.get("BeyondCompare"))
          )
  ```
  <sup><a href='/tests/samples/test_getting_started.py#L11-L22' title='Snippet source file'>snippet source</a> | <a href='#snippet-select_reporter_from_factory' title='Start of snippet'>anchor</a></sup>
  <!-- endSnippet -->

  Or you can build your own GenericDiffReporter on the fly

  <!-- snippet: custom_generic_diff_reporter -->
  <a id='snippet-custom_generic_diff_reporter'></a>
  ```py
  class GettingStartedTest(unittest.TestCase):
      def test_simple(self):
          verify(
              "Hello",
              options=Options().with_reporter(
                  GenericDiffReporter.create(r"C:\my\favorite\diff\utility.exe")
              ),
          )
  ```
  <sup><a href='/tests/samples/test_getting_started.py#L34-L45' title='Snippet source file'>snippet source</a> | <a href='#snippet-custom_generic_diff_reporter' title='Start of snippet'>anchor</a></sup>
  <!-- endSnippet -->

  As long as `C:/my/favorite/diff/utility.exe` can be invoked from the command line using the format `utility.exe file1 file2`
  then it will be compatible with GenericDiffReporter. Otherwise you will have to derive your own reporter, which
  we won't cover here.



  To wrap things up, I should note that you can completely replace the collection of reporters known to the reporter
  factory by writing your own JSON file and loading it.

  For example if you had `C:/myreporters.json`

  ```json
  [
      ["BeyondCompare4", "C:/Program Files (x86)/Beyond Compare 4/BCompare.exe"],
      ["WinMerge", "C:/Program Files (x86)/WinMerge/WinMergeU.exe"],
      ["Tortoise", "C:/Program Files (x86)/TortoiseSVN/bin/tortoisemerge.exe"]
  ]
  ```

  You could then use that file by loading it into the factory:

  ```python

  import unittest

  from approvaltests.approvals import verify
  from approvaltests.reporters.generic_diff_reporter_factory import GenericDiffReporterFactory


  class GettingStartedTest(unittest.TestCase):
      def setUp(self):
          factory = GenericDiffReporterFactory()
          factory.load('C:/myreporters.json')
          self.reporter = factory.get_first_working()

      def test_simple(self):
          verify('Hello', self.reporter)

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

  Of course, if you have some interesting new reporters in `myreporters.json` then please consider updating the
  `reporters.json` file that ships with Approvals and submitting a pull request.



  -   [Documentation](/docs/README.md)

  -   GitHub: [https://github.com/approvals/ApprovalTests.Python](https://github.com/approvals/ApprovalTests.Python)

  -   ApprovalTests Homepage: [http://www.approvaltests.com](http://www.approvaltests.com)



  If there is documentation you wish existed, please add a `page request` to [this issue](https://github.com/approvals/ApprovalTests.Python/issues/135).



  ApprovalTests require Python 3.8 or greater and the following dependencies:



  These dependencies are always required for approvaltests

  <!-- snippet: requirements.prod.required.txt -->
  <a id='snippet-requirements.prod.required.txt'></a>
  ```txt
  pytest>=4.0.0
  empty-files>=0.0.3
  typing_extensions>=3.6.2
  ```
  <sup><a href='/requirements.prod.required.txt#L1-L5' title='Snippet source file'>snippet source</a> | <a href='#snippet-requirements.prod.required.txt' title='Start of snippet'>anchor</a></sup>
  <!-- endSnippet -->



  These dependencies are required if you are going to use the related functionality
  If you want the bare minimum you can use the pypi project
  [approvaltests-minimal](https://pypi.org/project/approvaltests-minimal/)

  <!-- snippet: requirements.prod.extras.txt -->
  <a id='snippet-requirements.prod.extras.txt'></a>
  ```txt
  pyperclip>=1.5.29     # For Clipboard Reporter
  beautifulsoup4>=4.4.0 # For verify_html
  allpairspy>=2.1.0     # For PairwiseCombinations
  mrjob>=0.7.4          # For MrJob
  testfixtures >= 7.1.0 # For verify_logging
  mock >= 5.1.0         # For verify_logging
  ```
  <sup><a href='/requirements.prod.extras.txt#L1-L6' title='Snippet source file'>snippet source</a> | <a href='#snippet-requirements.prod.extras.txt' title='Start of snippet'>anchor</a></sup>
  <!-- endSnippet -->





  The best way to contribute is to [join our weekly mob/ensemble](./docs/Contribute.md)



  Pull requests are welcomed, particularly those accompanied by automated tests.

  To run the self-tests:
  `./run_tests.sh`

  This will run the self-tests on several python versions. We support python 3.8 and above.

  All pull requests will be pre-checked using GitHub actions to execute all these tests. You can see the [results of test
  runs here](https://github.com/approvals/ApprovalTests.Python/actions).


pkgId: 0d87c185c0c1ecc605e1e3805f53b386b6cd088bbae458d305678fab7a046621
name: python-approvaltests-minimal
arch: src
version: 14.1.0
epoch: 0
release: 1
url: https://github.com/approvals/ApprovalTests.Python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-approvaltests-minimal-14.1.0-1.src.rpm
checksum_type: sha256
summary:
  Assertion/verification library to aid testing with the minimal required dependencies + the ability to opt in for the others

description:
[cell repeats an earlier one in this file: 12211 characters]


pkgId: f1af53839da1e6f66a980ded76066bb66015dfa82bd027f6013bc0a707d7a6c8
name: python-appsflyer
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: AppsFlyer S2S events API client
url: https://github.com/fredericojordan/appsflyer-python/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-appsflyer-0.1.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/appsflyer.svg)](https://pypi.python.org/pypi/appsflyer)
  [![Maintainability](https://api.codeclimate.com/v1/badges/6bc700e876085158380d/maintainability)](https://codeclimate.com/github/fredericojordan/appsflyer-python/maintainability)
  [![Test Coverage](https://api.codeclimate.com/v1/badges/6bc700e876085158380d/test_coverage)](https://codeclimate.com/github/fredericojordan/appsflyer-python/test_coverage)



  The documentation for AppsFlyer's Server-to-server events API for mobile can be found [here](https://support.appsflyer.com/hc/en-us/articles/207034486-Server-to-server-events-API-for-mobile-S2S-mobile-).



  Install using [`pip`](https://pypi.org/project/pip/):

  ```shell
  pip install appsflyer
  ```

  Alternatively, you may download the repository and run the installation directly:

  ```shell
  git clone https://github.com/fredericojordan/appsflyer-python.git
  cd appsflyer-python
  python setup.py install
  ```



  To start generating events, we need only a `Client` instance.

  The `Client` needs your AppsFlyer credentials. You can pass these directly to the constructor:

  ```python
  from appsflyer.rest import Client

  app_id = "XXXXXXXXXXXXXXXXX"
  dev_key = "YYYYYYYYYYYYYYYY"

  appsflyer_client = Client(app_id=app_id, dev_key=dev_key)
  ```

  - `app_id`: The app identifier used in the AppsFlyer dashboard. Insert it precisely as it appears on the dashboard.
  - `dev_key`: The authentication token in the header. To get the dev key, in the AppsFlyer dashboard go to: **App Settings > Dev Key**



  To generate an event, simply call `Client.generate_event()` with keyword arguments:

  ```python
  from appsflyer.rest import Client

  app_id = "XXXXXXXXXXXXXXXXX"
  dev_key = "YYYYYYYYYYYYYYYY"

  appsflyer_client = Client(app_id=app_id, dev_key=dev_key)

  appsflyer_client.generate_event(
      appsflyer_id="9999999999999-9999999999999999999",
      customer_user_id="example_customer_id_123",
      ip="199.0.2.1",
      app_version_name="example_version_name",
      event_time="2020-02-25 12:00.000",
      event_name="af_purchase",
      event_currency="ZAR",
      event_value={
          "af_revenue": "1006",
          "af_content_type": "wallets",
          "af_content_id": "15854",
          "af_quantity": "1",
      },
  )
  ```

  The parameters `event_name`, `event_value` and `appsflyer_id` are mandatory.



  Additional data parameters (such as an [IDFA] or [GAID] identifiers) may be sent as keyword arguments:

  ```python
  appsflyer_client.generate_event(
      appsflyer_id="9999999999999-9999999999999999999",
      event_name="af_purchase",
      event_value={"af_revenue": "420"},
      idfa="9876F1SS-2983-3855-27RR-2R626772VFNB",
  )
  ```

  [AppsFlyer API](https://support.appsflyer.com/hc/en-us/articles/207034486-Server-to-server-events-API-for-mobile-S2S-mobile-#payload-parameters) expects one or more of the following device identifiers:

  - `idfa`
  - `idfv`
  - `advertising_id` (GAID)
  - `oaid`
  - `amazon_aid`
  - `imei`

  [IDFA]: https://developer.apple.com/documentation/appstoreconnectapi/advertising_identifier_idfa_declarations
  [GAID]: https://support.google.com/googleplay/android-developer/answer/6048248


pkgId: d214b5a0c11a30d72ffcec53194025d88b0706aa9a3e897a4b25af50ff74bc71
name: python-appstoreconnect
arch: src
version: 0.10.1
epoch: 0
release: 1
summary: A Python wrapper around Apple App Store Api
url: https://ponytech.net/projects/app-store-connect
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-appstoreconnect-0.10.1-1.src.rpm
checksum_type: sha256
description:
  This is a Python wrapper around the **Apple App Store Api** : https://developer.apple.com/documentation/appstoreconnectapi
  So far, it handles token generation / expiration, methods for listing resources and downloading reports.


pkgId: 1eb52a542c912e4e6ce94906ddb096fcdf8de8018929c3a7e25b5f9874f9cd61
name: python-appsync-gremlin
arch: src
version: 0.0.19
epoch: 0
release: 1
summary: A simple Python interface for AppSync resolvers and Gremlin traversals.
url: https://pypi.org/project/appsync-gremlin/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-appsync-gremlin-0.0.19-1.src.rpm
checksum_type: sha256
description:
  Through the AppSync-Gremlin, developers can write powerful queries in GraphQL without having to worry
  too much about the underlying database query language in AWS Neptune. The AppSync-Gremlin provides
  lambda function code that converts query operation types (from GraphQL) to a gremlin traversal.




  - **Property field**: A field corresponding to a property of a vertex in the AWS Neptune graph database. In the below example,
    the `name` field is a property field.
    ```
    {
      User {
          name
          following {
              name
          }
      }
    }
    ```
    > Query 1 : (Vertex Field Example)

  - **Vertex field**: A field corresponding to a vertex in the AWS Neptune graph database. In the above example,
    `location` is a vertex field.

  - **Vertex list fields**: A field corresponding to a list of vertices in the AWS Neptune graph database. In the above example,
    `following` is a vertex list field.

  - **Result set**: An assignment of vertices in the graph to fields in the query. As the database processes the query, new
    result sets may be created (e.g. when traversing edges), and result sets may be discarded when they do not satisfy filters.
    After all parts of the query are processed by the database, all remaining result sets are used to form the query result, by taking their values at all
    properties marked for output (anything in an output scope).

  - **Scope**: The part of a query between any pair of parentheses or curly braces. We often refer to the parts between parentheses as the
    *input scope* and the parts between curly braces as the *output scope* or *payload scope*.
    For example, consider the query
    ```
    {
      User (
          input: {
              name: {
                  eq: "John"
              }
          }
      ) {
          name
          following {
              name
          }
      }
    }
    ```
    > Query 2 : (Scope Example)






  We define a filtering standard on the following scalar fields:

  - **ID**:
    For ID filtering we define the following input for filtering:
    ```
    input IDFilterInput {
      ne: ID
      eq: ID

      in: [ID!]
      not_in: [ID!]
    }
    ```
  - **String**: For String filtering we define the following input for filtering
    ```
    input StringFilterInput {
      ne: String
      eq: String

      in: [String!]
      not_in: [String!]

      contains: String
      not_contains: String

      begins_with: String
      not_begins_with: String

      ends_with: String
      not_ends_with: String
    }
    ```
  - **Int**: For Integer filtering we define the following input for filtering
    ```
    input IntFilterInput {
      ne: Int
      eq: Int
      le: Int
      lt: Int
      ge: Int
      gt: Int

      in: [Int!]
      not_in: [int!]
    }
    ```
  - **Float**: For Float filtering we define the following input for filtering
    ```
    input FloatFilterInput {
      ne: Float
      eq: Float
      le: Float
      lt: Float
      ge: Float
      gt: Float

      in: [Float!]
      not_in: [Float!]
    }
    ```
  - **Boolean**: For Boolean filtering we define the following input for filtering
    ```
    input BooleanFilterInput {
      eq: Boolean
      ne: Boolean
    }
    ```
  - **DateTime**: For DateTime we first have to define our own DateTime input definition. To avoid confusion and to prevent the use of different DateTime formats
    in this interface, we have defined the following `DateTimeInput` to expose the individual date components (such as day, month, year, etc) as well
    as a `formatted` field which is the ISO 8601 string representation of the DateTime value:
    ```
    input DateTimeInput {
      year: Int
      month: Int
      day: Int
      hour: Int
      minute: Int
      second: Int
      formatted: DateTime #custom datetime scalar
    }
    ```
    Using this input definition, we can then create the following input for filtering:
    ```
    input DateTimeFilterInput {
      eq: DateTimeInput
      ne: DateTimeInput

      in: [DateTimeInput!]
      not_in: [DateTimeInput!]

      le: DateTimeInput
      lt: DateTimeInput
      ge: DateTimeInput
      gt: DateTimeInput
    }
    ```

  and a filtering standard on enum types:
  ```
  enum ENUM_FIELD_TYPE {
      E_1
      E_2
      .
      .
      .
      E_n
  }

  input EnumFilterInput {
      eq: ENUM_FIELD_TYPE
      ne: ENUM_FIELD_TYPE
      in: [ENUM_FIELD_TYPE!]
      not_in: [ENUM_FIELD_TYPE!]
  }
  ```

  Note that these standards must be manually implemented in the original GraphQL schema. In future we may devise some method of augmenting a GraphQL schema
  so we don't have to manually implement them.

  Each of these scalar filters has a corresponding filter in the AppSync-Gremlin library. For example, the `StringFilterInput` has
  the scalar filter `string_filter`, etc.



  The AppSync-Gremlin library also allows custom `vertex`, `relationship` and `scalar` filters to be implemented.

  - **Scalar filters**: We define a `scalar` filter as a filter that maps GraphQL fields to Gremlin predicates. Consider an `id_filter`.
    In GraphQL, the `IDFilterInput` has the following fields: `eq, ne, in, not_in`. The Gremlin predicates that correspond to these fields are
    `eq, neq, within, without`. So we construct the following dictionary to map the GraphQL fields to the Gremlin predicates:
    ```python
    from gremlin_python.process.traversal import eq, neq, within, without

    def id_scalar_filter():
        return {
            "eq": eq,
            "ne": neq,
            "in": within,
            "not_in": without
        }
    ```
    By using this dictionary, we can construct a filter function that applies the predicates to some traversal `g`, such that the traverser is
    at some vertices `v` with property `property_name`,
    producing a filtered traversal with the general form ,

          `g' = g.has(property_name, p_1).has(property_name, p_2). ... .has(property_name, p_n)`,

    where `p_1, p_2, ..., p_n` are predicates that are applied to the property `property_name` at `v`.

    The `@scalar_filter` decorator provided by the AppSync-Gremlin library produces a function that takes a `property_name`
    and returns the function described above. So by applying this to the above `id_filter` gives us
    ```python
    from gremlin_python.process.traversal import eq, neq, within, without
    from appsync_gremlin import scalar_filter

    @scalar_filter
    def id__filter():
        return {
            "eq": eq,
            "ne": neq,
            "in": within,
            "not_in": without
        }
    ```
    However, at this stage the filter cannot actually be used, since it requires a `property_name`. The AppSync-Gremlin library
    provides two different ways of applying a `property_name` to a filter. Either we can simply call `id_scalar_filter`
    with out desired `property_name`, or we can apply the `@name` decorator.

    For scalar filters, we advice that the former is used. Since this provides a better generalisation for your scalar filter.
    Since a vertex could implement it's own custom id with property name `"id"` or simply make use of the built in vertex id
    `T.id`.

  - **Vertex filter**: We define a `vertex` filter as a filter that maps GraphQL fields to `scalar` or `relationship` (see below) filters.
    Let us consider the following GraphQL `User` type:
    ```
    type User {
        id: ID!
        email: String!

        name: String
        about: String

        following: [User]!
        followed_by: [User]!
    }
    ```
    We have 4 scalar fields (`id, email, name, about`) and 2 vertex list fields (`following, followed_by`). In the Graph database, we define
    a `User` vertex with properties `email, name, about` (string) and a single relationship `User -> FOLLOWS -> User`. So in a similar fashion to
    a scalar filter, let us define some function that returns a dictionary mapping the GraphQL fields to filters:
    ```python
    from gremlin_python.process.traversal import T
    from appsync_gremlin import id_filter, string_filter

    def user_filter():
        return {
            "id": id_filter(T.id),
            "email": string_filter("email"),
            "name": string_filter("name"),
            "about": string_filter("about"),
            "following": ?,
            "followed_by": ?
        }
    ```
    By using this dictionary we can construct a filter function that applies the `scalar` and `relationship` filters to some
    supplied traversal `g`, such that the traverser is at some vertices `v` which matches the desired filter (in this case the travesers must all be at `User` vertices),
    producing a filtered traversal `g'` with the general form:

          g' = r_1(r_2( ... (r_n(s_1( ... s_m(g) ... ))) ... ))

    where `r_1, r_2, ..., r_n` are relationship filters and `s_1, s_2, ..., s_m` are scalar filters. Note that the order of application of scalar and relationship
    filters does not matter, however, we advice that scalar filters should be applied first as it is more efficient.

    The `@vertex_filter` decorator provided by the AppSync-Gremlin library produces a function that takes a `vertex_label`
    and returns the function described above. So by applying this to the above `user_filter` gives us
    ```python
    from gremlin_python.process.traversal import T
    from appsync_gremlin import id_filter, string_filter, vertex_filter, name

    @name("User")
    @vertex_filter
    def user_filter():
        return {
            "id": id_filter(T.id),
            "email": string_filter("email"),
            "name": string_filter("name"),
            "about": string_filter("about"),
            "following": ?,
            "followed_by": ?
        }
    ```
    Similarly to the `scalar_filter`, we can apply the `@name` decorator to pass the `vertex_label` to the filter function.
    This label should match the label of the `User` vertex in the Graph database.

    With the vertex filter now completely implemented, we can now define our relationship filters (see below). In this case
    we have the relationship filters:
    ```python
    from gremlin_python.process.traversal import T
    from appsync_gremlin import id_filter, string_filter, vertex_filter, name, relationship_filter, RelationshipDirection

    @name("User")
    @vertex_filter
    def user_filter():
        return {
            "id": id_filter(T.id),
            "email": string_filter("email"),
            "name": string_filter("name"),
            "about": string_filter("about"),
            "following": relationship_filter(("FOLLOWS", RelationshipDirection.OUT), user_filter),
            "followed_by": relationship_filter(("FOLLOWS", RelationshipDirection.IN), user_filter)
        }
    ```

  - **Relationship filter**: We define a relationship `R` from some vertex `u` to `v` as `R = (name, direction)`. We can
    filter `u` based on the whether a relationship `R` exists and whether `v` satisfies certain conditions.

    Consider a Gremlin traversal `g`, such that the traverser is at some vertices `u`. We can produce a filtered traversal
    `g'` based on whether the vertices selected by `g` have the relationship `R` and the vertices `v` (the other vertex in `R`) satisfy
    a vertex filter `v_f`. This filtered traversal has the general form:

          g' = g.where(v_f(direction(name))).

    The AppSync-Gremlin library produces a function `relationship_filter` that takes a `relationship`, a tuple consisting of a
    edge label (`name`) and a edge direction (`direction`), and a vertex filter `v_f` for the other vertex in the relationship.

    (See above for example).




  We also implement a pagination standard. Note that pagination can only be applied to vertex list fields.

   For simplicity, we've decided to implement an offset based pagination, as it allows us to make us
  of the Gremlin traversal step `.range(first, offset)`. The stanardised pagination input is defined as follows:
  ```
  input PaginationInput {
    page: Int!
    per_page: Int!
  }
  ```
  We then use `page` and `per_page` to compute `first` and `offset` using the function `get_range`, shown below.
  ```python
  from typing import Tuple

  def get_range(page: int, per_page: int) -> Tuple[int, int]:
      """
      Returns the Gremlin range from page options in the format:
          (first, last)

      :param page: (Integer)
      :param per_page: (Integer)
      :return: (Integer, Integer)
      """

      return (page - 1) * per_page, page * per_page
  ```

  Once the traversal has been submitted and the result set has been return, we format the response into a pagination
  response object. The GraphQL type for this response object for some GraphQL type `Type` is
  ```
  type Type {
      .
      .
      .
  }

  type TypePage {
      data: [Type]!
      page: Int!
      per_page: Int!
      total: Int!
  }
  ```
  where `total` is the `total` number of pages available.



  The AppSync-Gremlin library provides automatic error handling for AppSync. The library does this via the user of the `AppSyncException`.
  The `AppSyncException` requires 3 arguments when instantiated: `error_type`, `error_message` and `error_data` for type
   string, string and dictionary respectively.

  For example, consider the mutation resolver that creates a `User` vertex. Naturally we want to ensure that a user doesn't have a duplicate vertex,
  therefore we must add some form of validation within the resolver code which raises an `AppSyncException` with the relevant error information
  if the validation fails.

  ```python
  from gremlin_python.process.graph_traversal import GraphTraversal
  from appsync_gremlin import ResolverInput, AppSyncException, mutation_resolver

  @mutation_resolver
  def create_user(traversal: GraphTraversal, resolver_input: ResolverInput) -> GraphTraversal:

      username = resolver_input.arguments.get("username")
      user = traversal.V().hasLabel("User").has("username", username)

      if user.hasNext():
          raise AppSyncException(
              error_type="BAD_REQUEST",
              error_message="A user with username {} is already stored in the AWS Neptune database.".format(username),
              error_data={
                  "username": username
              }
          )

      .
      .
      .
  ```

  In order to ensure our `AppSyncException` work's with AppSync, we've had to define a request / response template mapping standard.
  For all resolvers, we must have the request template mapping:
  ```
  {
    "version" : "2018-05-29",
    "operation": "(Invoke|BatchInvoke)",
    "payload": {
      "type_name": String!,
      "field_name": String!,
      "arguments": $util.toJson($context.args),
      "identity": $util.toJson($context.identity),
      "source": $util.toJson($context.source)
    }
  }
  ```
  and the response mapping template:
  ```

      $utils.error($context.result.error.error_message, $context.result.error.error_type, $context.result.error.data)

      $utils.toJson($context.result.data)

  ```



  The AppSync-Gremlin library currently provides 4 different resolver types in the form of function decorators:
  - `vertex_list_field_resolver`
  - `vertex_field_resolver`
  - `calculated_field_resolver`
  - `mutation_resolver`

  The first 3 resolvers are Query based resolvers, that is to say they are designed to be used for resolving GraphQL
  queries.

  Each resolver has the same function type signature:

      resolver : (GraphTraversal, ResolverInput) -> GraphTraversal

  Note the custom `ResolverInput` object. A `ResolverInput` object simply stores the data passed from the Apache VTL
  request mapping template described in the section above. Hence the `ResolverInput` object has the following properties:
   - `type_name`: `(String)`
   - `field_name`: `(String)`
   - `arguments`: `(Dictionary)`
   - `identity` : `(Dictionary | None)`
   - `source`: `(Dictionary | None)`

  Hence these properties can be referenced in the resolvers to build the Gremlin traversals.


pkgId: 0f4ca48bb3b040c042f80ac82ddaf9fb12a1fe933d2cb20148527b589ea36b80
name: python-appsync-router
arch: src
version: 4.0.3
epoch: 0
release: 1
summary: A framework easily routing AppSync requests using AWS Lambda
url: https://github.com/QuiNovas/appsync-router
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-appsync-router-4.0.3-1.src.rpm
checksum_type: sha256
description:
  > **WARNING - Version 4.0.0 is a breaking change from version 3.x.x. Please review the documentation before upgrading**

  A micro-library that allows for the registration of functions corresponding to
  AWS AppSync routes. This allows for cleanly creating a single AWS Lambda datasource
  without large numbers of conditionals to evaluate the called route.


  ```bash
  pip install appsync-router
  ```


  ```python
  from appsync_router import discrete_route, route_event


  from appsync_router.context import Context



  @discrete_route("Query", "getItems")
  def get_items(context: Context) -> list:
      return [1, 2, 3, 4]

  def function_handler(event, context):
      
      return route_event(event)
  ```

  > NOTE - `appsync-router` is designed to be used as a Direct Invocation AWS AppSync
  datasource. If you put a request VTL template in front of it, you must pass in the WHOLE
  $ctx/$context object.



  Each route type has an overloaded signature allowing for simple declaration.

  - `discrete_route` - This discretely routes to a named type and field
  - `multi_route` - This routes to a set of named type/field combinations
  - `pattern_route` - This routes to types/fields that match the type and field regex patterns provided
  - `glob_route` - This routes to the types/fields that match the type and field glob patterns provided


  As seen in the example above, the simplest form of event routing is to call `route_event` with only the event argument. This will do the following:

  1. Determine the route for the event
      1. If no route is found, raise `NoRouteFoundException`
      2. If more than one route is found, use the first route found
  2. Route the event if it is a single context, or map the event to the route if it is multiple contexts

  Many times this will be sufficient. However, this behavior can be modified:
  - Passing a `default_route` of type `Route` to the `route_event` method will call your `default_route` if no route is found
  - Passing `short_circuit=False` to the `route_event` method will cause a `MultipleRoutesFoundException` to be raised in the case of multiple matched routes.
  - Passing an `executor` of type `concurrent.futures.Executor` to the `route_event` method will cause all batch invocations (where the `event` has a list of contexts) to be executed using your executor.


  You may extend the `appsync_router` with your own route types. Any routes that you create must extend from the `appsync_router.routes.Route` class.


pkgId: 12c27d64e281e5ea906b61ab3d32457f31dfee6175901a8a88d1728a0a17cddc
name: python-appthreat-chen
arch: src
version: 2.1.9
epoch: 0
release: 1
summary: Code Hierarchy Exploration Net (chen)
url: https://github.com/AppThreat/chen
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-appthreat-chen-2.1.9-1.src.rpm
checksum_type: sha256
description:
  annotations      | List annotations                                                          | annotations                                                   |
  callTree         | Show call tree for the given method                                       | callTree(method full name)                                    |
  close            | Close project by name                                                     | close(projectName)                                            |
  declarations     | List declarations                                                         | declarations                                                  |
  distance         | Show graph edit distance from the source method to the comparison methods | distance(source method iterator, comparison method iterators) |
  exit             | Exit the REPL                                                             |                                                               |
  files            | List files                                                                | files                                                         |
  importAtom       | Create new project from existing atom                                     | importAtom("app.atom")                                        |
  importCode       | Create new project from code                                              | importCode("example.jar")                                     |
  imports          | List imports                                                              | imports                                                       |
  methods          | List methods                                                              | methods('Methods', includeCalls=true, tree=true)              |
  sensitive        | List sensitive literals                                                   | sensitive                                                     |
  showSimilar      | Show methods similar to the given method                                  | showSimilar(method full name)                                 |
  summary          | Display summary information                                               | summary                                                       |
  reachables       | Show reachable flows from a source to sink. Default source: framework-input and sink: framework-output | reachables                       |
  cryptos          | Show reachable flows from a source to sink. Default source: crypto-algorithm and sink: crypto-generate | cryptos                          |
  ```
  Refer to the documentation site to learn more about the commands.

  - C/C++
  - H (C/C++ Header files alone)
  - Java (Requires compilation) - 8 to 21
  - Jar
  - Android APK (Requires Android SDK. Set the environment variable `ANDROID_HOME`)
  - JavaScript
  - TypeScript
  - Python
  - PHP (Requires PHP >= 7.0. Supports PHP 5.2 to 8.3)


  You might see errors like this in chennai console.
  ```shell
  chennai> help
  -- [E006] Not Found Error: -----------------------------------------------------
  1 |help
    |^^^^
    |Not found: help
    |-----------------------------------------------------------------------------
    | Explanation (enabled by `-explain`)
    |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    | The identifier for `help` is not bound, that is,
    | no declaration for this identifier can be found.
    | That can happen, for example, if `help` or its declaration has either been


pkgId: 2429d7b51ae34850c1736514793db1428f3470538276f8b7e48612f8361d6976
name: python-appthreat-depscan
arch: src
version: 4.2.3
epoch: 0
release: 1
url: https://github.com/appthreat/dep-scan
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-appthreat-depscan-4.2.3-1.src.rpm
checksum_type: sha256
summary:
  Fully open-source security audit for project dependencies based on known vulnerabilities and advisories.

description:
  --type python,depscan,credscan
  ```
  This approach should work for all CI environments supported by scan.

  ```bash
  sudo npm install -g @cyclonedx/cdxgen
  pip install appthreat-depscan
  ```
  This would install two commands called `cdxgen` and `scan`.
  You can invoke the scan command directly with the various options.
  ```bash
  cd <project to scan>
  depscan --src $PWD --reports-dir $PWD/reports
  ```
  Full list of options are below:
  ```bash
  usage: depscan [-h] [--no-banner] [--cache] [--cache-os] [--sync] [--suggest] [--risk-audit] [--private-ns PRIVATE_NS] [-t PROJECT_TYPE] [--bom BOM] -i SRC_DIR
                [--reports-dir REPORTS_DIR] [--no-error] [--deep]
    -h, --help            show this help message and exit
    --no-banner           Do not display banner
    --cache               Cache vulnerability information in platform specific user_data_dir
    --cache-os            Cache OS vulnerability information in platform specific user_data_dir
    --sync                Sync to receive the latest vulnerability data. Should have invoked cache first.
    --risk-audit          Perform package risk audit (slow operation). Npm only.
    --private-ns PRIVATE_NS
                          Private namespace to use while performing oss risk audit. Private packages should not be available in public registries by default. Comma
                          separated values accepted.
    -t PROJECT_TYPE, --type PROJECT_TYPE
                          Override project type if auto-detection is incorrect
    --bom BOM             Examine using the given Software Bill-of-Materials (SBoM) file in CycloneDX format. Use cdxgen command to produce one.
    -i SRC_DIR, --src SRC_DIR
                          Source directory
    --reports-dir REPORTS_DIR
                          Reports directory
    --no-error            Continue on error to prevent build from breaking
    --deep                Perform deep scan by passing this --deep argument to cdxgen. Useful while scanning docker images and OS packages.
    --no-universal        Depscan would attempt to perform a single universal scan instead of individual scans per language type.
    --no-vuln-table       Do not print the table with the full list of vulnerabilities. This can help reduce console output.
    --threatdb-server THREATDB_SERVER
                          ThreatDB server url. Eg: https://api.sbom.cx
    --threatdb-username THREATDB_USERNAME
                          ThreatDB username
    --threatdb-password THREATDB_PASSWORD
                          ThreatDB password
    --threatdb-token THREATDB_TOKEN
                          ThreatDB token for token based submission
  ```

  Scan `latest` tag of the container `shiftleft/scan-slim`
  ```bash
  depscan --no-error --cache --src shiftleft/scan-slim -o containertests/depscan-scan.json -t docker
  ```
  Include `license` to the type to perform license audit.
  ```bash
  depscan --no-error --cache --src shiftleft/scan-slim -o containertests/depscan-scan.json -t docker,license
  ```
  You can also specify the image using the sha256 digest
  ```bash
  depscan --no-error --src redmine@sha256:a5c5f8a64a0d9a436a0a6941bc3fb156be0c89996add834fe33b66ebeed2439e -o containertests/depscan-redmine.json -t docker
  ```
  You can also save container images using docker or podman save command and pass the archive to depscan for scanning.
  ```bash
  docker save -o /tmp/scanslim.tar shiftleft/scan-slim:latest

  depscan --no-error --src /tmp/scanslim.tar -o reports/depscan-scan.json -t docker
  ```
  Refer to the docker tests under GitHub action workflow for this repo for more examples.

  `ghcr.io/appthreat/dep-scan` or `public.ecr.aws/appthreat/dep-scan:latest` container image can be used to perform the scan.
  To scan with default settings
  ```bash
  docker run --rm -v $PWD:/app ghcr.io/appthreat/dep-scan --src /app --reports-dir /app/reports
  ```
  Using AWS public ECR image
  ```bash
  docker run --rm -v $PWD:/app public.ecr.aws/appthreat/dep-scan --src /app --reports-dir /app/reports
  ```
  To scan with custom environment variables based configuration
  ```bash
  docker run --rm \
      -e VDB_HOME=/db \
      -e NVD_START_YEAR=2010 \
      -e GITHUB_PAGE_COUNT=5 \
      -e GITHUB_TOKEN=<token> \
      -v /tmp:/db \
      -v $PWD:/app ghcr.io/appthreat/dep-scan --src /app --reports-dir /app/reports
  ```
  In the above example, `/tmp` is mounted as `/db` into the container. This directory is then specified as `VDB_HOME` for caching the vulnerability information. This way the database can be cached and reused to improve performance.

  dep-scan uses [cdxgen](https://github.com/CycloneDX/cdxgen) command internally to create Software Bill-of-Materials (SBoM) file for the project. This is then used for performing the scans.
  The following projects and package-dependency format is supported by cdxgen.
  | Language                 | Package format                                                                          |
  | ------------------------ | --------------------------------------------------------------------------------------- |
  | node.js                  | package-lock.json, pnpm-lock.yaml, yarn.lock, rush.js, bower.json, .min.js              |
  | java                     | maven (pom.xml [1]), gradle (build.gradle, .kts), scala (sbt), bazel                    |
  | php                      | composer.lock                                                                           |
  | python                   | setup.py, requirements.txt [2], Pipfile.lock, poetry.lock, bdist_wheel, .whl, .egg-info |
  | go                       | binary, go.mod, go.sum, Gopkg.lock                                                      |
  | ruby                     | Gemfile.lock, gemspec                                                                   |
  | rust                     | binary, Cargo.toml, Cargo.lock                                                          |
  | .Net                     | .csproj, packages.config, project.assets.json [3], packages.lock.json, .nupkg           |
  | dart                     | pubspec.lock, pubspec.yaml                                                              |
  | haskell                  | cabal.project.freeze                                                                    |
  | elixir                   | mix.lock                                                                                |
  | c/c++                    | conan.lock, conanfile.txt                                                               |
  | clojure                  | Clojure CLI (deps.edn), Leiningen (project.clj)                                         |
  | docker / oci image       | All supported languages and Linux OS packages                                           |
  | GitHub Actions Workflows | .github/workflows/\*.yml                                                                |
  | Jenkins Plugins          | .hpi files                                                                              |
  | YAML manifests           | docker-compose, kubernetes, kustomization, skaffold, tekton etc                         |
  **NOTE**
  The docker image for dep-scan currently doesn't bundle suitable java and maven commands required for bom generation. To workaround this limitation, you can -
  1. Use python-based execution from a VM containing the correct versions for java, maven and gradle.
  2. Generate the bom file by invoking `cdxgen` command locally and subsequently passing this to `dep-scan` via the `--bom` argument.


  Refer to [this example yaml](https://github.com/AppThreat/WebGoat/blob/develop/azure-pipelines.yml#L33) configuration for integrating dep-scan with Azure Pipelines. The build step would perform the scan and display the report inline as shown below:
  ![Azure DevOps integration](docs/dep-scan-azure.png)

  This tool can be used with GitHub Actions using this [action](https://github.com/marketplace/actions/dep-scan).
  This repo self-tests itself with both sast-scan and dep-scan! Check the GitHub [workflow file](https://github.com/AppThreat/dep-scan/blob/master/.github/workflows/pythonapp.yml) of this repo.
  ```yaml
  - name: Self dep-scan
    uses: AppThreat/dep-scan-action@master
    env:
      VDB_HOME: ${{ github.workspace }}/db
      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
  ```

  The following environment variables can be used to customise the behaviour.
  - VDB_HOME - Directory to use for caching database. For docker based execution, this directory should get mounted as a volume from the host
  - NVD_START_YEAR - Default: 2018. Supports upto 2002
  - GITHUB_PAGE_COUNT - Default: 2. Supports upto 20

  To download security advisories from GitHub, a personal access token with the following scope is necessary.
  - read:packages
  ```bash
  export GITHUB_TOKEN="<PAT token>"
  ```

  Fix version for each vulnerability is retrieved from the sources. Sometimes, there might be known vulnerabilities in the fix version reported. Eg: in the below screenshot the fix versions suggested for jackson-databind might contain known vulnerabilities.
  ![Normal mode](docs/depscan-normal.png)
  By passing an argument `--suggest` it is possible to force depscan to recheck the fix suggestions. This way the suggestion becomes more optimal for a given package group.
  ![Suggest mode](docs/depscan-suggest.png)
  Notice, how the new suggested version is `2.9.10.5` which is an optimal fix version. Please note that the optimal fix version may not be the appropriate version for your application based on compatibility.

  `--risk-audit` argument enables package risk audit. Currently, only npm and pypi packages are supported in this mode. A number of risk factors are identified and assigned weights to compute a final risk score. Packages that then exceed a maximum risk score (`config.pkg_max_risk_score`) are presented in a table.
  Use `--private-ns` to specify the private package namespace that should be checked for dependency confusion type issues where a private package is available on public npm/pypi registry.
  For example, to check if private packages with namespaces @appthreat and @shiftleft are not accidentally made public, use the below argument.
  ```
  --private-ns appthreat,shiftleft
  ```
  | Risk category                  | Default Weight | Reason                                                                                                                                                                                                     |
  | ------------------------------ | -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  | pkg_private_on_public_registry | 4              | Private package is available on a public registry                                                                                                                                                          |
  | pkg_min_versions               | 2              | Packages with less than 3 versions represent an extreme where they could be either super stable or quite recent. Special heuristics are applied to ignore older stable packages                            |
  | mod_create_min_seconds         | 1              | Less than 12 hours difference between modified and creation time. This indicates that the upload had a defect that had to be rectified immediately. Sometimes, such a rapid update could also be malicious |
  | latest_now_min_seconds         | 0.5            | Less than 12 hours difference between the latest version and the current time. Depending on the package such a latest version may or may not be desirable                                                  |
  | latest_now_max_seconds         | 0.5            | Package versions that are over 6 years old are in use. Such packages might have vulnerable dependencies that are known or yet to be found                                                                  |
  | pkg_min_maintainers            | 2              | Package has less than 2 maintainers. Many opensource projects have only 1 or 2 maintainers so special heuristics are used to ignore older stable packages                                                  |
  | pkg_min_users                  | 0.25           | Package has less than 2 npm users                                                                                                                                                                          |
  | pkg_install_scripts            | 2              | Package runs a custom pre or post installation scripts. This is often malicious and a downside of npm.                                                                                                     |
  | pkg_node_version               | 0.5            | Package supports outdated version of node such as 0.8, 0.10, 4 or 6.x. Such projects might have prototype pollution or closure related vulnerabilities                                                     |
  | pkg_scope                      | 4 or 0.5       | Packages that are used directly in the application (required scope) gets a score with a weight of 4. Optional packages get a score of 0.25                                                                 |
  | deprecated                     | 1              | Latest version is deprecated                                                                                                                                                                               |
  Refer to `pkg_query.py::get_category_score` method for the risk formula.

  A parameter called `created_now_quarantine_seconds` is used to identify packages that are safely past the quarantine period (1 year). Certain risks such as `pkg_min_versions` and `pkg_min_maintainers` are suppressed for packages past the quarantine period. This adjustment helps reduce noise since it is unlikely that a malicious package can exist in a registry unnoticed for over a year.

  All parameters can be customized by using environment variables. For eg:
  export PKG_MIN_VERSIONS=4 to increase and set the minimum versions category to 4.

  By passing `-t os`, depscan can generate an SBoM for a live operating system or a VM with OS packages and kernel information. Optionally, pass the argument `--deep` to generate an SBoM with both OS and application packages and to check for application vulnerabilities.
  All OS packages.
  ```bash
  depscan -t os -i . -o reports/depscan.json
  ```
  All OS and application packages.
  ```bash
  depscan -t os --deep -i . -o reports/depscan.json
  ```

  dep-scan can scan the dependencies for any license limitations and report them directly on the console log. To enable license scanning set the environment variable `FETCH_LICENSE` to `true`.
  ```
  export FETCH_LICENSE=true
  ```
  The license data is sourced from choosealicense.com and is quite limited. If the license of a given package cannot be reliably matched against this list it will get silently ignored to reduce any noise. This behavior could change in the future once the detection logic gets improved.
  ![License scan](docs/license-scan.png)

  dep-scan could auto-detect most cloud applications and Kubernetes manifest files. Pass the argument `-t yaml-manifest` to manually specify the type.

  [Dependency Check](https://github.com/jeremylong/DependencyCheck) is considered the industry standard for open-source dependency scanning. After personally using this great product for many years, I decided to write my own from scratch, partly as a dedication to this project. By using a streaming database based on msgpack and using JSON schema, dep-scan is more performant than dependency check in CI environments. Plus, with support for GitHub advisory source and grafeas report export and submission, dep-scan is on track to become a next-generation dependency audit tool.
  Several other tools piggyback on Sonatype [ossindex](https://ossindex.sonatype.org/) API server. For some reason, I always felt uncomfortable letting a commercial company track the usage of various projects worldwide. dep-scan is, therefore, 100% private and guarantees never to perform any tracking!

  These mature projects are considered the benchmark for container, filesystem and registry scanning. dep-scan is yet to be benchmarked against these projects for results and performance. dep-scan even uses Trivy for container SBoM generation via cdxgen-binary-plugins, although this would change in the future. I aspire to make dep-scan outperform these projects with simplicity and **actionable results**. The CVE insights offered by dep-scan could be used for prioritization to reduce the number of package updates and container rebuilds.

  The developers could be reached via the [discord](https://discord.gg/DCNxzaeUpd) channel.


pkgId: 2f749be3a33959a2b95692befe0812d5b0057fc0ec518a27ecf7ce4d720e6c02
name: python-appthreat-vulnerability-db
arch: src
version: 6.1.0
epoch: 0
release: 1
url: https://github.com/appthreat/vulnerability-db
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-appthreat-vulnerability-db-6.1.0-1.src.rpm
checksum_type: sha256
summary:
  AppThreat's vulnerability database and package search library with a built-in sqlite based storage. OSV, CVE, GitHub, npm are the primary sources of vulnerabilities.

description:
  This repo is a vulnerability database and package search for sources such as AppThreat vuln-list, OSV, NVD, and GitHub. Vulnerability data are downloaded from the sources and stored in a sqlite based storage with indexes to allow offline access and efficient searches.



  A good vulnerability database must have the following properties:

  - Accuracy
  - Easy to [download](#download-pre-built-database-recommended), [integrate](./INTEGRATION.md), and use
  - Performance

  Multiple upstream sources are used by vdb to improve accuracy and reduce false negatives. SQLite database containing data in CVE 5.0 schema format is precompiled and distributed as files via ghcr to simplify download. With automatic purl prefix generation even for git repos, searches on the database can be performed with purl, cpe, or even http git url string. Every row in the database uses an open specification such as CVE 5.0 or Package URL (purl and vers) thus preventing the possibility of vendor lock-in.



  - Linux [vuln-list](https://github.com/appthreat/vuln-list) (Forked from AquaSecurity)
  - OSV (1)
  - NVD
  - GitHub

  1 - We exclude Linux and oss-fuzz feeds by default. Set the environment variable `OSV_INCLUDE_FUZZ` to include them.



  - AlmaLinux
  - Debian
  - Alpine
  - Amazon Linux
  - Arch Linux
  - RHEL/CentOS
  - Rocky Linux
  - Ubuntu
  - OpenSUSE
  - Photon
  - Chainguard
  - Wolfi OS



  ```shell
  pip install appthreat-vulnerability-db>=6.0.1
  ```

  To install vdb with optional dependencies such as `oras` use the `[oras]` or `[all]` dependency group.

  ```shell
  pip install appthreat-vulnerability-db[all]
  ```

  **NOTE:** VDB v6 is a major rewrite to use SQLite database. Current users of depscan v5 must continue using version 5.6.x

  ```shell
  pip install appthreat-vulnerability-db==5.6.7
  ```



  This package is ideal as a library for managing vulnerabilities. This is used by [owasp-dep-scan](http://github.com/owasp-dep-scan/dep-scan), a free open-source dependency audit tool. However, there is a limited cli capability available with few features to test this tool directly.



  To download a pre-built SQLite database ([refreshed](https://github.com/AppThreat/vdb/actions) every 6 hours) containing all application vulnerabilities (~ 700MB). This step is recommended for all users.

  ```shell

  vdb --download-image
  ```

  You can execute this command daily or when a fresh database is required.

  To perform containers and OS scans, download the full image (~ 7.5GB) which includes all application and OS vulnerabilities.

  ```
  vdb --download-full-image
  ```



  Using [ORAS cli](https://oras.land/) might be slightly faster.

  ```
  export VDB_HOME=$HOME/vdb
  oras pull ghcr.io/appthreat/vdbxz:v6 -o $VDB_HOME
  tar -xvf *.tar.xz
  rm *.tar.xz
  ```

  Use any sqlite browser or cli tools to load and query the two databases.

  **data.index.vdb6** - index db with purl prefix and vers

  <img src="./docs/index-vdb6.png" alt="index" width="400">

  **data.vdb6** - Contains source data in CVE 5.0 format stored as a jsonb blob.

  <img src="./docs/vdb6.png" alt="database" width="400">



  Cache application vulnerabilities

  ```shell
  vdb --cache
  ```

  The typical size of this database is over 700 MB.

  Cache from just [OSV](https://osv.dev)

  ```shell
  vdb --cache --only-osv
  ```

  It is possible to customize the cache behavior by increasing the historic data period to cache by setting the following environment variables.

  - NVD_START_YEAR - Default: 2018. Supports up to 2002
  - GITHUB_PAGE_COUNT - Default: 2. Supports up to 20

  Cache application and OS vulnerabilities

  ```shell
  vdb --cache-os
  ```

  Note the size of the database with OS vulnerabilities is over 7.5 GB. It is possible to ignore/exlude specific OS distros using environment variables.

  Example to ignore almalinux and ubuntu data from getting included, set the below environment variables:

  ```shell
  export VDB_IGNORE_ALMALINUX=true
  export VDB_IGNORE_UBUNTU=true
  ```

  Refer to the variable `LINUX_DISTRO_VULN_LIST_PATHS` in [config.py](./vdb/lib/config.py) for the full list of distro strings supported.



  ```shell
  usage: vdb [-h] [--clean] [--cache] [--cache-os] [--only-osv] [--only-aqua] [--only-ghsa] [--search SEARCH] [--list-malware] [--bom BOM_FILE]

  AppThreat's vulnerability database and package search library with a built-in sqlite based storage.

  options:
    -h, --help       show this help message and exit
    --clean          Clear the vulnerability database cache from platform specific user_data_dir.
    --cache          Cache vulnerability information in platform specific user_data_dir.
    --cache-os       Cache OS vulnerability information in platform specific user_data_dir.
    --only-osv       Use only OSV as the source. Use with --cache.
    --only-aqua      Use only Aqua vuln-list as the source. Use with --cache.
    --only-ghsa      Use only recent ghsa as the source. Use with --cache.
    --search SEARCH  Search for the package or CVE ID in the database. Use purl, cpe, or git http url.
    --list-malware   List latest malwares with CVE ID beginning with MAL-.
    --bom BOM_FILE   Search for packages in the CycloneDX BOM file.
    --download-image      Downloaded pre-created vdb image to platform specific user_data_dir. Application vulnerabilities only.
    --download-full-image
                          Downloaded pre-created vdb image to platform specific user_data_dir. All vulnerabilities including OS.
    --print-vdb-metadata  Display metadata about the current vdb in user_data_dir.
  ```



  It is possible to perform a range of searches using the cli.

  ```shell
  vdb --search pkg:pypi/xml2dict@0.2.2


  vdb --search pkg:pypi/xml2dict


  vdb --search "pkg:swift/github.com/vapor/vapor@4.39.0"

  vdb --search "pkg:swift/vapor/vapor@4.89.0"


  vdb --search "cpe:2.3:a:npm:gitblame:*:*:*:*:*:*:*:*"


  vdb --search "npm:gitblame:0.0.1"


  vdb --search CVE-2024-25169


  vdb --search CVE-2024-%


  vdb --search "https://github.com/electron/electron"


  vdb --bom bom.json
  ```



  To list malware entries with the `MAL-` prefix, use the following command.

  ```shell
  vdb --list-malware
  ```



  Refer to [cli.py](./vdb/cli.py) for usage. Below is a sample code snippet.

  ```python
  from vdb.lib import config, db6 as db_lib, search
  from vdb.lib.cve_model import CVE


  results = search.search_by_any("purl or cpe or url", with_data=True)


  from vdb.lib.orasclient import download_image

  download_image(config.VDB_DATABASE_URL, config.DATA_DIR)


  if db_lib.needs_update():
      print("Database needs to be updated")
      download_image(...)
  ```



  MIT


pkgId: f5682a8f6f64b141f3a8f9eaf20052a94543d4efa50f8e7909718a8807e0a395
name: python-appthreat-vulnerability-db
arch: src
version: 6.1.1
epoch: 0
release: 1
url: https://github.com/appthreat/vulnerability-db
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-appthreat-vulnerability-db-6.1.1-1.src.rpm
checksum_type: sha256
summary:
  AppThreat's vulnerability database and package search library with a built-in sqlite based storage. OSV, CVE, GitHub, npm are the primary sources of vulnerabilities.

description:
  This repo is a vulnerability database and package search for sources such as AppThreat vuln-list, OSV, NVD, and GitHub. Vulnerability data are downloaded from the sources and stored in a sqlite based storage with indexes to allow offline access and efficient searches.



  A good vulnerability database must have the following properties:

  - Accuracy
  - Easy to [download](#download-pre-built-database-recommended), [integrate](./INTEGRATION.md), and use
  - Performance

  Multiple upstream sources are used by vdb to improve accuracy and reduce false negatives. SQLite database containing data in CVE 5.0 schema format is precompiled and distributed as files via ghcr to simplify download. With automatic purl prefix generation even for git repos, searches on the database can be performed with purl, cpe, or even http git url string. Every row in the database uses an open specification such as CVE 5.0 or Package URL (purl and vers) thus preventing the possibility of vendor lock-in.



  - Linux [vuln-list](https://github.com/appthreat/vuln-list) (Forked from AquaSecurity)
  - OSV (1)
  - NVD
  - GitHub

  1 - We exclude Linux and oss-fuzz feeds by default. Set the environment variable `OSV_INCLUDE_FUZZ=true` to include them.
  2 - Malware feeds are included by default, thus increasing the db size slightly. Set the environment variable `OSV_EXCLUDE_MALWARE=true` to exclude them.



  - AlmaLinux
  - Debian
  - Alpine
  - Amazon Linux
  - Arch Linux
  - RHEL/CentOS
  - Rocky Linux
  - Ubuntu
  - OpenSUSE
  - Photon
  - Chainguard
  - Wolfi OS



  ```shell
  pip install appthreat-vulnerability-db>=6.0.1
  ```

  To install vdb with optional dependencies such as `oras` use the `[oras]` or `[all]` dependency group.

  ```shell
  pip install appthreat-vulnerability-db[all]
  ```

  **NOTE:** VDB v6 is a major rewrite to use SQLite database. Current users of depscan v5 must continue using version 5.6.x

  ```shell
  pip install appthreat-vulnerability-db==5.6.7
  ```



  This package is ideal as a library for managing vulnerabilities. This is used by [owasp-dep-scan](http://github.com/owasp-dep-scan/dep-scan), a free open-source dependency audit tool. However, there is a limited cli capability available with few features to test this tool directly.



  To download a pre-built SQLite database ([refreshed](https://github.com/AppThreat/vdb/actions) every 6 hours) containing all application vulnerabilities (~ 700MB). This step is recommended for all users.

  ```shell

  vdb --download-image
  ```

  You can execute this command daily or when a fresh database is required.

  To perform containers and OS scans, download the full image (~ 7.5GB) which includes all application and OS vulnerabilities.

  ```
  vdb --download-full-image
  ```



  Using [ORAS cli](https://oras.land/) might be slightly faster.

  ```
  export VDB_HOME=$HOME/vdb
  oras pull ghcr.io/appthreat/vdbxz:v6 -o $VDB_HOME
  tar -xvf *.tar.xz
  rm *.tar.xz
  ```

  Use any sqlite browser or cli tools to load and query the two databases.

  **data.index.vdb6** - index db with purl prefix and vers

  <img src="./docs/index-vdb6.png" alt="index" width="400">

  **data.vdb6** - Contains source data in CVE 5.0 format stored as a jsonb blob.

  <img src="./docs/vdb6.png" alt="database" width="400">



  Cache application vulnerabilities

  ```shell
  vdb --cache
  ```

  The typical size of this database is over 700 MB.

  Cache from just [OSV](https://osv.dev)

  ```shell
  vdb --cache --only-osv
  ```

  It is possible to customize the cache behavior by increasing the historic data period to cache by setting the following environment variables.

  - NVD_START_YEAR - Default: 2018. Supports up to 2002
  - GITHUB_PAGE_COUNT - Default: 2. Supports up to 20

  Cache application and OS vulnerabilities

  ```shell
  vdb --cache-os
  ```

  Note the size of the database with OS vulnerabilities is over 7.5 GB. It is possible to ignore/exlude specific OS distros using environment variables.

  Example to ignore almalinux and ubuntu data from getting included, set the below environment variables:

  ```shell
  export VDB_IGNORE_ALMALINUX=true
  export VDB_IGNORE_UBUNTU=true
  ```

  Refer to the variable `LINUX_DISTRO_VULN_LIST_PATHS` in [config.py](./vdb/lib/config.py) for the full list of distro strings supported.



  ```shell
  usage: vdb [-h] [--clean] [--cache] [--cache-os] [--only-osv] [--only-aqua] [--only-ghsa] [--search SEARCH] [--list-malware] [--bom BOM_FILE]

  AppThreat's vulnerability database and package search library with a built-in sqlite based storage.

  options:
    -h, --help       show this help message and exit
    --clean          Clear the vulnerability database cache from platform specific user_data_dir.
    --cache          Cache vulnerability information in platform specific user_data_dir.
    --cache-os       Cache OS vulnerability information in platform specific user_data_dir.
    --only-osv       Use only OSV as the source. Use with --cache.
    --only-aqua      Use only Aqua vuln-list as the source. Use with --cache.
    --only-ghsa      Use only recent ghsa as the source. Use with --cache.
    --search SEARCH  Search for the package or CVE ID in the database. Use purl, cpe, or git http url.
    --list-malware   List latest malwares with CVE ID beginning with MAL-.
    --bom BOM_FILE   Search for packages in the CycloneDX BOM file.
    --download-image      Downloaded pre-created vdb image to platform specific user_data_dir. Application vulnerabilities only.
    --download-full-image
                          Downloaded pre-created vdb image to platform specific user_data_dir. All vulnerabilities including OS.
    --print-vdb-metadata  Display metadata about the current vdb in user_data_dir.
  ```



  It is possible to perform a range of searches using the cli.

  ```shell
  vdb --search pkg:pypi/xml2dict@0.2.2


  vdb --search pkg:pypi/xml2dict


  vdb --search "pkg:swift/github.com/vapor/vapor@4.39.0"

  vdb --search "pkg:swift/vapor/vapor@4.89.0"


  vdb --search "cpe:2.3:a:npm:gitblame:*:*:*:*:*:*:*:*"


  vdb --search "npm:gitblame:0.0.1"


  vdb --search CVE-2024-25169


  vdb --search CVE-2024-%


  vdb --search "https://github.com/electron/electron"


  vdb --bom bom.json
  ```



  To list malware entries with the `MAL-` prefix, use the following command.

  ```shell
  vdb --list-malware
  ```



  Refer to [cli.py](./vdb/cli.py) for usage. Below is a sample code snippet.

  ```python
  from vdb.lib import config, db6 as db_lib, search
  from vdb.lib.cve_model import CVE


  results = search.search_by_any("purl or cpe or url", with_data=True)


  from vdb.lib.orasclient import download_image

  download_image(config.VDB_DATABASE_URL, config.DATA_DIR)


  if db_lib.needs_update():
      print("Database needs to be updated")
      download_image(...)
  ```



  MIT


pkgId: 416fe2e213e85d4da1d1aa4a7c4ad43703f97467c48ad8cf951b4ad1adf77f0d
name: python-appthreat-vulnerability-db
arch: src
version: 6.2.1
epoch: 0
release: 1
url: https://github.com/appthreat/vulnerability-db
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-appthreat-vulnerability-db-6.2.1-1.src.rpm
checksum_type: sha256
summary:
  AppThreat's vulnerability database and package search library with a built-in sqlite based storage. OSV, CVE, GitHub, npm are the primary sources of vulnerabilities.

description:
  This repo is a vulnerability database and package search for sources such as AppThreat vuln-list, OSV, NVD, and GitHub. Vulnerability data are downloaded from the sources and stored in a sqlite based storage with indexes to allow offline access and efficient searches.



  A good vulnerability database must have the following properties:

  - Accuracy
  - Easy to [download](#download-pre-built-database-recommended), [integrate](./INTEGRATION.md), and use
  - Performance

  Multiple upstream sources are used by vdb to improve accuracy and reduce false negatives. SQLite database containing data in CVE 5.1 schema format is precompiled and distributed as files via ghcr to simplify download. With automatic purl prefix generation even for git repos, searches on the database can be performed with purl, cpe, or even http git url string. Every row in the database uses an open specification such as CVE 5.0 or Package URL (purl and vers) thus preventing the possibility of vendor lock-in.



  - Linux [vuln-list](https://github.com/appthreat/vuln-list) (Forked from AquaSecurity)
  - OSV (1)
  - NVD
  - GitHub

  1 - We exclude Linux and oss-fuzz feeds by default. Set the environment variable `OSV_INCLUDE_FUZZ=true` to include them.
  2 - Malware feeds are included by default, thus increasing the db size slightly. Set the environment variable `OSV_EXCLUDE_MALWARE=true` to exclude them.



  - AlmaLinux
  - Debian
  - Alpine
  - Amazon Linux
  - Arch Linux
  - RHEL/CentOS
  - Rocky Linux
  - Ubuntu
  - OpenSUSE
  - Photon
  - Chainguard
  - Wolfi OS



  ```shell
  pip install appthreat-vulnerability-db>=6.2.0
  ```

  To install vdb with optional dependencies such as `oras` use the `[oras]` or `[all]` dependency group.

  ```shell
  pip install appthreat-vulnerability-db[all]
  ```

  **NOTE:** VDB v6 is a major rewrite to use SQLite database. Current users of depscan v5 must continue using version 5.8.x

  ```shell
  pip install appthreat-vulnerability-db==5.8.0
  ```



  This package is ideal as a library for managing vulnerabilities. This is used by [owasp-dep-scan](http://github.com/owasp-dep-scan/dep-scan), a free open-source dependency audit tool. However, there is a limited cli capability available with few features to test this tool directly.



  To download a pre-built SQLite database ([refreshed](https://github.com/AppThreat/vdb/actions) every 6 hours) containing all application vulnerabilities (~ 700MB). This step is recommended for all users.

  ```shell

  vdb --download-image
  ```

  You can execute this command daily or when a fresh database is required.

  To perform containers and OS scans, download the full image (~ 7.5GB) which includes all application and OS vulnerabilities.

  ```
  vdb --download-full-image
  ```



  Using [ORAS cli](https://oras.land/) might be slightly faster.

  ```
  export VDB_HOME=$HOME/vdb
  oras pull ghcr.io/appthreat/vdbxz:v6 -o $VDB_HOME
  tar -xvf *.tar.xz
  rm *.tar.xz
  ```

  Use any sqlite browser or cli tools to load and query the two databases.

  **data.index.vdb6** - index db with purl prefix and vers

  <img src="./docs/index-vdb6.png" alt="index" width="400">

  **data.vdb6** - Contains source data in CVE 5.1 format stored as a jsonb blob.

  <img src="./docs/vdb6.png" alt="database" width="400">



  Cache application vulnerabilities

  ```shell
  vdb --cache
  ```

  The typical size of this database is over 700 MB.

  Cache from just [OSV](https://osv.dev)

  ```shell
  vdb --cache --only-osv
  ```

  It is possible to customize the cache behavior by increasing the historic data period to cache by setting the following environment variables.

  - NVD_START_YEAR - Default: 2018. Supports up to 2002
  - GITHUB_PAGE_COUNT - Default: 2. Supports up to 20

  Cache application and OS vulnerabilities

  ```shell
  vdb --cache-os
  ```

  Note the size of the database with OS vulnerabilities is over 7.5 GB. It is possible to ignore/exlude specific OS distros using environment variables.

  Example to ignore almalinux and ubuntu data from getting included, set the below environment variables:

  ```shell
  export VDB_IGNORE_ALMALINUX=true
  export VDB_IGNORE_UBUNTU=true
  ```

  Refer to the variable `LINUX_DISTRO_VULN_LIST_PATHS` in [config.py](./vdb/lib/config.py) for the full list of distro strings supported.



  ```shell
  usage: vdb [-h] [--clean] [--cache] [--cache-os] [--only-osv] [--only-aqua] [--only-ghsa] [--search SEARCH] [--list-malware] [--bom BOM_FILE]

  AppThreat's vulnerability database and package search library with a built-in sqlite based storage.

  options:
    -h, --help       show this help message and exit
    --clean          Clear the vulnerability database cache from platform specific user_data_dir.
    --cache          Cache vulnerability information in platform specific user_data_dir.
    --cache-os       Cache OS vulnerability information in platform specific user_data_dir.
    --only-osv       Use only OSV as the source. Use with --cache.
    --only-aqua      Use only Aqua vuln-list as the source. Use with --cache.
    --only-ghsa      Use only recent ghsa as the source. Use with --cache.
    --search SEARCH  Search for the package or CVE ID in the database. Use purl, cpe, or git http url.
    --list-malware   List latest malwares with CVE ID beginning with MAL-.
    --bom BOM_FILE   Search for packages in the CycloneDX BOM file.
    --download-image      Downloaded pre-created vdb image to platform specific user_data_dir. Application vulnerabilities only.
    --download-full-image
                          Downloaded pre-created vdb image to platform specific user_data_dir. All vulnerabilities including OS.
    --print-vdb-metadata  Display metadata about the current vdb in user_data_dir.
  ```



  It is possible to perform a range of searches using the cli.

  ```shell
  vdb --search pkg:pypi/xml2dict@0.2.2


  vdb --search pkg:pypi/xml2dict


  vdb --search "pkg:swift/github.com/vapor/vapor@4.39.0"

  vdb --search "pkg:swift/vapor/vapor@4.89.0"


  vdb --search "cpe:2.3:a:npm:gitblame:*:*:*:*:*:*:*:*"


  vdb --search "npm:gitblame:0.0.1"


  vdb --search CVE-2024-25169


  vdb --search CVE-2024-%


  vdb --search "https://github.com/electron/electron"


  vdb --bom bom.json
  ```



  To list malware entries with the `MAL-` prefix, use the following command.

  ```shell
  vdb --list-malware
  ```



  Refer to [cli.py](./vdb/cli.py) for usage. Below is a sample code snippet.

  ```python
  from vdb.lib import config, db6 as db_lib, search
  from vdb.lib.cve_model import CVE


  results = search.search_by_any("purl or cpe or url", with_data=True)


  from vdb.lib.orasclient import download_image

  download_image(config.VDB_DATABASE_URL, config.DATA_DIR)


  if db_lib.needs_update():
      print("Database needs to be updated")
      download_image(...)
  ```



  MIT


pkgId: 0445f8ce63931c9cccdbaca53841618ff307b5a25f7ddbe58eded1d0715f484c
name: python-appwrite
arch: src
version: 7.0.0
epoch: 0
release: 1
url: https://appwrite.io/support
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-appwrite-7.0.0-1.src.rpm
checksum_type: sha256
summary:
  Appwrite is an open-source self-hosted backend server that abstract and simplify complex and repetitive development tasks behind a very simple REST API

description:
  ![License](https://img.shields.io/github/license/appwrite/sdk-for-python.svg?style=flat-square)
  ![Version](https://img.shields.io/badge/api%20version-1.6.0-blue.svg?style=flat-square)
  [![Build Status](https://img.shields.io/travis/com/appwrite/sdk-generator?style=flat-square)](https://travis-ci.com/appwrite/sdk-generator)
  [![Twitter Account](https://img.shields.io/twitter/follow/appwrite?color=00acee&label=twitter&style=flat-square)](https://twitter.com/appwrite)
  [![Discord](https://img.shields.io/discord/564160730845151244?label=discord&style=flat-square)](https://appwrite.io/discord)

  **This SDK is compatible with Appwrite server version 1.6.x. For older versions, please check [previous releases](https://github.com/appwrite/sdk-for-python/releases).**

  Appwrite is an open-source backend as a service server that abstract and simplify complex and repetitive development tasks behind a very simple to use REST API. Appwrite aims to help you develop your apps faster and in a more secure way. Use the Python SDK to integrate your app with the Appwrite server to easily start interacting with all of Appwrite backend APIs and tools. For full API documentation and tutorials go to [https://appwrite.io/docs](https://appwrite.io/docs)

  ![Appwrite](https://github.com/appwrite/appwrite/raw/main/public/images/github.png)



  To install via [PyPI](https://pypi.org/):

  ```bash
  pip install appwrite
  ```





  Initialize your SDK with your Appwrite server API endpoint and project ID which can be found on your project settings page and your new API secret Key from project's API keys section.

  ```python
  from appwrite.client import Client
  from appwrite.services.users import Users

  client = Client()

  (client
    .set_endpoint('https://[HOSTNAME_OR_IP]/v1') # Your API Endpoint
    .set_project('5df5acd0d48c2') # Your project ID
    .set_key('919c2d18fb5d4...a2ae413da83346ad2') # Your secret API key
    .set_self_signed() # Use only on dev mode with a self-signed SSL cert
  )
  ```


  Once your SDK object is set, create any of the Appwrite service objects and choose any request to send. Full documentation for any service method you would like to use can be found in your SDK documentation or in the [API References](https://appwrite.io/docs) section.

  ```python
  users = Users(client)

  result = users.create(ID.unique(), email = "email@example.com", phone = "+123456789", password = "password", name = "Walter O'Brien")
  ```


  ```python
  from appwrite.client import Client
  from appwrite.services.users import Users
  from appwrite.id import ID

  client = Client()

  (client
    .set_endpoint('https://[HOSTNAME_OR_IP]/v1') # Your API Endpoint
    .set_project('5df5acd0d48c2') # Your project ID
    .set_key('919c2d18fb5d4...a2ae413da83346ad2') # Your secret API key
    .set_self_signed() # Use only on dev mode with a self-signed SSL cert
  )

  users = Users(client)

  result = users.create(ID.unique(), email = "email@example.com", phone = "+123456789", password = "password", name = "Walter O'Brien")
  ```


  The Appwrite Python SDK raises `AppwriteException` object with `message`, `code` and `response` properties. You can handle any errors by catching `AppwriteException` and present the `message` to the user or handle it yourself based on the provided error information. Below is an example.

  ```python
  users = Users(client)
  try:
    result = users.create(ID.unique(), email = "email@example.com", phone = "+123456789", password = "password", name = "Walter O'Brien")
  except AppwriteException as e:
    print(e.message)
  ```


  You can use the following resources to learn more and get help
  - 🚀 [Getting Started Tutorial](https://appwrite.io/docs/getting-started-for-server)
  - 📜 [Appwrite Docs](https://appwrite.io/docs)
  - 💬 [Discord Community](https://appwrite.io/discord)
  - 🚂 [Appwrite Python Playground](https://github.com/appwrite/playground-for-python)




  This library is auto-generated by Appwrite custom [SDK Generator](https://github.com/appwrite/sdk-generator). To learn more about how you can help us improve this SDK, please check the [contribution guide](https://github.com/appwrite/sdk-generator/blob/master/CONTRIBUTING.md) before sending a pull-request.



  Please see the [BSD-3-Clause license](https://raw.githubusercontent.com/appwrite/appwrite/master/LICENSE) file for more information.


pkgId: c2f29daa52089a7df2b597f297be12b41c077735e5bcb59d90d3e2bf0e2167b8
name: python-appyc
arch: src
version: 0.1.5
epoch: 0
release: 1
url: https://github.com/habanero-lab/APPy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-appyc-0.1.5-1.src.rpm
checksum_type: sha256
summary:
  APPy (Annotated Parallelism for Python) enables users to annotate loops and tensor expressions in Python with compiler directives akin to OpenMP, and automatically compiles the annotated code to GPU kernels.

description:
  APPy (Annotated Parallelism for Python) enables users to parallelize generic Python loops and tensor expressions for execution on GPUs by adding OpenMP-like compiler directives (annotations) to Python code. With APPy, parallelizing a Python for loop on the GPU can be as simple as adding a `#pragma parallel for` before the loop, like the following:

  ```python

  for i in range(N):
      C[i] = A[i] + B[i]
  ```

  The APPy compiler will recognize the pragma, JIT-compile the loop to GPU code, and execute the loop on the GPU. A detailed description of APPy can be found in [APPy: Annotated Parallelism for Python on GPUs](https://dl.acm.org/doi/10.1145/3640537.3641575). This document provides a quick guide to get started.



  ```bash
  pip install -e .
  ```

  Note that due to APPy generates [Triton](https://github.com/openai/triton/tree/main) code under the hood, it requires a Linux platform with an NVIDIA GPU (Compute Capability 7.0+).



  ```bash
  python examples/01-vec_add.py
  ```



  A loop can be parallelized by being annotated with `#pragma parallel for`, where the end of the loop acts as a synchronization point. Each loop iteration is said to be assigned to a *worker*, and the number of workers launched is always equal to the number of loop iterations, unless directive `#pragma sequential for` is used, which launches only one worker that executes all iterations, e.g. due to loop-carried dependences. Each worker is scheduled to a single vector processor, and executes its instructions sequentially.
  A parallel for-loop must be a for-range loop, and the number of loop iterations must be known at kernel launch time, i.e. no dynamic parallelism.

  Tensors within the parallel region must already be a GPU tensor (data reside in the GPU memory), and currently `cupy` and `pytorch` are supported. Such libraries also provide APIs to create a GPU tensor from a NumPy array.

  A vector addition example is shown below. Parallelize a for loop with APPy via `#pragma parallel for`. `#pragma ...` is a regular comment in Python, but will be parsed and treated as a directive by APPy.

  ```python
  @appy.jit
  def vector_add(A, B, C, N):
      
      for i in range(N):
          C[i] = A[i] + B[i]
  ```


  A key design of APPy is that it assumes a simple abstract machine model, i.e. a multi-vector processor, instead of directly exposing the complex GPU architecture to the programmer. In this multi-vector processor, there are 2 layers of parallelism: 1) each vector processor is able to do vector processing (SIMD); 2) different vector processors run independently and simultaneously (MIMD). Pragma `#pragma parallel for` corresponds to the MIMD parallelism, which is also referred to as parallelization. The SIMD parallelism is referred to as vectorization, as described in more detail in the next section. Maximum parallelism is achieved with the loop is both parallelized and vectorized.

  <p align="center">
    <img src="https://github.com/habanero-lab/APPy/assets/7697776/6425b55c-4148-4bac-9eae-e0fbab3cfa31" width=50% height=50%>
  </p>



  Although `#pragma parallel for` parallelizes a loop, maximum parallelism is achieved when the loop body is also vectorized, when applicable. APPy provides two high-level ways to achieve vectorization: 1) use tensor/array expressions (compiler generates a loop automatically); 2) annotate a loop with the `#pragma simd`, which divides the loop into smaller chunks.

  Vector addition example.

  ```python
  @appy.jit
  def vector_add(A, B, C, N):
      
      for i in range(N):
          C[i] = A[i] + B[i]
  ```

  SpMV example.

  ```python
  @appy.jit
  def spmv(A_row, A_col, A_val, x, y, N):
      
      for i in range(N - 1):
          y[i] = 0.0
          
          for j in range(A_row[i], A_row[1+i]):
              col = A_col[j]
              y[i] += A_val[j] * x[col]
  ```

  A loop that is not applicable for parallelization may be vectorizable. One example is the `j` loop in the SpMV example, where it has dynamic loop bounds.


  APPy does not require the programmer to manually specify whether each variable is private or shared. Instead, it enforces syntactical difference between array and non-array variables, and use simple rules to infer the scope of the variables. Array variables are always followed by a square bracket, such as `A[vi]`, and the rest are non-array variables. Array variables inside the parallel region are always considered shared (and their data reside in the global memory of the GPU). Non-array variables defined within the parallel region are considered private to each worker. Read-Only non-array variables are shared. APPy prohibits multiple reaching definitions from both inside and outside the parallel region of a non-array variable, which prevents writing into a shared non-array variable. To achieve such effects, the idiom is make the variable an array of size 1 (thus it has a global scope).


  The only synchronization across workers (loop iterations) supported is atomically updating a memory location. This can be achieved by either using "assembly-level" programming of the abstract machine via instruction `appy.atomic_<op>`, or by annotating a statement with compiler directive `#pragma atomic`. Note that within a worker, no synchronization is necessary even if it works on multiple elements.

  A parallel reduction example.
  ```python
  @appy.jit
  def vector_sum(A, s, N):
      
      for i in range(N):
          
          s[0] += A[i]
  ```


  In addition to loops, APPy also allows users to use tensor/array expressions and the tensors can have arbitrary size. This often results in more natural and succinct program compared to the loop oriented version.

  ```python
  @appy.jit(auto_simd=True)
  def gesummv(alpha, beta, A, B, x, y, tmp, M, N):
      
      y[:M] = mv(alpha * A[:M, :N], x[:N])
      
      tmp[:M] = mv(beta * B[:M, :N], x[:N])
      
      y[:M] += tmp[:M]

  @appy.jit(auto_simd=True)
  def jacobi_2d_one_iteration(A, B, M, N):
      
      B[1:M-1, 1:N-1] = 0.2 * (A[1:M-1, 1:N-1] + A[1:M-1, :N-2] +
                 A[1:M-1, 2:N] + A[2:M, 1:N-1] + A[0:M-2, 1:N-1])
      
      A[1:M-1, 1:N-1] = 0.2 * (B[1:M-1, 1:N-1] + B[1:M-1, :N-2] +
                 B[1:M-1, 2:N] + B[2:M, 1:N-1] + B[0:M-2, 1:N-1])
  ```


  Within an APPy parallel region, only elementary mathematical function and reduction functions are supported. Other operations including higher-level functions such as matrix inversion, shuffling functions such as sorting are not supported (will not compile).


pkgId: 29604104802d6d0c38eac859c9d9df2a5f3b2394d649a69ebfa830f556d03aed
name: python-apread
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: Import data from CatmanAP binary files.
url: https://github.com/leonbohmann/APReader
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apread-1.1.3-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
     <img src="logo.svg" height="200">
  </div>

  <div align="center">
    <h1>
    apread
    </h1>
    <h3>
    previously: Catman Reader
    </h3>
  </div>


  [![PyPi Upload](https://github.com/leonbohmann/APReader/actions/workflows/python-publish.yml/badge.svg)](https://github.com/leonbohmann/APReader/actions/workflows/python-publish.yml)
  ![pyPI - Version](https://badgen.net/pypi/v/apread?label=PyPi%20Version&icon)
  ![PyPI - Downloads](https://badgen.net/pypi/dm/apread?label=Monthly)
  [![Downloads](https://static.pepy.tech/personalized-badge/apread?period=total&units=international_system&left_color=grey&right_color=brightgreen&left_text=Total%20Downloads)](https://pepy.tech/project/apread)



  <a href="https://www.buymeacoffee.com/leonbohmann" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/default-orange.png" alt="Buy Me A Coffee" height="41" width="174"></a>



  If you use this software in any of your work, please cite it using the "Cite this repository" button in the right sidebar or use this:

  ```
  @software{leonbohmann_APReader,
     author = {Bohmann, Leon},
     doi = {10.5281/zenodo.8369804},
     month = sep,
     title = {{leonbohmann/APReader: v1.1.2}},
     url = {https://github.com/leonbohmann/APReader},
     version = {v1.1.2},
     year = {2023}
  }
  ```



  > Read binary files produced from catmanAP projects directly into python.

  CatmanAP procudes .bin files after each measurement. While it is possible to export as a different format (i.e. txt or asc) it's not efficient because one has to change the export format after every measurement. Here comes the treat: Just export as binary and use this package to work with binary files directly.

  After reading all channels from the binary file, the channels are analyzed and every measure-channel will receive a reference to a time channel, depending on the amount of entries in the channels and the fact, that the time-channel has to contain "time" or "zeit" in its name. What that means is, that a channel with x entries and the name "time - 1" will be regarded as the time-channel of any other channel with x Data Entries.

  Here is an example plot, generated directly from a binary file:
  ![apread_demo_out_1](https://user-images.githubusercontent.com/13386367/169707732-240a916e-228f-4ef9-8c3c-e560a2647c97.png)



  Anywhere with python (note the uppercase U):

  ```sh
  pip install -U apread
  ```



  The workflow of the package is straight-forward. You supply a binary file created with CatmanAP and the script will read that into python.

  First of all, the binary data is analyzed and packaged into seperate `Channel` objects. When all `Channels` are created, each `Channel.Name` will be checked against `([T|t]ime)|([Z|z]eit)`, which mark time channels which usually are the reference.

  These `Channels` marked as `istime` are the basis for `Groups`. Inside a group you will find the `ChannelX` (time channel) and a bunch of other channels in `ChannelsY`, which are the channels containing data in that time domain. The corresponding channels inside a `Group` are found by analyzing their length. Since the total time measured is the same for all groups, it is assumed that `Channels` with the same data-length belong to the same group. Connecting the matching channels to the group give a structured representation of your measurement data.

  Now that the Data is available in python you are free to do with that whatever you want. Until Version `1.0.x` there were some features in which you can save the data but that feature has been removed.



  Lets say you produced a file called `measurements.bin` and you put it in the directory of your python script, then you can create the `APReader` on that file. It's that simple. The Initialization may take some time depending on how large your .bin-File is.

  ```python
  from apread import APReader

  reader = APReader('measurements.bin')   # this will read in the file
  ```



  Afterwards you can access the `Channels` by accessing the `APReader.Channels` Member. `Channel` and `Group` implement `__str__` which will return the name and the length of data inside it.

  ```python
  for channel in reader.Channels:
      print(channel)







  ```

  ```python
  for group in reader.Groups:
      print(group)



  ```



  To review your data on the fly, you can plot every entity in the data structure by calling `.plot()`. When plotting, every group will get its own figure window, in which all connected channels are plotted.

  ```python

  reader.plot()

  for group in reader.Groups:
      group.plot()

  for channel in reader.Channels:
      channel.plot()
  ```

  As you can see, you can access the channels from the reader, which contains all channels (including time channels) or you can access them from the groups.

  There are some more functions to plot specific data. When plotting multiple channels each channel gets its own y-axis.

  ```python
  group.plotChannel(0)           # specific channel
  group.plotChannels(0,3)        # channel 1 to 3 (1,2,3)
  group.plot([0, 2, 4])          # channel 1, 3 and 5
  ```

  The same can be applied to the `APReader`. The only difference is that you can plot specific groups instead of channels.

  ```python
  reader.plotGroup(0)           # specific group
  reader.plotGroups(0,3)        # group 1 to 3 (1,2,3)
  reader.plot([0, 2, 4])        # group 1, 3 and 5
  ```



  Thanks to ([hakonbars PR13](https://github.com/leonbohmann/APReader/pull/13)) you are now able to access external header information using `channel.exthdr`, a dicitionary containing all keys as described in [this sheet](https://github.com/leonbohmann/APReader/blob/dev-2/test/catmanBinaryFormat.xls).

  ```python
  ['T0']                 # ACQ timestamp info (NOW format)
  ['dt']                 # ACQ delta t in ms
  ['SensorType']         # IDS code of sensor type
  ['SupplyVoltage']      # IDS code supply voltage
  ['FiltChar']           # IDS code of filter characteristics
  ['FiltFreq']           # IDS code of filter frequency
  ['TareVal']            # Current value in tare buffer
  ['ZeroVal']            # Current value in zero adjustment buffer
  ['MeasRange']          # IDS code of measuring range
  ['InChar']             # Input characteristics (0=x1,1=y1,2=x2,3=y2)
  ['SerNo']              # Amplifier serial number
  ['PhysUnit']           # Physical unit (if user scaling in effect, this is the user unit!)
  ['NativeUnit']         # Native unit
  ['Slot']               # Hardware slot number
  ['SubSlot']            # Sub-channel, 0 if single channel slot
  ['AmpType']            # IDS code of amplifier type
  ['APType']             # IDS code of AP connector type (MGCplus only)
  ['kFactor']            # Gage factor used in strain gage measurements
  ['bFactor']            # Bridge factor used in strain gage measurements
  ['MeasSig']            # IDS code of measurement signal (e.g. GROSS, NET) (MGCplus only)
  ['AmpInput']           # IDS code of amplifier input (ZERO,CAL,MEAS)
  ['HPFilt']             # IDS code of highpass filter
  ['OLImportInfo']       # Special information used in online export file headers
  ['ScaleType']          # 0=Engineering units, 1=Electrical
  ['SoftwareTareVal']    # Software tare (zero) for channels carrying a user scale
  ['WriteProtected']     # If true, write access is denied
  ['NominalRange']       # CAV value
  ['CLCFactor']          # Cable length compensation factor (CANHEAD only)
  ['ExportFormat']       # 0=8-Byte Double, 1=4-Byte Single, 2=2-Byte Integer (FOR CATMAN BINARY EXPORT ONLY!)
  ```



  > Only available from version `v1.1.1-alpha1` and above

  See `test/testing.py` for a full example. Modify the following around your `APReader` call:

  ```python
  import multiprocessing as mp
  ...


  if __name__ == '__main__': # this line has to be included!
      
      pool = mp.Pool()

      
      reader = APReader(file, parallelPool=pool)

      
      mp.close()
      mp.join()
  ```

  For the parallel loading to work, you have to define a parallel pool of processes in your top-level script. These processes will be accessed from within `APReader`-Functions. When passing no arguments to `mp.Pool()` it will automatically create as many processes as possible, according to the amount of threads your CPU allows (cores + virtual cores). It does not make sense to pass in more, since the `APReader` spawns the same amount of processes as there are CPU Threads. Increasing the amount of processes in your pool does not increase the amount of parallelism. It is fixed.

  > Keep in mind, that parallelisation is not always faster. Spawning of processes is expensive and can be wasteful for small files.

  The results from `APReader` stay the same and you can continue your analysis.





  * Added converted timestamp property on channels (`Channel.date`)
    * *Property `Channel.time` will be deleted at some point in the future...*
  * Parallel reading of binary files
    * Max degree of parallelism is automatically set to amount of available cores
  * ----------------------------
  * ----------------------------





  * Removed saving functions, this will be up to the user
      > Since these function change a lot based on current needs, I decided to remove the post-processing functionality completely. The user now needs to do the post-processing on his own, meaning the creation of plots using time and data channels...



  * ([hakonbar PR13](https://github.com/leonbohmann/APReader/pull/13)) Differentiate floating point precision
  * ([hakonbar PR13](https://github.com/leonbohmann/APReader/pull/13)) Reading additional header information
  * ([hakonbar PR13](https://github.com/leonbohmann/APReader/pull/13)) Supplying binary format reference
  * Fixed null returning string conversion function
  * Using regex to find time channels
  * Improved plotting with multiple axes
  * Printing channels and groups will now give a summary instead of all data



  * Fixed an issue with groups where time channels are not recognized
  * now, user is prompted, when suspected time channel is found
  * plotting is not possible when there is no time-channel found
  * save groups and channels even when there is no time channel



  * Updated serialisation-procedures to always encode in `UTF-8`



  * Switched to explicit type hinting with `typing` package (compatibility issues with python <3.9.x)



  * Fixed an issue with saving and non-existent directories
  * Added `getas` to generate formatted string without saving



  * Output file-names updated



  * Group channels with their time-channel into "groups"
  * Multiple plot modes:
    * Whole file
    * Channel/Group only
  * Output data
    * json
    * csv



  * Progressbars indicate read-progress of files
  * Multiple plot modes



  * Convert catman files to channels



  Leon Bohmann – mail@leonbohmann.de

  Distributed under the MIT license. See ``LICENSE`` for more information.

  This software comes with no warranty, expressed or implied. Use at your own risk!

  [https://github.com/leonbohmann/apreader](https://github.com/leonbohmann/apreader)


pkgId: ea8b6d3bef5652a437403701940662044c25a4e67f0e6a36ca6fd3bbae399973
name: python-april-vision
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: An AprilTags wrapper with camera discovery and axis conversion.
url: https://pypi.org/project/april-vision/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-april-vision-2.2.0-1.src.rpm
checksum_type: sha256
description:
  [![Lint & build](https://github.com/WillB97/april_vision/actions/workflows/test_build.yml/badge.svg)](https://github.com/WillB97/april_vision/actions/workflows/test_build.yml)
  [![PyPI version](https://badge.fury.io/py/april-vision.svg)](https://badge.fury.io/py/april-vision)
  [![MIT license](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)](https://opensource.org/licenses/MIT)

  A fiducial marker system used by Student Robotics.
  Uses [april tag](https://april.eecs.umich.edu/software/apriltag) markers to provide detection, pose and distance estimation for these markers.



  This library requires OpenCV but the default installation does not install OpenCV. There are a few different versions of OpenCV with different install sizes, to install the default package without OpenCV, run the following command.

  ```bash
  pip install april-vision
  ```

  To install the lightweight headless version OpenCV install the library with the following command.

  ```bash
  pip install april-vision[opencv]
  ```

  If you want to perform some of the more advanced features of the CLI (live view of the camera) you need the full version of OpenCV.
  The CLI dependecies can be installed with the following command.

  ```bash
  pip install april-vision[cli]
  ```

  Then the full version of OpenCV can then be installed with the following command.

  ```bash
  pip install opencv-python>=4.8
  ```

  All the versions of OpenCV (standard, headless and contrib) clash so you should only have one installed.



  ```python
  from april_vision.examples.camera import setup_cameras


  tag_sizes = {
      range(0, 100): 80
  }


  cameras = setup_cameras(tag_sizes)

  if len(cameras) == 0:
      print("No cameras found")

  for name, cam in cameras.items():
      print(name)
      print(cam.see())
  ```



  When installed april_vision can be used on the command line providing the following list of useful tools. Each of the tools contain help text on correct usage accessed via the `-h` argument.

  ```bash
  annotate_image
  annotate_video
  calibrate
  live
  marker_generator
  vision_debug
  tools
      family_details
      list_cameras
  ```

rpm_license:
  MIT License  Copyright (c) 2022 Will Barber  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: 3b665b1dee60bfe482e376deaaef8b4ecd271a3347c4abf9ea2a262d2d05063b
name: python-apriori-python
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: A simple apriori algorithm python implementation
url: https://github.com/chonyy/apriori_python
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apriori-python-1.0.4-1.src.rpm
checksum_type: sha256
description:
  <p align=center>
      <a target="_blank" href="https://travis-ci.com/chonyy/apriori_python" title="Build Status"><img src="https://travis-ci.com/chonyy/apriori_python.svg?branch=master"></a>
      <a target="_blank" href="#" title="pip"><img src="https://img.shields.io/pypi/v/apriori_python?color=brightgreen"></a>
      <a target="_blank" href="#" title="language count"><img src="https://img.shields.io/github/languages/count/chonyy/apriori_python"></a>
      <a target="_blank" href="#" title="top language"><img src="https://img.shields.io/github/languages/top/chonyy/apriori_python?color=orange"></a>
      <a target="_blank" href="https://opensource.org/licenses/MIT" title="License: MIT"><img src="https://img.shields.io/badge/License-MIT-blue.svg"></a>
      <a target="_blank" href="#" title="repo size"><img src="https://img.shields.io/github/repo-size/chonyy/apriori_python"></a>
      <a target="_blank" href="http://makeapullrequest.com" title="PRs Welcome"><img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg"></a>
  </p>





  ```
  pip install apriori_python
  ```

  Then use it like

  ```python
  from apriori_python import apriori
  itemSetList = [['eggs', 'bacon', 'soup'],
                  ['eggs', 'bacon', 'apple'],
                  ['soup', 'bacon', 'banana']]
  freqItemSet, rules = apriori(itemSetList, minSup=0.5, minConf=0.5)
  print(rules)


  ```



  To run the program with dataset provided and default values for *minSupport* = 0.5 and *minConfidence* = 0.5

  ```
  python apriori.py -f dataset.csv
  ```

  To run program with dataset and min support and min confidence

  ```
  python apriori.py -f dataset.csv -s 0.17 -c 0.68
  ```


pkgId: ab461614293702a50247eeeeb654b4624646f55b675d431b1ace0f4c52126f89
name: python-apronpy
arch: src
version: 1.0.10
epoch: 0
release: 1
summary: Python Interface for the APRON Numerical Abstract Domain Library
url: https://github.com/caterinaurban/apronpy
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apronpy-1.0.10-1.src.rpm
checksum_type: sha256
description:
  Python Interface for the
  [APRON Numerical Abstract Domain Library](http://apron.cri.ensmp.fr/library/).





  * Install [**APRON**](https://github.com/antoinemine/apron)

  * Install [**Python 3.x**](http://www.python.org/)



  * Create a virtual Python environment:

      | Linux or Mac OS X                   |
      | ----------------------------------- |
      | `virtualenv --python=python3 <env>` |

  * Install apronpy in the virtual environment:

      | Linux or Mac OS X                 |
      | --------------------------------- |
      | `./<env>/bin/pip install apronpy` |


pkgId: 3f8f415b2353d278541660e8519b4faf939d43b22bacb6bced49358daf23178d
name: python-apropos-ai
arch: src
version: 0.4.5
epoch: 0
release: 1
summary: Learning algorithms for production language model programs
url: https://pypi.org/project/apropos-ai/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apropos-ai-0.4.5-1.src.rpm
checksum_type: sha256
description:
  Learning algorithms for production language model programs.


  Get started by running
  ```pip install apropos-ai```


  To get started with simple bootstrapped fewshot random search on the Hendryks Math benchmark, run:
  ```
  python examples/hello_world.py
  ```


  To get started with a custom dataset and/or language model program, if your program happens to be a single-prompt program, we have a simple demo [here](examples/quick_start.py)

  Simply replace
  ```
  messages_examples, gold_outputs, custom_math_metric = (
        get_hendryks_messages_and_gold_outputs()
  )
  ```
  with your own data (in the form of system/user prompt pairs and possibly gold outputs) and a metric of your choosing. Then, run away!

  Nota Bene: the logic involved in converting this data to the appropriate DAG / benchmark is very new and experimental, please file an issue if you run into any trouble.



  uv venv apropos-dev
  source apropos-dev/bin/activate


     /bash<br>
     `pyenv install 3.11.0`<br>
     `pyenv virtualenv 3.11.0 apropos-dev`<br>
     `pyenv activate apropos-dev`


     /bash<br>
     `curl -sSL https://install.python-poetry.org | python3 -`<br>
     `poetry install`



  If you use the following idea(s):
  - Optimizing over variations of specific substrings within a prompt

  please cite this repo and forthcoming paper when released

  If you use the MIPROv2 optimizer in your academic work, please cite the following [paper](https://arxiv.org/abs/2406.11695):

  ```
  @misc{opsahlong2024optimizinginstructionsdemonstrationsmultistage,
        title={Optimizing Instructions and Demonstrations for Multi-Stage Language Model Programs},
        author={Krista Opsahl-Ong and Michael J Ryan and Josh Purtell and David Broman and Christopher Potts and Matei Zaharia and Omar Khattab},
        year={2024},
        eprint={2406.11695},
        archivePrefix={arXiv},
        primaryClass={cs.CL},
        url={https://arxiv.org/abs/2406.11695},
  }
  ```

  Moreover, if you find the notion of learning from bootstrapped demonstrations useful, or have used algorithms such as the breadth-first random search optimizer, consider citing the following [paper](https://arxiv.org/abs/2310.03714)

  ```
  @misc{khattab2023dspycompilingdeclarativelanguage,
        title={DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines},
        author={Omar Khattab and Arnav Singhvi and Paridhi Maheshwari and Zhiyuan Zhang and Keshav Santhanam and Sri Vardhamanan and Saiful Haq and Ashutosh Sharma and Thomas T. Joshi and Hanna Moazam and Heather Miller and Matei Zaharia and Christopher Potts},
        year={2023},
        eprint={2310.03714},
        archivePrefix={arXiv},
        primaryClass={cs.CL},
        url={https://arxiv.org/abs/2310.03714},
  }
  ```


pkgId: 76e7f5c9401420271034f6dca115e192468602c94404a8a971cb5a8b8760e08f
name: python-aprscot
arch: src
version: 6.1.0
epoch: 0
release: 1
summary: APRS Cursor-on-Target Gateway.
url: https://github.com/ampledata/aprscot
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aprscot-6.1.0-1.src.rpm
checksum_type: sha256
description:
  **Tech Support**: Email support@undef.net or Signal/WhatsApp: +1-310-621-9598
  This tool has been developed for the Disaster Response, Public Safety and
  Frontline Healthcare community. This software is currently provided at no-cost
  to users. Any contribution you can make to further this project's development
  efforts is greatly appreciated.


pkgId: a367c682cfb9007797cec41017fe5ac715920bcba7884160acf9d3b34a637888
name: python-aprsd
arch: src
version: 3.4.3
epoch: 0
release: 1
summary: APRSd is a APRS-IS server that can be used to connect to APRS-IS and send and receive APRS packets.
url: https://github.com/craigerl/aprsd
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aprsd-3.4.3-1.src.rpm
checksum_type: sha256
rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.


pkgId: a5bb5f23bd0a51c2d769338874f556e827075d43f37f7bfaebc7c8c2425395ac
name: python-aprslib
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: Module for accessing APRS-IS and parsing APRS packets
url: https://github.com/rossengeorgiev/aprs-python
rpm_license: GPLv2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aprslib-0.7.2-1.src.rpm
checksum_type: sha256
description:
  To install the latest release from ``pypi``::
      pip install aprslib
  To install the latest dev version from the `Github repo <https://github.com/rossengeorgiev/aprs-python/>`_::
      pip install git+https://github.com/rossengeorgiev/aprs-python


pkgId: 133d4161bcc8c61a57bc0e040f6350e9cae13ea49e549f4a8d9f1ced36ff1e75
name: python-aprstastic
arch: src
version: 0.0.1a23
epoch: 0
release: 1
summary: A Meshtastic-APRS Gateway
url: https://pypi.org/project/aprstastic/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aprstastic-0.0.1a23-1.src.rpm
checksum_type: sha256
description:
  > [!WARNING]
  > Legal operation of this software requires an amateur radio license and a valid call sign.
  > [!NOTE]
  > Star this repo to follow our progress! This code is under active development, and contributions are both welcomed and appreciated. See [CONTRIBUTING.md](https://github.com/afourney/aprstastic/blob/main/CONTRIBUTING.md) for details.


  `aprstastic` is a bidirectional Meshtastic APRS gateway for Meshtastic users **with amateur radio licenses**. It runs on stock Meshtastic devices (LongFast, 915MHz, etc.), allowing you to participate and extend the public network, while using pre-registered associations between Meshtastic device IDs and amateur radio call signs to _bidirectionally_ gate APRS packets in a way that is compliant with FCC regulations. To this end, operation requires at least two Meshtastic devices: one to serve as the gateway, and the others are the clients. The following image demonstrates how operators can register with the gateway (and the broader global network, if registration beaconing is enabled):
  ![Example aprstastic registration flow. Start by sending 'aprs?' to any public channel. Wait for a direct message. Reply with !register CALLSIGN-SSID.](https://github.com/afourney/aprstastic/blob/main/imgs/flow.png "Example aprstastic registration flow.")
  In this scenario, direct messages to the gateway will be forwarded to APRS with the "from" call sign `KK7CMT-8`. Likewise, APRS messages addressed to `KK7CMT-8` will be routed to the originating/registered Meshtastic device via direct message. If registration beaconing is enabled, registration will also trigger a one-time APRS broadcast of the device-id to call sign mapping, allowing all other participating `aprstastic` gateways to learn the association. This enables devices to roam between participating gateways.
  These interactions are demonstrated in the following YouTube video [https://www.youtube.com/watch?v=qUvpZUwl-cY](https://www.youtube.com/watch?v=qUvpZUwl-cY)
  Each gateway mimics an iGate, and can support multiple Meshtastic users, as long as their call signs and devices are pre-registered.

  Various special commands can be issued by sending direct Meshtastic messages to the gateway. The following commands are currently supported.
  **Register a device:**
  Use the following command to register a Meshtastic device to a call sign, replacing `<YOUR_CALLSIGN>` appropriately:
  ```
  !register <YOUR_CALLSIGN>
  ```
  e.g.,
  ```
  !register N0CALL-1
  ```
  **Unregister a device:**
  Use the following command to unregister a Meshtastic device AND call sign.
  ```
  !unregister
  ```
  **Print version information:**
  Use the following command to print the gateway's info and version.
  ```
  !version
  ```

  ```console
  pip install aprstastic
  ```
  ```console
  python -m aprstastic
  ```
  The first time aprstastic runs, it will create a sample `aprstastic.yaml` file. **Edit the sample**, then run it again.
  ```console
  nano ~/.config/aprstastic/aprstastic.yaml
  python -m aprstastic
  ```

  How does the gateway know the addressee ("to" address) of APRS packets when all Meshtastic messages are addressed to the gateway device?
  To address this, we adopt the "CALLSIGN: " convention. Messages should start with the addressee's call sign, followed by a colon. **If this is omitted, then the call sign of the addressee is taken to be that of the previous message (i.e., to respond to the previously received message).**
  As an example, from Meshtastic you could interact with the Winlink gateway (WLNK-1) as follows:
  ```
  WLNK-1: ?
  ```
  The reply from Winlink would be:
  ```
  NOCALL-1: SP, SMS, L, R#, K#, Y#, F#, P, G, A, I, PR, B (? + cmd for more)
  ```
  You could then simply enter:
  ```
  L
  ```
  and it would assume a reply to `WLNK-1`, producing the following response:
  ```
  NOCALL-1: 10/11/2024 23:52:30 No messages.
  ```

  aprstastic only allows messages to transit if they are found in the client device-to-callsign mapping, and are thus attributable to a licensed operator. Random messages published on channels like LongFast, or from other devices do not qualify. All messages are unencrypted before they leave Meshtastic, so all APRS traffic is clear text.

  Instances of the aprstastic gateway identify themselves to the APRS-IS level 2 servers with the software version number `APZMAG`. In accordance to the [Protocol Reference](http://www.aprs.org/doc/APRS101.PDF), `APZ` designates an experimental application in development. In this case, `MAG` is short for 'Meshtastic-APRS Gateway'.

  `aprstastic` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.


pkgId: 73469098b6316347f16d997b4a0e88b7513a6b6d2b67116d54d33361ca76e910
name: python-aprxc
arch: src
version: 2.0.0
epoch: 0
release: 1
url: https://pypi.org/project/aprxc/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aprxc-2.0.0-1.src.rpm
checksum_type: sha256
summary:
  A command-line tool to estimate the number of distinct lines in a file/stream using Chakraborty/Vinodchandran/Meel’s approximation algorithm.

description:
  A command-line tool (and Python class) to approximately count the number of
  distinct elements in files (or a stream/pipe) using the “simple, intuitive,
  sampling-based space-efficient algorithm” by S. Chakraborty, N. V. Vinodchandran
  and K. S. Meel, as described in their 2023 paper [Distinct Elements in Streams:
  An Algorithm for the (Text) Book](https://arxiv.org/pdf/2301.10191#section.2).

  **Motivation:** Easier to remember, always faster and (much) less
  memory-intensive than `sort | uniq | wc -l` or `awk '!a[$0]++' | wc -l`. In this
  implementation’s default configuration results are precise until ~83k unique
  values (on 64-bit CPUs), with deviations of commonly 0.4-1% afterwards.



  Choose your preferred way to install it from [PyPI](https://pypi.org/project/aprxc/):

  ```shell
  pip install aprxc
  uv tool install aprxc
  ```

  Alternatively, run it in an isolated environment, using [pipx
  run](https://pipx.pypa.io/) or [uvx](https://docs.astral.sh/uv/concepts/tools/):

  ```shell
  pipx run aprxc --help
  uvx aprxc --help
  ```

  Lastly, as `aprxc.py` has no dependencies besides Python 3.11+, you can simply
  download the script, run it, put it your PATH, vendor it, etc.



  * Easier to remember than the pipe constructs.
  * 20–60% faster than sort/uniq.
  * 30–99% less memory-intensive than sort/uniq (for mid/high-cardinality data)
  * (Roughly double these numbers when compared against awk.)
  * Memory usage has a (configurable) upper bound.

  Now let's address the elephant in the room: These advantages are bought with
  **an inaccuracy in the reported results**. But how inaccurate?



  In its default configuration the algorithm has a **mean inaccuracy of about
  0.4%**, with **outliers around 1%**. For example, if the script encounters 10M
  (`10_000_000`) actual unique values, the reported count is typically ~40k off
  (e.g. `10_038_680`), sometimes ~100k (e.g. `9_897_071`).

  **However:** If the number of encountered actual unique elements is smaller than
  the size of the internally used set data structure, then the reported counts are
  **exact**; only once this limit is reached, the approximation algorithm 'kicks
  in' and the result will become an approximation.

  Here's an overview (highly unscientific!) of how the algorithm parameters 𝜀 and
  𝛿 (`--epsilon` and `--delta` on the command line) affect the inaccuracy. The
  default of `0.1` for both values seems to strike a good balance (and a memorable
  inaccuracy of ~1%). Epsilon is the 'main manipulation knob', and you can see
  quite good how its value affects especially the maximum inaccuracy.

  For this first table I counted 10 million unique 32-character strings, and for
  each iteration checked the reported count and compared to the actual number of
  unique items. _Mean inacc._ is the mean inaccuracy across all 10M steps; _max
  inacc._ is the highest deviation encountered; _memory usage_ is the linux tool
  `time`'s reported _maxresident_; _time usage_ is wall time.

  | tool (w/ options)     | memory [MiB]|    time [s]|mean ina.| max ina.|   set size|
  |-----------------------|------------:|-----------:|--------:|--------:|----------:|
  |`sort \| uniq \| wc -l`| 1541 (100%) |  5.5 (100%)|      0% |      0% |          —|
  |`sort --parallel=16`   | 1848 (120%) |  5.2 ( 95%)|      0% |      0% |          —|
  |`sort --parallel=1`    |  780 ( 51%) | 18.1 (328%)|      0% |      0% |          —|
  |`aprxc --epsilon=0.001`| 1044 ( 68%) |  4.1 ( 75%)|      0% |      0% |831_863_138|
  |`aprxc --epsilon=0.01` | 1137 ( 74%) |  5.5 (100%)|  0.001% |   0.02% |  8_318_632|
  |`aprxc --epsilon=0.05` |   78 (  5%) |  2.2 ( 40%)|  0.080% |   0.42% |    332_746|
  |`aprxc` (Python 3.13)  |   35 (  2%) |  1.8 ( 32%)|  0.400% |   1.00% |     83_187|
  |`aprxc` (Python 3.12)  |   28 (  2%) |  2.0 ( 36%)|  0.400% |   1.00% |     83_187|
  |`aprxc --epsilon=0.2`  |   26 (  2%) |  1.8 ( 32%)|  0.700% |   2.10% |     20_797|
  |`aprxc --epsilon=0.5`  |   23 (  1%) |  1.7 ( 31%)|  1.700% |   5.40% |      3_216|
  |`awk '!a[$0]++'\|wc -l`| 3094 (201%) |  9.3 (169%)|      0% |      0% |          —|




  For `linux-6.11.6.tar`, a medium-cardinality (total: 39_361_138, 43.3% unique)
  input file:

  | tool (w/ options)     | memory [MiB]|    time [s]|
  |-----------------------|------------:|-----------:|
  |`sort \| uniq \| wc -l`| 6277 (100%) | 41.4 (100%)|
  |`sort --parallel=16`   | 7477 (119%) | 36.7 ( 89%)|
  |`sort --parallel=1`    | 3275 ( 52%) |158.6 (383%)|
  |`aprxc --epsilon=0.001`| 2081 ( 33%) | 13.1 ( 32%)|
  |`aprxc --epsilon=0.01` | 1364 ( 22%) | 15.3 ( 37%)|
  |`aprxc --epsilon=0.05` |  105 (  2%) |  8.2 ( 20%)|
  |`aprxc` (Python 3.13)  |   39 (  1%) |  7.2 ( 17%)|
  |`aprxc` (Python 3.12)  |   35 (  1%) |  8.1 ( 20%)|
  |`aprxc --epsilon=0.2`  |   27 (  0%) |  7.2 ( 17%)|
  |`aprxc --epsilon=0.5`  |   23 (  0%) |  7.2 ( 17%)|
  |`awk '!a[$0]++'\|wc -l`| 5638 ( 90%) | 24.8 ( 60%)|

  For `cut -f 1 clickstream-enwiki-2024-04.tsv`, a low-cardinality (total:
  34_399_603, unique: 6.4%), once via temporary file¹, once via pipe²:

  | tool (w/ options)     |   ¹mem [MiB]|   ¹time [s]|   ²mem [MiB]|   ²time [s]|
  |-----------------------|------------:|-----------:|------------:|-----------:|
  |`sort \| uniq \| wc -l`| 4823 (100%) | 11.6 (100%)|   14 (100%) | 50.3 (100%)|
  |`sort --parallel=16`   | 5871 (122%) | 11.9 (103%)|   14 (100%) | 48.7 ( 97%)|
  |`sort --parallel=1`    | 2198 ( 46%) | 50.5 (436%)|   10 ( 71%) | 48.7 ( 97%)|
  |`aprxc --epsilon=0.001`|  214 (  4%) | 10.8 ( 93%)|  215 (1532%)| 10.7 ( 21%)|
  |`aprxc --epsilon=0.01` |  215 (  4%) | 10.5 ( 91%)|  215 (1534%)| 10.6 ( 21%)|
  |`aprxc --epsilon=0.05` |   73 (  2%) |  8.2 ( 71%)|   73 (524%) |  7.7 ( 15%)|
  |`aprxc` (Python 3.13)  |   35 (  1%) |  6.4 ( 55%)|   36 (254%) |  6.5 ( 13%)|
  |`aprxc` (Python 3.12)  |   29 (  1%) |  7.4 ( 64%)|   29 (204%) |  7.2 ( 14%)|
  |`aprxc --epsilon=0.2`  |   27 (  1%) |  5.8 ( 50%)|   27 (189%) |  5.8 ( 11%)|
  |`aprxc --epsilon=0.5`  |   23 (  0%) |  6.0 ( 52%)|   23 (164%) |  6.1 ( 12%)|
  |`awk '!a[$0]++'\|wc -l`|  666 ( 14%) | 15.7 (136%)|  666 (4748%)| 14.4 ( 29%)|



  You have to accept the inaccuracies, obviously. But if you are working
  exploratory and don't care about exact number or plan to round or throw them
  away anyway; or if or you are in a memory-constrained situation and need to deal
  with large input files or streaming data; or if you just cannot remember the
  multi-command pipe alternatives, then this might be a tool for you.



  I've added a couple of lines of code to support a 'top most common' items
  feature. An alternative to the `sort | uniq -c | sort -rn | head`-pipeline or
  [Tim Bray's nice `topfew` tool (written in
  Go)](https://github.com/timbray/topfew/).

  It kinda works, but…

  - The counts are good, even surprisingly good, as for the whole base algorithm,
    but definitely worse and not as reliable as the nice 1-inaccuracy for
    the total count case.
  - I lack the mathematical expertise to prove or disprove anything about that
    feature.
  - If you ask for a top 10 (`-t10` or `--top 10`), you mostly get what you
    expect, but if the counts are close the lower ranks become 'unstable'; even
    rank 1 and 2 sometimes switch places etc.
  - Compared with `topfew` (I wondered if this approximation algorithm could be
    _an optional_ flag for `topfew`), this Python code is impressively close to
    the Go performance, especially if reading a lot of data from a pipe.
    Unfortunately, I fear that this algorithm is not parallelizable. But I leave
    that, and the re-implementation in Go or Rust, as an exercise for the reader
    :)
  - Just try it!



  ```shell
  usage: aprxc [-h] [--top [X]] [--size SIZE] [--epsilon EPSILON]
               [--delta DELTA] [--cheat] [--count-total] [--verbose] [--version]
               [--debug]
               [path ...]

  Aproximately count the number of distinct lines in a file or pipe.

  positional arguments:
    path                  Input file path(s) and/or '-' for stdin (default:
                          stdin)

  options:
    -h, --help            show this help message and exit
    --top [X], -t [X]     EXPERIMENTAL: Show X most common values. Off by
                          default. If enabled, X defaults to 10.
    --size SIZE, -s SIZE  Expected (estimated) total number of items. Reduces
                          memory usages, increases inaccuracy.
    --epsilon EPSILON, -E EPSILON
    --delta DELTA, -D DELTA
    --cheat               Improve accuracy by tracking 'total seen' and use it
                          as upper bound for result.
    --count-total, -T     Count number of total seen values.
    --verbose, -v
    --version, -V         show program's version number and exit
    --debug               Track, calculate, and display various internal
                          statistics.
  usage: aprxc [-h] [--top [X]] [--size SIZE] [--epsilon EPSILON]
               [--delta DELTA] [--cheat] [--verbose] [--version] [--benchmark]
               [--debug] [--debug-lines N]
               [path ...]


pkgId: 6329fc05c6cf354aee70849d7f8931bd7c1e20c71db3a3d1b8441ed3087e9b74
name: python-apscale
arch: src
version: 2.0.3
epoch: 0
release: 1
summary: Advanced Pipeline for Simple yet Comprehensive AnaLysEs of DNA metabarcoding data
url: https://github.com/DominikBuchner/apscale
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apscale-2.0.3-1.src.rpm
checksum_type: sha256
description:
  Advanced Pipeline for Simple yet Comprehensive AnaLysEs of DNA metabarcoding data


  Apscale is a metabarcoding pipeline that handles the most common tasks in metabarcoding
  pipelines like paired-end merging, primer trimming, quality filtering, otu clustering and
  denoising as well as an otu filtering step. It uses a simple command line interface and is configured via a single configuration file.
  It automatically uses the available ressources on the machine it runs on while still providing the option
  to use less if desired. All modules can be run on their own or as a comprehensive workflow.

  A graphical user interface version for apscale is available [here](https://github.com/TillMacher/apscale_gui).

  Programs used:
  * vsearch (PE merging, quality filtering, otu clustering, denoising) (https://github.com/torognes/vsearch)
  * cutadapt (primer trimming) (https://github.com/marcelm/cutadapt)
  * lulu (implemented in python for apscale) (https://github.com/tobiasgf/lulu)

  Input:
  * demultiplexed gzipped reads

  Output:
  * log files, project report, OTU/ESV table



  Apscale can be installed on all common operating systems (Windows, Linux, MacOS).
  Apscale requires Python 3.7 or higher and can be easily installed via pip in any command line:

  `pip install apscale`

  To update apscale run:

  `pip install --upgrade apscale`



  Apscale calls vsearch for multiple modules. It should be installed and be in PATH to be executed
  from anywhere on the system.

  Check the vsearch Github page for further info:

  https://github.com/torognes/vsearch

  Support for compressed files with zlib is necessary. For Unix based systems this is shipped with
  vsearch, for Windows the zlib.dll can be downloaded via:

  [zlib for Windows](https://sourceforge.net/projects/mingw-w64/files/External%20binary%20packages%20%28Win64%20hosted%29/Binaries%20%2864-bit%29/zlib-1.2.5-bin-x64.zip/download)

  The dll has to be in the same folder as the vsearch executable. If you need help with adding a folder to PATH in windows
  please take a look at the first answer on this stackoverflow issue:

  [How to add a folder to PATH Windows](https://stackoverflow.com/questions/44272416/how-to-add-a-folder-to-path-environment-variable-in-windows-10-with-screensho)

  To check if everything is correctly set up please type this into your command line:

  `vsearch --version`

  It should return a message similar to this:

  ```
  vsearch v2.19.0_win_x86_64, 31.9GB RAM, 24 cores
  https://github.com/torognes/vsearch

  Rognes T, Flouri T, Nichols B, Quince C, Mahe F (2016)
  VSEARCH: a versatile open source tool for metagenomics
  PeerJ 4:e2584 doi: 10.7717/peerj.2584 https://doi.org/10.7717/peerj.2584

  Compiled with support for gzip-compressed files, and the library is loaded.
  zlib version 1.2.5, compile flags 65
  Compiled with support for bzip2-compressed files, but the library was not found.
  ```



  Apscale also calls cutadapt with some modules. Cutadapt should be downloaded and installed
  automatically with the Apscale installation. To check this, type:

  `cutadapt --version`

  and it should return the version number, for example:

  `3.5`





  Apscale is organized in projects with the following structure:

  <pre>
  C:\USERS\DOMINIK\DESKTOP\EXAMPLE_PROJECT
  â”œâ”€â”€â”€1_raw data
  â”‚   â””â”€â”€â”€data
  â”œâ”€â”€â”€2_demultiplexing
  â”‚   â””â”€â”€â”€data
  â”œâ”€â”€â”€3_PE_merging
  â”‚   â””â”€â”€â”€data
  â”œâ”€â”€â”€4_primer_trimming
  â”‚   â””â”€â”€â”€data
  â”œâ”€â”€â”€5_quality_filtering
  â”‚   â””â”€â”€â”€data
  â”œâ”€â”€â”€6_dereplication_pooling
  â”‚   â””â”€â”€â”€data
  â”‚       â”œâ”€â”€â”€dereplication
  â”‚       â””â”€â”€â”€pooling
  â”œâ”€â”€â”€7_otu_clustering
  â”‚   â””â”€â”€â”€data
  â”œâ”€â”€â”€8_denoising
  â”‚   â””â”€â”€â”€data
  â””â”€â”€â”€9_lulu_filtering
      â”œâ”€â”€â”€denoising
      â”‚   â””â”€â”€â”€data
      â””â”€â”€â”€otu_filtering
          â””â”€â”€â”€data

  </pre>

  A new project can be initialized with the command:

  `apscale --create_project NAME`

  If you prefer to have your data all in one place you can copy the raw data into 1_raw_data/data.
  Demultiplexing won't be handled by Apscale because there are to many different tagging systems out there to implement in a single pipeline.
  If you are using inline barcodes you can take a look at https://github.com/DominikBuchner/demultiplexer.
  If you are already starting with **demultiplexed** data please copy them into 2_demultiplexing/data.



  Associated with every newly created project, Apscale will generate an Excel sheet in the project folder called "Settings.xlsx".
  It is divided into seperate sheets for every module and a 0_general_settings tab.
  By default Apscale will set 'cores to use' to all available cores on the system the project is created - 2, but this can be lowered
  if the capacity is needed for other processes on your computer.
  Apscale only works with compressed data, so it takes compressed data as input and has compressed data as output.
  The compression level can be set in the general settings as well. Its default value is 6 since this is the default value of gzip.
  The higher the compression level, the longer Apscale will take to process the data and vice versa, so if runtime is an issue, you can
  lower the compression level and if disk space is a concern, the compression level can be set to 9 as maximum value.



  Apscale gives default values for most of its settings. They can be changed if desired, please refer to the manual of vsearch and cutadapt
  for further information. The only value Apscale needs from the user is the primers used and the expected length of the fragment excluding which is used
  for quality filtering. After these are set, Apscale is ready to run!



  Navigate to the project folder you would like to process. Apscale can be run from anywhere on the system, but then needs a PATH to the project folder.

  `apscale -h`

  Will give help on the different functions of apscale.
  To run an all-in-one analysis on your dataset run:

  `apscale --run_apscale [PATH]`

  The PATH argument is optional and only needs to be used if you are not located in the project folder.
  This will automatically do PE merging, primer trimming, quality filter, OTU clustering and denoising of the data.
  The individual modules can also be run separately (see `apscale -h` for respective commands). A project report will be saved in the project folder as well as an individual
  report for the individual steps of the pipeline. Information about the versions of the programs used as well as how many reads where used and passed the module as well as a timestamp when the file finished.

  The main output of Apscale will be an OTU table and an ESV table, as well as two .fasta files, which can be used for taxonomic assignment. For example, for COI sequences,
  BOLDigger (https://github.com/DominikBuchner/BOLDigger) can be used directly with the output of Apscale to assign taxonomy to the OTUs / ESVs using the Barcode of Life Data system (BOLD) database. Furthermore, the ESV and OTU tables are compatible with TaxonTableTools (https://github.com/TillMacher/TaxonTableTools), which can be used for DNA metabarcoding specific analyses.



  Integrate swarm
  Adjust code to vsearch 2.28 output


pkgId: 4e77b70c8f34e95a57508277f2d6117362ad0e1ea36290a00cdd470138b8e6f4
name: python-apscale
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Advanced Pipeline for Simple yet Comprehensive AnaLysEs of DNA metabarcoding data
url: https://github.com/DominikBuchner/apscale
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apscale-2.1.0-1.src.rpm
checksum_type: sha256
description:
  Advanced Pipeline for Simple yet Comprehensive AnaLysEs of DNA metabarcoding data


  Apscale is a metabarcoding pipeline that handles the most common tasks in metabarcoding
  pipelines like paired-end merging, primer trimming, quality filtering and
  denoising. It uses a simple command line interface and is configured via a single configuration file.
  It automatically uses the available ressources on the machine it runs on while still providing the option
  to use less if desired. All modules can be run on their own or as a comprehensive workflow.

  A graphical user interface version for apscale is available [here](https://github.com/TillMacher/apscale_gui).

  Programs used:
  * vsearch (PE merging, quality filtering, denoising, chimera removal) (https://github.com/torognes/vsearch)
  * cutadapt (primer trimming) (https://github.com/marcelm/cutadapt)

  Input:
  * demultiplexed gzipped reads

  Output:
  * log files, project report, ESV table



  Apscale can be installed on all common operating systems (Windows, Linux, MacOS).
  Apscale requires Python 3.7 or higher and can be easily installed via pip in any command line:

  `pip install apscale`

  To update apscale run:

  `pip install --upgrade apscale`



  Apscale calls vsearch for multiple modules. It should be installed and be in PATH to be executed
  from anywhere on the system.

  Check the vsearch Github page for further info:

  https://github.com/torognes/vsearch

  Support for compressed files with zlib is necessary. For Unix based systems this is shipped with
  vsearch, for Windows the zlib.dll can be downloaded via:

  [zlib for Windows](https://sourceforge.net/projects/mingw-w64/files/External%20binary%20packages%20%28Win64%20hosted%29/Binaries%20%2864-bit%29/zlib-1.2.5-bin-x64.zip/download)

  The dll has to be in the same folder as the vsearch executable. If you need help with adding a folder to PATH in windows
  please take a look at the first answer on this stackoverflow issue:

  [How to add a folder to PATH Windows](https://stackoverflow.com/questions/44272416/how-to-add-a-folder-to-path-environment-variable-in-windows-10-with-screensho)

  To check if everything is correctly set up please type this into your command line:

  `vsearch --version`

  It should return a message similar to this:

  ```
  vsearch v2.19.0_win_x86_64, 31.9GB RAM, 24 cores
  https://github.com/torognes/vsearch

  Rognes T, Flouri T, Nichols B, Quince C, Mahe F (2016)
  VSEARCH: a versatile open source tool for metagenomics
  PeerJ 4:e2584 doi: 10.7717/peerj.2584 https://doi.org/10.7717/peerj.2584

  Compiled with support for gzip-compressed files, and the library is loaded.
  zlib version 1.2.5, compile flags 65
  Compiled with support for bzip2-compressed files, but the library was not found.
  ```



  Apscale also calls cutadapt with the primer trimming module. Cutadapt should be downloaded and installed
  automatically with the Apscale installation. To check this, type:

  `cutadapt --version`

  and it should return the version number, for example:

  `4.1`





  Apscale is organized in projects with the following structure:

  <pre>
  C:\USERS\DOMINIK\DESKTOP\EXAMPLE_PROJECT
  â”œâ”€â”€â”€1_raw data
  â”‚   â””â”€â”€â”€data
  â”œâ”€â”€â”€2_demultiplexing
  â”‚   â””â”€â”€â”€data
  â”œâ”€â”€â”€3_PE_merging
  â”‚   â””â”€â”€â”€data
  â”œâ”€â”€â”€4_primer_trimming
  â”‚   â””â”€â”€â”€data
  â”œâ”€â”€â”€5_quality_filtering
  â”‚   â””â”€â”€â”€data
  â”œâ”€â”€â”€6_dereplication
  â”‚   â””â”€â”€â”€data
  â”œâ”€â”€â”€7_denoising
  â”‚   â””â”€â”€â”€data
  â””â”€â”€â”€8_esv_table
  </pre>

  A new project can be initialized with the command:

  `apscale --create_project NAME`

  If you prefer to have your data all in one place you can copy the raw data into 1_raw_data/data.
  Demultiplexing won't be handled by Apscale because there are to many different tagging systems out there to implement in a single pipeline.
  If you are using inline barcodes you can take a look at https://github.com/DominikBuchner/demultiplexer2.
  If you are already starting with **demultiplexed** data please copy them into 2_demultiplexing/data.



  Associated with every newly created project, Apscale will generate an Excel sheet in the project folder called "Settings.xlsx".
  It is divided into seperate sheets for every module and a 0_general_settings tab.
  By default Apscale will set 'cores to use' to all available cores on the system the project is created - 2, but this can be lowered
  if the capacity is needed for other processes on your computer.
  Apscale only works with compressed data, so it takes compressed data as input and has compressed data as output.
  The compression level can be set in the general settings as well. Its default value is 6 since this is the default value of gzip.
  The higher the compression level, the longer Apscale will take to process the data and vice versa, so if runtime is an issue, you can
  lower the compression level and if disk space is a concern, the compression level can be set to 9 as maximum value.



  Apscale gives default values for most of its settings. They can be changed if desired, please refer to the manual of vsearch and cutadapt
  for further information. The only value Apscale needs from the user is the primers used and the expected length of the fragment excluding the primers which is used for quality filtering. After these are set, Apscale is ready to run!



  Navigate to the project folder you would like to process. Apscale can be run from anywhere on the system, but then needs a PATH to the project folder.

  `apscale -h`

  Will give help on the different functions of apscale.
  To run an all-in-one analysis on your dataset run:

  `apscale --run_apscale [PATH]`

  The PATH argument is optional and only needs to be used if you are not located in the project folder.
  This will automatically do PE merging, primer trimming, quality filter and denoising of the data.
  The individual modules can also be run separately (see `apscale -h` for respective commands). A project report will be saved in the project folder as well as an individual
  report for the individual steps of the pipeline. Information about the versions of the programs used as well as how many reads where used and passed the module as well as a timestamp when the file finished.

  The main output of Apscale will be an ESV table, as well as a .fasta files, which can be used for taxonomic assignment. For example, for COI sequences,
  BOLDigger3 (https://github.com/DominikBuchner/BOLDigger3) can be used directly with the output of Apscale to assign taxonomy to ESVs using the Barcode of Life Data system (BOLD) database. Furthermore, the ESV tables are compatible with TaxonTableTools (https://github.com/TillMacher/TaxonTableTools), which can be used for DNA metabarcoding specific analyses.


pkgId: 9da1a3d544f6037c1cf31da3e2aa30e380b6c80b026e73725ac69e1b87f2e17d
name: python-apscale-blast
arch: src
version: 1.0.3
epoch: 0
release: 1
url: https://pypi.org/project/apscale_blast/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apscale-blast-1.0.3-1.src.rpm
checksum_type: sha256
summary:
  Advanced Pipeline for Simple yet Comprehensive AnaLysEs of DNA metabarcoding data - BLAST application

description:
  Advanced Pipeline for Simple yet Comprehensive AnaLysEs of DNA metabarcoding data

  [![Downloads](https://static.pepy.tech/badge/apscale)](https://pepy.tech/project/apscale)  - apscale

  [![Downloads](https://static.pepy.tech/badge/apscale-blast)](https://pepy.tech/project/apscale-blast)  - apscale_blast




  Apscale-blast is part of the metabarcoding pipeline [apscale](https://github.com/DominikBuchner/apscale/tree/main) and is used
  for the taxonomic assignment of OTUs or ESVs.

  Programs used:
  * [blast+](https://blast.ncbi.nlm.nih.gov/doc/blast-help/downloadblastdata.html) (blastn module)

  Input:
  * sequence fasta files (containing OTUs/ESVs) generated with Apscale (or any other metabarcoding pipeline)

  Output:
  * taxonomy table, log files



  Apscale-blast can be installed on all common operating systems (Windows, Linux, MacOS).
  Apscale-blast requires Python 3.10 or higher and can be easily installed via pip in any command line:

  `pip install apscale_blast`

  To update apscale-blast run:

  `pip install --upgrade apscale_blast`



  Apscale-blast is also available as executable file that does not require the installation of python.
  Please make sure to add the executable to the whitelist of your anti-virus software, otherwise the apscale-blast
  will be blocked or deleted.

  Distributables will soon be available [here](https://seafile.rlp.net/d/754a25aa76e44b2381b6/).



  Apscale-blast calls blast+ (blastn) in the background. It should be installed and be in PATH to be executed
  from anywhere on the system. However, a PATH to the executable can also be provided within the command.

  You can find the latest blast+ executables and further information on the installation [here](https://ftp.ncbi.nlm.nih.gov/blast/executables/blast+/LATEST/).

  IMPORTANT: Please cite the blast+ software.

  Camacho, C., Coulouris, G., Avagyan, V., Ma, N., Papadopoulos, J., Bealer, K., & Madden, T. L. (2009). BLAST+: Architecture and applications. BMC Bioinformatics, 10, 421. https://doi.org/10.1186/1471-2105-10-421



  Apscale-blast uses pre-compiled databases. These databases will be tested and should prevent user-error. However, custom databases can also be created using [these scripts](https://github.com/TillMacher/apscale_blast/tree/main/db_creator), which are used to create the pre-compiled databases.

  The pre-compiled databases are available under the following [server](https://seafile.rlp.net/d/754a25aa76e44b2381b6/) and will be updated regularly.

  IMPORTANT: Please cite the used database accordingly!



  Leray, M., Knowlton, N., & Machida, R. J. (2022). MIDORI2: A collection of quality controlled, preformatted, and regularly updated reference databases for taxonomic assignment of eukaryotic mitochondrial sequences. Environmental DNA, 4(4), 894–907. https://doi.org/10.1002/edn3.303



  Nilsson, R. H., Larsson, K.-H., Taylor, A. F. S., Bengtsson-Palme, J., Jeppesen, T. S., Schigel, D., Kennedy, P., Picard, K., Glöckner, F. O., Tedersoo, L., Saar, I., Kõljalg, U., & Abarenkov, K. (2019). The UNITE database for molecular identification of fungi: Handling dark taxa and parallel taxonomic classifications. Nucleic Acids Research, 47(D1), Article D1. https://doi.org/10.1093/nar/gky1022

  When using the all eukaryote database, please cite it as follows:

  Abarenkov, Kessy; Zirk, Allan; Piirmann, Timo; Pöhönen, Raivo; Ivanov, Filipp; Nilsson, R. Henrik; Kõljalg, Urmas (2024): UNITE general FASTA release for eukaryotes 2. Version 04.04.2024. UNITE Community. https://doi.org/10.15156/BIO/2959335

  Includes global and 3% distance singletons.

  When using the fungi database, please cite it as follows:

  Abarenkov, Kessy; Zirk, Allan; Piirmann, Timo; Pöhönen, Raivo; Ivanov, Filipp; Nilsson, R. Henrik; Kõljalg, Urmas (2024): UNITE general FASTA release for Fungi 2. Version 04.04.2024. UNITE Community. https://doi.org/10.15156/BIO/2959333

  Includes global and 3% distance singletons.



  Quast, C., Pruesse, E., Yilmaz, P., Gerken, J., Schweer, T., Yarza, P., Peplies, J., & Glöckner, F. O. (2013). The SILVA ribosomal RNA gene database project: Improved data processing and web-based tools. Nucleic Acids Research, 41(D1), D590–D596. https://doi.org/10.1093/nar/gks1219



  Guillou, L., Bachar, D., Audic, S., Bass, D., Berney, C., Bittner, L., Boutte, C., Burgaud, G., de Vargas, C., Decelle, J., del Campo, J., Dolan, J. R., Dunthorn, M., Edvardsen, B., Holzmann, M., Kooistra, W. H. C. F., Lara, E., Le Bescot, N., Logares, R., … Christen, R. (2013). The Protist Ribosomal Reference database (PR2): A catalog of unicellular eukaryote Small Sub-Unit rRNA sequences with curated taxonomy. Nucleic Acids Research, 41(Database issue), D597–D604. https://doi.org/10.1093/nar/gks1160



  Rimet, F., Gusev, E., Kahlert, M., Kelly, M. G., Kulikovskiy, M., Maltsev, Y., Mann, D. G., Pfannkuchen, M., Trobajo, R., Vasselon, V., Zimmermann, J., & Bouchez, A. (2019). Diat.barcode, an open-access curated barcode library for diatoms. Scientific Reports, 9(1), Article 1. https://doi.org/10.1038/s41598-019-51500-6







  * Open a terminal, powershell, or command line window. Then, execute the following command:

  `apscale_blast blastn`



  * Open a terminal, powershell, or command line window. Navigate to the folder where the executable is located. Then, execute the following command:

  Windows: `./apscale_blast.exe blastn`

  MacOS: `./apscale_blast blastn`



  * You will be asked to provide the FULL PATH to your database. Enter the PATH in the command line. For example:

  `/Users/tillmacher/Downloads/MIDORI2_UNIQ_NUC_GB260_srRNA_BLAST`

  * Next, you will be asked to provide the FULL PATH to your query fasta file that contains the OTU/ESV sequences. Enter the PATH in the command line. For example:

  `/Users/tillmacher/Downloads/test_data_OTUs.fasta`

  * Apscale-blast will split your fasta into smaller subsets [DEFAULT: 100].

  * Each subset fasta file will be seperately blasted in parallel [DEFAULT: CPU count - 1].

  * A new folder is created containing the unfiltered blastn results:

  <pre>
  ├───test_data_OTUs.fasta
  └───test_data_OTUs
      ├───IDs.txt
      ├───log.txt
      ├───test_data_OTUs.parquet.snappy
      └───subsets
          ├───subset_1_blastn.csv
          ├───subset_2_blastn.csv
          ├───subset_3_blastn.csv
          └───subset_4_blastn.csv
  </pre>



  * Execute apscale-blast again and call the filter module:

  `apscale_blast filter`

  or

  Windows: `./apscale_blast.exe filter`

  MacOS: `./apscale_blast filter`

  * You will be asked to provide the FULL PATH to your database. Enter the PATH in the command line. For example:

  `/Users/tillmacher/Downloads/MIDORI2_UNIQ_NUC_GB260_srRNA_BLAST`

  * Next, you will be asked to provide the FULL PATH to the output folder that contains the unfiltered blastn results. Enter the PATH in the command line. For example:

  `/Users/tillmacher/Downloads/test_data_OTUs`

  * Apscale-blast will now filter the blastn results according to the following criteria:

  - By e-value (the e-value is the number of expected hits of similar quality which could be found just by chance):
  - The hit(s) with the lowest e-value are kept (the lower the e-value the better).
  - By taxonomy:
  - Hits with the same taxonomy are dereplicated.
  - Hits are adjusted according to thresholds (default: species >=98%, genus >=95%, family >=90%, order >=85%) and dereplicated.
  - Hits with still conflicting taxonomy are set back to the most recent common taxonomy
  - OTU without matches in the blastn search are re-added as 'No Match'

  * The results are collected and written to an new Excel file.

  <pre>
  ├───test_data_OTUs.fasta
  └───test_data_OTUs
      ├───IDs.txt
      ├───log.txt
      ├───test_data_OTUs_taxonomy.xlsx  <-- Filtered taxonomic identification results!
      ├───test_data_OTUs.parquet.snappy
      └───subsets
          ├───subset_1_blastn_filtered.xlsx
          ├───subset_1_blastn.csv
          ├───subset_2_blastn_filtered.xlsx
          ├───subset_2_blastn.csv
          ├───subset_3_blastn_filtered.xlsx
          ├───subset_3_blastn.csv
          ├───subset_4_blastn_filtered.xlsx
          └───subset_4_blastn.csv
  </pre>





  options:

    -h, --help -> show this help message and exit

    -database DATABASE -> PATH to blastn database.

    -apscale_gui APSCALE_GUI -> Can be ignored: Only required for APSCALE-GUI.

    -blastn_exe BLASTN_EXE -> PATH to blast executable. [DEFAULT: blastn]

    -query_fasta QUERY_FASTA -> PATH to fasta file.

    -n_cores N_CORES -> Number of cores to use. [DEFAULT: CPU count - 1]

    -task TASK -> Blastn task: blastn, megablast, or dc-megablast. [DEFAULT: blastn]

    -out OUT -> PATH to output directory. A new folder will be created here. [DEFAULT: ./]

    -subset_size SUBSET_SIZE -> Number of sequences for each subset of the query fasta. [DEFAULT: 100]

    -max_target_seqs MAX_TARGET_SEQS -> Number of hits retained from the blast search. Larger numbers will increase runtimes and required storage space [DEFAULT: 20]




  options:

    -h, --help -> show this help message and exit

    -database DATABASE -> PATH to blastn database.

    -apscale_gui APSCALE_GUI -> Can be ignored: Only required for APSCALE-GUI.

    -blastn_folder BLASTN_FOLDER -> PATH to blastn folder for filtering.

    -thresholds THRESHOLDS -> Taxonomy filter thresholds. [DEFAULT: 97,95,90,87,85]

    -n_cores N_CORES -> Number of cores to use. [DEFAULT: CPU count - 1]






  ![image](https://github.com/TillMacher/apscale_blast/blob/main/benchmarks/2024_09_benchmark.png?raw=true)


pkgId: e50773c83f3298a0cec9581bfcf423796ac372dbbb72b456f10cd08637966d6c
name: python-apscale-blast
arch: src
version: 1.0.4
epoch: 0
release: 1
url: https://pypi.org/project/apscale_blast/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apscale-blast-1.0.4-1.src.rpm
checksum_type: sha256
summary:
  Advanced Pipeline for Simple yet Comprehensive AnaLysEs of DNA metabarcoding data - BLAST application

description:
  Advanced Pipeline for Simple yet Comprehensive AnaLysEs of DNA metabarcoding data

  [![Downloads](https://static.pepy.tech/badge/apscale)](https://pepy.tech/project/apscale)  - apscale

  [![Downloads](https://static.pepy.tech/badge/apscale-blast)](https://pepy.tech/project/apscale-blast)  - apscale_blast




  Apscale-blast is part of the metabarcoding pipeline [apscale](https://github.com/DominikBuchner/apscale/tree/main) and is used
  for the taxonomic assignment of OTUs or ESVs.

  Programs used:
  * [blast+](https://blast.ncbi.nlm.nih.gov/doc/blast-help/downloadblastdata.html) (blastn module)

  Input:
  * sequence fasta files (containing OTUs/ESVs) generated with Apscale (or any other metabarcoding pipeline)

  Output:
  * taxonomy table, log files



  Apscale-blast can be installed on all common operating systems (Windows, Linux, MacOS).
  Apscale-blast requires Python 3.10 or higher and can be easily installed via pip in any command line:

  `pip install apscale_blast`

  To update apscale-blast run:

  `pip install --upgrade apscale_blast`

  The easiest installation option is the [Conda apscale environment](https://github.com/TillMacher/apscale_installer). This way, all dependencies will automatically be installed.



  Apscale-blast calls blast+ (blastn) in the background. It should be installed and be in PATH to be executed
  from anywhere on the system. However, a PATH to the executable can also be provided within the command.

  You can find the latest blast+ executables and further information on the installation [here](https://ftp.ncbi.nlm.nih.gov/blast/executables/blast+/LATEST/).

  IMPORTANT: Please cite the blast+ software.

  Camacho, C., Coulouris, G., Avagyan, V., Ma, N., Papadopoulos, J., Bealer, K., & Madden, T. L. (2009). BLAST+: Architecture and applications. BMC Bioinformatics, 10, 421. https://doi.org/10.1186/1471-2105-10-421



  Apscale-blast uses pre-compiled databases. These databases will be tested and should prevent user-error. However, custom databases can also be created using [these scripts](https://github.com/TillMacher/apscale_blast/tree/main/db_creator), which are used to create the pre-compiled databases.

  The [pre-compiled databases are available under the following server](https://seafile.rlp.net/d/474b9682a5cb4193a6ad/) and will be updated regularly.

  IMPORTANT: Please cite the used database accordingly!



  Leray, M., Knowlton, N., & Machida, R. J. (2022). MIDORI2: A collection of quality controlled, preformatted, and regularly updated reference databases for taxonomic assignment of eukaryotic mitochondrial sequences. Environmental DNA, 4(4), 894–907. https://doi.org/10.1002/edn3.303



  Nilsson, R. H., Larsson, K.-H., Taylor, A. F. S., Bengtsson-Palme, J., Jeppesen, T. S., Schigel, D., Kennedy, P., Picard, K., Glöckner, F. O., Tedersoo, L., Saar, I., Kõljalg, U., & Abarenkov, K. (2019). The UNITE database for molecular identification of fungi: Handling dark taxa and parallel taxonomic classifications. Nucleic Acids Research, 47(D1), Article D1. https://doi.org/10.1093/nar/gky1022

  When using the all eukaryote database, please cite it as follows:

  Abarenkov, Kessy; Zirk, Allan; Piirmann, Timo; Pöhönen, Raivo; Ivanov, Filipp; Nilsson, R. Henrik; Kõljalg, Urmas (2024): UNITE general FASTA release for eukaryotes 2. Version 04.04.2024. UNITE Community. https://doi.org/10.15156/BIO/2959335

  Includes global and 3% distance singletons.

  When using the fungi database, please cite it as follows:

  Abarenkov, Kessy; Zirk, Allan; Piirmann, Timo; Pöhönen, Raivo; Ivanov, Filipp; Nilsson, R. Henrik; Kõljalg, Urmas (2024): UNITE general FASTA release for Fungi 2. Version 04.04.2024. UNITE Community. https://doi.org/10.15156/BIO/2959333

  Includes global and 3% distance singletons.



  Quast, C., Pruesse, E., Yilmaz, P., Gerken, J., Schweer, T., Yarza, P., Peplies, J., & Glöckner, F. O. (2013). The SILVA ribosomal RNA gene database project: Improved data processing and web-based tools. Nucleic Acids Research, 41(D1), D590–D596. https://doi.org/10.1093/nar/gks1219



  Guillou, L., Bachar, D., Audic, S., Bass, D., Berney, C., Bittner, L., Boutte, C., Burgaud, G., de Vargas, C., Decelle, J., del Campo, J., Dolan, J. R., Dunthorn, M., Edvardsen, B., Holzmann, M., Kooistra, W. H. C. F., Lara, E., Le Bescot, N., Logares, R., … Christen, R. (2013). The Protist Ribosomal Reference database (PR2): A catalog of unicellular eukaryote Small Sub-Unit rRNA sequences with curated taxonomy. Nucleic Acids Research, 41(Database issue), D597–D604. https://doi.org/10.1093/nar/gks1160



  Rimet, F., Gusev, E., Kahlert, M., Kelly, M. G., Kulikovskiy, M., Maltsev, Y., Mann, D. G., Pfannkuchen, M., Trobajo, R., Vasselon, V., Zimmermann, J., & Bouchez, A. (2019). Diat.barcode, an open-access curated barcode library for diatoms. Scientific Reports, 9(1), Article 1. https://doi.org/10.1038/s41598-019-51500-6







  * Open a terminal, powershell, or command line window. Then, execute the following command:

  `apscale_blast blastn`



  * Open a terminal, powershell, or command line window. Navigate to the folder where the executable is located. Then, execute the following command:

  Windows: `./apscale_blast.exe blastn`

  MacOS: `./apscale_blast blastn`



  * You will be asked to provide the FULL PATH to your database. Enter the PATH in the command line. For example:

  `/Users/tillmacher/Downloads/MIDORI2_UNIQ_NUC_GB260_srRNA_BLAST`

  * Next, you will be asked to provide the FULL PATH to your query fasta file that contains the OTU/ESV sequences. Enter the PATH in the command line. For example:

  `/Users/tillmacher/Downloads/test_data_OTUs.fasta`

  * Apscale-blast will split your fasta into smaller subsets [DEFAULT: 100].

  * Each subset fasta file will be seperately blasted in parallel [DEFAULT: CPU count - 1].

  * A new folder is created containing the unfiltered blastn results:

  <pre>
  ├───test_data_OTUs.fasta
  └───test_data_OTUs
      ├───IDs.txt
      ├───log.txt
      ├───test_data_OTUs.parquet.snappy
      └───subsets
          ├───subset_1_blastn.csv
          ├───subset_2_blastn.csv
          ├───subset_3_blastn.csv
          └───subset_4_blastn.csv
  </pre>



  * Execute apscale-blast again and call the filter module:

  `apscale_blast filter`

  or

  Windows: `./apscale_blast.exe filter`

  MacOS: `./apscale_blast filter`

  * You will be asked to provide the FULL PATH to your database. Enter the PATH in the command line. For example:

  `/Users/tillmacher/Downloads/MIDORI2_UNIQ_NUC_GB260_srRNA_BLAST`

  * Next, you will be asked to provide the FULL PATH to the output folder that contains the unfiltered blastn results. Enter the PATH in the command line. For example:

  `/Users/tillmacher/Downloads/test_data_OTUs`

  * Apscale-blast will now filter the blastn results according to the following criteria:

  - By e-value (the e-value is the number of expected hits of similar quality which could be found just by chance):
  - The hit(s) with the lowest e-value are kept (the lower the e-value the better).
  - By taxonomy:
  - Hits with the same taxonomy are dereplicated.
  - Hits are adjusted according to thresholds (default: species >=98%, genus >=95%, family >=90%, order >=85%) and dereplicated.
  - Hits with still conflicting taxonomy are set back to the most recent common taxonomy
  - OTU without matches in the blastn search are re-added as 'No Match'

  * The results are collected and written to an new Excel file.

  <pre>
  ├───test_data_OTUs.fasta
  └───test_data_OTUs
      ├───IDs.txt
      ├───log.txt
      ├───test_data_OTUs_taxonomy.xlsx  <-- Filtered taxonomic identification results!
      ├───test_data_OTUs.parquet.snappy
      └───subsets
          ├───subset_1_blastn_filtered.xlsx
          ├───subset_1_blastn.csv
          ├───subset_2_blastn_filtered.xlsx
          ├───subset_2_blastn.csv
          ├───subset_3_blastn_filtered.xlsx
          ├───subset_3_blastn.csv
          ├───subset_4_blastn_filtered.xlsx
          └───subset_4_blastn.csv
  </pre>





  options:

    -h, --help -> show this help message and exit

    -database DATABASE -> PATH to blastn database.

    -apscale_gui APSCALE_GUI -> Can be ignored: Only required for APSCALE-GUI.

    -blastn_exe BLASTN_EXE -> PATH to blast executable. [DEFAULT: blastn]

    -query_fasta QUERY_FASTA -> PATH to fasta file.

    -n_cores N_CORES -> Number of cores to use. [DEFAULT: CPU count - 1]

    -task TASK -> Blastn task: blastn, megablast, or dc-megablast. [DEFAULT: blastn]

    -out OUT -> PATH to output directory. A new folder will be created here. [DEFAULT: ./]

    -subset_size SUBSET_SIZE -> Number of sequences for each subset of the query fasta. [DEFAULT: 100]

    -max_target_seqs MAX_TARGET_SEQS -> Number of hits retained from the blast search. Larger numbers will increase runtimes and required storage space [DEFAULT: 20]




  options:

    -h, --help -> show this help message and exit

    -database DATABASE -> PATH to blastn database.

    -apscale_gui APSCALE_GUI -> Can be ignored: Only required for APSCALE-GUI.

    -blastn_folder BLASTN_FOLDER -> PATH to blastn folder for filtering.

    -thresholds THRESHOLDS -> Taxonomy filter thresholds. [DEFAULT: 97,95,90,87,85]

    -n_cores N_CORES -> Number of cores to use. [DEFAULT: CPU count - 1]






  ![image](https://github.com/TillMacher/apscale_blast/blob/main/benchmarks/2024_09_benchmark.png?raw=true)


pkgId: 1ad554e5ce9b196ee95d97e5ee6d75fab1abfa3716e4cfde46fbe7eb1322fbd6
name: python-apscale-gui
arch: src
version: 2.0.3
epoch: 0
release: 1
url: https://github.com/TillMacher/apscale_gui
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apscale-gui-2.0.3-1.src.rpm
checksum_type: sha256
summary:
  Advanced Pipeline for Simple yet Comprehensive AnaLysEs of DNA metabarcoding data - Graphical User Interface

description:
  APSCALE is compatible with Windows, Linux, and macOS. Below are two ways to install APSCALE GUI:

  The easiest way to install APSCALE GUI is by using our APSCALE conda environment. [Follow the installation guide here](https://github.com/TillMacher/apscale_installer).

  To install via pip, run:
  `pip install apscale_gui`
  To update APSCALE GUI to the latest version, use:
  `pip install --upgrade apscale_gui`

  Creating a New Project
  1.	Create a new folder on your computer (e.g., on your desktop) and name it something like “APSCALE_projects.”
  2.	Activate the metabarcoding conda environment by running:
  `conda activate metabarcoding`
  3.	To start the APSCALE GUI, type:
  `apscale_gui`
  4.	When prompted, select an output directory. It is recommended to create a new folder, such as “APSCALE_projects,” and select it using the “Browse” button.
  <img src="https://github.com/TillMacher/apscale_gui/blob/master/_figures/Apscale_gui_1.png" alt="Startup window" width="500"/>
  5.	After clicking “Continue,” the main menu will appear.
  <img src="https://github.com/TillMacher/apscale_gui/blob/master/_figures/Apscale_gui_2.png" alt="Main window" width="500"/>
  6.	If you are starting APSCALE GUI for the first time, click the “Create New Apscale Project” button to start a new project. You will be prompted to name your project, and a new project folder will be created with the following subdirectories:
  <pre>
  /YOUR_PROJECT_PATH/My_new_project/
  ├───1_raw_data
  │   └───data
  ├───2_demultiplexing
  │   └───data
  ├───3_PE_merging
  │   └───data
  ├───4_primer_trimming
  │   └───data
  ├───5_quality_filtering
  │   └───data
  ├───6_dereplication_pooling
  │   └───data
  ├───7_denoising
  │   └───data
  ├───8_esv_table
  Settings_My_new_project.xlsx
  </pre>
  6. Alternatively, you can load an existing project by clicking “Load Existing Apscale Project.”


  APSCALE expects demultiplexed .fastq.gz files in the 2_demultiplexing/data folder (see project structure above).
  Ensure that the paired-end reads end with _R1.fastq.gz and _R2.fastq.gz.
  Optionally, you can place raw data in the 1_raw_data/data folder, but note that APSCALE does not handle demultiplexing directly. You can use tools like the [Demultiplexer tool](https://github.com/DominikBuchner/demultiplexer) for this step.

  <img src="https://github.com/TillMacher/apscale_gui/blob/master/_figures/Apscale_gui_3.png" alt="Startup window" width="500"/>
  1. Adjust Settings: Before running APSCALE, make sure to adjust the necessary settings. You can do this:
  * Directly in the GUI, or
  * By manually editing the settings file.
  2. While most settings can be left on default, you need to configure the following:
  * Forward primer sequence (in 5’-3’ orientation)
  * Reverse primer sequence (in 5’-3’ orientation)
  * Length of the target fragment (after primer trimming)
  9. Run the Pipeline
  * You can choose to run the entire APSCALE pipeline or specific parts. To run the entire pipeline, select “Run Apscale” and click “Save & Submit.”

  The Local BLASTn module performs taxonomic assignments for your data. It uses the APSCALE-BLAST module.
  <img src="https://github.com/TillMacher/apscale_gui/blob/master/_figures/Apscale_gui_4.png" alt="Startup window" width="500"/>
  1. Download Database: [Download your database of choice from this server](https://seafile.rlp.net/d/754a25aa76e44b2381b6/).
  2. Select Database: After unpacking the database into the “Apscale_databases” folder within your project directory, select the desired database for taxonomic assignment in the GUI.
  3. Run the BLASTn search.
  4. Save Results: The taxonomy table will automatically be saved to the 8_esv_table folder.

  The BOLDigger2 module is used for taxonomic assignments against the BOLD database, based on the [BOLDigger2 pipeline](https://github.com/DominikBuchner/BOLDigger2/tree/main).
  <img src="https://github.com/TillMacher/apscale_gui/blob/master/_figures/Apscale_gui_5.png" alt="Startup window" width="500"/>
  1. Enter Credentials: You will need to provide your BOLDsystems username and password to allow BOLDigger2 to perform the taxonomic assignment.
  2. Save Results: The resulting taxonomy table will be written into the 8_esv_table folder.

  When using APSCALE, please cite the following:
  * [APSCALE](https://academic.oup.com/bioinformatics/article/38/20/4817/6677653?login=false)
  * [VSEARCH](https://peerj.com/articles/2584/)
  * [Cutadapt](https://journal.embnet.org/index.php/embnetjournal/article/view/200)
  * [BOLDigger](https://mbmg.pensoft.net/article/53535/)
  * [The specific database for local BLASTn search](https://github.com/TillMacher/apscale_blast?tab=readme-ov-file#available-databases).


pkgId: 99b5b20814447ef0489b8bf0052b38b8e0e64c2d5fb3f76b7ec8764a81ed1d16
name: python-apsg
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: APSG - The package for structural geologists
url: https://github.com/ondrolexa/apsg
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apsg-1.2.3-1.src.rpm
checksum_type: sha256
description:
  <img src="https://ondrolexa.github.io/apsg/apsg_banner.svg" alt="APSG logo" width="300px"/>

  [![PyPI - Version](https://img.shields.io/pypi/v/apsg)](https://pypi.org/project/apsg)
  [![Conda](https://img.shields.io/conda/v/conda-forge/apsg)](https://anaconda.org/conda-forge/apsg)
  [![Documentation Status](https://readthedocs.org/projects/apsg/badge/?version=stable)](https://apsg.readthedocs.io/en/stable/?badge=stable)
  [![DOI](https://zenodo.org/badge/24879346.svg)](https://zenodo.org/badge/latestdoi/24879346)



  APSG is the package for structural geologists. It defines several new python classes to easily manage, analyze and visualize orientational structural geology data.



  APSG has been significantly refactored from version 1.0 and several changes are
  breaking backward compatibility. The main APSG namespace provides often-used
  classes in lowercase names as aliases to `PascalCase` convention used in
  modules to provide a simplified interface for users. The `PascalCase` names of
  classes use longer and plain English names instead acronyms for better
  readability.

  Check [documentation](https://apsg.readthedocs.org) for more details.




  You need Python 3.8 or later to run APSG. The package requires [NumPy](https://numpy.org/) and [SciPy](https://www.scipy.org/), and [Matplotlib](https://matplotlib.org/).



  APSG can be installed using pip:
  ```
  pip install apsg
  ```
  If you want to run the latest version of the code, you can install it from git:
  ```
  pip install git+https://github.com/ondrolexa/apsg.git
  ```
  Alternatively, you can download the package manually from the GitHub repository [https://github.com/ondrolexa/apsg](https://github.com/ondrolexa/apsg), unzip it, navigate into the package, and use the command:
  ```
  python setup.py install
  ```
  or
  ```
  pip install .
  ```



  To upgrade an existing version of APSG from PyPI, execute
  ```
  pip install apsg --upgrade --no-deps
  ```
  Please note that the dependencies (Matplotlib, NumPy and SciPy) will also be upgraded if you omit the `--no-deps` flag; use the `--no-deps` ("no dependencies") flag if you don't want this.



  The APSG package is also available on `conda-forge` channel.



  | Name | Downloads | Version | Platforms |
  | --- | --- | --- | --- |
  | [![Conda Recipe](https://img.shields.io/badge/recipe-apsg-green.svg)](https://anaconda.org/conda-forge/apsg) | [![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/apsg.svg)](https://anaconda.org/conda-forge/apsg) | [![Conda Version](https://img.shields.io/conda/vn/conda-forge/apsg.svg)](https://anaconda.org/conda-forge/apsg) | [![Conda Platforms](https://img.shields.io/conda/pn/conda-forge/apsg.svg)](https://anaconda.org/conda-forge/apsg) |



  Installing `apsg` from the `conda-forge` channel can be achieved by adding `conda-forge` to your channels with:

  ```
  conda config --add channels conda-forge
  ```

  Once the `conda-forge` channel has been enabled, `apsg` can be installed with:

  ```
  conda install apsg
  ```

  It is possible to list all of the versions of `apsg` available on your platform with:

  ```
  conda search apsg --channel conda-forge
  ```



  Explore the full features of APSG. You can find detailed documentation [here](https://apsg.readthedocs.org).



  Most discussion happens on [Github](https://github.com/ondrolexa/apsg). Feel free to open [an issue](https://github.com/ondrolexa/apsg/issues/new) or comment on any open issue or pull request. Check ``CONTRIBUTING.md`` for more details.



  APSG is an open-source project, available for you for free. It took a lot of time and resources to build this software. If you find this software useful and want to support its future development please consider donating me.

  [![Donate via PayPal](https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=QTYZWVUNDUAH8&item_name=APSG+development+donation&currency_code=EUR&source=url)



  APSG is free software: you can redistribute it and/or modify it under the terms of the MIT License. A copy of this license is provided in ``LICENSE`` file.





   * ClusterSet accepts PairSet and FaultSet
   * quicknet label option added
   * vector pow bug fix


   * Fault sense could be defined by str, one of 's', 'd', 'n' and 'r'


   * Fault sense could be defined by str, one of 's', 'd', 'n' and 'r'


   * sqlalchemy and pandas added to requirements
   * quicknet fault bug fixed


   * paleomag Core .dd bug fixed
   * fix round-off domain math error for acosd and asind


   * Ellipsoid repr bugfix


  Bugfix release
   * slip and dilatation tendency methods added to stress
   * proj alias of project for FeatureSet added


   * added title_kws argument for plotting routines


   * sigma estimate contour fix


  APSG offers convenient pandas integration via pandas accessors.

  See documentation and Pandas interface tutorial for further details.

   * StereoNet tensor method added
   * Cluster class renamed to ClusterSet


   * lambda properties of tensors renamed to S
   * cursor coordinates in stereonet show lin and fol


   * density_lookup method implemented for StereoNet.grid
   * Stress tensor sigma* properties using inverted order of eigenvalues
   * render2fig method of StereoNet implemented
   * vector-like objects are not iterable, so properly render in pandas


  New major release

  APSG has been significantly refactored from version 1.0 and several changes are
  breaking backward compatibility. The main APSG namespace provides often-used
  classes in lowercase names as aliases to `PascalCase` convention used in
  modules to provide a simplified interface for users. The `PascalCase` names of
  classes use longer and plain English names instead acronyms for better
  readability.

  See documentation for further details.


   * figure window title removed from StereoNet
   * for future only bugfixes planned, foo further development see versions >=1.0


   * bugfix release


   * paleomag rs3 input/output improved
   * Simple SQLAlchemy API to sdb database implemented
   * StereoNet arc method fixed
   * StereoNet polygon method added



  * Python 2 support dropped
  * RosePlot added
  * Ortensor has from_pairs method for Lisle tensor for orthogonal data
  * StereoNet scatter method has labels kwarg to show hover annotations



  * Python 2/3 compatibility fix



  * few minor bugs fixed
  * Stereogrid apply_func passes Vec3 instead numpy array
  * Pair H method to get mutual rotation implemented
  * velgrad method of DefGrad accepts steps kwarg
    to generate list of DefGrad tensors
  * Added Tensor class to work with deformation tensors



  * Stereogrid always use Euclidean norms as weights
  * DefGrad properties e1, e2, e3 (natural principal strains) added
  * DefGrad properties eoct, goct (octahedral strains) added
  * DefGrad from_ratios class method added
  * DefGrad properties k, d, K, D (strain symmetries and intesities) added
  * New class Ellipsoid added to work with ellipsoids
  * FabricPLot renamed to VollmerPlot for consistency
  * RamsayPlot, FlinnPlot and HsuPlot implemented
  * All fabric plots have new path method accepting list of tensors



  * Stress always gives eigenvalues sorted
  * Stress I1, I2, I3 properties for invariants implemented
  * Stress mean_stress property implemented
  * Stress hydrostatic and deviatoric properties implemented
  * precision added to settings to control numerical comparisms
  * figsize added to settings to control figure size across APSG
  * Animation examples fixed
  * rand class method implemented for Fol, Lin, Vec3 and Pair to
    generate random instance
  * Group to_csv and from_csv improved
  * SDB tags method works properly for multiple tags
  * SDB can modify database metadata
  * QGIS 3 plugin ReadSDB compatibility



  * StereoNet has cbpad keyword for colorbar padding
  * FabricPlot bug introduced in 0.5.2 fixed.



  * Bugfix release



  * Fischer distribution sampling added
  * transform method has norm kwarg to normalize tranformed vectors
  * axisangle property to calculate axis and angle from rotation matrix
  * StereoNet arc method added
  * Vec3 and Group upper and flip properties implemented
  * DefGrad, VelGrad and Stress rotate method accepts also rotation matrix
  * velgrad method added to DefGrad to calculate matrix logarithm
  * StereoGrid has new methods max, min, max_at, min_at



  * Kent distribution sampling added
  * Automatic kernel density estimate for contouring
  * UserWarnings fix



  * bux fix minor release



  * Group method centered improved
  * Group method halfspace added to reorient all vectors towards resultant
    halfspace



  * Stress tensor with few basic methods implemented
  * StereoGrid keyword argument 'weighted' to control weighting
  * StereoNet kwargs are passed to underlying methods for immediate plots
  * StereoNet tensor method implemented (draw eigenlins or fols based on
    fol_plot settings)
  * Group totvar property and dot and proj methods implemented
  * Fol and Lin dot method returns absolute value of dot product
  * Vec3 H method to get mutual rotation implemented
  * StereoNet.contourf method draw contour lines as well by default. Option
    clines controls it.
  * centered bug fixed
  * StereoNet allows simple animations. Add `animate=True` kwarg to plotting
    method and finally call StereoNet animate method.



  * bugfix



  * Density class renamed to StereoGrid
  * Fault sense under rotation fixed
  * FaultSet example provided
  * Angelier-Mechler dihedra method implemented for FaultSet
  * StereoNet accepts StereoGrid and Ortensor as quick plot arguments
  * StereoNet instance has axtitle method to put text below stereonet



  * conda build for all platforms
  * numpy, matplotlib and other helpres imported by default
  * ortensor is normed by default
  * ortensor MADp, MADo, MAD and kind properties added



  * shell script iapsg opens interactive console



  * Simple settings interface implemented in in apsg.core.seetings dictionary.
    To change settings use:
    ```
    from apsg.core import settings
    setting['name']=value
    ```
  * `notation` setting with values `dd` or `rhr` control how azimuth argument of
    Fol is represented.
  * `vec2dd` setting with values `True` or `False` control how `Vec3` is
    represented.
  * Vec3 could be instantiated by one arument (vector like), 2 arguments
    (azimuth, inclination) or 3 arguments (azimuth, inclination, magnitude).
  * Group and FaultSet can return array or list of user-defined attributes of
    all elements



  * RTD fix



  * Added E1,E2,E3 properties and polar decomposition method to DefGrad object
  * StereoNet has vector method to mimics lower and upper hemisphere plotting
    of Lin and Vec3 objects as used in paleomagnetic plots
  * StereoNet could be initialized with subplots
  * rake method of Fol added to return vector defined by rake
  * Density could be initialized without data for user-defined calculations
    New method apply_func could be used to calculate density
  * Contour(f) methods accept Density object as argument
  * Added Group class methods to generate Spherical Fibonacci and Golden Section
    based uniform distributions of Vec3, Lin and Fol



  * FabricPlot - triangular fabric plot added
  * .asvec3 property has .V alias
  * Resultant of Fol and Lin is calculated as vectorial in centered position
  * dv property of Fol added to return dip slip vector



  * SDB class improved. Support basic filtering including tags
  * StereoNet has close method to close figure and new method
    to re-initialize figure when closed in interactive mode
  * iapsg shell script added to invoke apsg ipython shell



  * Group fancy indexing implemented. Group could be indexed by sequences
    of indexes like list, tuple or array as well as sliced.
  * Cluster class with hierarchical clustering implemented
  * Group to_file and from_file methods implemented to store data in file
  * Group copy method for shallow copy implemented
  * StereoNet now accept Vec3 and Fault object as well for instant plotting.
  * Ortensor updated with new properties E1,E2,E3 and Vollmer(1989) indexes
    P,G,R and C. Bug in Woodcocks's shape and strength values fixed.
  * uniform_lin and uniform_fol improved.
  * asvec3 method implemented for Fol and Lin
  * fol_plot property of StereoNet allows choose poles or great circles for
    immediate plotting
  * bootstrap method of Group provide generator of random resampling with
    replacements.
  * Group examples method provide few well-known datasets.
  * Matplotlib deprecation warnings are ignored by default



  * New Docstrings format
  * StereoNet.getfols method bug fixed.
  * Shell scripts to run interactive session improved.



  * FaultSet class added. Fault and Hoeppner methods of StereoNet implemented
  * VelGrad and DefGrad classes used for transformations added
  * G class to quickly create groups from strings added.



  * Quick plotting of groups fixed.



  * new StereoNet class for Schmidt projection
  * Quick plot when data are passed as argument `StereoNet` class instantiation
  * mplstereonet dependency depreceated
  * new `Pair` and `Fault` classes to manipulate paired data (full support in future)
  * new `uniform_lin` and `uniform_fol` `Group` methods
  * abs for `Group` implemented to calculate euclidean norms
  * new `Group` method normalized
  * new `Group` properties and methods to calculate spherical statistics



  * First release of APSG


pkgId: 2fc1a5a20d46ca0312e9e94adc730a89440e421ab5a57d59e6b1604ac13fb10e
name: python-apsimNGpy
arch: src
version: 0.0.27.9
epoch: 0
release: 1
summary: apsimx next generation package interface
url: https://github.com/MAGALA-RICHARD/apsimNGpy.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apsimNGpy-0.0.27.9-1.src.rpm
checksum_type: sha256
description:
  Our cutting-edge open-source framework, apsimNGpy, empowers advanced agroecosystem modeling through the utilization
  of object-oriented principles. It features fast batch file simulation, model prediction, evaluation,
  apsimx file editing, seamless weather data retrieval, and efficient soil profile development
  Requirements
  ***********************************************************************************
  1. Dotnet, install from https://learn.microsoft.com/en-us/dotnet/core/install/
  2. Python3
  3. APSIM: Add the directory containing the models executable to the system's PATH or python path (to locate the required .dll files). This can be achieved in either of the following ways:
  4. Utilize the APSIM installer provided for this purpose.
  5. Build APSIM from its source code. This is comming soon
  6. Minimum; 8GM RAM, CPU Core i7
  Installation
  ********************************************************************************
  All versions are currently in development, phase and they can be installed as follows:
  - Method 1. install from PyPI
      pip install apsimNGpy
  - Method 1. clone the current development repositry
      git clone https://github.com/MAGALA-RICHARD/apsimNGpy.git@dev
      cd apsimNGpy
      pip install .
  - Method 2. Use pip straight away and install from github
       pip install git+https://github.com/MAGALA-RICHARD/apsimNGpy.git@dev
  Debugging import error due to improper SYSTEM APSIM path configuration
  *********************************************************************************
  If you have apsim installed and the program refuses to load run the following code at the top of your python script
  before importing any apsimNGpy class, especially class from ApsimNGpy.core modules The classes are  CamelCased.
      
      import os
      
      from apsimNGpy.config import Config
      
      Config.set_aPSim_bin_path(path = r'path/toyourapsimbinaryfolder/bin)
      
      
      
      os.environ['APSIM'] =r'path/toyourapsimbinaryfolder/bin
      
      os.environ['Models'] =r'path/toyourapsimbinaryfolder/bin
      
      
      
      
      from apsimNGpy.core.apsim import ApsimModel
  The above code is also applicable for running different versions of APSIM models. Please note that if your APSIM installation hasn't been added to the system path, this script line should always be placed at the beginning of your simulation script.
  Required Dependencies:
  *****************************
  - numpy
  - pandas
  - pythonnet
  - xmltodict
  - tqdm
  - requests
  Please note that apsimNGpy is tested on Python 3. We are not aware of its performance in Python 2 because it utilizes some of the new libraries like pathlib and f-strings.
  Usage
  *********************************************************************************
      import apsimNGpy
      from apsimNGpy.core.base_data import LoadExampleFiles
      from apsimNGpy.core.apsim  import ApsimModel as SoilModel
      from pathlib import Path
      import os
      from apsimNGpy.validation.visual import plot_data
      cwd = Path.cwd().home() # sending this to your home folder
      wd = cwd.joinpath("apsimNGpy_demo")
      if not wd.exists():
         os.mkdir(wd)
      
      os.chdir(wd)
      
      data = LoadExampleFiles(wd)
      
      maize = data.get_maize
      
      soybean_model = load_default_simulations(crop = 'soybean') # don't worry it is not case senstive
      
      
      apsim = SoilModel(maize, copy=True)
      
      apsim.run() # use run to print time taken to excute or run the model
      
      print(apsim.results) # prints all data frames in the storage domain subset usign report names
      
      
      sim_name = apsim.simulation_names
      apsim.examine_management_info(simulations=sim_name)
      
      
      res = apsim.results['MaizeR']
      plot_data(res.Year, res.Yield, xlabel='Years', ylabel=" Maize Yield (kg/ha)")
  A graph should be able to appear like the ones below. Note that plot_data function just wraps matplotlib plot function
  for quick visualisation
  Congratulations you have successfully used apsimNGpy package
  *********************************************************************************
  Change APSIM simulation dates
  *********************************************************************************
      import apsimNGpy
      from apsimNGpy.core.base_data import LoadExampleFiles
      from apsimNGpy.core.apsim  import ApsimModel as SoilModel
      from pathlib import Path
      import os
      from apsimNGpy.validation.visual import plot_data
      cwd = Path.cwd().home() # sending this to your home folder
      wd = cwd.joinpath("apsimNGpy_demo")
      if not wd.exists():
        os.mkdir(wd)
      
      os.chdir(wd)
      
      data = LoadExampleFiles(wd)
      
      maize = data.get_maize
      
      apsim = SoilModel(maize, copy=True)
      apsim.change_simulation_dates(start_date='01/01/1998', end_date='12/31/2010')
  Change  APSIM model management decisions
  *********************************************************************************
      
      apsim.examine_management_info()
      
      passed in the dictionary.
      
      something else
      rotation  = {'Name': "Simple Rotation", "Crops": 'Maize, Wheat, Soybean'}, # the crops must be seperated my commas
      apsim.update_mgt(management = rotation, reload=True)
      
      same time
  Populating the APSIM model with new weather data
  *********************************************************************************
      from apsimNGpy.core.weather import daymet_bylocation_nocsv
      lonlat = -93.08, 42.014
      start_year, end_year = 2000, 2002
      wf = daymet_bylocation_nocsv(lonlat, startyear, endyear, filename="mymet.met")
      
      mis = apsim.show_met_file_in_simulation()
      print(mis)
      
      apsim.replace_met_file(weather_file=wf)
      
      mis = apsim.show_met_file_in_simulation()
      print(mis)
  Evaluate Predicted Variables
  *********************************************************************************
  The apsimNGpy Python package provides a convenient way to validate model simulations against measured data. Below
  is a step-by-step guide on how to use the validation.evaluator module from apsimNGpy.
      
      from apsimNGpy.validation.evaluator import validate
      import pandas as pd
      
      df = pd.read_csv('evaluation.csv')
      apsim_results = apsim.results  # Assuming 'apsim' is a predefined object from aopsimNGpy.core.core.APSIMN class and contains your simualted results
      
      
      
      measured = df['Measured']
      predicted = apsim_results['MaizeR'].Yield
      
      val = validate(measured, predicted)
      
      
      
      metrics = val.evaluate_all(verbose=True)
      
      
      RMSE = val.evaluate("RMSE")
      print(RMSE)
      
      available_metrics = metrics.keys()
      print(available_metrics)
      
  How to Contribute to apsimNGpy
  *********************************************************************************
  We welcome contributions from the community, whether they are bug fixes, enhancements, documentation updates, or new features. Here's how you can contribute to ``apsimNGpy``:


pkgId: fd85b1ca0858dabdddea3481dc4c37d3efed24f5dcd53b8249a5da7b49f75cac
name: python-apstools
arch: src
version: 1.7.0
epoch: 0
release: 1
summary: Library of Python tools for use with the Bluesky Framework at the APS.
url: https://bcda-aps.github.io/apstools/latest/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apstools-1.7.0-1.src.rpm
checksum_type: sha256
description:
  [![tag](https://img.shields.io/github/tag/BCDA-APS/apstools.svg)](https://github.com/BCDA-APS/apstools/tags) | [![release](https://img.shields.io/github/release/BCDA-APS/apstools.svg)](https://github.com/BCDA-APS/apstools/releases) | [![PyPi](https://img.shields.io/pypi/v/apstools.svg)](https://pypi.python.org/pypi/apstools) | [![conda-forge](https://img.shields.io/conda/vn/conda-forge/apstools)](https://anaconda.org/conda-forge/apstools)

rpm_license:
  Copyright (c) 2017-2024, UChicago Argonne, LLC  All Rights Reserved  apstools (previously: APS_BlueSky_tools)  BCDA, Advanced Photon Source, Argonne National Laboratory   OPEN SOURCE LICENSE  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  Software changes, modifications, or derivative works, should be noted with comments and the author and organization's name.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the names of UChicago Argonne, LLC or the Department of Energy nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  4. The software and the end-user documentation included with the redistribution, if any, must include the following acknowledgment:  "This product includes software produced by UChicago Argonne, LLC under Contract No. DE-AC02-06CH11357 with the Department of Energy."  ****************************************************************************  DISCLAIMER  THE SOFTWARE IS SUPPLIED "AS IS" WITHOUT WARRANTY OF ANY KIND.  Neither the United States GOVERNMENT, nor the United States Department of Energy, NOR uchicago argonne, LLC, nor any of their employees, makes any warranty, express or implied, or assumes any legal liability or responsibility for the accuracy, completeness, or usefulness of any information, data, apparatus, product, or process disclosed, or represents that its use would not infringe privately owned rights.  ****************************************************************************


pkgId: 9917a35bc7fe93b09636039fd042ed7fb18fed2c640ebf45922c7188fabcf9d9
name: python-apsw
arch: src
version: 3.46.1.0
epoch: 0
release: 1
summary: Another Python SQLite Wrapper
url: https://github.com/rogerbinns/apsw/
rpm_license: OSI Approved
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apsw-3.46.1.0-1.src.rpm
checksum_type: sha256
description:
  APSW lets you get the most out of the `SQLite <https://sqlite.org/>`__
  embedded relational database engine from Python, and the most out of
  Python from SQLite.  APSW glues together the complete `SQLite C API
  <https://sqlite.org/c3ref/intro.html>`__ and `Python's C API
  <https://docs.python.org/3/c-api/index.html>`__, staying up to date
  with both SQLite and Python.
  It is recommended to use the builtin `sqlite3 module
  <https://docs.python.org/3/library/sqlite3.html>`__ if you want SQLite
  to appear interchangeable with the other database drivers.
  Use APSW when you want to use SQLite fully, and have an improved
  developer experience.  The `documentation
  <https://rogerbinns.github.io/apsw/pysqlite.html>`__ has a section on
  the differences between APSW and sqlite3.


pkgId: f18341f56ae8eb7eb045e68b30a000fdf692b63f48de7c86e7d1679aa452ccf2
name: python-apsw
arch: src
version: 3.47.0.0
epoch: 0
release: 1
summary: Another Python SQLite Wrapper
url: https://github.com/rogerbinns/apsw
rpm_license: OSI Approved
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apsw-3.47.0.0-1.src.rpm
checksum_type: sha256
description:
  APSW lets you get the most out of the `SQLite <https://sqlite.org/>`__
  embedded relational database engine from Python, and the most out of
  Python from SQLite.  APSW glues together the complete `SQLite C API
  <https://sqlite.org/c3ref/intro.html>`__ and `Python's C API
  <https://docs.python.org/3/c-api/index.html>`__, staying up to date
  with both SQLite and Python.  This includes `full text search
  <https://rogerbinns.github.io/apsw/textsearch.html>`__.
  It is recommended to use the builtin `sqlite3 module
  <https://docs.python.org/3/library/sqlite3.html>`__ if you want SQLite
  to appear interchangeable with the other database drivers.
  Use APSW when you want to use SQLite fully, and have an improved
  developer experience.  The `documentation
  <https://rogerbinns.github.io/apsw/pysqlite.html>`__ has a section on
  the differences between APSW and sqlite3.


pkgId: 129f9511ec97701ae2bf9bec72f5f3c085e4910b33f215270cb0288c1350b6dd
name: python-apsw-sqlite3mc
arch: src
version: 3.46.1.0
epoch: 0
release: 1
summary: SQLite3 Multiple Ciphers combined with Another Python SQLite Wrapper
url: https://github.com/utelle/apsw-sqlite3mc
rpm_license: OSI Approved
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apsw-sqlite3mc-3.46.1.0-1.src.rpm
checksum_type: sha256
description:
  This project packages 3 things together
  `APSW <https://rogerbinns.github.io/apsw/>`__
    Another Python SQLite wrapper, providing complete access to SQLite3
    from Python.
  `SQLite 3 <https://www.sqlite.org/>`__
    Small, fast, self-contained, high-reliability, full-featured, SQL
    database engine.  SQLite is configured with `secure delete
    <https://www.sqlite.org/pragma.html#pragma_secure_delete>`__ turned
    on, and to use `memory for temporary storage
    <https://www.sqlite.org/tempfiles.html#the_sqlite_temp_store_compile_time_parameter_and_pragma>`__.
  `SQLite3 Multiple Ciphers <https://utelle.github.io/SQLite3MultipleCiphers/>`__
    Extends SQLite 3 to allow reading and writing encrypted databases.
  The distribution is entirely self contained, and does not use or alter
  any existing SQLite you may already have on your system.


pkgId: bd14ef9fe6c55b25cad7177f702f847095e2fceb2123f6e42779ea2664de433b
name: python-apsystems-ez1
arch: src
version: 2.4.0
epoch: 0
release: 1
url: https://pypi.org/project/apsystems-ez1/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apsystems-ez1-2.4.0-1.src.rpm
checksum_type: sha256
summary:
  The APsystems EZ1 Python library offers a streamlined interface for interacting with the local API of APsystems EZ1 Microinverters.

description:
  This library is published, maintained, and developed by Sonnenladen GmbH. Our collaboration with the APsystems R&D Team has been instrumental in making this API a reality. At Sonnenladen GmbH, we are committed to providing top-notch solar energy solutions and are excited to offer this library to enhance the experience of using APsystems inverters.


pkgId: 766232cb313fda5d7ed553b13d641d668df4a21d15591600113aab6c50208a44
name: python-apsystems_api
arch: src
version: 0.1.15
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/apsystems_api/
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apsystems_api-0.1.15-1.src.rpm
checksum_type: sha256
description:
  This API is used to interface with the [APsystems EZ1-M](https://emea.apsystems.com/diy/ez1/) using their cloud service.


pkgId: f40d4a4c5631276c3ea23e46ed81222fd9b5d4d457cd813a972e3de1fc3181ef
name: python-apt-wrapper
arch: src
version: 1.19
epoch: 0
release: 1
summary: A simpler interface to the Debian/Ubuntu APT command-line tools.
url: https://github.com/mixmastamyk/apt-wrapper
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apt-wrapper-1.19-1.src.rpm
checksum_type: sha256
description:
  Note:
      This still works but is deprecated in favor of the spam project,
      by the same developer.
  A shorter, simpler, and slightly saner interactive interface to the
  `Debian/Ubuntu APT <http://en.wikipedia.org/wiki/Advanced_Packaging_Tool>`_
  command-line tools.
  **Note:** This utility is not as useful as it once was because the apt command
  has already incorported its headline features.
  However, it is still more convenient in a number of ways,
  so read on if you'd like.
  ``apt`` may be thought of as a traffic cop
  that directs commands to the appropriate tool,
  automatically elevating itself with sudo if need-be.
  It consolidates all commands from ``apt-get`` and ``apt-cache``,
  and the most common from
  ``aptitude, dpkg, dpkg-query, add-apt-repository``, and ``apt-key``.
  It has a much narrower focus than "kitchen-sink" tools such as ``wajig``.
  Hopefully this micro-project will make your life a tiny bit easier.
  |


pkgId: bb80aed41f02aa8703d8ef869bc27dcea6077be2bcdd9c6df5e902f5d4b687b1
name: python-aptio
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Aptio package manager.
url: https://github.com/arye-zamir/aptio
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aptio-0.0.2-1.src.rpm
checksum_type: sha256
description:
  A modern Python package manager GUI and CLI tool. stay tuned for updates!

  The name Aptio is derived from the Latin word _aptus_, meaning "fit" or "suitable," reflecting its goal to provide a streamlined and adaptable solution for Python package management. It is pronounced **"ap-tee-oh"**.



  Modern Python development often involves juggling multiple tools and dependencies to set up even the simplest project. For instance, installing essential build tools like `setuptools`, `twine`, and `build`, alongside a basic developer experience (DevEx) stack such as `black`, `bandit`, `pylint`, and `pytest`, can result in a requirements.txt file with over 50 packages due to transitive dependencies.

  In such cases, it becomes nearly impossible to determine which dependencies were explicitly installed and which were pulled in as subdependencies. This lack of visibility creates challenges in managing, updating, and auditing project dependencies, particularly in environments with strict security or compliance requirements.

  Aptio aims to simplify and modernize Python package management by providing tools for clear dependency visualization, streamlined installation, and proactive monitoring. With a graphical and CLI-based approach, Aptio empowers developers to maintain control over their Python environments, ensuring transparency and efficiency at every stage of development.


pkgId: d0176af44683deb9eee02b15dc6ce285d3106d5162ae749693ef046d5349fe34
name: python-aptly-api-client
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: A Python 3 client for the Aptly API
url: https://pypi.org/project/aptly-api-client/
rpm_license: Mozilla Public License 2.0 (MPL 2.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aptly-api-client-0.2.4-1.src.rpm
checksum_type: sha256
description:
  This is a thin abstraction layer for interfacing with
  `Aptly's HTTP API <https://www.aptly.info/doc/api/>`__. It's used by
  `GoPythonGo <https://github.com/gopythongo/gopythongo/>`__, but can be used as
  a standalone library from Pypi.
      pip install aptly-api-client


pkgId: e786b90f4c1a311e06acd2f8c6df1f5c31e2a0b1fab05bc98fbf97f79d5c1a93
name: python-aptos-sdk
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: Aptos SDK
url: https://github.com/aptos-labs/aptos-core/tree/main/ecosystem/python/sdk
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aptos-sdk-0.10.0-1.src.rpm
checksum_type: sha256
description:
  [![Discord][discord-image]][discord-url]
  [![PyPI Package Version][pypi-image-version]][pypi-url]
  [![PyPI Package Downloads][pypi-image-downloads]][pypi-url]

  This provides basic functionalities to interact with [Aptos](https:/github.com/aptos-labs/aptos-core/). Get started [here](https://aptos.dev/guides/system-integrators-guide/#getting-started).

  Currently, this is still in development and may not be suitable for production purposes.

  Note: The sync client is deprecated, please only start new projects using the async client. Feature contributions to the sync client will be rejected.


  This SDK uses [Poetry](https://python-poetry.org/docs/#installation) for packaging and dependency management:

  ```
  curl -sSL https://install.python-poetry.org | python3 -
  poetry install
  ```


  ```bash
  make test
  ```



  * Download and install the [Aptos CLI](https://aptos.dev/tools/aptos-cli/use-cli/running-a-local-network).
  * Set the environment variable `APTOS_CLI_PATH` to the full path of the CLI.
  * Retrieve the [Aptos Core Github Repo](https://github.com/aptos-labs/aptos-core) (git clone https://github.com/aptos-labs/aptos-core)
  * Set the environment variable `APTOS_CORE_REPO` to the full path of the Repository.
  * `make integration_test`

  You can do this a bit more manually by:

  First, run a local testnet (run this from the root of aptos-core):

  ```bash
  aptos node run-local-testnet --force-restart --assume-yes --with-indexer-api
  ```

  Next, tell the end-to-end tests to talk to this locally running testnet:

  ```bash
  export APTOS_CORE_REPO="/path/to/repo"
  export APTOS_FAUCET_URL="http://127.0.0.1:8081"
  export APTOS_INDEXER_URL="http://127.0.0.1:8090/v1/graphql"
  export APTOS_NODE_URL="http://127.0.0.1:8080/v1"
  ```

  Finally run the tests:

  ```bash
  make examples
  ```

  Integration Testing Using the Aptos CLI:

  ```bash
  make integration_test
  ```

  > [!NOTE]
  > The Python SDK does not require the Indexer, if you would prefer to test without it, unset or do not set the environmental variable `APTOS_INDEXER_URL` and exclude `--with-indexer-api` from running the aptos node software.


  ```bash
  make fmt
  ```


  ```bash
  make lint
  ```



  * Download the [Aptos CLI](https://aptos.dev/tools/aptos-cli/install-cli/).
  * Set the environment variable `APTOS_CLI_PATH` to the full path of the CLI.
  * `poetry run python -m aptos_sdk.cli` and set the appropriate command-line parameters


  This project follows [semver](https://semver.org/) as closely as possible

  [repo]: https://github.com/aptos-labs/aptos-core
  [pypi-image-version]: https://img.shields.io/pypi/v/aptos-sdk.svg
  [pypi-image-downloads]: https://img.shields.io/pypi/dm/aptos-sdk.svg
  [pypi-url]: https://pypi.org/project/aptos-sdk
  [discord-image]: https://img.shields.io/discord/945856774056083548?label=Discord&logo=discord&style=flat~~~~
  [discord-url]: https://discord.gg/aptosnetwork


pkgId: 6b3384d9e4b5ddd5ed5779132a5567b0afe4c2cbf5353d3b7d6feb3cc0c3fb10
name: python-apyanki
arch: src
version: 0.16.2
epoch: 0
release: 1
summary: CLI script for interacting with local Anki collection
url: https://github.com/lervag/apy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apyanki-0.16.2-1.src.rpm
checksum_type: sha256
description:
  [Anki](https://apps.ankiweb.net/index.html) is a flash card program which makes
  remembering things easy. `apy` is a Python script for easily adding cards to
  Anki. It does not require Anki to be running at the same time.



  * This script and its author(s) are not affiliated/associated with the main
    Anki project in any way.
  * Use this software entirely at your own risk. Frequent backups are encouraged.



  * [Install instructions](#install-instructions)
  * [Usage](#usage)
  * [Configuration](#configuration)
  * [Zsh completion](#zsh-completion)
  * [Changelog](#changelog)
  * [Relevant resources](#relevant-resources)
  * [Alternatives](#alternatives)



  `apy` can be installed in the "usual" way with `pip`:

  ```bash
  pip install apyanki
  ```

  **However**, note that installing Python packages outside [virtual
  environments](https://docs.python.org/3/library/venv.html) is not recommended,
  even at the user level! If you do this, then be aware that you may experience
  issues due to conflicts with other packages/tools installed in the same manner.

  Instead, the best way to install `apy` for normal usage is with
  [`pipx`](https://pypa.github.io/pipx/). This will ensure `apy` doesn't
  interfere with other Python packages already on your system.

  If you don't already have `pipx`, install it with your distribution's package
  manager. For instance, on Ubuntu:

  ```bash
  sudo apt update
  sudo apt install pipx
  ```

  Then, install `apy` with:

  ```bash
  pipx install apyanki
  ```



  `apy` should work for Python 3.9 and later.

  Technically, `apy` does **not** depend on any existing Anki installation, since
  it pulls in a copy of the non-GUI components of Anki as a separate dependency.
  However, you still need to have an Anki database with collections and profile
  settings already existing on your machine, since `apy` can't create one from
  nothing.



  ```sh
  apy --help
  ```

  Some examples:

  ```sh

  apy add



  apy add-single -s preset "Question/Front" "Answer/Back"



  apy list -v tag:leech


  apy review cid:12345678
  ```

  `apy` can be combined with editor specific configuration and workflows to
  improve the process of adding and editing cards. For more information about
  this, see [the Wiki](https://github.com/lervag/apy/wiki/Vim).



  `apy` loads configuration from `~/.config/apy/apy.json`. The following keys are
  currently recognized:

  - `base_path`: Specify where `apy` should look for your Anki database. This is
    usually something like `/home/your_name/.local/share/Anki2/`.
  - `img_viewers`: Specify a dictionary of image viewer commands. Each key is
    a file extension. The value is a command list, e.g. `['display', 'density',
    '300']` which specifies the command and its options to use for the
    corresponding key (file extension).
  - `img_viewers_default`: Specify the default command to show an image. Must be
    provided as a list of the command and desired options, such as `['feh',
    '-d']`.
  - `markdown_models`: Specify a list of models for which `apy` will use
    a markdown converter.
  - `markdown_pygments_style`: Specify the code highlight scheme to use for
    fenced code blocks in Markdown notes. See the [Pygments
    documentation](https://pygments.org/docs/styles/) for more details.
  - `pngCommands`/`svgCommands`: Set LaTeX commands to generate PNG/SVG files.
    This is inspired by the [Edit LaTeX build
    process](https://ankiweb.net/shared/info/937148547) addon to Anki.
  - `presets`: Specify preset combination of model and tags for use with `apy
    add-single`.
  - `profile_name`: Specify which profile to load by default.
  - `query`: Specify default query for `apy list`, `apy review` and `apy tag`.
  - `review_show_cards`: Whether to show list of cards by default during note
    review

  An example configuration:

  ```json
  {
    "base_path": "/home/your_name/.local/share/Anki2/",
    "profile_name": "MyAnkiProfile",
    "query": "tag:leech",
    "presets": {
      "default": { "model": "Custom", "tags": ["marked"] }
    },
    "pngCommands": [
      ["latex", "-interaction=nonstopmode", "tmp.tex"],
      ["dvipng", "-D", "150", "-T", "tight", "-bg", "Transparent",
        "tmp.dvi", "-o", "tmp.png"]
    ],
    "svgCommands": [
      ["lualatex", "-interaction=nonstopmode", "tmp.tex"],
      ["pdfcrop", "tmp.pdf", "tmp.pdf"],
      ["pdf2svg", "tmp.pdf", "tmp.svg"]
    ],
    "review_show_cards": true
  }
  ```



  There is also a zsh completion file available. To use it, one may symlink or
  copy it to a location that is already in ones `fpath` variable, or one may add
  the `apy/completion` directory to the `fpath` list.

  As an example, one may first symlink the `_apy` file:

  ```sh
  mkdir -p ~/.local/zsh-functions
  ln -s /path/to/apy/completion/_apy ~/.local/zsh-functions
  ```

  Then add the following line to ones `.zshrc` file:

  ```sh
  fpath=($HOME/.local/zsh-functions $fpath)
  ```



  See the [release history on GitHub](https://github.com/lervag/apy/releases).
  For details, feel free to inspect the commity history.



  Here are a list of relevant resources for learning how to work with the Anki
  databases and code:
  * [AnkiDroid: Database
    Structure](https://github.com/ankidroid/Anki-Android/wiki/Database-Structure)
  * [AnkiConnect.py](https://github.com/FooSoft/anki-connect/blob/master/AnkiConnect.py)
  * [The Anki Manual](https://docs.ankiweb.net)



  Here are some alternatives to `apy` from which I've drawn inspiration. I've
  also added a short note on why I did not just settle for the alternative.



  [Ankiconnect](https://foosoft.net/projects/anki-connect/) is an Anki plugin [2055492159](https://ankiweb.net/shared/info/2055492159)) hosted on [github](https://github.com/FooSoft/anki-connect).

  > Ankiconnect enables external applications to communicate with Anki over
  > a network interface. The exposed API makes it possible to execute queries
  > against the user’s card deck, automatically create new vocabulary and Kanji
  > flash cards, and more.

  A couple of relevant applications that use Ankiconnect:

  * [Anki Quick Adder](https://codehealthy.com/chrome-anki-quick-adder/):
    A Chrome extension to add words to Anki desktop quickly.

  * [Anki-editor](https://github.com/louietan/anki-editor) is an emacs plugin for
    making Anki cards with Org.

  * [anki-cli](https://github.com/towercity/anki-cli) is a simple nodejs based
    command-line interface for Anki.

  * [trrc](https://github.com/Constantin1489/trrc) is a command-line program to
    add a card to Anki using AnkiConnect API.

  _The Dealbreaker_: I wanted a script that does not require Anki to be running.



  [Anki::Import](https://github.com/sdondley/Anki-Import) (see also
  [here](https://metacpan.org/pod/Anki::Import)) allows one to "Efficiently
  generate Anki notes with your text editor for easy import into Anki". Quote:

  > Inputting notes into Anki can be a tedious chore. Anki::Import lets you you
  > generate Anki notes with your favorite text editor (e.g. vim, BBEdit, Atom,
  > etc.) so you can enter formatted notes into Anki's database more
  > efficiently.

  _The Dealbreaker_: This sounds very good, except there are too many steps.
  I didn't want to have to open Anki desktop. It should work flawlessly directly
  from the terminal.



  [AnkiVim](https://github.com/MFreidank/AnkiVim) may be used to "Use vim to
  rapidly write textfiles immediately importable into anki(1)."

  _The Dealbreaker_: Similar to `Anki::Import`: I didn't want to have to open
  Anki desktop. It should work flawlessly directly from the terminal.



  [Knowledge](https://github.com/tbabej/knowledge) is a Vim plugin for generating
  flash cards to either Anki or Mnemosyne.

  _The Dealbreaker_: It has [a single, open
  issue](https://github.com/tbabej/knowledge/issues/1), which seems to indicate
  that the application does not work very well and/or is not well maintained.



  [Ankisync](https://github.com/patarapolw/ankisync) seems somewhat promising, in
  that it exposes an API for working with Anki collections from Python. It is
  a successor to [AnkiTools](https://github.com/patarapolw/AnkiTools), which is
  stated to be "an Anki *.apkg and collection.anki2 reader and editor".

  _The Dealbreaker_: It does not include any features to add or edit notes (as
  far as I could tell).



  [Genanki](https://github.com/kerrickstaley/genanki) is a library for generating
  Anki decks.

  _The Dealbreaker_: It is quite close to being something I wanted, except that
  it needs to run as a plugin to Anki desktop to generate notes to a local
  collection. It does not seem to allow editing/adding to a local collection
  outside of Anki desktop.



  [inka](https://github.com/lazy-void/inka) is a CLI utility for adding
  flashcards from Markdown files to Anki.

  _The Dealbreaker_: This did not exist when apy was created. It seems to be
  close to what I would personally be interested in, but today I find apy solves
  all (or most) of my requirements. Also, `inka` requires the AnkiConnect plugin.



  [Obsidian_to_Anki](https://github.com/Pseudonium/Obsidian_to_Anki) is a plugin to add flashcards from a text or markdown file to Anki. It can also be run from the command-line as a python script. Built with Obsidian markdown syntax in mind.

  _The Dealbreaker_: Requires AnkiConnect.



  [Markdown2Anki](https://github.com/Mochitto/Markdown2Anki) is a Python script that allows you to easily format your cards
  using Markdown syntax, and then import them into Anki while retaining the
  structure you gave them.

  As many other alternatives, you need to manually import cards. It may provide
  support for AnkiConnect.



  The following is a short and simple guide to getting started with contributing
  and developing the `apy` code.



  This project uses [Poetry](https://python-poetry.org/) as the build system and
  to manage dependencies.

  Install Poetry first if you don't have it already. Fork the repository, then
  clone your fork and install a local development build of the project using
  Poetry.

  ```sh

  git clone git@github.com:<username>/apy.git
  cd apy/


  poetry install
  ```

  Poetry will create a virtual environment for you (see
  [here](https://python-poetry.org/docs/configuration/#virtualenvsin-project) for
  where the environment is created). You can either activate this environment
  yourself then issue commands in the usual way, or you can prefix your commands
  with `poetry run`. Example:

  ```sh
  poetry run apy --version
  ```



  To run the tests, activate the virtual environment and run:

  ```sh
  pytest
  ```

  Alternatively, without activating the environment:

  ```sh
  poetry run pytest
  ```



  To format the code, run:

  ```sh
  poetry run black .
  ```

  To type-check the code, run:

  ```sh
  poetry run mypy src
  ```


pkgId: e72877665b7ba1bb69e6f185aa6dec01447bd3f0d7ab56978f82ec41c6855bdb
name: python-apycalc
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: APY trend calculator with configurable Moving Average
url: https://github.com/dmotte/apycalc
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apycalc-1.0.1-1.src.rpm
checksum_type: sha256
description:
  [![GitHub main workflow](https://img.shields.io/github/actions/workflow/status/dmotte/apycalc/main.yml?branch=main&logo=github&label=main&style=flat-square)](https://github.com/dmotte/apycalc/actions)
  [![PyPI](https://img.shields.io/pypi/v/apycalc?logo=python&style=flat-square)](https://pypi.org/project/apycalc/)

  **APY** (_Annual Percentage Yield_) **trend calculator**, with configurable MA (_Moving Average_).

  Please refer to the [GitHub repository](https://github.com/dmotte/apycalc) for more information.


pkgId: 2554eba06c7643fb7d90500edfc5f0e53895a6119e9c2d0d380453ae3c9115f7
name: python-apyefa
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: Python API for EFA(Elektronische Fahrplanauskunft) async requests
url: https://github.com/alex-jung/apyefa
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apyefa-0.0.1-1.src.rpm
checksum_type: sha256
description:
  [![Python package](https://github.com/alex-jung/apyefa/actions/workflows/python-package.yml/badge.svg)](https://github.com/alex-jung/apyefa/actions/workflows/python-package.yml)
  [![License](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

  **apyefa** is a python package used to asynchronously fetch public transit routing data via EFA  interfaces like [efa.vgn](https://efa.vgn.de/vgnExt_oeffi/"). It can request itineraries for Bus/Trams/Subways etc. connections and return data in a human and machine readable format.

  You only need to install the **apyefa** package, for example using pip:
  ``` bash
  pip install apyefa
  ```


  Currently the package supports only endpoints using [RapidJSON](https://rapidjson.org/) format. To check whether the endpoint supports this format, please call:
  ``` bash
  To describe(!)
  ```


  Create and activate virtual environment. Then install dependencies required by `apefa` package.
  ``` bash
  python3 -m venv .venv
  source .venv/bin/activate
  pip install .
  ```


  |Function name                                       |Implementation    |Documentation     |
  |----------------------------------------------------|------------------|------------------|
  |[info()](#info)                                     |:white_check_mark:|:white_check_mark:|
  |[locations_by_name()](#locations_by_name)           |:white_check_mark:|:white_check_mark:|
  |[location_by_coord()](#locations_by_coord)          |:white_check_mark:|:white_check_mark:|
  |[trip()](#trip)                                     |:x:               |:x:               |
  |[departures_by_location()](#departures_by_location) |:white_check_mark:|:white_check_mark:|
  |[lines_by_name()](#lines_by_name)                   |:white_check_mark:|:white_check_mark:|
  |[lines_by_location()](#lines_by_location)           |:white_check_mark:|:white_check_mark:|
  |[locations_by_line()](#locations_by_line) |:x:               |:x:               |
  |[coords()](#coords)                                 |:x:               |:x:               |
  |[geo_object()](#geo_object)                         |:x:               |:x:               |
  |[trip_stop_time()](#trip_stop_time)                 |:x:               |:x:               |
  |[stop_seq_coord()](#stop_seq_coord)                 |:x:               |:x:               |
  |[map_route()](#map_route)                           |:x:               |:x:               |
  |[add_info()](#add_info)                             |:x:               |:x:               |
  |[stop_list()](#stop_list)                           |:x:               |:x:               |
  |[line_list()](#line_list)                           |:x:               |:x:               |


  Provides end API system information.


  None


  |Type|Description|
  |----|-----------|
  |[SystemInfo](#systeminfo)|System information object|


  ``` python
  from apyefa import EfaClient, SystemInfo
  from pprint import pprint

  async with EfaClient("https://efa.vgn.de/vgnExt_oeffi/") as client:
      info: SystemInfo = await client.info()

      pprint(info)

      
      
      
      
      
      
      
  ```


  Find localities by name or unique id.


  |Name     |Type                |Required|Description|
  |---------|--------------------|--------|-----------|
  |name     |str                 |required|Name or id ID of locality to search for|
  |filters  |list[[LocationFilter](#locationfilter)]|optional|The localition search may be limited by certain types of objects using this parameter. Default value is `[]`|
  |limit    |int                 |optional|Max size of returned list. Default value is `30`|


  |Type|Description|
  |----|-----------|
  |list[[Location](#location)]|List of locations found py provided name sorted by match quality|



  1. Search for all localities contain name `Plärrer`
  ``` python
  from apyefa import EfaClient, Location, LocationFilter

  async with EfaClient("https://efa.vgn.de/vgnExt_oeffi/") as client:
      locations: list[Location] = await client.locations_by_name("Plärrer")

      print(f"Found {len(locations)} location(s)")
      print(location[0].id)
      print(location[0].name)
      print(location[0].loc_type)
      
      
      
      
      
  ```
  2. Search for POIs and Addresses with name `Plärrer`
  ``` python
  async with EfaClient("https://efa.vgn.de/vgnExt_oeffi/") as client:
      locations: list[Location] = await client.locations_by_name("Plärrer", filters=[LocationFilter.ADDRESSES, LocationFilter.POIS])

      print(f"Found {len(locations)} location(s)")
      print(location[0].id)
      print(location[0].name)
      print(location[0].loc_type)

      
      
      
      
      
  ```
  3. Search by `stop id`
  ``` python
  async with EfaClient("https://efa.vgn.de/vgnExt_oeffi/") as client:
      locations: list[Location] = await client.locations_by_name("de:09564:704")

      print(f"Found {len(locations)} location(s)")
      print(location[0].id)
      print(location[0].name)
      print(location[0].loc_type)
      
      
      
      
      
  ```


  Find localities by coordinates.

  > :x: Currently test endpoint does not sent any answers for this request


  |Arguments|Type                |Required|Description|
  |---------|--------------------|--------|-----------|
  |coord_x  |float               |required|X-coordinate|
  |coord_y  |float               |required|Y-coordinate|
  |format   |[CoordFormat](#coordformat)|optional|Coordinates format used for request|
  |limit    |int                 |optional|Max size of returned list. Default value is `10`|


  |Type|Description|
  |----|-----------|
  |list[[Location](#location)]|List of locations found py provided name sorted by match quality|




  Find all departures for a specific location


  |Arguments|Type                |Required|Description|
  |---------|--------------------|--------|-----------|
  |stop     |[Location](#location) \| str |required|Location for which the departures are being sought|
  |limit    |int                 |optional|Max size of returned list. Default value is `40`|
  |date     |str                 |optional|Date/time for which the departures are sought in format "YYYYMMDD hh:mm", "YYYYMMDD" or "mm:hh". Default value is `empty`|


  |Type|Description|
  |----|-----------|
  |list[[Departure](#departure)]|List of departures sorted by departure time|


  ``` python
  from apyefa import EfaClient, Departure

  async with EfaClient("https://efa.vgn.de/vgnExt_oeffi/") as client:
      departures: list[Departure] = await client.departures_by_location("de:09564:704", limit=3, date="22:13")

      print(f"Found {len(departures)} departure(s)")
      print(location[0].line_name)
      print(location[0].route)
      print(location[0].transport)
      print(location[0].planned_time)
      
      
      
      
      
      
  ```


  Find lines by name.


  |Arguments|Type                |Required|Description|
  |---------|--------------------|--------|-----------|
  |name  |str               |required|Name of the line to search. e.g. `U1` or `67`|


  |Type|Description|
  |----|-----------|
  |list[[Line](#line)]|List of lines found for provided name|

  > NOTE: The attribute `origin` of returned `line` objects is None


  ``` python
  async with EfaClient("https://efa.vgn.de/vgnExt_oeffi/") as client:
      lines: list[Line] = await client.lines_by_name("U1")

      print(f"Found {len(lines)} line(s)")
      print(f"id         : {lines[0].id}")
      print(f"name       : {lines[0].name}")
      print(f"description: {lines[0].description}")
      print(f"product    : {lines[0].product}")

      
      
      
      
      
      
  ```


  Find lines pass provided location.


  |Arguments|Type                |Required|Description|
  |---------|--------------------|--------|-----------|
  |location |str \| [Location](#location) |required|The location passed by searched line(s)|


  |Type|Description|
  |----|-----------|
  |list[[Line](#line)]|List of lines found for provided location|

  > The attribute `origin` of returned `line` objects is None


  ``` python
  async with EfaClient("https://efa.vgn.de/vgnExt_oeffi/") as client:
      lines: list[Line] = await client.lines_by_location("de:09564:704")

      print(f"Found {len(lines)} line(s)")
      print(f"id         : {lines[0].id}")
      print(f"name       : {lines[0].name}")
      print(f"description: {lines[0].description}")
      print(f"product    : {lines[0].product}")

      
      
      
      
      
      
  ```












  |Attribute   |Type|Description  |
  |------------|----|------------------------ |
  |version     |str |API internal information|
  |app_version |str |API internal information |
  |data_format |str |API internal information |
  |data_build  |str |API internal information |
  |valid_from  |date|Start validity date      |
  |valid_to    |date|End validity date        |


  |Attribute        |Type               |Description  |
  |-----------------|-------------------|-------------|
  |name             |str                |Name of location e.g. `Nürnberg, Nordostbahnhof`|
  |loc_type         |[LocationType](#locationtype)|Type of location e.g. `STOP` or `POI`|
  |id               |str                |Location unique id|
  |coord            |list[int]          |Location coordinates|
  |transports       |list[[TransportType](#transporttype)]|Transport type(s) this location pass|
  |parent           |[Location](#location) \| None|Parent location|
  |stops            |list[[Location](#location)]|Location with type `STOP` assigned to this location|
  |properties       |dict               |API internal information|


  |Attribute      |Type|Description              |
  |---------------|----|------------------------|
  |location       |[Location](#location) |Location of departure|
  |line_name      |str |Line name e.g. `U3`|
  |route          |str |The complete route name from origin to destination stops e.g. `Nordwestring - Hauptbahnhof - Plärrer - Großreuth bei Schweinau`|
  |origin         |[Location](#location)|Origin location|
  |destination    |[Location](#location)|Destination location|
  |transport      |[TransportType](#transporttype)|Transport type e.g. `Bus` or `Subway`|
  |planned_time   |datetime|Planned departure time|
  |estimated_time |datetime \| None|Estimated departure time(will be provided by endpoits supporting real time mode)|
  |infos          |list[dict] \| None|List of ICS messages|


  |Attribute   |Type|Description              |
  |------------|----|------------------------ |
  |id          |str |Line id                  |
  |name        |str |Line name                |
  |description |str |Route name               |
  |product     |[TransportType](#transporttype) |Type of transportation. Bus, Subway etc.|
  |destination |[Location](#location)|Line destination location|
  |origin      |[Location](#location) \| None|Line start location|
  |properties  |dict|Additional properties    |



  ```python
  class TransportType(IntEnum):
      RAIL        = 0
      SUBURBAN    = 1
      SUBWAY      = 2
      CITY_RAIL   = 3
      TRAM        = 4
      BUS         = 5
      RBUS        = 6
      EXPRESS_BUS = 7
      CABLE_TRAM  = 8
      FERRY       = 9
      AST         = 10  # Anruf-Sammel-Taxi
  ```


  ```python
  class CoordFormat(StrEnum):
      WGS84 = "WGS84 [dd.ddddd]"
  ```


  ```python
  class LocationFilter(IntEnum):
      NO_FILTER     = 0
      LOCATIONS     = 1
      STOPS         = 2
      STREETS       = 4
      ADDRESSES     = 8
      INTERSACTIONS = 16
      POIS          = 32
      POST_CODES    = 64
  ```


  ```python
  class LocationType(StrEnum):
      STOP     = "stop"
      POI      = "poi"
      ADDRESS  = "address"
      STREET   = "street"
      LOCALITY = "locality"
      SUBURB   = "suburb"
      PLATFORM = "platform"
      UNKNOWN  = "unknown"
  ```

rpm_license:
  MIT License  Copyright (c) 2024 Alex Jung  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: 53e885c5fc6a202ab353534345bf2be3af667428a5e76b0b9dc0b19b4029fa3b
name: python-apyori
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: Simple Apriori algorithm Implementation.
url: https://github.com/ymoch/apyori
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apyori-1.1.2-1.src.rpm
checksum_type: sha256
description:
  *Apyori* is a simple implementation of
  Apriori algorithm with Python 2.7 and 3.3 - 3.5,
  provided as APIs and as commandline interfaces.


pkgId: 05b3928939667068537e87d972e4d83de22e31b72ba615310cdae787647f6bc8
name: python-apypie
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Apipie bindings for Python
url: https://github.com/Apipie/apypie
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apypie-0.4.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/Apipie/apypie.svg?branch=master)](https://travis-ci.com/Apipie/apypie)
  [![codecov](https://codecov.io/gh/Apipie/apypie/branch/master/graph/badge.svg)](https://codecov.io/gh/Apipie/apypie)
  [![Documentation Status](https://readthedocs.org/projects/apypie/badge/?version=latest)](https://apypie.readthedocs.io/en/latest/?badge=latest)


pkgId: 7f6add21952108c0ecd4c9d79a8be0b1738b88893ebb2e727a2353f00b9b94ba
name: python-apypie
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Apipie bindings for Python
url: https://github.com/Apipie/apypie
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apypie-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/Apipie/apypie/actions/workflows/main.yml/badge.svg)](https://github.com/Apipie/apypie/actions/workflows/main.yml)
  [![codecov](https://codecov.io/gh/Apipie/apypie/branch/master/graph/badge.svg)](https://codecov.io/gh/Apipie/apypie)
  [![Documentation Status](https://readthedocs.org/projects/apypie/badge/?version=latest)](https://apypie.readthedocs.io/en/latest/?badge=latest)


pkgId: 5c5c4ae4e3a9a2aab0b9768f09c0b869ad7b50fcd14b3128881e6cc585c62d33
name: python-apys
arch: src
version: 3.2.1
epoch: 0
release: 1
summary: A simple back-end rest framework in python using aiohttp lib
url: https://github.com/seijihirao/apys
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apys-3.2.1-1.src.rpm
checksum_type: sha256
description:
  1. Install python 3
      * Windows - [Link](https://www.python.org/download/releases/3.5/)
      * Ubuntu - `sudo apt-get install python`
      * Fedora - `sudo yum install python`
      * Arch - `sudo pacman -S python`
  2. Install PIP - Python libraries manager
      * Windows - [Link](http://www.lfd.uci.edu/~gohlke/pythonlibs/#pip)
      * Ubuntu - `sudo apt-get install pip`
      * Fedora - `sudo yum install pip`
      * Arch - `sudo pacman -S pip`
  3. Install this framework using PIP


pkgId: e4290d9824615afc98d281943ea5f638389e36c43a527d26087ff424a3cf7e16
name: python-apywrapper
arch: src
version: 0.1.12
epoch: 0
release: 1
summary: make wrapper for RESTful API
url: https://github.com/sh1ma/apywrapper
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-apywrapper-0.1.12-1.src.rpm
checksum_type: sha256
description:
  <img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1giomjylcsuj30zk0hsq32.jpg" alt="apywrapper" style="zoom:80%;" />



  ![lint](https://github.com/sh1ma/apywrapper/workflows/lint/badge.svg?branch=develop)
  [![PyPI version](https://badge.fury.io/py/apywrapper.svg)](https://badge.fury.io/py/apywrapper)

  Easy development of RESTful API wrapper


  - Get response as dataclass object you defined
  - Return type can be specified by type annotation of api function
  - All parameters (query, path variable, or json data) can be specified at once




  ```
  pip install apywrapper
  ```



  ```python
  from apywrapper import Apy, delete, get, patch, post, put
  from typing import List, no_type_check
  from dataclasses import dataclass


  @dataclass
  class User:
      name: str
      id: str


  @no_type_check
  class ApiClient(Apy):
      def __init__(self, token, host="https://example.com/api":
          super().__init__(host, headers={"api-token": token})

      @get("/users/")
      def get_users(self) -> List[User]:
          return {}

      @get("/users/{user_id}")
      def get_user(self, user_id) -> User:
          return {"user_id": user_id}

  api = ApiClient(token="xxxxxxxxxxxxxxxxxx")
  sh1ma = api.get_user("sh1ma") # return User object
  ```


pkgId: 6f4aa44031d9273961121a594684294e66e48533c5189759c3a1e57bd86777e5
name: python-aq-dbmigration
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: a database migration tool
url: https://github.com/nanshens/AQ-DBMigration
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aq-dbmigration-1.0.2-1.src.rpm
checksum_type: sha256
description:
  a db migration tool in python


  [github: nanshens/AQ-DBMigration](https://github.com/nanshens/AQ-DBMigration)


  `pip install aq-dbmigration`



  ```python
      config = MigrationConfig("db_name", "db_user", "db_password", "db_host", "db_port", DBConstant.Type.PostgreSQL, "db file path")
      db = DBMigration(config)
      db.migration()
  ```

  if you want to skip migration, you can set skip is True in db.migration(), like this:

  ```python
      db.migration(True)
  ```




  file format: V{version}__{description}.sql
  example: V1__test.sql, V2__issue1.sql, V2.1__issue11.sql, V2.12__issue12.sql

  version:
  version = main sequence + . + sub sequence, so order by main first, then sub.
  example: V1.2 run first and V1.13 second, because 2 < 13.

  please start from V1




  please use absolute path.
  if you use flask, you can set db_path in flask config,
  like this `app.config['DB_MIGRATION_PATH'] = os.path.join(app.root_path, 'resource', 'db_migration')`
  and use `MigrationConfig("db_name", "db_user", "db_password", "db_host", "db_port", DBConstant.Type.PostgreSQL, app.config['DB_MIGRATION_PATH'])` to init



  When used for the first time, it will set the baseline, and subsequent changes will not take effect.
  Only read sql files larger than baseline.



  1. postgresql(tested pass)
  2. mysql(in testing)
  3. maria(in testing)
  4. sqlite(in testing)



  This project is licensed under the terms of the [GNU General Public License v3.0](LICENSE).


pkgId: 0e0694676243025416127779c57222c6b6c234c787c68dcacd9bbeae54c50293
name: python-aq-geometric
arch: src
version: 2024.9.2.1
epoch: 0
release: 1
summary: Geometric deep learning on air quality data.
url: https://pypi.org/project/aq-geometric/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aq-geometric-2024.9.2.1-1.src.rpm
checksum_type: sha256
description:
  This repository contains the code used for geometric deep learning on air-quality data. The code is based on the [PyTorch Geometric](https://pytorch-geometric.readthedocs.io/en/latest/) library.

  Generate build artifacts via ```python3 pip wheel --no-cache-dir --extra-index-url=https://download.pytorch.org/whl/cpu aq-geometric/ -w kubeflow/artifacts/wheels/aq-geometric/```


pkgId: 9bdda5d51d5a3c48e2859ae65232a36f7b43a7846df7bb6f75290c1d4f72b45c
name: python-aq-utilities
arch: src
version: 2024.7.14.4
epoch: 0
release: 1
summary: Data utilities for air quality data.
url: https://pypi.org/project/aq-utilities/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aq-utilities-2024.7.14.4-1.src.rpm
checksum_type: sha256
description:
  This repository contains the code used for pulling and air-quality data in support of the wider `aq` project.

  Generate build artifacts via ```python3 pip wheel --no-cache-dir aq-utils/ -w kubeflow/artifacts/wheels/aq-utils/```


pkgId: cc2590f47400d575fb4e4654098abade72902e01b2f34762d349c45a73d9767e
name: python-aqicalc
arch: src
version: 0.0.8.1
epoch: 0
release: 1
summary: A library to convert between AQI value and pollutant concentration (µg/m³ or ppm)
url: https://github.com/ambeelabs/aqicalc
rpm_license: BSD 3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aqicalc-0.0.8.1-1.src.rpm
checksum_type: sha256
description:
  * Added CPCB AQI Calculation
  * Added IEMA Brazil AQI Calculation
  * Added Kuwait AQI
  * Added Unit Conversion Functions
  * Added Exception Handling (returns the number or NaN back if it can't convert)


pkgId: fd0531afa76d61a293279431404b75e61ad1c4fde4511a38aaf3aa1196ff9c42
name: python-aqimon
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Air Quality Index Monitor
url: https://pypi.org/project/aqimon/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aqimon-0.6.0-1.src.rpm
checksum_type: sha256
description:
  A simple Air Quality Index monitor, designed to work on the Raspberry Pi with the SDS011 Nova PM Sensor.

  - [AQIMON](#aqimon)
    - [Screenshot](#screenshot)
    - [Installation](#installation)
      - [Pre-Requisites](#pre-requisites)
      - [Install](#install)
    - [Running Aqimon](#running-aqimon)
      - [Configure With Systemd](#configure-with-systemd)
    - [Configuration](#configuration)
    - [Contributing](#contributing)
      - [Toolset](#toolset)
      - [Quickstart](#quickstart)
      - [Using the Mock Reader](#using-the-mock-reader)
      - [Submitting a PR](#submitting-a-pr)



  ![Screenshot](screenshot.png)





  - Python 3.9+



  ```commandline
  pip install aqimon
  ```



  Aqimon is a simple web server.  To start with all the defaults (assuming available SDS011 hardware on `/dev/ttyUSB0`), you can just run:

  ```commandline
  aqimon
  ```

  And then go to your browser at `http://{serveraddress}:8000/` to view the UI.

  If you don't have the requisite SDS011 hardware, you can use a mock data source via a [mock reader](#using-the-mock-reader).



  Generally, you'd want to run `Aqimon` as an always-on service, using `systemd`.

  To do so, create a file at `/etc/systemd/system/aqimin.service` with the following contents:

  ```text
  [Unit]
  Description=AQIMON
  After=multi-user.target

  [Service]
  Type=simple
  Restart=always
  ExecStart=aqimon

  [Install]
  WantedBy=multi-user.target
  ```

  And then run:

  ```commandline
  sudo systemctl daemon-reload
  sudo systemctl start aqimon
  ```



  Aqimon uses environment variables for configuration, but all values should ship with sensible defaults.

  | Variable                           | Default             | Description                                                                                                                       |
  |------------------------------------|---------------------|-----------------------------------------------------------------------------------------------------------------------------------|
  | **AQIMON_DB_PATH**                 | ~/.aqimon/db.sqlite | The path to the database file, where read information is stored. It should be an absolute path; user home expansion is supported. |
  | **AQIMON_POLL_FREQUENCY_SEC**      | 900 (15 minutes)    | Sets how frequently to read from the device, in seconds.                                                                          |
  | **AQIMON_RETENTION_MINUTES**       | 10080 (1 week)      | Sets how long data will be kept in the database, in minutes.                                                                      |
  | **AQIMON_READER_TYPE**             | NOVAPM              | The reader type to use, either NOVAPM or MOCK.                                                                                    |
  | **AQIMON_USB_PATH**                | /dev/ttyUSB0        | The path to the USB device for the sensor.                                                                                        |
  | **AQIMON_SLEEP_SEC_BETWEEN_READS** | 5                   | The number of seconds to wait for between each read in a set of reads.                                                            |
  | **AQIMON_SAMPLE_COUNT_PER_READ**   | 5                   | The number of reads to take with each sample.                                                                                     |
  | **AQIMON_WARM_UP_SEC**             | 15                  | The number of seconds to wait for the device to warm up before reading.                                                           |
  | **AQIMON_COMMAND_WAIT_TIME**       | 1                   | The number of seconds to wait for the device respond to a command.                                                                |
  | **AQIMON_EPA_LOOKBACK_MIN**        | 60*8                | The number of minutes to look back at read data to calculate the EPA AQI.                                                         |
  | **AQIMON_SERVER_PORT**             | 8000                | The port to run the server on.                                                                                                    |
  | **AQIMON_SERVER_HOST**             | 0.0.0.0             | The host to run the server on.                                                                                                    |





  To start developing, you'll need to install the following tools:

  - [Python 3.9+](https://www.python.org/) - For API Code
  - [Elm 0.19](https://elm-lang.org/) - For client code
  - [poetry](https://python-poetry.org/) - For python package management
  - [justfile](https://github.com/casey/just) - For builds
  - [elm-format](https://github.com/avh4/elm-format) - For auto-formatting elm code.

  Optionally, we have [pre-commit](https://pre-commit.com/) hooks available as well.  To install hooks, just run
  `pre-commit install` and then linters and autoformatting will be applied automatically on commit.



  To build the project, and install all dev-dependencies, run:

  ```commandline
  just build
  ```

  To start the server in develop mode, run:

  ```commandline
  poetry run aqimond
  ```

  To compile elm changes, run:

  ```commandline
  just compile_elm
  ```

  To manually run lint checks on the code, run:

  ```commandline
  just lint
  ```

  To run auto-formatters, run:

  ```commandline
  just format
  ```



  Aqimon ships with a mock reader class that you can use in the event that you don't have a reader available on your
  development computer.  The mock reader just returns randomized reads.  To use it, you can start the server like:

  ```commandline
  AQIMON_READER_TYPE=MOCK poetry run aqimon
  ```



  Master branch is locked, but you can open a PR on the repo.  Build checks must pass, and changes approved by a code
  owner, before merging.


pkgId: 618d11494ac44b4286d353992702e9925261d3572119dc80c05d3aa7034139a3
name: python-aqipy-atmotech
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: AQI calculation library
url: https://pypi.org/project/aqipy-atmotech/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aqipy-atmotech-0.1.5-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/aqipy-atmotech.svg)](https://badge.fury.io/py/aqipy-atmotech)
  [![pypi supported versions](https://img.shields.io/pypi/pyversions/aqipy-atmotech.svg)](https://pypi.python.org/pypi/aqipy-atmotech)

  The library calculates the following indexes:
  - AQI (US)
  - AQHI (Canada)
  - CAQI (Europe)
  - DAQI (UK)
  - AQI (Australia)
  - CAI (South Korea)
  - PSI (Singapore)
  - AQHI (Hong Kong)
  - AQI (Mainland China)
  - AQI (India)



  From source:

  ```
  git clone --recursive https://github.com/atmotube/aqipy.git
  cd python
  python setup.py install
  ```

  From [PyPI](https://pypi.python.org/pypi/aqipy-atmotech/) directly:

  ```
  pip3 install aqipy-atmotech
  ```



  calculate US AQI:

  ```python
  from aqipy import aqi_us

  aqi, aqi_data = aqi_us.get_aqi(o3_8h=0.07853333, co_8h=5)
  print('AQI:', aqi)
  print('AQI O3:', aqi_data['o3_8h'][0])
  print('Effects O3:', aqi_data['o3_8h'][1])
  print('Cautions O3:', aqi_data['o3_8h'][2])
  print('AQI CO:', aqi_data['co_8h'][0])
  print('Effects CO:', aqi_data['co_8h'][1])
  print('Cautions CO:', aqi_data['co_8h'][2])
  ```

  output will be:
  ```
  AQI: 126
  AQI O3: 126
  Effects O3: Increasing likelihood of respiratory symptoms and breathing discomfort in people with lung disease (such as asthma), children, older adults, people who are active outdoors (including outdoor workers), people with certain genetic variants, and people with diets limited in certain nutrients.
  Cautions O3: People with lung disease (such as asthma), children, older adults, people who are active outdoors (including outdoor workers), people with certain genetic variants, and people with diets limited in certain nutrients should reduce prolonged or heavy outdoor exertion.
  AQI CO: 56
  Effects CO:
  Cautions CO:
  ```


  | Pollutant          | Units           |
  |--------------------|-----------------|
  | CO                 |ppm              |
  | O<sub>3</sub>      |ppm              |
  | NO<sub>2</sub>     |ppm              |
  | SO<sub>2</sub>     |ppm              |
  | NH<sub>3</sub>     |ppm              |
  | Pb                 |ppm              |
  | PM<sub>2.5</sub>   |μg/m<sup>3</sup> |
  | PM<sub>10</sub>    |μg/m<sup>3</sup> |


  | Index               |PM<sub>2.5</sub> | PM<sub>10</sub> |O<sub>3</sub>     |NO<sub>2</sub>   |CO               |SO<sub>2</sub>   |NH<sub>3</sub>   |Pb               |
  |---------------------|-----------------|-----------------|------------------|-----------------|-----------------|-----------------|-----------------|-----------------|
  | AQI (US)            |24h              |24h              |8h/1h	         |1h	           |8h               |1h               |-                |-                |
  | AQHI (Canada)       |3h	            |3h	              |3h                |3h               |-	             |-	               |-	             |-                |
  | CAQI (Europe)       |1h/24h           |1h/24h           |max in 1h         |max in 1h	       |8h	             |max in 1h        |-	             |-                |
  | DAQI (UK)           |24h	            |24h	          |8h                |1h	           |-	             |15m              |-	             |-                |
  | AQI (Australia)     |24h	            |24h              |1h/4h             |1h	           |8h	             |1h	           |-	             |-                |
  | CAI (South Korea)   |24h	            |24h              |1h	             |1h               |1h	             |1h	           |-                |-                |
  | PSI (Singapore)     |24h	            |24h              |8h	             |1h	           |8h	             |24h              |-	             |-                |
  | AQHI (Hong Kong)    |3h	            |3h	              |3h                |3h	           |3h               |3h               |-	             |-                |
  | AQI (Mainland China)|24h	            |24h              |1h/8h             |24h	           |24h	             |24h	           |-	             |-                |
  | AQI (India)         |24h              |24h              |8h                |24h              |8h               |24h	           |24h	             |24h              |


pkgId: 9930f22a11ac87408dc24128878912285e209e6f646c5f77263b02519d762dfb
name: python-aql-builder
arch: src
version: 0.0.13
epoch: 0
release: 1
summary: ArangoDB AQL builder
url: https://foss.heptapod.net/aquapenguin/aql-builder
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aql-builder-0.0.13-1.src.rpm
checksum_type: sha256
description:
  [![pipeline status](https://foss.heptapod.net/aquapenguin/aql-builder/badges/branch/default/pipeline.svg)](https://foss.heptapod.net/aquapenguin/aql-builder/-/pipelines)
  [![coverage report](https://foss.heptapod.net/aquapenguin/aql-builder/badges/branch/default/coverage.svg)](https://foss.heptapod.net/aquapenguin/aql-builder/-/commits/branch/default)
  [![Latest Release](https://foss.heptapod.net/aquapenguin/aql-builder/-/badges/release.svg)](https://foss.heptapod.net/aquapenguin/aql-builder/-/releases)
  [![Python version](https://img.shields.io/badge/Python-3.7%2B-blue)](https://www.python.org/)
  [![ArangoDB version](https://img.shields.io/badge/ArangoDB-3.8%2B-%23DDDF72)](https://www.arangodb.com/docs/stable/aql/)




  Python AQL builder for [ArangoDB](https://www.arangodb.com), a scalable multi-model
  database natively supporting documents, graphs and search.



  - Python version 3.7+



  ```shell
  pip install aql-builder --upgrade
  ```



  Here are simple usage examples:

  ```python
  >>> from aql_builder import AQLBuilder as AB
  >>>
  >>> AB.for_('my').in_('mycollection').return_('my._key').to_aql()
  'FOR my IN mycollection RETURN my._key'
  >>>
  >>> AB.for_('u').in_('users').replace('u').in_('backup').to_aql()
  'FOR u IN users REPLACE u IN backup'
  >>>
  >>> AB.for_('u').in_('users')
  ...     .filter(
  ...         AB.ref('u.active').eq(True)
  ...         .and_(AB.ref('u.age').gte(35))
  ...         .and_(AB.ref('u.age').lte(37))
  ...     )
  ...     .remove('u').in_('users')
  ...     .to_aql()
  'FOR u IN users FILTER (((u.active == true) && (u.age >= 35)) && (u.age <= 37)) REMOVE u IN users'
  >>>
  ```

  Working with query parameters:

  ```python
  >>> from aql_builder import AQLBuilder as AB
  >>>
  >>> AB.for_('user').in_('@@users').filter(AB.ref('user.age').gte('@min_age')).return_('user._key').to_aql()
  'FOR user IN @@users FILTER (user.age >= @min_age) RETURN user._key'
  >>>
  ```

  Working with graph:

  ```python
  >>> from aql_builder import AQLBuilder as AB
  >>>
  >>> AB.for_('v').in_graph(
  ...         graph='knowsGraph',
  ...         direction='OUTBOUND',
  ...         start_vertex=AB.str('users/1'),
  ...         min_depth=1,
  ...         max_depth=3
  ...     )
  ...     .return_('v._key')
  ...     .to_aql()
  'FOR v IN 1..3 OUTBOUND "users/1" GRAPH "knowsGraph" RETURN v._key'
  >>>
  ```

  More complex examples:

  ```python
  >>> from aql_builder import AQLBuilder as AB
  >>>
  >>> AB.for_('i').in_(AB.range(1, 1000))
  ...     .insert({
  ...         'id': AB(100000).add('i'),
  ...         'age': AB(18).add(AB.FLOOR(AB.RAND().times(25))),
  ...         'name': AB.CONCAT('test', AB.TO_STRING('i')),
  ...         'active': False,
  ...         'gender': (
  ...             AB.ref('i').mod(2).eq(0).then('"male"').else_('"female"')
  ...         )
  ...     }).into('users')
  ...     .to_aql()
  'FOR i IN 1..1000 INSERT '
  '{"id": (100000 + i), '
  '"age": (18 + FLOOR((RAND() * 25))), '
  '"name": CONCAT(test, TO_STRING(i)), '
  '"active": false, '
  '"gender": (((i % 2) == 0) ? "male" : "female")} '
  'INTO users'
  >>>
  >>>
  >>> AB.for_('u').in_('users')
  ...     .filter(AB.ref('u.active').eq(True))
  ...     .collect({
  ...         'ageGroup': AB.FLOOR(AB.ref('u.age').div(5)).times(5),
  ...         'gender': 'u.gender'
  ...     }).into('group')
  ...     .sort('ageGroup', 'DESC')
  ...     .return_({
  ...         'ageGroup': 'ageGroup',
  ...         'gender': 'gender'
  ...     })
  ...     .to_aql()
  'FOR u IN users '
  'FILTER (u.active == true) '
  'COLLECT ageGroup = (FLOOR((u.age / 5)) * 5), gender = u.gender INTO group '
  'SORT ageGroup DESC '
  'RETURN {"ageGroup": ageGroup, "gender": gender}'
  >>>
  ```



  AQL builder is a free software project hosted at https://foss.heptapod.net. Thanks
  to the support of [Clever Cloud](https://clever-cloud.com),
  [Octobus](https://octobus.net) and the sponsors of the [heptapod project](https://heptapod.net/).

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2022 aquapenguin  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: d9043895c63c5de0c32c27d8ecf28dae7fe4a6504164be3adb395cdd8d268634
name: python-aqsc
arch: src
version: 0.1.10
epoch: 0
release: 1
summary: Constructs QS stellarator equilibrium to all orders.
url: https://github.com/lankef/pyAQSC
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aqsc-0.1.10-1.src.rpm
checksum_type: sha256
description:
  This code constructs globally quasi-symmetric stellarator equilibria with
  anisotropic pressure near axis expansion to any order.


  [Click here to read pyAQSC documentations.](https://pyaqsc.readthedocs.io/en/latest/)


  The python codes requires Numpy, Matplotlib, and JAX. To install a JAX version
  matching your hardware, see the official
  [JAX installation guide](https://jax.readthedocs.io/en/latest/installation.html).

  The Maxima notebooks requires wxMaxima to view. The notebooks are not required to
  run the main code, but contains source expressions much of code is parsed from.


  ```
  ├── README.MD
  ├── test_data_eduardo/              -> Known leading order terms for some equilibria.
  ├── docs/                           -> Documentations
  ├── dist/                           -> Built python package
  ├── examples/                       -> Jupyter notebooks with use cases for the code.
  ├── magnetic_recursion_relations/   -> Maxima notebooks for iterating the
  │   │                                  magnetic equations
  │   ├── <Quantity name>.wxmx        -> Maxima notebooks for the recursion relations.
  │   └── general_formulae/           -> Maxima notebooks directly expanding
  │                                      the governing equations. for reference only.
  ├── MHD_recursion_relations/        -> Maxima notebooks for iterating the
  │   │                                  magnetic and force balance equations
  │   ├── looped.lisp                 -> Variables associated with the "looped equation"[2].
  │   │                                  see Looped.wxmx and Looped study simplified.wxmx
  │   │                                  see for details.
  │   ├── <Quantity name>.wxmx        -> ...
  │   └── general_formulae/           -> ...
  │
  ├── maxima_scripts/                 -> Maxima libraries
  │   ├── near_axis_expansion.mac     -> Stores the governing equations and
  │   │                                  variable dependencies.
  │   ├── power_mode_matching/        -> A standalone, symbolic infinite/finite
  │   │   │                              power/Fourier series order/mode matcher.
  │   │   ├── power_matching.mac      -> The power series order matcher
  │   │   └── trig_fourier_or... .mac -> The Fourier series mode matcher
  │   ├── python_parser.mac           -> A code translating maxima summations
  │   │                                  to python codes. Works with
  │   │                                  python_source/math_utilities.py
  │   ├── sbatch_maxima.mac           -> A code generating slurm jobscripts for
  │   │                                  evaluating maxima expressions in parallel
  │   └── test_cases/                 -> Test cases for Maxima scripts.
  └── src/aqsc/                       -> Python source for the main code.
      ├── __init__.py
      ├── config.py                   -> Configurations. (numerical, run-time, ...)
      ├── equilibrium.py              -> Contains the Equilibrium object that manages
      │                                  the iteration of an equilibrium represented
      │                                  by near axis expansion. Also contains wrappers
      │                                  for methods in parsed/ and MHD_parsed/.
      ├── chiphiepsfunc.py            -> A list-like data structure for storing power coeffs.
      ├── chiphifunc.py               -> A data structure representing f(chi,phi)
      │                                  as chi Fourier coeffs on phi grids, implementation
      │                                  for operators, and some solvers/utilities.
      ├── chiphifunc_test_suite.py    -> Useful functions for testing and plotting.
      ├── math_utilities.py           -> More numerical operations needed to run
      │                                  python methods in python_source/parsed/
      ├── looped_solver.py            -> Solver for the "looped equations" [2, 3]
      ├── parsed/                     -> Parsed expressions for the magnetic-only
      │                                  recursion relations [1]. All generated by notebooks
      ├── looped_coefs/               -> Coefficients in the looped equations.
      └── MHD_parsed/                 -> Parsed expressions for the full (magnetic and
                                                 force balance) recursion relations [2]. All
                                                 generated by notebooks in MHD_recursion_relations/

  ```


  1. [Weakly Quasisymmetric Near-Axis Solutions to all Orders](https://doi.org/10.1063/5.0076583)
  2. [Solving the problem of overdetermination of quasisymmetric equilibrium solutions by near-axis expansions. I. Generalized force balance](https://doi.org/10.1063/5.0027574)
  3. [Solving the problem of overdetermination of quasisymmetric equilibrium solutions by near-axis expansions. II. Circular axis stellarator solutions](https://aip.scitation.org/doi/10.1063/5.0027575)
  4. [pyQSC](https://github.com/landreman/pyQSC)


