# packages

pkgId: e1aeae52c5eda46e3e8475b4e112cd230a7dd5b60d588a532bf54fcb34a62fa9
name: python-additional-urwid-widgets
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Some (in my opinion) useful widgets that extend the python library 'urwid'.
url: https://github.com/AFoeee/additional_urwid_widgets
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-additional-urwid-widgets-0.4.1-1.src.rpm
checksum_type: sha256
description:
  The python library [`urwid`](http://urwid.org/index.html) contains many basic widgets, but lacks (in my opinion) of "more specialized" widgets, such as a date picker.

  This project provides such "more specialized" widgets.

  ***


  The project can be installed via [pip](https://pypi.org/project/additional-urwid-widgets/).


  There are several approaches to install a package via the terminal (as discribed [here](https://github.com/googlesamples/assistant-sdk-python/issues/236#issuecomment-383039470)):
  *  Setup a virtual env to install the package (**recommended**):

          python3 venv env
          source ./env/bin/activate
          python3 -m pip install additional-urwid-widgets

  * Install the package to the user folder:

          python3 -m pip install --user additional-urwid-widgets

  * Install to the system folder (**not recommended**):

          python3 -m pip install additional-urwid-widgets

  ***



  See the corresponding wiki entries of the widgets for more information.

  * [**DatePicker**](https://github.com/AFoeee/additional_urwid_widgets/wiki/DatePicker)
  A (rudimentary) date picker.

  * [**IndicativeListBox**](https://github.com/AFoeee/additional_urwid_widgets/wiki/IndicativeListBox)
  A [`urwid.ListBox`](http://urwid.org/reference/widget.html#listbox) with additional bars to indicate hidden list items.

  * [**IntegerPicker**](https://github.com/AFoeee/additional_urwid_widgets/wiki/IntegerPicker)
  A selector for integer numbers.

  * [**MessageDialog**](https://github.com/AFoeee/additional_urwid_widgets/wiki/MessageDialog)
  Wraps [`urwid.Overlay`](http://urwid.org/reference/widget.html#overlay) to show a message and expects a reaction from the user.

  * [**SelectableRow**](https://github.com/AFoeee/additional_urwid_widgets/wiki/SelectableRow)
  Wraps [`urwid.Columns`](http://urwid.org/reference/widget.html#columns) to make it selectable and adds behavior.


pkgId: 415f5bfdabc72302cb96c4f516b6ed5e64e814546316c5105f2430753d7f4c99
name: python-addok-csv
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Add CSV support to your Addok instance
url: https://github.com/addok/addok-csv
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-addok-csv-1.1.0-1.src.rpm
checksum_type: sha256
description:
      pip install addok-csv



  **Warning: this plugin will not work when running `addok serve`, you need either
  gunicorn or uWSGI (see [falcon-multipart issue](https://github.com/yohanboniface/falcon-multipart/issues/1)).**

  This plugin adds the following endpoints:




  Batch geocode a csv file.



  - **data**: the CSV file to be processed
  - **columns** (multiple): the columns, ordered, to be used for geocoding; if no
    column is given, all columns will be used
  - **encoding** (optional): encoding of the file (you can also specify a `charset` in the
    file mimetype), such as 'utf-8' or 'iso-8859-1' (default to 'utf-8-sig')
  - **delimiter** (optional): CSV delimiter (`,` or `;`); if not given, we try to
    guess
  - **with_bom**: if true, and if the encoding if utf-8, the returned CSV will contain
    a BOM (for Excel users…)
  - `lat` and `lon` parameters (optionals), like filters, can be used to
    define columns names that contain latitude and longitude
    values, for adding a preference center in the geocoding of each row



      http -f POST http://localhost:7878/search/csv/ columns='voie' columns='ville' data@path/to/file.csv
      http -f POST http://localhost:7878/search/csv/ columns='rue' postcode='code postal' data@path/to/file.csv



  Batch reverse geocode a csv file.



  - **data**: the CSV file to be processed; must contain columns `latitude` (or `lat`) and
    `longitude` (or `lon` or `lng`)
  - **encoding** (optional): encoding of the file (you can also specify a `charset` in the
    file mimetype), such as 'utf-8' or 'iso-8859-1' (default to 'utf-8-sig')
  - **delimiter** (optional): CSV delimiter (`,` or `;`); if not given, we try to
    guess


  Any filter can be passed as `key=value` querystring, where `key` is the filter
  name and `value` is the column name containing the filter value for each row.
  For example, if there is a column "code_insee" and we want to use it for
  "citycode" filtering, we would pass `citycode=code_insee` as query string
  parameter.



  - CSV_ENCODING: default encoding to open CSV files (default: 'utf-8-sig')
  - CSV_EXTRA_FIELDS: list of field names to be added to the results rows
    (default: names of the registered `FIELDS`)


pkgId: deb67a77d5fd573909ca3f9cbbf69d313cd4c68c16a25834442fb9984a61ce9a
name: python-addok-fr
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Add French specific string processors.
url: https://github.com/addok/addok-fr
rpm_license: WTFPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-addok-fr-1.0.1-1.src.rpm
checksum_type: sha256
description:
      pip install addok-fr




  - Add `phonemicize` into PROCESSORS_PYPATHS:

      PROCESSORS_PYPATHS = [
          …,
          'addok_fr.phonemicize'
      ]


pkgId: f71de4fba3272a5dd0b3c1754146db40bdb199b3363da500f8031d9d0ac30515
name: python-addok-france
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: Add France specific string processors.
url: https://github.com/etalab/addok-france
rpm_license: WTFPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-addok-france-1.1.3-1.src.rpm
checksum_type: sha256
description:
      pip install addok-france




  - Add QUERY_PROCESSORS_PYPATHS

      QUERY_PROCESSORS_PYPATHS = [
          …,
          "addok_france.extract_address",
          "addok_france.clean_query",
      ]

  - Add PROCESSORS_PYPATHS

      PROCESSORS_PYPATHS = [
          …,
          "addok_france.glue_ordinal",
          "addok_france.fold_ordinal",
          "addok_france.flag_housenumber",
          …,
      ]

  - Replace default `make_labels` by France dedicated one:

      SEARCH_RESULT_PROCESSORS_PYPATHS = [
          'addok_france.make_labels',
          …,
      ]


pkgId: 4ca44ccb8f3300756ea21dde63d8d372f4e3a23afd4308ed9b762c2f74665670
name: python-addonfactory-splunk-conf-parser-lib
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: Splunk .conf files parser
url: https://github.com/splunk/addonfactory-splunk-conf-parser-lib
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-addonfactory-splunk-conf-parser-lib-0.4.3-1.src.rpm
checksum_type: sha256
description:
  This repository provides a one-file library to parse Splunk-specific `.conf` files.

  Currently, it supports:

  1. Read/write .conf files with comments
  2. Additional comment prefix such as *
  3. Support multiline end with \



  This project uses `poetry 1.5.1`.


pkgId: 8184ad4835b050b6e137fe4553750100b30cca22b473f3bc74da6a13c991d043
name: python-addonupdater
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/ludeeus/addonupdater
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-addonupdater-0.1.2-1.src.rpm
checksum_type: sha256
description:
  _Update dependencies in Community add-ons._
  **NB!: This package is intended only for maintainers of the community add-ons project.**



  **Require Python version 3.5.3+**

  ```bash
  pip install addonupdater
  ```



  ```bash
  addonupdater --token AAAAAAAAAAAAAAAAAAAAA --addon sqlite-web --test
  Starting upgrade sequence for sqlite-web
  Checking for apk uppdates
  g++ Allready have the newest version 6.4.0-r9
  gcc Allready have the newest version 6.4.0-r9
  make Allready have the newest version 4.2.1-r2
  python3-dev Allready have the newest version 3.6.6-r0
  apache2-utils Allready have the newest version 2.4.35-r0
  nginx Allready have the newest version 1.14.2-r0
  python3 Allready have the newest version 3.6.6-r0
  cython Allready have the newest version 0.28.2-r0
  Checking for pip uppdates
  flask Allready have the newest version 1.0.2
  sqlite-web Allready have the newest version 0.3.5
  :arrow_up: Upgrades peewee to version 3.8.0
  Test was enabled, skipping commit
  :arrow_up: Upgrades datasette to version 0.26
  Test was enabled, skipping commit
  ```



  param | alias | description
  -- | -- | --
  `--token` | `-T` | An GitHub Access token with `repo` permissions.
  `--addon` | `-A` | Name of the add-on, this has to match the dir that contains the `Dockerfile`.
  `--repo` | `-R` | Name of the repo for the add-on, this is optional and defaults to `addon-ADDONNAME`.
  `--test` | `None` | If this flag is used commits will be omitted.
  `--verbose` | `None` | Print more stuff to the console.
  `--apk_version` | `None` | Target version of apk packages, like `3.9`.
  `--skip_apk` | `None` | Skip apk updates.
  `--skip_custom` | `None` | Skip custom updates.
  `--skip_pip` | `None` | Skip pip updates.
  `--skip_base` | `None` | Skip base image updates.
  `--org` | `None` | Specify GitHub org, defaults to 'hassio-addons'.
  `-pull_request` | `-PR` | Create a PR instead of pushing directly to master.

  ***

  [![BuyMeCoffee](https://camo.githubusercontent.com/cd005dca0ef55d7725912ec03a936d3a7c8de5b5/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f6275792532306d6525323061253230636f666665652d646f6e6174652d79656c6c6f772e737667)](https://www.buymeacoffee.com/ludeeus)


pkgId: e220f48d839ae27d28731ef3dadb30f8db652089547075cc0460030abd25b97b
name: python-address-parser
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Address parser
url: https://github.com/CivicKnowledge/address_parser
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-address-parser-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Yet another python address parser for US postal addresses
  Basic usage:
      from address_parser import Parser
      parser = Parser()
      adr = parser.parse(line)
  The ``adr`` object is a nested object with address parts as properties.
      return TopBunch(
              number=Bunch(
                  type='P',
                  number=int(self.number) if self.number else -1,
                  tnumber=str(self.number),
                  end_number=self.multinumber,
                  fraction=self.fraction,
                  suite=self.suite,
                  is_block=self.is_block
              ),
              road=Bunch(
                  type='P',
                  name=self.street_name,
                  direction=self.street_direction if self.street_direction else '',
                  suffix=self.street_type if self.street_type else ''
              ),
              locality=Bunch(
                  type='P',
                  city=self.city,
                  state=self.state,
                  zip=self.zip
              ),
              hash=self.hash,
              text=str(self)
          )
  Then, you can access properties on the object. The top level properties are:
  - number: The house number
      - number.number. The number as an integer, or -1 if there is no house number
      - number.tnumber: The number as text
      - number.end_number: The final number in a number rage
      - number.fraction: The fractional part of the house number
      - number.suite: A suite or unit number.
  - road: The street
      - road.name: The bare street name
      - road.direction. A cardinal direction, N, S, E, W, NE, NW, etc.
      - road.suffix. The road type, sich as St, Ave, Pl.
  - locality: City, state, zip
      - locality.city
      - locality.state
      - locality.zip
  - text: Holds the whole address as text.
  You can also access everything as dicts. From the top level, ``adr.dict`` will return all parsed components as a dict, and each of the top level bunches can also be acess as dicts, such as ``adr.road.dict``


pkgId: 133ed3a2968db40be444b03b366af9a2e281b37d7e5225432e0590986d513793
name: python-addressable
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: Use lists like you would dictionaries.
url: https://github.com/debrouwere/python-addressable/
rpm_license: ISC
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-addressable-1.4.2-1.src.rpm
checksum_type: sha256
description:
  ``addressable`` is a silly little utility that allows you to access
  items inside of a list using one or more indices as keys. You pretty
  much get to pretend pretend that a list is a souped-up dictionary.

  ::

      artists = [{
          'id': '0488',
          'name': 'Lambchop',
          'members': ['Kurt Wagner'],
      }, {
          'id': '9924',
          'name': 'Dire Straits',
          'members': ['Mark Knopfler'],
      }]

      
      artists = List(artists, indices=('id', 'name'))
      print artists['0488'] == artists['Lambchop']

      
      artists = List(artists, indices=('id', 'title'), fuzzy=True)
      print artists['strait']

      
      artists = List(artists, indices=('id', 'title'), facet='title')
      print artists['9924'] == 'Dire Straits'

  So why would you want to do any of this? You probably don't.

  ``addressable`` can be useful for certain DSL or library code where you
  want to give the end users some freedom to code things their way, when
  you need to be able to very easily refer to certain things that are
  weirdly named or when there's multiple common ways of referring to
  something and you want the flexibility to mix-and-match.


pkgId: d2512c878bbfee501c529befbad638c33f5820cff573a6ab4130e0672c33c7e6
name: python-addresser
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: A Python port of the `parse-address` npm library
url: https://github.com/consbio/addresser
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-addresser-1.2.0-1.src.rpm
checksum_type: sha256
description:
  Addresser parses and normalizes street addresses and intersections. It is a port of the Node package,
  `parse-address <https://github.com/hassansin/parse-address>`_, which in turn is a port of the PERL package,
  `Geo::StreetAddress::US <http://search.cpan.org/~timb/Geo-StreetAddress-US-1.04/US.pm>`_.
  From the `Geo::StreetAddress::US` description:
      Geo::StreetAddress::US is a regex-based street address and street intersection parser for the United States. Its
      basic goal is to be as forgiving as possible when parsing user-provided address strings. Geo::StreetAddress::US knows
      about directional prefixes and suffixes, fractional building numbers, building units, grid-based addresses (such as
      those used in parts of Utah), 5 and 9 digit ZIP codes, and all of the official USPS abbreviations for street types
      and state names...


pkgId: 07dbb96f76be343c769fe16475aa6aa9869a90b5b5c1ee85c6160a43edd87152
name: python-addressformatting
arch: src
version: 1.3.2
epoch: 0
release: 1
summary: Formatting utility for international postal addresses
url: https://github.com/pudo/addressformatting
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-addressformatting-1.3.2-1.src.rpm
checksum_type: sha256
description:
  This is a address formatter that can format addresses in multiple formats that are common
  in different countries.

  For formatting the addresses the `worldwide.yml` from [OpenCageData address-formatting repository](https://github.com/OpenCageData/address-formatting) is used to format the address according to customs in the country that is been encoded.



  The complete project contains actually only one class:



  Publicly accessible method prototypes are:

  ```python
  def __init__(self, config=None):
      pass

  def format(self, address, country=None):
      pass

  def one_line(self, address, country=None):
      pass
  ```



  Initialize the address formatter
  - `config`: (optional) override default config file to use for the address formatter, defaults to config file included in this package



  Format an address in the default layout used in the specified country. Return value may contain line breaks.
  - `address`: Dictionary that contains the address parts, see below for recognized keys
  - `country`: Country code of the formatting template to use

  Recognized keys in `address`:
  - `attention`
  - `house`
  - `road`
  - `house_number`
  - `postcode`
  - `city`
  - `town`
  - `village`
  - `county`
  - `state`
  - `country`
  - `suburb`
  - `city_district`
  - `state_district`
  - `state_code`
  - `neighbourhood`



  Works the same as `format` but returns a single line of text.


pkgId: 3bcb5015763203c25cd3dc33a93377d95b2d6e7612895799b9d60da27e3ab9b2
name: python-addroot
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: add a project's root to the python import path
url: https://github.com/fenke/addroot
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-addroot-0.1.0-1.src.rpm
checksum_type: sha256
description:
  <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->

  This file will become your README and also the index of your
  documentation.



  ``` sh
  pip install addroot
  ```



  Fill me in please! Don’t forget code examples:

  ``` python
  1+1
  ```

      2


pkgId: 1702fe4af474a5cc10e387ce4a6f3fe06e9d9aed79817df11f17de0e049f369e
name: python-adengine
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Engine for Activity Data Extractor
url: https://git.miem.hse.ru/397/adengine
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adengine-0.3.1-1.src.rpm
checksum_type: sha256
description:
  This is a python engine for Activity Data Extractor.
  It is a special python module, designed to extract data from multiple activity files at the same time.

  1. Download and install Cisco Packet Tracer
  1. Download and install [Activity Data Extractor](https://git.miem.hse.ru/397/activity_data_extractor)
  1. Download and install Python
  1. Install engine from [PyPI](https://pypi.org/project/adengine/) using command `python3 -m pip install adengine`
  1. Now the engine should be installed and ready to go

  * Cisco Packet Tracer 7.3.0, 7.3.1 or 8.0.0.
    It is possible, that engine would run on higher versions on PacketTracer, but this is **untested** functionality.
  * [Activity Data Extractor](https://git.miem.hse.ru/397/activity_data_extractor) 1.0.3 and higher.
  * Python 3.8 or higher.
  * OS depends on version of Packet Tracer
      - Ubuntu 18.04 for Cisco Packet Tracer 7.3.*
      - Ubuntu 20.04 for Cisco Packet Tracer 8.0.0
  * Java 8 or higher.
  * xvfb and xvfb-run, if you want to run app using virtual display.

  There are several possible ADEngine use cases:
  1. Use ADEngine from Python code. Actual documentation for API can be found [here](http://urbash.ru)
  1. Run ADEngine server using command `python3 -m adegine.server`
     Additional parameters can be found using command `python3 -m adengine.server --help`
     Parameters can be passed to ADEngine using command line parameters or via environment variable.
     Command line parameters have and advantage.
     Parameter|Description|Using cmd|Using env|Possible values|Default
     Log level|Level of logs|-|ADENGINE_LOG_LEVEL|DEBUG,INFO,WARNING,ERROR|INFO
     Queue size|Size of queue with tasks|--queue-size|ADENGINE_QUEUE_SIZE|positive integer|20
     Read file timeout|Timeout for ADE to read file in seconds|--read-file-timeout|ADENGINE_READ_FILE_TIMEOUT|positive integer in range 5..60|10
     Use virtual display|Enable using xvfb to run Packet Tracer|--use-virtual-display|ADENGINE_USE_VIRTUAL_DISPLAY|0 or 1 for env, specified or not specified for cmd|Disabled
     Result TTL|Result time to live|--result-ttl|ADENGINE_RESULT_TTL|hh:mm:ss|00:05:00
     Tasks before session restart|Num of tasks before session restart|--tasks-before-session-restart|ADENGINE_TASKS_BEFORE_SESSION_RESTART|positive integer|100
     Unix socket|Path to unix socket|--unix-socket|ADENGINE_UNIX_SOCK|absolute path to unix socket (non existent)|/tmp/adengine.sock
     Max connections|Num of maximum connections to server|--max-connections|ADENGINE_MAX_CONNECTIONS|positive integer|10
  1. Run ADEngine client using command `python3 -m adegine.client`
     Additional parameters can be found using command `python3 -m adengine.client --help`
     Parameters can be passed to ADEngine using command line parameters or via environment variable.
     Command line parameters have and advantage.
     Parameter|Description|Using cmd|Using env|Possible values|Default
     Activity|Absolute path to activity file|activity|-|absolute path to file|-
     Password|Password to activity file|--password|-|string|None
     Net stabilization delay|Simulated network stabilization delay|--net-stabilization-delay|-|non negative integer in range 0..600|0
     Socket|Absolute path to unix socket to connect to ADEngine server|--socket|ADENGINE_UNIX_SOCK|absolute path to file|/tmp/adengine.sock


  Данный репозиторий содержит движок и API на Python для Activity Data Extractor.
  Это специальный модуль Python, разработанный для параллельного извлечения данных из нескольких файлов Packet Tracer Activity.

  1. Скачайте и установите Cisco Packet Tracer
  1. Скачайте и установите [Activity Data Extractor](https://git.miem.hse.ru/397/activity_data_extractor)
  1. Скачайте и установите Python
  1. Установите движок из [PyPI](https://pypi.org/project/adengine/) используя команду `python3 -m pip install adengine`
  1. Теперь движок должен быть установлен и готов к использованию

  * Cisco Packet Tracer 7.3.0, 7.3.1 или 8.0.0.
    Вполне возможно, что движок будет работать и на более свежих версиях Cisco Packet Tracer, но эта функциональность **не протестирована**.
  * [Activity Data Extractor](https://git.miem.hse.ru/397/activity_data_extractor) 1.0.3 или выше.
  * Python 3.8 или выше.
  * ОС зависит от версии Packet Tracer
      - Ubuntu 18.04 для Cisco Packet Tracer 7.3.*
      - Ubuntu 20.04 для Cisco Packet Tracer 8.0.0
  * Java 8 или выше.
  * xvfb и xvfb-run, если вы хотите запустить приложение с использованием виртуального дисплея.

  Есть несколько вариантов использования ADEngine:
  1. ADEngine можно использовать как модуль Python. Актуальная документация API находится [здесь](http://urbash.ru)
  1. Запускать сервер ADEngine используя команду `python3 -m adegine.server`
     Дополнительный параметры можно посмотреть используя команду `python3 -m adengine.server --help`
     Параметры могут быть переданы серверу ADEngine используя аргументы командной строки или через переменные среды.
     Аргументы командной строки имеют преимущество.
     Параметр|Описание|Аргумент комадной строки|Переменная окружения|Возможные значения|Значение по умолчанию
     Log level|Уровень логирования|-|ADENGINE_LOG_LEVEL|DEBUG,INFO,WARNING,ERROR|INFO
     Queue size|Размер очереди задач|--queue-size|ADENGINE_QUEUE_SIZE|положительное целое число|20
     Read file timeout|Таймаут для ADE на чтение файла в секундах|--read-file-timeout|ADENGINE_READ_FILE_TIMEOUT|положительное целое число в диапазоне 5..60|10
     Use virtual display|Включает использование виртуального дисплея для запуска Packet Tracer|--use-virtual-display|ADENGINE_USE_VIRTUAL_DISPLAY|0 или 1 для переменной окружения, указано или не указано для аргумента командной строки|Выключено
     Result TTL|Время жизни результата|--result-ttl|ADENGINE_RESULT_TTL|чч:мм:сс|00:05:00
     Tasks before session restart|Количество выполненных задач перед перезапуском сессии|--tasks-before-session-restart|ADENGINE_TASKS_BEFORE_SESSION_RESTART|положительное целое число|100
     Unix socket|Путь к unix сокету|--unix-socket|ADENGINE_UNIX_SOCK|абсолютный путь к unix сокету (на данный момент файл не должен существовать)|/tmp/adengine.sock
     Max connections|Максимальное количество одновременных подключений к серверу|--max-connections|ADENGINE_MAX_CONNECTIONS|положительное целое число|10
  1. Запускать клиент ADEngine используя команду `python3 -m adegine.client`
     Дополнительный параметры можно посмотреть используя команду `python3 -m adengine.client --help`
     Параметры могут быть переданы клиенту ADEngine используя аргументы командной строки или через переменные среды.
     Аргументы командной строки имеют преимущество.
     Параметр|Описание|Аргумент комадной строки|Переменная окружения|Возможные значения|Значение по умолчанию
     Activity|Абсолютный путь до файла Packet Tracer Activity|activity|-|абсолютный путь до файла|-
     Password|Пароль к файлу Packet Tracer Activity|--password|-|строка|None
     Net stabilization delay|Время стабилизации симулируемой сети|--net-stabilization-delay|-|неотрицательное целое число в диапазоне 0..600|0
     Socket|Абсолютный путь до Unix сокета для подключения с серверу ADEngine|--socket|ADENGINE_UNIX_SOCK|абсолютный путь до файла|/tmp/adengine.sock


pkgId: dece77248cbffa4536c1f76c4fbaac30c1edc3d073b91ac0980bb2e49d797df9
name: python-adeploy
arch: src
version: 1.1.5
epoch: 0
release: 1
url: https://awesome-it.de
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adeploy-1.1.5-1.src.rpm
checksum_type: sha256
summary:
  Universal deployment tool for Kubernetes that supports rendering and deployment of lightweight Jinja templated k8s manifests as well as complex Helm charts.

description:
  <!-- --8<-- [start:intro] -->

  We build `adeploy`, an universal deployment tool for Kubernetes that supports rendering and deployment of lightweight
  Jinja templated k8s manifests and also Helm charts.

  We’ve added support for ...

  * using **Jinja variables** from per cluster, namespaces or release configuration
  * easy **secret management** based on [Gopass](https://github.com/gopasspw/gopass) or other command line based password managers
  * running deployment tests in **CI/CD pipelines**
  * **previewing** and **patching** upstream [Helm Charts](https://artifacthub.io/) before deploying
  * **extending** upstream Helm Charts with custom Jinja-templates manifests
  * handy templating for **labels, annotations, probes, resource limits** and other metadata

  ... and even more to make your daily work with k8s easier.

  <!-- --8<-- [end:intro] -->



  * `adeploy` is Open Source and hosted on GitHub: [https://github.com/awesome-it/adeploy](https://github.com/awesome-it/adeploy).
  * You can report issues on GitHub: [https://github.com/awesome-it/adeploy/issues](https://github.com/awesome-it/adeploy/issues).
  * Find the documentation at [https://awesome-it.de/docs/adeploy/latest](https://awesome-it.de/docs/adeploy/latest).



  This is how you can render, test (preview) and deploy a Helm Chart:
  [![asciicast](https://asciinema.org/a/iToqBOzT8t2Up6x6lRhjF0sk2.svg)](https://asciinema.org/a/iToqBOzT8t2Up6x6lRhjF0sk2)

  Or you can render, test (preview) and deploy Jinja-templated manifests:
  [![asciicast](https://asciinema.org/a/li2ZqLa5pnh6pj1KWoOrUIHOe.svg)](https://asciinema.org/a/li2ZqLa5pnh6pj1KWoOrUIHOe)

  You'll find some examples in the [example](https://github.com/awesome-it/adeploy/tree/master/examples) directory.



  <!-- --8<-- [start:install] -->

  You can find `adeploy` on [GitHub](https://github.com/awesome-it/adeploy). But it is recommended to install
  or upgrade [adeploy](https://pipy.org/project/adeploy) using `pip`:

  ```shell
  $ pip install adeploy
  ```

  Or use [pipx](https://github.com/pypa/pipx) to install, upgrade and run `adeploy` in an isolated environment:

  ```shell
  $ pipx install adeploy
  $ pipx upgrade adeploy
  ```

  You should now be able to run `adeploy` from the command line:

  ```shell
  adeploy --help
  ```

  You can now start to use `adeploy`.

  <!-- --8<-- [end:install] -->

  See the [usage documentation](https://awesome-it.de/docs/adeploy/latest/usage/) to start using `adeploy`.



  * https://awesome-it.de/2020/09/11/adeploy-an-universal-deployment-tool-for-kubernetes/


pkgId: 037f1aaf8a738f7ec76f1591c1dfc3ff53ffa24f1ac7d1f5ad5936f782f34e3a
name: python-adeqt
arch: src
version: 0.2
epoch: 0
release: 1
summary: An interactive Python shell plugin for PyQt & PySide applications
url: https://pypi.org/project/adeqt/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adeqt-0.2-1.src.rpm
checksum_type: sha256
description:
  Adeqt gives you a Python shell inside your Qt applications using PyQt or PySide.
  You can use this for simple debugging or as a 'power user' feature.



  Install the adeqt package: `pip install adeqt`.

  If you don't want to add any dependencies, you can copy `adeqt.py` into your own
  project instead. You might also want to change the imports to use your chosen
  Python Qt package directly (it normally uses the
  [QtPy](https://pypi.org/project/QtPy/) compatibility layer).

  Connect up a menu entry or a keyboard shortcut to open the Adeqt window like
  this:

  ```python
  from PyQt5.QtCore import Qt
  from PyQt5.QtGui import QKeySequence
  from PyQt5.QtWidgets import QAction, QMainWindow, QShortcut


  class MainWindow(QMainWindow):

      def __init__(self, parent=None):
          super().__init__(parent)

          

          
          adeqt_action = QAction("Python console", self)
          adeqt_action.triggered.connect(self.show_adeqt)
          some_menu.addAction(adeqt_action)

          
          adeqt_shortcut = QShortcut(QKeySequence(Qt.Key_F12), self)
          adeqt_shortcut.activated.connect(self.show_adeqt)

      adeqt_window = None

      def show_adeqt(self):
          
          from adeqt import AdeqtWindow
          if self.adeqt_window is None:
              self.adeqt_window = AdeqtWindow({'window': self}, parent=self)
          self.adeqt_window.show()
  ```

  The dictionary you pass to `AdeqtWindow` defines variables that will be
  available in the console. This will normally have at least the main
  window/application object, and any other objects you want convenient access to.

  When using the console window:

  - Ctrl-Enter executes the existing code
  - Tab shows available completions
  - Ctrl-W closes the console window



  - Adeqt is deliberately **simple**, providing a basic console experience. It's
  meant to be easy to copy into your project and easy to modify as required.

  - It **doesn't protect anything from malicious users**. Users running a Python
  application can probably do anything anyway, but Adeqt makes it very easy.
  If you need to restrict what users can do, think about security at other levels.

  - **User code runs in the main thread**. This makes it easy to safely call Qt
  methods, but if you run something slow from the console, the GUI locks up until
  it finishes.



  The [Jupyter Qt Console](https://github.com/jupyter/qtconsole) can be [embedded
  in an application](https://qtconsole.readthedocs.io/en/stable/#embedding-the-qtconsole-in-a-qt-application).
  This is a much more featureful console - with rich output, syntax highlighting,
  better tab completions, etc. - but it's designed to run code in a separate
  'kernel' process. Running the code in the same process as the console
  ('inprocess') is possible, but not well supported. It also needs quite a few
  dependencies.

  Debuggers can pause your code during execution and give you a place to run
  commands and explore the stack. Some modern debuggers can also 'attach' to a
  process which wasn't started in a debugger. A good debugger is strictly more
  powerful than Adeqt, but that power also makes it trickier to use.


pkgId: d54a017c25e2dacf004e908d04cb5a3ed619cb8bd2b64149570bc3013a8274d7
name: python-adetailer
arch: src
version: 24.9.0
epoch: 0
release: 1
summary: An object detection and auto-mask extension for stable diffusion webui.
url: https://pypi.org/project/adetailer/
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adetailer-24.9.0-1.src.rpm
checksum_type: sha256
description:
  ADetailer is an extension for the stable diffusion webui that does automatic masking and inpainting. It is similar to the Detection Detailer.



  You can install it directly from the Extensions tab.

  ![image](https://i.imgur.com/qaXtoI6.png)

  Or

  (from Mikubill/sd-webui-controlnet)

  1. Open "Extensions" tab.
  2. Open "Install from URL" tab in the tab.
  3. Enter `https://github.com/Bing-su/adetailer.git` to "URL for extension's git repository".
  4. Press "Install" button.
  5. Wait 5 seconds, and you will see the message "Installed into stable-diffusion-webui\extensions\adetailer. Use Installed tab to restart".
  6. Go to "Installed" tab, click "Check for updates", and then click "Apply and restart UI". (The next time you can also use this method to update extensions.)
  7. Completely restart A1111 webui including your terminal. (If you do not know what is a "terminal", you can reboot your computer: turn your computer off and turn it on again.)



  | Model, Prompts                    |                                                                                    |                                                                                                                                                        |
  | --------------------------------- | ---------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
  | ADetailer model                   | Determine what to detect.                                                          | `None` = disable                                                                                                                                       |
  | ADetailer model classes           | Comma separated class names to detect. only available when using YOLO World models | If blank, use default values.<br/>default = [COCO 80 classes](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) |
  | ADetailer prompt, negative prompt | Prompts and negative prompts to apply                                              | If left blank, it will use the same as the input.                                                                                                      |
  | Skip img2img                      | Skip img2img. In practice, this works by changing the step count of img2img to 1.  | img2img only                                                                                                                                           |

  | Detection                            |                                                                                              |              |
  | ------------------------------------ | -------------------------------------------------------------------------------------------- | ------------ |
  | Detection model confidence threshold | Only objects with a detection model confidence above this threshold are used for inpainting. |              |
  | Mask min/max ratio                   | Only use masks whose area is between those ratios for the area of the entire image.          |              |
  | Mask only the top k largest          | Only use the k objects with the largest area of the bbox.                                    | 0 to disable |

  If you want to exclude objects in the background, try setting the min ratio to around `0.01`.

  | Mask Preprocessing              |                                                                                                                                     |                                                                                         |
  | ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------- |
  | Mask x, y offset                | Moves the mask horizontally and vertically by                                                                                       |                                                                                         |
  | Mask erosion (-) / dilation (+) | Enlarge or reduce the detected mask.                                                                                                | [opencv example](https://docs.opencv.org/4.7.0/db/df6/tutorial_erosion_dilatation.html) |
  | Mask merge mode                 | `None`: Inpaint each mask<br/>`Merge`: Merge all masks and inpaint<br/>`Merge and Invert`: Merge all masks and Invert, then inpaint |                                                                                         |

  Applied in this order: x, y offset → erosion/dilation → merge/invert.



  Each option corresponds to a corresponding option on the inpaint tab. Therefore, please refer to the inpaint tab for usage details on how to use each option.



  You can use the ControlNet extension if you have ControlNet installed and ControlNet models.

  Support `inpaint, scribble, lineart, openpose, tile, depth` controlnet models. Once you choose a model, the preprocessor is set automatically. It works separately from the model set by the Controlnet extension.

  If you select `Passthrough`, the controlnet settings you set outside of ADetailer will be used.



  API request example: [wiki/REST-API](https://github.com/Bing-su/adetailer/wiki/REST-API)

  `[SEP], [SKIP], [PROMPT]` tokens: [wiki/Advanced](https://github.com/Bing-su/adetailer/wiki/Advanced)



  - 🎥 [どこよりも詳しい After Detailer (adetailer)の使い方 ① 【Stable Diffusion】](https://youtu.be/sF3POwPUWCE)
  - 🎥 [どこよりも詳しい After Detailer (adetailer)の使い方 ② 【Stable Diffusion】](https://youtu.be/urNISRdbIEg)

  - 📜 [ADetailer Installation and 5 Usage Methods](https://kindanai.com/en/manual-adetailer/)



  | Model                 | Target                | mAP 50                        | mAP 50-95                     |
  | --------------------- | --------------------- | ----------------------------- | ----------------------------- |
  | face_yolov8n.pt       | 2D / realistic face   | 0.660                         | 0.366                         |
  | face_yolov8s.pt       | 2D / realistic face   | 0.713                         | 0.404                         |
  | hand_yolov8n.pt       | 2D / realistic hand   | 0.767                         | 0.505                         |
  | person_yolov8n-seg.pt | 2D / realistic person | 0.782 (bbox)<br/>0.761 (mask) | 0.555 (bbox)<br/>0.460 (mask) |
  | person_yolov8s-seg.pt | 2D / realistic person | 0.824 (bbox)<br/>0.809 (mask) | 0.605 (bbox)<br/>0.508 (mask) |
  | mediapipe_face_full   | realistic face        | -                             | -                             |
  | mediapipe_face_short  | realistic face        | -                             | -                             |
  | mediapipe_face_mesh   | realistic face        | -                             | -                             |

  The YOLO models can be found on huggingface [Bingsu/adetailer](https://huggingface.co/Bingsu/adetailer).

  For a detailed description of the YOLO8 model, see: https://docs.ultralytics.com/models/yolov8/#overview

  YOLO World model: https://docs.ultralytics.com/models/yolo-world/



  Put your [ultralytics](https://github.com/ultralytics/ultralytics) yolo model in `models/adetailer`. The model name should end with `.pt`.

  It must be a bbox detection or segment model and use all label.



  ADetailer works in three simple steps.

  1. Create an image.
  2. Detect object with a detection model and create a mask image.
  3. Inpaint using the image from 1 and the mask from 2.



  ADetailer is developed and tested using the stable-diffusion 1.5 model, for the latest version of [AUTOMATIC1111/stable-diffusion-webui](https://github.com/AUTOMATIC1111/stable-diffusion-webui) repository only.



  ADetailer is a derivative work that uses two AGPL-licensed works (stable-diffusion-webui, ultralytics) and is therefore distributed under the AGPL license.



  - https://github.com/ototadana/sd-face-editor
  - https://github.com/continue-revolution/sd-webui-segment-anything
  - https://github.com/portu-sim/sd-webui-bmab


pkgId: 9fd7e674692c31bacc41629713511d5c0e15f3effa282d11d42a0f1c5962715c
name: python-adext
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: AlarmDecoder extended
url: https://github.com/ajschmidt8/adext
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adext-0.4.3-1.src.rpm
checksum_type: sha256
description:
  `adext` is a small package that extends [alarmdecoder](https://github.com/nutechsoftware/alarmdecoder/) to include some additional methods for [Home Assistant](https://github.com/home-assistant/core).

  Specifically, the following methods have been added:

  - `arm_home`
  - `arm_away`
  - `arm_night`

  Each method accepts the arguments described below to determine which key sequences are used to arm a panel based on factors like panel brand and user config settings.



  - **code**: (`None` or `str`) - the code used to arm a panel (i.e. `'1234'`)
  - **auto_bypass**: (`bool`) - for Honeywell only. set to `True` to prefix an arming sequence with `<code> + 6#` in order to automatically bypass any faulted zones. This will require a code to be entered even if `code_arm_required` is set to `false`."
  - **code_arm_required**: (`bool`) - set to `False` to enable arming without a code. see [Arming Key Sequences](#Arming-Key-Sequences) below.
  - **alt_night_mode**: (`bool`) - For Honeywell systems, set to `true` to enable *Night-Stay* mode instead of *Instant* mode for night arming. For DSC systems, set to `true` to enable *No-Entry* mode instead of *Stay* mode for night arming. For both systems, whenever this option is set to `true`, a code will be required for night arming **regardless of the `code_arm_required` setting.** See [Arming Key Sequences](#Arming-Key-Sequences) section below for more information.




  The tables below show the key press sequences used for arming for the different panel brands and configuration setting combinations.





  | Mode                                                    | Key Sequence                |
  | ------------------------------------------------------- | --------------------------- |
  | `alarm_arm_home`                                        | `code` + `3`                |
  | `alarm_arm_away`                                        | `code` + `2`                |
  | `alarm_arm_night` (`alt_night_mode` = `false`, default) | `code` + `7`                |
  | `alarm_arm_night` (`alt_night_mode` = `true`)           | `code` + `33`               |



  | Mode                                                    | Key Sequence                |
  | ------------------------------------------------------- | --------------------------- |
  | `alarm_arm_home`                                        | `#3`                        |
  | `alarm_arm_away`                                        | `#2`                        |
  | `alarm_arm_night` (`alt_night_mode` = `false`, default) | `#7`                        |
  | `alarm_arm_night` (`alt_night_mode` = `true`)           | `code` + `33`               |





  | Mode                                                    | Key Sequence                |
  | ------------------------------------------------------- | --------------------------- |
  | `alarm_arm_home`                                        | `code`                      |
  | `alarm_arm_away`                                        | `code`                      |
  | `alarm_arm_night` (`alt_night_mode` = `false`, default) | `code`                      |
  | `alarm_arm_night` (`alt_night_mode` = `true`)           | `*9` + `code`               |



  <div class='note'>

  The `chr(4)` and `chr(5)` sequences below are equivalent to pressing the <em>Stay</em> and <em>Away</em> keypad keys respectively (as outlined in the <a href='http://www.alarmdecoder.com/wiki/index.php/Protocol#Special_Keys'>AlarmDecoder documentation</a>).

  </div>

  | Mode                                                    | Key Sequence                    |
  | ------------------------------------------------------- | ------------------------------- |
  | `alarm_arm_home`                                        | `chr(4)` + `chr(4)` + `chr(4)`  |
  | `alarm_arm_away`                                        | `chr(5)` + `chr(5)` + `chr(5)`  |
  | `alarm_arm_night` (`alt_night_mode` = `false`, default) | `chr(4)` + `chr(4)` + `chr(4)`  |
  | `alarm_arm_night` (`alt_night_mode` = `true`)           | `*9` + `code`                   |


pkgId: e714abffbafa585edd29fd19b762a13c40470633a3407d2edf34b9c268f12816
name: python-adftotxt
arch: src
version: 0.0.18
epoch: 0
release: 1
summary: Convert ADF (Atlassian Document Format) to Plain Texts
url: https://pypi.org/project/adftotxt/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adftotxt-0.0.18-1.src.rpm
checksum_type: sha256
description:
  ADF is basically JSON Document. To use it in places like Google Sheet, it needs to parsed and converted to Simple Texts. This is what is being done here.


pkgId: 524899ce73bdb6ee8041d49d31a4f4685afe3660bf70241c0091122fb71e80a2
name: python-adg
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: A powerful diagram generator and evaluator for many-body formalisms in physics and chemistry
url: https://github.com/adgproject/adg
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adg-3.1.0-1.src.rpm
checksum_type: sha256
description:
  ADG is a tool generating diagrams and producing their expressions for given many-body formalisms. Diagrammatic rules from the formalism are combined with graph theory objects to produce diagrams and expressions in a fast, simple and error-safe way.

  The only input consists in the theory and order of interest, and the N-body character of the operators of interest. The main output is a LaTeX file containing the diagrams, their associated expressions and additional informations that can be compiled by ADG if needed. Other computer-readable files may be produced as well.


pkgId: 6bf3029048eb474aa588b325ea48524c32c2baa6ba05c4edee615f12b859eb66
name: python-adguardhome
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Asynchronous Python client for the AdGuard Home API.
url: https://github.com/frenck/python-adguardhome
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adguardhome-0.7.0-1.src.rpm
checksum_type: sha256
description:
  [![GitHub Release][releases-shield]][releases]
  [![Python Versions][python-versions-shield]][pypi]
  ![Project Stage][project-stage-shield]
  ![Project Maintenance][maintenance-shield]
  [![License][license-shield]](LICENSE.md)

  [![Build Status][build-shield]][build]
  [![Code Coverage][codecov-shield]][codecov]
  [![Quality Gate Status][sonarcloud-shield]][sonarcloud]
  [![Open in Dev Containers][devcontainer-shield]][devcontainer]

  [![Sponsor Frenck via GitHub Sponsors][github-sponsors-shield]][github-sponsors]

  [![Support Frenck on Patreon][patreon-shield]][patreon]

  Asynchronous Python client for the AdGuard Home API.



  This package allows you to control and monitor an AdGuard Home instance
  programmatically. It is mainly created to allow third-party programs to automate
  the behavior of AdGuard.

  An excellent example of this might be Home Assistant, which allows you to write
  automations, to turn on parental controls when the kids get home.



  ```bash
  pip install adguardhome
  ```



  ```python
  from adguardhome import AdGuardHome

  import asyncio


  async def main():
      """Show example how to get status of your AdGuard Home instance."""
      async with AdGuardHome("192.168.1.2") as adguard:
          version = await adguard.version()
          print("AdGuard version:", version)

          active = await adguard.protection_enabled()
          active = "Yes" if active else "No"
          print("Protection enabled?", active)

          if not active:
              print("AdGuard Home protection disabled. Enabling...")
              await adguard.enable_protection()


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



  This repository keeps a change log using [GitHub's releases][releases]
  functionality. The format of the log is based on
  [Keep a Changelog][keepchangelog].

  Releases are based on [Semantic Versioning][semver], and use the format
  of `MAJOR.MINOR.PATCH`. In a nutshell, the version will be incremented
  based on the following:

  - `MAJOR`: Incompatible or major changes.
  - `MINOR`: Backwards-compatible new features and enhancements.
  - `PATCH`: Backwards-compatible bugfixes and package updates.



  This is an active open-source project. We are always open to people who want to
  use the code or contribute to it.

  We've set up a separate document for our
  [contribution guidelines](CONTRIBUTING.md).

  Thank you for being involved! :heart_eyes:



  This Python project is fully managed using the [Poetry][poetry] dependency
  manager. But also relies on the use of NodeJS for certain checks during
  development.

  You need at least:

  - Python 3.11+
  - [Poetry][poetry-install]
  - NodeJS 20+ (including NPM)

  To install all packages, including all development requirements:

  ```bash
  npm install
  poetry install
  ```

  As this repository uses the [pre-commit][pre-commit] framework, all changes
  are linted and tested with each commit. You can run all checks and tests
  manually, using the following command:

  ```bash
  poetry run pre-commit run --all-files
  ```

  To run just the Python tests:

  ```bash
  poetry run pytest
  ```



  The original setup of this repository is by [Franck Nijhof][frenck].

  For a full list of all authors and contributors,
  check [the contributor's page][contributors].



  MIT License

  Copyright (c) 2019-2024 Franck Nijhof

  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.

  [build-shield]: https://github.com/frenck/python-adguardhome/actions/workflows/tests.yaml/badge.svg
  [build]: https://github.com/frenck/python-adguardhome/actions/workflows/tests.yaml
  [codecov-shield]: https://codecov.io/gh/frenck/python-adguardhome/branch/main/graph/badge.svg
  [codecov]: https://codecov.io/gh/frenck/python-adguardhome
  [contributors]: https://github.com/frenck/python-adguardhome/graphs/contributors
  [devcontainer-shield]: https://img.shields.io/static/v1?label=Dev%20Containers&message=Open&color=blue&logo=visualstudiocode
  [devcontainer]: https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/frenck/python-adguardhome
  [frenck]: https://github.com/frenck
  [github-sponsors-shield]: https://frenck.dev/wp-content/uploads/2019/12/github_sponsor.png
  [github-sponsors]: https://github.com/sponsors/frenck
  [keepchangelog]: http://keepachangelog.com/en/1.0.0/
  [license-shield]: https://img.shields.io/github/license/frenck/python-adguardhome.svg
  [maintenance-shield]: https://img.shields.io/maintenance/yes/2024.svg
  [patreon-shield]: https://frenck.dev/wp-content/uploads/2019/12/patreon.png
  [patreon]: https://www.patreon.com/frenck
  [poetry-install]: https://python-poetry.org/docs/#installation
  [poetry]: https://python-poetry.org
  [pre-commit]: https://pre-commit.com/
  [project-stage-shield]: https://img.shields.io/badge/project%20stage-production%20ready-brightgreen.svg
  [pypi]: https://pypi.org/project/adguardhome/
  [python-versions-shield]: https://img.shields.io/pypi/pyversions/adguardhome
  [releases-shield]: https://img.shields.io/github/release/frenck/python-adguardhome.svg
  [releases]: https://github.com/frenck/python-adguardhome/releases
  [semver]: http://semver.org/spec/v2.0.0.html
  [sonarcloud-shield]: https://sonarcloud.io/api/project_badges/measure?project=frenck_python-adguardhome&metric=alert_status
  [sonarcloud]: https://sonarcloud.io/summary/new_code?id=frenck_python-adguardhome


pkgId: 81bf533b5aecd6e2de7573411145328fe5c5d7659408991749ab48770643d7b7
name: python-adh-sample-library-preview
arch: src
version: 0.10.11rc0
epoch: 0
release: 1
summary: A preview of an ADH (Aveva Data Hub) client library
url: https://github.com/aveva/sample-adh-sample_libraries-python
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adh-sample-library-preview-0.10.11rc0-1.src.rpm
checksum_type: sha256
description:
  Developed using Python 3.10.1
  [AVEVA Samples](https://github.com/AVEVA/AVEVA-Samples) are licensed under the Apache 2 license.
  For the main ADH sample libraries page [ReadMe](https://github.com/AVEVA/AVEVA-Samples/blob/main/README.md)
  For the main AVEVA samples page [ReadMe](https://github.com/AVEVA)


pkgId: 690a8432730e0fb4927fe425f556acb0fa968f495f4b89d69771551011650751
name: python-adhoc-api
arch: src
version: 0.2.8
epoch: 0
release: 1
url: https://pypi.org/project/adhoc-api/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adhoc-api-0.2.8-1.src.rpm
checksum_type: sha256
summary:
  Agent automatically figures out how to make API requests given API docs and user query in plain text

description:
  An [Archytas](https://github.com/jataware/archytas) tool that uses LLMs to interact with APIs given documentation. User explains what they want in plain english, and then the agent (using the APIs docs for context) writes python code to complete the task.


  ```bash
  pip install adhoc-api
  ```



  This is designed to be paired with an Archytas agent. You may omit the python tool, and the agent should instead return the source code to you rather than running it.

  Here is a complete example of grabbing the HTML content of an API documentation page, converting it to markdown, and then having the adhoc-api tool interact with the API using the generated markdown documentation (see [examples/jokes.py](examples/jokes.py) for reference):

  ```python
  from archytas.react import ReActAgent, FailedTaskError
  from archytas.tools import PythonTool
  from easyrepl import REPL
  from adhoc_api.tool import AdhocApi, APISpec

  from bs4 import BeautifulSoup
  import requests
  from markdownify import markdownify


  def main():
      
      gdc_api: APISpec = {
          'name': "JokesAPI",
          'description': 'JokeAPI is a REST API that serves uniformly and well formatted jokes.',
          'documentation': get_joke_api_documentation(),
      }

      
      adhoc_api = AdhocApi(
          apis=[gdc_api],
          drafter_config={'model': 'gemini-1.5-flash-001'},
          finalizer_config={'model': 'gpt-4o'}
      )
      python = PythonTool()
      agent = ReActAgent(model='gpt-4o', tools=[adhoc_api, python], verbose=True)

      
      for query in REPL(history_file='.chat'):
          try:
              answer = agent.react(query)
              print(answer)
          except FailedTaskError as e:
              print(f"Error: {e}")


  def get_joke_api_documentation() -> str:
      """Download the HTML of the joke API documentation page with soup and convert it to markdown."""
      url = 'https://sv443.net/jokeapi/v2/'
      response = requests.get(url)
      soup = BeautifulSoup(response.text, 'html.parser')
      markdown = markdownify(str(soup))

      return markdown


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

  Then you can run the script and interact with the agent in the REPL:

  ```
  $ python example.py

  >>> Can you tell me what apis are available?
  The available API is JokesAPI, which is a REST API that serves uniformly and well formatted jokes.

  >>> Can you fetch a safe joke?
  Here is a safe joke from the JokesAPI:

  Category: Pun
  Type: Two-part
  Setup: What kind of doctor is Dr. Pepper?
  Delivery: He's a fizzician.
  ```


pkgId: 69cede425bd1e5e4940d421d86bb591362b55b5521310b27f0b8c2b4dcc8c905
name: python-adi-env-parser
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Adinsure Environment parser
url: https://pypi.org/project/adi-env-parser/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adi-env-parser-1.1.1-1.src.rpm
checksum_type: sha256
description:
  * Python - Minimum required version is 3.8



  EnvironmentParser class parses all environment variables with certain prefix and
  creates a Python dictionary based on the structure of these variables. The values
  are converted to booleans and integers when detected as such by default.

  General variable structure rules:

  * variable name after prefix should not be empty
  * first character of variable name after prefix should not be "_"
  * different levels of depth within environment variables are specified by using
    "__" string.
  * arrays can be specified by using numeric index as a key within particular level
  * array numeric indices should be defined in order, variables with invalid index
    will be discarded

  Value conversion rules:

  * value will be converted to boolean if it matches `true` or `false` when lower
    cased
  * value will be converted to integer if it contains digits only



  Example of instantiating of EnvironmentParser object using `MYPREFIX` as a prefix
  for environment variables. Upon instantiation, the object will automatically parse
  the current environment variables and store them in its `configuration` property.

  ```python
  import json
  from adi_env_parser import EnvironmentParser

  parser = EnvironmentParser(prefix="MYPREFIX")
  print(json.dump(json.dumps(parser.configuration, indent=4)))
  ```

  It is possible to provide existing JSON formatted file as a configuration base.

  ```python
  import json
  from adi_env_parser import EnvironmentParser

  parser = EnvironmentParser(prefix="MYPREFIX", config_file="configuration.json")
  print(json.dump(json.dumps(parser.configuration, indent=4)))
  ```

  It is possible to disable value conversion by setting `convert_values` parameter
  when instantiating `EnvironmentParser` object.

  ```python
  from adi_env_parser import EnvironmentParser

  parser = EnvironmentParser(prefix="MYPREFIX", convert_values=False)
  ```



  Examples use PYENV as environment variable prefix. This is default prefix used
  when not specifying one explicitly when instatiating EnvironmentParser.



  Environment variables:

  ```sh
  PYENV_hotel_name="Blue Falcon"
  PYENV_rooms__room_1="James Holden"
  PYENV_rooms__room_2="Amos Burton"
  PYENV_rooms__room_3="Naomi Nagata"
  PYENV_rooms__room_4="Alex Kamal"
  ```

  Resulting object:

  ```json
  {
      "hotel_name": "Blue Falcon",
      "rooms": {
          "room_1": "James Holden",
          "room_2": "Amos Burton",
          "room_3": "Naomi Nagata",
          "room_4": "Alex Kamal"
      }
  }
  ```



  Environment variables:

  ```sh
  PYENV_hotel_name="Blue Falcon"
  PYENV_room_1__inventory__0="Wardrobe"
  PYENV_room_1__inventory__1="Table"
  PYENV_room_1__inventory__2="Lamp"
  ```

  Resulting object:

  ```json
  {
      "hotel_name": "Blue Falcon",
      "room_1": {
          "inventory": [
              "Wardrobe",
              "Table",
              "Lamp"
          ]
      }
  }
  ```



  Environment variables:

  ```sh
  PYENV_hotel_name="Blue Falcon"
  PYENV_rooms__0__name="Room 1"
  PYENV_rooms__0__capacity="2"
  PYENV_rooms__2__name="Room 2"
  PYENV_rooms__2__capacity="2"
  ```

  Resulting object:

  ```json
  {
      "hotel_name": "Blue Falcon",
      "rooms": [
          {
              "name": "Room 1",
              "capacity": "2"
          },
          {
              "name": "Room 2",
              "capacity": "2"
          }
      ]
  }
  ```



  Module provides console utility which can be used for parsing of environment
  variables. It also supports reading of existing JSON formatted file and setting
  indentation for output of created configuration JSON object.

  ```sh
  ➜ adi-env-parser --help
  usage: adi-env-parser -p <prefix> -j <base_json_file>

  Parses environment variables with defined prefix and creates JSON output from the parsed structure.

  optional arguments:
    -h, --help            show this help message and exit
    --prefix [PREFIX], -p [PREFIX]
                          Environment variable prefix. Default: PYENV
    --json [JSON], -j [JSON]
                          JSON formatted file to read as base configuration
    --indent [INDENT], -i [INDENT]
                          Number of spaces to use for indentation of output JSON string
    --ignore-prefix IGNORE_PREFIX, -n IGNORE_PREFIX
                          Environment variable prefix to ignore. Can be used multiple times.
  ```





  ```sh
  pip install -e ".[dev]"
  pip install -e ".[test]"

  pip install -e ".[build-local]"
  ```



  ```sh
  pre-commit install
  ```



  New version is built and published on tag in GitHub repository. The package version is infered from commit name.

rpm_license:
  MIT License  Copyright (c) 2022 ADACTA d.o.o.  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: 96b02b63c37609e508efdffb013096f835ca8adac39b77c349caa19b5d896608
name: python-adia
arch: src
version: 4.1.0
epoch: 0
release: 1
summary: Language for ASCII diagrams.
url: http://github.com/pylover/adia
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adia-4.1.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](http://img.shields.io/pypi/v/adia.svg)](https://pypi.python.org/pypi/adia)
  [![Build](https://github.com/pylover/adia/actions/workflows/build.yml/badge.svg)](https://github.com/pylover/adia/actions/workflows/build.yml)
  [![Coverage Status](https://coveralls.io/repos/github/pylover/adia/badge.svg?branch=master)](https://coveralls.io/github/pylover/adia?branch=master)
  [![Python](https://img.shields.io/badge/Python-%3E%3D3.6-blue)](https://python.org)
  [![Documentation](https://img.shields.io/badge/Documentation-almost%20done-blue)](https://pylover.github.io/adia/docs/latest/html/)



  ```adia
  diagram: Foo
  sequence:
  foo -> bar: Hello World!
  ```

  Output:

  ```
   DIAGRAM: Foo

   +-----+             +-----+
   | foo |             | bar |
   +-----+             +-----+
      |                   |
      |~~~Hello World!~~~>|
      |                   |
      |<------------------|
      |                   |
   +-----+             +-----+
   | foo |             | bar |
   +-----+             +-----+
  ```

  [ADia](https://github.com/pylover/adia) is a language specially designed to
  render ASCII diagrams.

  Currently, only sequence diagrams are supported, but the roadmap is to support
  two more types of diagrams: `fork` (pylover/adia#42) and `class`
  (pylover/adia#41).



  - [live demo page](https://pylover.github.io/adia/)
  - [documentation](https://pylover.github.io/adia/docs/latest/html/)

  The ADia can also run flawlessly inside the browsers using the awesome
  project: [Brython](https://github.com/brython-dev/brython).

  The https://github.com/pylover/adia-live is a good example of how
  to use it inside the Javascript. In addition, please read the
  [Javascript API](https://pylover.github.io/adia/docs/latest/html/javascriptapi.html#introduction)
  section of the [documentation](https://pylover.github.io/adia/docs/latest/html/).


pkgId: 8c33681a29dcee127eb3fd9ae90f43b86bf831e10537286dc99cc6ae98c45f36
name: python-adicity
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: A fixed-arity high level functional programming language engine.
url: https://github.com/cole-wilson/adicity
rpm_license: none
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adicity-0.7.0-1.src.rpm
checksum_type: sha256
description:
  	
  	A fixed-arity high level functional programming language engine.
  	
  	- Cole Wilson
  	
  	<cole@colewilson.xyz>


pkgId: 2dae79b7957f1b93e6b6ee0e8176680b6b89fcad016ba0ef984721989cf2175c
name: python-adif-io
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: Input and output of ADIF radio amateur log files.
url: https://gitlab.com/andreas_krueger_py/adif_io
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adif-io-0.5.2-1.src.rpm
checksum_type: sha256
description:
  Main result of parsing: List of QSOs:

  * Each QSO is represented by a special-purpose Python mapping.
  * Keys in that mapping are ADIF field names in upper case,
  * value for a key is whatever was found in the ADIF, as a string
    (though some values are converted to upper case on output).

  Order of QSOs in the list is same as in ADIF file.

  Secondary result of parsing: The ADIF headers.
  This is returned as a Python mapping as well.

  Normally, you'd call `adif_io.read_from_file(filename)`.  But you can
  also provide a string with an ADI-file's content, as follows:

  ```
  import adif_io

  qsos, header =  adif_io.read_from_string(
      "A sample ADIF content for demonstration.\n"
      "<adif_ver:5>3.1.0<eoh>\n"

      "<QSO_DATE:8>20190714 <time_on:4>1140<CALL:5>LY0HQ"
      "<mode:2>CW<BAND:3>40M<RST_SENT:3>599<RST_RCVD:3>599"
      "<STX_STRING:2>28<SRX_STRING:4>LRMD<EOR>\n"

      "<QSO_DATE:8>20190714<TIME_ON:4>1130<CALL:5>SE9HQ<MODE:2>CW<FREQ:1>7"
      "<BAND:3>40M<RST_SENT:3>599<RST_RCVD:3>599"
      "<SRX_STRING:3>SSA<DXCC:3>284<EOR>")
  ```

  After this setup, `print(header)` will print out a valid ADIF file start:

  >  &lt;ADIF_VER:5>3.1.0 &lt;EOH>

  (This starts with a blank space, as the ADIF spec demands a header must not
  start with the `<` character.)

  And

  ```
  for qso in qsos:
      print(qso)
  ```

  prints

  > &lt;QSO_DATE:8>20190714 &lt;TIME_ON:4>1140 &lt;CALL:5>LY0HQ &lt;MODE:2>CW &lt;BAND:3>40M &lt;RST_RCVD:3>599 &lt;RST_SENT:3>599 &lt;SRX_STRING:4>LRMD &lt;STX_STRING:2>28 &lt;EOR>
  >
  > &lt;QSO_DATE:8>20190714 &lt;TIME_ON:4>1130 &lt;CALL:5>SE9HQ &lt;FREQ:1>7 &lt;MODE:2>CW &lt;BAND:3>40M &lt;DXCC:3>284 &lt;RST_RCVD:3>599 &lt;RST_SENT:3>599 &lt;SRX_STRING:3>SSA &lt;EOR>
  >

  So `str(qso)` for a single QSO generates that QSO as an ADIF string.

  Fine points:

  - The ADIF string of the headers or that of a QSO are each terminated by a `\n`.
  - ADIF allows lower- and upper case field names. You can feed either to this software.
  - Field names are consistently converted to upper case internally.
  - Any non-field text in the header or in a QSO or between QSOs is ignored.
    (This may change at some undetermined time in the future.)
  - Value content is always a string.
  - Fields with zero-length content are treated as non-existent.
  - The output of a single QSO has a few important fields first,
    then all other fields in alphabetic order.
    The details may change over time.
  - Some QSO fields, in particular `CALL` and `MODE`, are automatically converted to upper case on output.
    This is not done systematically (for other fields that would also benefit from this),
    and the details may change.




  Given one `qso` dict, you can also have the QSO's start time calculated as a Python `datetime.datetime` value:

      adif_io.time_on(qsos[0])

  If your QSO data also includes `TIME_OFF` fields (and, ideally, though
  not required, `QSO_DATE_OFF`), this will also work:

      adif_io.time_off(qsos[0])



  ADIF uses a somewhat peculiar 11 character `XDDD MM.MMM` format to
  code geographic coordinates (fields `LAT` or `LON`).  The more common
  format these days are simple floats that code degrees.  You can convert
  from one to the other:

  ```
  adif_io.degrees_from_location("N052 26.592") # Result: 52.4432
  adif_io.location_from_degrees(52.4432, True) # Result: "N052 26.592"
  ```

  The additional `bool` argument of `location_from_degrees` should be
  `True` for latitudes (N / S) and `False` for longitudes (E / W).



  There is little ADIF-version-specific here.  (Everything should work
  with ADI-files of ADIF version 3.1.3, if you want to nail it.)



  This parser knows nothing about ADIF data types or enumerations.
  Everything is a string. So in that sense, this parser is fairly simple.

  But it does correcly handle things like:

      <notes:66>In this QSO, we discussed ADIF and in particular the <eor> marker.

  So, in that sense, this parser is _somewhat_ sophisticated.



  This parser only handles ADI files. It knows nothing of the ADX file format.



  Here is some sample code:

  ```
  import adif_io

  qsos_raw, adif_header = adif_io.read_from_file("log.adi")


  qsos_raw_sorted = sorted(qsos_raw, key = adif_io.time_on)
  ```

  Pandas / Jupyter users may want to add `import pandas as pd`
  up above and continue like this:

  ```
  qsos = pd.DataFrame(qsos_raw_sorted)
  qsos.info()
  ```


pkgId: a30ec1e59d7adb1e51a395157931899f741da96fca5b09a5b657b57caafe5127
name: python-adif-io
arch: src
version: 0.5.3
epoch: 0
release: 1
summary: Input and output of ADIF radio amateur log files.
url: https://gitlab.com/andreas_krueger_py/adif_io
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adif-io-0.5.3-1.src.rpm
checksum_type: sha256
description:
  Main result of parsing: List of QSOs:

  * Each QSO is represented by a special-purpose Python mapping.
  * Keys in that mapping are ADIF field names in upper case,
  * value for a key is whatever was found in the ADIF, as a string
    (though some values are converted to upper case on output),
  * you can access individual field values via either
    `qso[fieldname]` or [`qso.get(fieldname)`](https://docs.python.org/3/library/stdtypes.html#dict.get)
    (depending on which behavior you want when your field does not exist).

  Order of QSOs in the list is same as in ADIF file.

  Secondary result of parsing: The ADIF headers.
  This is returned as a Python mapping as well.

  Normally, you'd call `adif_io.read_from_file(filename)`.  But you can
  also provide a string with an ADI-file's content, as follows:

  ```
  import adif_io

  qsos, header =  adif_io.read_from_string(
      "A sample ADIF content for demonstration.\n"
      "<adif_ver:5>3.1.0<eoh>\n"

      "<QSO_DATE:8>20190714 <time_on:4>1140<CALL:5>LY0HQ"
      "<mode:2>CW<BAND:3>40M<RST_SENT:3>599<RST_RCVD:3>599"
      "<STX_STRING:2>28<SRX_STRING:4>LRMD<EOR>\n"

      "<QSO_DATE:8>20190714<TIME_ON:4>1130<CALL:5>SE9HQ<MODE:2>CW<FREQ:1>7"
      "<BAND:3>40M<RST_SENT:3>599<RST_RCVD:3>599"
      "<SRX_STRING:3>SSA<DXCC:3>284<EOR>")
  ```

  After this setup, `print(header)` will print out a valid ADIF file start:

  >  &lt;ADIF_VER:5>3.1.0 &lt;EOH>

  (This starts with a blank space, as the ADIF spec demands a header must not
  start with the `<` character.)

  And

  ```
  for qso in qsos:
      print(qso)
  ```

  prints

  > &lt;QSO_DATE:8>20190714 &lt;TIME_ON:4>1140 &lt;CALL:5>LY0HQ &lt;MODE:2>CW &lt;BAND:3>40M &lt;RST_RCVD:3>599 &lt;RST_SENT:3>599 &lt;SRX_STRING:4>LRMD &lt;STX_STRING:2>28 &lt;EOR>
  >
  > &lt;QSO_DATE:8>20190714 &lt;TIME_ON:4>1130 &lt;CALL:5>SE9HQ &lt;FREQ:1>7 &lt;MODE:2>CW &lt;BAND:3>40M &lt;DXCC:3>284 &lt;RST_RCVD:3>599 &lt;RST_SENT:3>599 &lt;SRX_STRING:3>SSA &lt;EOR>
  >

  So `str(qso)` for a single QSO generates that QSO as an ADIF string.

  Fine points:

  - The ADIF string of the headers or that of a QSO are each terminated by a `\n`.
  - ADIF allows lower- and upper case field names. You can feed either to this software.
  - Field names are consistently converted to upper case internally.
  - Any non-field text in the header or in a QSO or between QSOs is ignored.
    (This may change at some undetermined time in the future.)
  - Value content is always a string.
  - Fields with zero-length content are treated as non-existent.
  - The output of a single QSO has a few important fields first,
    then all other fields in alphabetic order.
    The details may change over time.
  - Some QSO fields, in particular `CALL` and `MODE`, are automatically converted to upper case on output.
    This is not done systematically (for other fields that would also benefit from this),
    and the details may change.




  Given one `qso` dict, you can also have the QSO's start time calculated as a Python `datetime.datetime` value:

      adif_io.time_on(qsos[0])

  If your QSO data also includes `TIME_OFF` fields (and, ideally, though
  not required, `QSO_DATE_OFF`), this will also work:

      adif_io.time_off(qsos[0])



  ADIF uses a somewhat peculiar 11 character `XDDD MM.MMM` format to
  code geographic coordinates (fields `LAT` or `LON`).  The more common
  format these days are simple floats that code degrees.  You can convert
  from one to the other:

  ```
  adif_io.degrees_from_location("N052 26.592") # Result: 52.4432
  adif_io.location_from_degrees(52.4432, True) # Result: "N052 26.592"
  ```

  The additional `bool` argument of `location_from_degrees` should be
  `True` for latitudes (N / S) and `False` for longitudes (E / W).



  There is little ADIF-version-specific here.  (Everything should work
  with ADI-files of ADIF version 3.1.3, if you want to nail it.)



  This parser knows nothing about ADIF data types or enumerations.
  Everything is a string. So in that sense, this parser is fairly simple.

  But it does correcly handle things like:

      <notes:66>In this QSO, we discussed ADIF and in particular the <eor> marker.

  So, in that sense, this parser is _somewhat_ sophisticated.



  This parser only handles ADI files. It knows nothing of the ADX file format.



  Here is some sample code:

  ```
  import adif_io

  qsos_raw, adif_header = adif_io.read_from_file("log.adi")


  qsos_raw_sorted = sorted(qsos_raw, key = adif_io.time_on)
  ```

  Pandas / Jupyter users may want to add `import pandas as pd`
  up above and continue like this:

  ```
  qsos = pd.DataFrame(qsos_raw_sorted)
  qsos.info()
  ```


pkgId: b9ef21cfbe10a38bef79e2ff4dd73550c4b91a5b17185b0a6725809789fe09a9
name: python-adios4dolfinx
arch: src
version: 0.9.1.post0
epoch: 0
release: 1
summary: Checkpointing functionality for DOLFINx meshes/functions with ADIOS2
url: https://pypi.org/project/adios4dolfinx/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adios4dolfinx-0.9.1.post0-1.src.rpm
checksum_type: sha256
description:
  ![MIT](https://img.shields.io/github/license/jorgensd/adios4dolfinx)
  [![DOI](https://joss.theoj.org/papers/10.21105/joss.06451/status.svg)](https://doi.org/10.21105/joss.06451)
  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/adios4dolfinx/badges/version.svg)](https://anaconda.org/conda-forge/adios4dolfinx)

  ADIOS4DOLFINx is an extension for [DOLFINx](https://github.com/FEniCS/dolfinx/) to checkpoint meshes, meshtags and functions using [ADIOS 2](https://adios2.readthedocs.io/en/latest/).

  The code uses the ADIOS2 Python-wrappers to write DOLFINx objects to file, supporting N-to-M (_recoverable_) and N-to-N (_snapshot_) checkpointing.
  See: [Checkpointing in DOLFINx - FEniCS 23](https://jsdokken.com/checkpointing-presentation/#/) or the examples in the [Documentation](https://jsdokken.com/adios4dolfinx/) for more information.

  For scalability, the code uses [MPI Neighbourhood collectives](https://www.mpi-forum.org/docs/mpi-3.1/mpi31-report/node200.htm) for communication across processes.



  As the usage of high performance computing clusters increases, more and more large-scale, long-running simulations are deployed.
  The need for storing intermediate solutions from such simulations are crucial, as the HPC system might crash, or the simulation might crash or exceed the alloted computational budget.
  Having a checkpoint of related variables, such as the solutions to partial differential equations (PDEs) is therefore essential.
  The `adios4dolfinx` library extends the [DOLFINx](https://github.com/FEniCS/dolfinx/) computational framework for solving PDEs with checkpointing functionality, such that immediate solutions and mesh information can be stored and re-used in another simulation.



  Compatibility with DOLFINx:

  - ADIOS4DOLFINx v0.8.1 is compatible with DOLFINx v0.8.x
  - ADIOS4DOLFINx v0.7.3 is compatible with DOLFINx v0.7.x



  The library depends on the Python-interface of [DOLFINx](https://github.com/) and an MPI-build of [ADIOS2](https://adios2.readthedocs.io/en/latest/setting_up/setting_up.html#as-package).
  Therefore `ADIOS2` should not be install through PYPI/pip, but has to be installed through Conda, Spack or from source.



  An MPI build of ADIOS2 is installed in the official DOLFINx containers, and thus there are no additional dependencies required to install `adios4dolfinx`
  on top of DOLFINx in these images.

  Create a Docker container, named for instance `dolfinx-checkpoint`.
  Use the `nightly` tag to get the main branch of DOLFINx, or `stable` to get the latest stable release

  ```bash
  docker run -ti -v $(pwd):/root/shared -w /root/shared --name=dolfinx-checkpoint ghcr.io/fenics/dolfinx/dolfinx:nightly
  ```

  For the latest version compatible with nightly (with the ability to run the test suite), use

  ```bash
  python3 -m pip install adios4dolfinx[test]@git+https://github.com/jorgensd/adios4dolfinx@main
  ```

  If you are using the `stable` image, you can install `adios4dolfinx` from [PYPI](https://pypi.org/project/adios4dolfinx/) with

  ```bash
  python3 -m pip install adios4dolfinx[test]
  ```

  This docker container can be opened with

  ```bash
  docker container start -i dolfinx-checkpoint
  ```

  at a later instance



  > [!NOTE]
  > Conda supports the stable release of DOLFINx, and thus the appropriate version should be installed, see the section above for more details.

  Following is a minimal recipe of how to install adios4dolfinx, given that you have conda installed on your system.

  ```bash
  conda create -n dolfinx-checkpoint python=3.10
  conda activate dolfinx-checkpoint
  conda install -c conda-forge adios4dolfinx
  ```

  > [!NOTE]
  > Remember to download the appropriate version of `adios4dolfinx` from Github [adios4dolfinx: Releases](https://github.com/jorgensd/adios4dolfinx/releases)

  To run the test suite, you should also install `ipyparallel`, `pytest` and `coverage`, which can all be installed with conda

  ```bash
  conda install -c conda-forge ipyparallel pytest coverage
  ```





  - Reading and writing meshes, using `adios4dolfinx.read/write_mesh`
  - Reading and writing meshtags associated to meshes `adios4dolfinx.read/write_meshtags`
  - Reading checkpoints for any element (serial and parallel, arbitrary number of functions and timesteps per file). Use `adios4dolfinx.read/write_function`.
  - Writing standalone function checkpoints relating to "original meshes", i.e. meshes read from `XDMFFile`. Use `adios4dolfinx.write_function_on_input_mesh` for this.
  - Store mesh partitioning and re-read the mesh with this information, avoiding calling SCOTCH, Kahip or Parmetis.

  > [!IMPORTANT]
  > For checkpoints written with `write_function` to be valid, you first have to store the mesh with `write_mesh` to the checkpoint file.

  > [!IMPORTANT]
  > A checkpoint file supports multiple functions and multiple time steps, as long as the functions are associated with the same mesh

  > [!IMPORTANT]
  > Only one mesh per file is allowed



  The repository contains many documented examples of usage, in the `docs`-folder, including

  - [Reading and writing mesh checkpoints](./docs/writing_mesh_checkpoint.py)
  - [Storing mesh partitioning data](./docs/partitioned_mesh.py)
  - [Writing mesh-tags to a checkpoint](./docs/meshtags.py)
  - [Reading and writing function checkpoints](./docs/writing_functions_checkpoint.py)
  - [Checkpoint on input mesh](./docs/original_checkpoint.py)
    Further examples can be found at [ADIOS4DOLFINx examples](https://jsdokken.com/adios4dolfinx/)



  > [!WARNING]
  > If you are using v0.7.2, you are adviced to upgrade to v0.7.3, as it contains som crucial fixes for openmpi.



  Only checkpoints for `Lagrange` or `DG` functions are supported from legacy DOLFIN

  - Reading meshes from the DOLFIN HDF5File-format
  - Reading checkpoints from the DOLFIN HDF5File-format (one checkpoint per file only)
  - Reading checkpoints from the DOLFIN XDMFFile-format (one checkpoint per file only, and only uses the `.h5` file)

  See the [API](./docs/api) for more information.



  This library uses `pytest` for testing.
  To execute the tests, one should first install the library and its dependencies, as listed above.
  Then, can execute all tests by calling

  ```bash
  python3 -m pytest .
  ```



  Some tests check the capability of reading data created with the legacy version of DOLFIN.
  To create this dataset, start a docker container with legacy DOLFIN, for instance:

  ```bash
  docker run -ti -v $(pwd):/root/shared -w /root/s
  hared --rm ghcr.io/scientificcomputing/fenics:2024-02-19
  ```

  Then, inside this container, call

  ```bash
  python3 ./tests/create_legacy_data.py --output-dir=legacy
  ```



  Some tests check the capability to read data generated by `adios4dolfinx<0.7.2`.
  To generate data for these tests use the following commands:

  ```bash
  docker run -ti -v $(pwd):/root/shared -w /root/shared --rm ghcr.io/fenics/dolfinx/dolfinx:v0.7.3
  ```

  Then, inside the container, call

  ```bash
  python3 -m pip install adios4dolfinx==0.7.1
  python3 ./tests/create_legacy_checkpoint.py --output-dir=legacy_checkpoint
  ```



  The long term plan is to get this library merged into DOLFINx (rewritten in C++ with appropriate Python-bindings).

rpm_license:
  Copyright 2023 Jørgen S. Dokken  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: 89daac75b81068a2cfa690560158677b7b4e5bb889286d057ad8585597ebc4f6
name: python-adix
arch: src
version: 0.2.6
epoch: 0
release: 1
summary: Automated exploratory data analysis (EDA).
url: https://imooger.github.io
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adix-0.2.6-1.src.rpm
checksum_type: sha256
description:
  ![PyPI - Version](https://img.shields.io/pypi/v/adix)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/adix)
  ![PyPI - License](https://img.shields.io/pypi/l/adix)

  **ADIX** is a free, open-source, color-customizable data analysis tool that simplifies Exploratory Data Analysis (EDA) with a single command `ix.eda()`. Experience a streamlined approach to uncovering insights, empowering you to focus on your data without distraction.
  **Color customization** is at your fingertips, allowing you to tailor your analysis to your exact needs. Explore your data with confidence and efficiency, knowing that **adix** (Automatic Data Inspection and eXploration) has your back every step of the way.
  ![logo](https://raw.githubusercontent.com/imooger/adix/master/assets/main_fade.gif)


  - **Customizable Themes**
    - Spruce up the **adix** environment with your own personal touch by playing with color schemes!
  - **Eficient Cache Utilization**
    - Experience faster load times through optimized caching mechanisms, enhancing overall system performance.
  - **Rapid Data Insight**
    - **adix** prioritizes swiftly showcasing crucial data insights, ensuring quick access to important information.
  - **Automatic Type Detection**
    - Detects numerical, categorical, and text features automatically, with the option for manual overrides when
    necessary.
  - **Statistically Rich Summary Information:**
    - Unveil the intricate details of your data with a comprehensive summary, encompassing type identification, unique values, missing values, duplicate rows, the most frequent values and more.
    - Delve deeper into numerical data, exploring properties like min-max range, quartiles, average, median, standard deviation, variance, sum, kurtosis, skewness and more.
  - **Univariate and Bivariate Statistics Unveiled**
      - Explore univariate and bivariate insights with adix's versatile visualization options. From bar charts to matrices, and box plots, uncover a multitude of ways to interpret and analyze your data effectively.

  [Docs](https://imooger.github.io)

  The best way to install **adix** (other than from source) is to use pip:
  ```
  pip install adix
  ```
  **adix is still under development** If you encounter any data, compatibility, or installation issues, please don't hesitate to reach out!

  The system is designed for rapid visualization of target values and dataset, facilitating quick analysis of target characteristics with just one function `ix.eda()`. Similar to pandas' df.describe() function, it provides extended analysis capabilities, accommodating time-series and text data for comprehensive insights.
  ```python
  import adix as ix
  from adix.datasets load_dataset
  titanic = load_dataset('titanic')
  ```


  ```python
  ix.eda(titanic)
  ```
  - using _forest color theme_


pkgId: f35362c8169ad80297c8703a441fce13fbbf312f82c7ecda4974caee9b61d951
name: python-adjango
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: A library with many features for interacting with Django
url: https://github.com/Artasov/adjango
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adjango-0.1.6-1.src.rpm
checksum_type: sha256
description:
  > Sometimes I use this in different projects, so I decided to put it on pypi

  `ADjango` is a convenient library for simplifying work with Django, which offers various useful managers, services, decorators, utilities for asynchronous programming, a task scheduler for Celery, working with transactions and much more.
  - [Installation](#installation-%EF%B8%8F)
  - [Settings](#settings-%EF%B8%8F)
  - [Overview](#overview)
    - [Manager & Services](#manager--services-%EF%B8%8F)
    - [Utils](#utils-)
    - [Decorators](#decorators-)
    - [Other](#other)


  ```bash
  pip install adjango
  ```



  * ### Add the application to the project.
      ```python
      INSTALLED_APPS = [
          
          'adjango',
      ]
      ```
  * ### In `settings.py` set the params
      ```python
      
      

      
      LOGIN_URL = '/login/'

      
      ADJANGO_BACKENDS_APPS = BASE_DIR / 'apps' # for management commands
      ADJANGO_FRONTEND_APPS = BASE_DIR.parent / 'frontend' / 'src' / 'apps' # for management commands
      ADJANGO_APPS_PREPATH = 'apps.'  # if apps in BASE_DIR/apps/app1,app2...
      ADJANGO_UNCAUGHT_EXCEPTION_HANDLING_FUNCTION = ... # Read about @acontroller, @controller
      ADJANGO_CONTROLLERS_LOGGER_NAME = 'global' # only for usage @a/controller decorators
      ADJANGO_CONTROLLERS_LOGGING = True # only for usage @a/controller decorators
      ADJANGO_EMAIL_LOGGER_NAME = 'email' # for send_emails_task logging
      ```
      ```python
      MIDDLEWARE = [
          ...
          
          'adjango.middleware.IPAddressMiddleware',
          ...
      ]
      ```

  Most functions, if available in asynchronous form, are also available in synchronous form.


  A simple example and everything is immediately clear...
  ```python
  from adjango.fields import AManyToManyField
  from adjango.managers.base import AManager
  from adjango.services.base import ABaseService
  from adjango.models import AModel
  from adjango.polymorphic_models import APolymorphicModel

  class User(AbstractUser, ABaseService):
      objects = AManager()

  class User(AbstractUser, AModel): pass


  class Product(APolymorphicModel):
      
      name = CharField(max_length=100)

  class Order(AModel):
      user = ForeignKey(User, CASCADE)
      products = AManyToManyField(Product)



  products = await Product.objects.aall()
  products = await Product.objects.afilter(name='name')

  order = await Order.objects.agetorn(id=69) # aget or none
  if not order: raise


  await order.products.aset(products)

  await order.products.aset(
    Product.objects.filter(name='name')
  )
  await order.products.aadd(products[0])


  order: Order = await Order.objects.aget(id=69)

  order.user = await order.related('user')
  products = await order.products.aall()

  ```

    `aall`, `afilter`,  `arelated`, и так далее доступны как отдельные функции
    ```python
    from adjango.utils.funcs import aall, agetorn, afilter, aset, aadd, arelated
    ```

  * `aforce_data`

      The `aforce_data` decorator combines data from the `GET`, `POST` and `JSON` body
      request in `request.data`. This makes it easy to access all request data in one place.

  * `atomic`

      An asynchronous decorator that wraps
      function into a transactional context. If an exception occurs, all changes are rolled back.

  * `acontroller/controller`

      An asynchronous decorator that wraps
      function into a transactional context. If an exception occurs, all changes are rolled back.
      ```python
      from adjango.adecorators import acontroller

      @acontroller(name='My View', logger='custom_logger', log_name=True, log_time=True)
      async def my_view(request):
          pass

      @acontroller('One More View')
      async def my_view_one_more(request):
          pass
      ```
      * These decorators automatically catch uncaught exceptions and log if the logger is configured
      `ADJANGO_CONTROLLERS_LOGGER_NAME` `ADJANGO_CONTROLLERS_LOGGING`.
      * You can also implement the interface:
          ```python
          class IHandlerControllerException(ABC):
              @staticmethod
              @abstractmethod
              def handle(fn_name: str, request: WSGIRequest | ASGIRequest, e: Exception, *args, **kwargs) -> None:
                  """
                  An example of an exception handling function.

                  @param fn_name: The name of the function where the exception occurred.
                  @param request: The request object (WSGIRequest or ASGIRequest).
                  @param e: The exception to be handled.
                  @param args: Positional arguments passed to the function.
                  @param kwargs: Named arguments passed to the function.

                  @return: None
                  """
                  pass
          ```
          and use `handle` to get an uncaught exception:
          ```python
          
          from adjango.handlers import HCE # use my example if u need
          ADJANGO_UNCAUGHT_EXCEPTION_HANDLING_FUNCTION = HCE.handle
          ```



  * `AsyncAtomicContextManager`🧘

      An asynchronous context manager for working with transactions, which ensures the atomicity of operations.
      ```python
      from adjango.utils.base import AsyncAtomicContextManager

      async def some_function():
          async with AsyncAtomicContextManager():
              ...
      ```

  * `Tasker`📋

      The Tasker class provides methods for scheduling tasks in `Celery` and `Celery Beat`.
      ```python
      from adjango.utils.tasks import Tasker

      task_id = Tasker.put(
          task=my_celery_task,
          param1='value1',
          param2='value2',
          countdown=60 # The task will be completed in 60 seconds
      )
      ```
      ```python
      from adjango.utils.tasks import Tasker
      from datetime import datetime

      
      Tasker.beat(
          task=my_celery_task,
          name='one_time_task',
          schedule_time=datetime(2024, 10, 10, 14, 30), # Start the task on October 10, 2024 at 14:30
          param1='value1',
          param2='value2'
      )

      
      Tasker.beat(
          task=my_celery_task,
          name='hourly_task',
          interval=3600, # The task runs every hour
          param1='value1',
          param2='value2'
      )
      ```

  * `send_emails`

      Allows you to send emails using templates and context rendering.
      ```python
      from adjango.utils.mail import send_emails

      send_emails(
          subject='Welcome!',
          emails=('user1@example.com', 'user2@example.com'),
          template='emails/welcome.html',
          context={'user': 'John Doe'}
      )
      ```
      ```python
      from adjango.tasks import send_emails_task
      from adjango.utils.tasks import Tasker

      send_emails_task.delay(
          subject='Hello!',
          emails=('user@example.com',),
          template='emails/hello.html',
          context={'message': 'Welcome to our service!'}
      )
      
      Tasker.put(
          task=send_emails_task,
          subject='Hello!',
          emails=('user@example.com',),
          template='emails/hello.html',
          context={'message': 'Welcome to our service!'},
          countdown=60 # The task will be completed in 5 seconds
      )
      ```


pkgId: 7dbf421a4337dccbf201db86da049285bfb7a1ea166f5c6f0d52154e5e48a9d6
name: python-adjidev-cbs
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Cyber brebes system advanced hacking tools
url: https://github.com/adjidev/cbs
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adjidev-cbs-1.0.1-1.src.rpm
checksum_type: sha256
description:
  CBS adalah alat hacking untuk menjalankan tools apapun ( mendukung semua bahasa program )



  1. Pertama tama install atau clone reposity ini
     ```bash
     git clone https://github/adjidev/cbs
     ```

     ```bash
     pip install adjidev-cbs
     ```

  2. Setelah itu jalankan tools nya
     ```bash
     cbs --help
     ```
     - Untuk melihat versinya
     ```bash
     cbs --version
     ```
     - Untuk wizard ui
     ```bash
     cbs --wizard
     ```





  Untuk menambahkan tools atau fitur baru sangatlah gampang anda tinggal menambahkan `cbs_config.xml` seperti ini dibawah ini:

  ```xml
  <cbs_settings>
      <cbs_setting>
          <cmd>sherlock</cmd>
          <description>Temukan username dari berbagai sosial media</description>
          <execute>python sherlock.py</execute>
          <!-- untuk <args> Opsional-->
          <args>--search {args}</args>
          <author>adjidev</author>
          <version>0.0.1</version>
      </cbs_setting>
  </cbs_settings>
  ```

  Setelah itu ikuti perintah perintah dibawah ini

  ```bash
  cbs --load "path/ke/folder" --folder "namapayload"
  ```
  - Untuk reposity github
  ```bash
  cbs --load "https://github.com/adjidev/sqlforce"
  ```


  _Terima kasih sudah membaca ini_

  > Disclaimer: jika anda menjual script ini tanpa izin dari saya, saya tidak akan segan segan melaporkan anda ke pihak berwenang


pkgId: 18b6157b205708cc791dc9478fd13538b8b443ca34ea1a572b1a2bb3762a6a48
name: python-adjust-client
arch: src
version: 1.0.8
epoch: 0
release: 1
summary: Adjust.com python API client
url: https://pypi.org/project/adjust-client/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adjust-client-1.0.8-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/mtizima/adjust-client/actions/workflows/python-package.yml/badge.svg)](https://github.com/mtizima/adjust-client/actions/workflows/python-package.yml)

  The Adjust Client Library is a Python library for sending events to Adjust using the HTTP API. It includes functionality for validation, error handling, and retry mechanisms.



  The Adjust Client Library is available on PyPI. You can install it using pip or poetry:

  ```bash
  pip install adjust-client
  ```

  ```bash
  poetry add adjust-client
  ```



  To use the Adjust Client Library, you need to create an instance of the `AdjustClient` class. You can then use the `send_event` method to send events to Adjust.

  ```python
  from adjust_client import AdjustClientConfig, AdjustClient
  config = AdjustClientConfig(app_token='your_app_token')

  event_data = {
      'idfa': 'D2CADB5F-410F-4963-AC0C-2A78534BDF1E',
      'adid': 'test_adid',
      'ip_address': '192.168.0.1',
      'created_at_unix': 1625077800,
      'created_at': '2021-06-30T12:30:00Z'
  }
  client = AdjustClient(config)
  await client.send_event(event_data)
  ```


pkgId: cecb3c8ad5a91eaeca126c5c486327a7c832f176c2b1961cb7cbafe0d9b6ee5e
name: python-adjust-precision-for-schema
arch: src
version: 0.3.4
epoch: 0
release: 1
url: https://pypi.org/project/adjust-precision-for-schema/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adjust-precision-for-schema-0.3.4-1.src.rpm
checksum_type: sha256
summary:
  Intended for use in singer-io targets to overcome the precision differences among certain data source systems, Python, and target systems


pkgId: 79682435dc7320ba7840bb707e586314eece5b2eee54f72c2fe25950f8488be8
name: python-adjustText
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Iteratively adjust text position in matplotlib plots to minimize overlaps
url: https://github.com/Phlya/adjustText
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adjustText-1.2.0-1.src.rpm
checksum_type: sha256
description:
  <img src="https://github.com/Phlya/adjustText/blob/master/adjustText_logo.svg" width="183">

  [![Documentation Status](https://readthedocs.org/projects/adjusttext/badge/?version=latest)](http://adjusttext.readthedocs.io/en/latest/?badge=latest)
  [![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/adjustText/Lobby)
  [![DOI](https://zenodo.org/badge/49349828.svg)](https://zenodo.org/badge/latestdoi/49349828)
  [![PyPI version](https://badge.fury.io/py/adjustText.svg)](https://badge.fury.io/py/adjustText)



  Inspired by **ggrepel** package for R/ggplot2 (https://github.com/slowkow/ggrepel)
  ![Alt text](figures/mtcars.gif "Labelled mtcars dataset")

  Alternative: **textalloc** https://github.com/ckjellson/textalloc



  The idea is that often when we want to label multiple points on a graph the text will start heavily overlapping with both other labels and data points. This can be a major problem requiring manual solution. However this can be largely automatized by smart placing of the labels (difficult) or iterative adjustment of their positions to minimize overlaps (relatively easy). This library (well... script) implements the latter option to help with matplotlib graphs. Usage is very straightforward with usually pretty good results with no tweaking (most important is to just make text slightly smaller than default and maybe the figure a little larger). However the algorithm itself is highly configurable for complicated plots.





  Should be installable from pypi:
  ```
  pip install adjustText
  ```
  Or with `conda`:
  ```
  conda install -c conda-forge adjusttext
  ```

  For the latest version from github:
  ```
  pip install https://github.com/Phlya/adjustText/archive/master.zip
  ```



  [Wiki] has some basic introduction, and more advanced usage examples can be found [here].

  Thanks to Christophe Van Neste @beukueb, **adjustText** has a simple documentation:
  http://adjusttext.readthedocs.io/en/latest/

  [Wiki]: https://github.com/Phlya/adjustText/wiki
  [here]: https://github.com/Phlya/adjustText/blob/master/docs/source/Examples.ipynb



  To cite the library if you use it in scientific publications (or anywhere else, if you wish), please use the link to the GitHub repository (https://github.com/Phlya/adjustText) and a zenodo doi (see top of this page). Thank you!


pkgId: 6454a91d5b906f0a01bc09318d660e0893255d9579a3121d5ae6689d629052db
name: python-adlfs
arch: src
version: 2024.7.0
epoch: 0
release: 1
summary: Access Azure Datalake Gen1 with fsspec and dask
url: https://pypi.org/project/adlfs/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adlfs-2024.7.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version shields.io](https://img.shields.io/pypi/v/adlfs.svg)](https://pypi.python.org/pypi/adlfs/)
  [![Latest conda-forge version](https://img.shields.io/conda/vn/conda-forge/adlfs?logo=conda-forge)](https://anaconda.org/conda-forge/aldfs)


pkgId: 5df0a903c3c0c96ad5e7c6b9195c9da17d60c9948c9b75cd2a603d14c4ce8053
name: python-adm-boundary-manager
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Load, manage and visualize Administrative Boundaries Data in Wagtail
url: https://github.com/wmo-raf/adm-boundary-manager
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adm-boundary-manager-0.2.1-1.src.rpm
checksum_type: sha256
description:
  Load, manage and visualize administrative boundaries for a country or more, in Wagtail Projects.



  The Admin Boundary Manager is a Wagtail based application that enables to load boundary datasets from different sources,
  at different administrative levels as provided by the source, for a country. The boundaries can then be served as vector
  tiles and used in web maps, and across your GIS based application that needs reference to a country and its boundaries.

  `A country` is at the core of the package. This means that you will load boundary data country by country. You can have
  multiple countries. This is a design decision specifically for this package. If you need to load, say continental data
  at once, this might not be the best solution for your case.



  - Load administrative boundaries from different sources. Supported sources include:
      - OCHA's Administrative Boundary Common Operational Datasets (COD-AB)
      - Global Administrative Areas 4.1 (GADM 4.1)
      - Load data from other sources. At the core, we define a boundary model schema that you can follow to load data from
        other sources not currently implemented out of the box
  - Preview loaded boundary data to check that everything is correct as expected
  - Serve boundary data as vector tiles for use in your web maps. Data is saved to a PostGIS Table.`ST_AsMVT` is used to
    serve vector tiles





  You need a Wagtail Project, with a PostGIS database setup, to support a GeoDjango project.



  You can install the package using pip:

  ```shell
  pip install adm-boundary-manager
  ```



  Make sure the following are all added to your `INSTALLED_APPS` in your Wagtail settings

  ```python
  INSTALLED_APPS = [
      "adminboundarymanager",
      "django_countries",
      "wagtailcache",

      "wagtail.contrib.modeladmin",
      "wagtail.contrib.settings",

      "django.contrib.gis",
  ]
  ```

  Run app migrations

  ```shell
  python manage.py migrate adminboundarymanager
  ```

  Add the following to your project's `urls.py`

  ```python
  urlpatterns = [
      ...
      path("", include("adminboundarymanager.urls")),
      ...
  ]
  ```



  The package uses the [wagtail-cache](https://github.com/coderedcorp/wagtail-cache) package for caching vector tile
  requests. Please have a look at the [wagtail-cache documentation](https://docs.coderedcorp.com/wagtail-cache/) for setup
  instructions.



  The `Admin Boundary settings` will be added to the `Wagtail Settings` panel automatically. To access the `Boundary Data`
  loader and preview interfaces, you can follow the following steps:

  In an existing or new Wagtail app, add the following to the `wagtail_hooks.py` file. Create one if it does not exist
  yet.

  ```python
  from wagtail.contrib.modeladmin.options import modeladmin_register

  from adminboundarymanager.wagtail_hooks import AdminBoundaryManagerAdminGroup

  modeladmin_register(AdminBoundaryManagerAdminGroup)
  ```

  This will add a `Boundary Manager` menu to the Wagtail Admin side panel, as in the below screenshot:

  ![Accessing admin](screenshots/abm_admin_access.png)

  Click to expand and access the submenu



  The `Boundary Settings` allow to configure settings used by the package. This
  uses [Wagtail's Site Settings](https://docs.wagtail.org/en/latest/reference/contrib/settings.html) contrib module.

  The following are the available settings, as shown in the screenshot below:

  ![Boundary Settings](screenshots/adb_admin.png)

  1. Access the `Boundary Manager` menu, as described in the previous section
  2. Click on `Admin Boundary Settings`
  3. `Boundary Data Source` - Select where you will be getting your boundary data from. See following sections for more
     details on the database model and supported data sources
  4. `Countries must share boundaries` - Check this if you plan to add boundaries for more than one country, and want to
     validate that all the added countries `share a boundary at least with one other country`.
  5. `Countries` - Here you can add multiple countries that you wish to load data for.
  6. Save button



  The `AdminBoundary` model is a simple [Geodjango](https://docs.djangoproject.com/en/4.2/ref/contrib/gis/model-api/)
  model with the following fields

  - name_0
  - name_1
  - name_2
  - name_3
  - name_4
  - gid_0
  - gid_1
  - gid_2
  - gid_3
  - gid_4
  - level
  - geom

  As you might have noticed, the model supports up to 4 administrative levels. The `level` field indicates the specific
  level for a given model instance.

  The fields starting with prefix `name_` correspond to the `name` of the admin boundary at a given level. For
  example `name_0`
  corresponds to the name of the boundary at admin level 0, which is usually the country level.

  The fields starting with prefix `gid_` correspond to the `ID` of the admin boundary at a given level. For
  example `gid_0` corresponds to the id of the boundary at admin level 0, which is usually the country code in
  either [alpha2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) (2-letter code)
  or [alpha3](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-3) (3-letter code) format.

  The `geom` field is a `Geodjango` field that stores the boundary geometry as a `Multipolygon`. Every boundary instance
  is saved as a Multipolygon, even if it was initially a Polygon. This is to ensure consistency across the Model.

  Using this schema, you can format any boundary data to follow this structure and easily load it.

  The [LayerMapping](https://docs.djangoproject.com/en/4.2/ref/contrib/gis/layermapping/) utility is used under the hood
  to load the boundaries from a GIS formatted file, that can be a shapefile or Geopackage, depending on the source.



  Currently, the following data sources are supported out of the box:

  - [OCHA's Administrative Boundary Common Operational Datasets (COD-AB)](https://humanitarian.atlassian.net/wiki/spaces/codtsp/pages/41973316/Administrative+Boundary+CODs+COD-AB)
  - [Global Administrative Areas 4.1 (GADM 4.1)](https://gadm.org/)



  [Administrative Boundary CODs](https://humanitarian.atlassian.net/wiki/spaces/codtsp/pages/41973316/Administrative+Boundary+CODs+COD-AB)
  are baseline geographical datasets that are used by humanitarian agencies during preparedness and response activities.

  They are preferably sourced from official government boundaries but when these are unavailable the IM network must
  develop and agree to a process to develop an alternate dataset.

  Where available, we `recommend` using this data source since most of the data is sourced from official Government
  sources. The boundary source covers most of African Countries.



  Below are steps to download and load the boundary data for a country of interest:

  - First you will need to access the
    OCHA's [Humanitarian Data Exchange](https://data.humdata.org/dashboards/cod?cod_level=cod-standard&cod_level=cod-enhanced&dataseries_name=COD%20-%20Subnational%20Administrative%20Boundaries&q=&sort=if(gt(last_modified%2Creview_date)%2Clast_modified%2Creview_date)%20desc)
    Platform.
    This [link](https://data.humdata.org/dashboards/cod?cod_level=cod-standard&cod_level=cod-enhanced&dataseries_name=COD%20-%20Subnational%20Administrative%20Boundaries&q=&sort=if(gt(last_modified%2Creview_date)%2Clast_modified%2Creview_date)%20desc)
    will take you directly to the COD-AB data download page, similar to the below screenshot:

  ![OCHA COD-AB download](screenshots/cod_ab_access.png)

  1. Make sure `CODS` is checked on the filter panel, under `Featured` section
  2. Still on the filter panel, under the `Data Series` section, make sure `COD - Subnational Administrative Boundaries`
     is checked
  3. You can search for your country of interest here
  4. The results will be shown here. Click on the country result to go to the download page, that will look similar to the
     screenshot below:

  ![Download COD-AB](screenshots/download_cod_ab.png)

  Once in the dataset detail page, follow the steps below to download the country boundaries `shapefiles`

  1. Select the `Data and Resources` tab if not selected by default
  2. Look for the `shapefile` dataset. The file name will usually end with `SHP.zip`. This is the correct file that you
     should download
  3. Once you identify the shapefile, click on the `DOWNLOAD` button to download the shapefile

  Once downloaded, extract the shapefile to an accessible location in your computer. Once extracted, you will notice a
  large number of files. That is ok.

  The files are for all the administrative levels, usually from 0 to 3, and also all levels combined. We want the data at
  different levels. We will need to `group and zip the files for the same levels`, as in the sample screenshot below:

  ![grouping shapefiles](screenshots/group_levels_cod_ab.png)

  Group similar admin level files and zip them. Look out for patterns, for example for admin level 0 files, they will
  contain the characters `adm0` or similar somewhere in the middle of the name.

  Make sure for each level you have at-least 3 files with the following extensions:

  - `.shp`
  - `.shx`
  - `.dbf`

  These are the necessary files for a valid shapefile. You should end up with zip files for at least 3 levels.

  You can name the admin level zip files with an easy name that you can identify later. For example for level one, you can
  have `<country_name>_level_0.zip`



  Before accessing the data loading interface, make sure you have
  selected ` OCHA Administrative Boundary Common Operational Datasets (COD-ABS)` as the `Boundary data source` option in
  the `Admin Boundary Settings`

  Also make sure you add the countries of interest under the `Countries` section in the `Admin Boundary Settings`

  ![Load COD-AB Admin](screenshots/abm_add_boundary_access.png)

  1. Click on the Boundary Manager
  2. Click on Boundary Data. This will open the boundary preview interface, with a `Add Boundary` button in the top right
     corner
  3. Click on the `Add Boundary` button, to open an interface that looks like in the below screenshot

  ![COD-AB upload form](screenshots/ocha_cod_form.png)

  1. This is the link to the data source, as described in the previous section
  2. Select the country you want to load the data for. Make sure you select the country corresponding to the country data
     you want to upload. To add a new country, you can do so from the `Admin Boundary Settings`
  3. Select the `Administrative level` for the country boundary data you want to upload
  4. Select the zipped shapefile for the country boundary level data. Make sure you select the correct zipped file for the
     correct country and level. The file must be a `zipped shapefile` as described the previous section.

  If done correctly, you will be redirected to the preview page, and see the data loaded on the map.

  ![COD Success](screenshots/cod_success.png)

  If an error was encountered during the upload process, an error message will show up with details of the error.

  Repeat the process for all the administrative levels datasets that you want to load.

  `NOTE:` If you load data for an already existing level and country, the existing boundary data for that level and
  country will be deleted and the new one saved.



  The [Global Administrative Areas 4.1 (GADM)](https://gadm.org/")  is a database of the location of the world's
  administrative areas (boundaries). Administrative areas in this database include: countries, counties, districts etc.
  and cover every country in the world. For each area it provides some attributes foremost being the name and in some
  cases variant names.

  The most recent version is `4.1` and is the version currently supported by this package.



  Access the [GADM data ](https://gadm.org/data.html) page. It should look similar to below screenshot:

  ![Access GADM data](screenshots/access_gadm.png)

  1. Click on the `Data` link from the navigation bar. The data page, at the time of writing, looks like the above
     screenshot.
  2. Click on the `country` link that will take you to a download interface for specific countries. Remember we have to do
     it country by country in our upload interface.

  The `Country` download interface will look like below:

  ![GADM Country Download](screenshots/gadm_download.png)

  1. Select your country of interest. GADM data should available for all countries in the world.
  2. Look for the `Geopackage` download link. For GADM data, downloading a geopackage comes with all the data for all the
     different levels. This allows to upload data for different levels of a country with one step.

  Once you download the `country geopackage` and saved it somewhere in your computer, you are ready to load it.



  Before accessing the data loading interface, make sure you have selected `Global Administrative Areas 4.1 (GADM)` as
  the `Boundary data source` option in the `Admin Boundary Settings`

  Go to `Boundary Data` > `Add Boundary`. The upload form should look like below

  ![GADM upload form](screenshots/gadm41_load_form.png)

  1. Link to download data for country, as explained in previous section
  2. Select the country for the data you downloaded. To add a new country, you can do so from
     the `Admin Boundary Settings`
  3. Choose the geopackage file for the country data you downloaded
  4. Click on upload

  If done correctly, you will be redirected to the preview page, and see the data loaded on the map.

  If an error was encountered during the upload process, an error message will show up with details of the error.

  Repeat the process for all the countries' data that you want to load.

  `NOTE:` If you load data for an already existing country, the existing boundary data for that country will be deleted
  and the new one saved.



  As explained in the [Boundary Model Structure](#boundary-model-structure) section, by following the defined model
  structure, you can add data from other sources.

  You will need to separate your country boundary dataset into the different levels. For example, for level 0 of a
  country, you will have one `zipped shapefile`, as so on for all the levels you want to upload.

  Your shapefile data should contain the following fields, for each level.



  - name_0
  - gid_0



  - name_0
  - gid_0
  - name_1
  - gid_1



  - name_0
  - gid_0
  - name_1
  - gid_1
  - name_2
  - gid_2



  - name_0
  - gid_0
  - name_1
  - gid_1
  - name_2
  - gid_2
  - name_3
  - gid_3

  `NOTE`: The field names are case-insensitive. They can be in lowercase or uppercase.



  Before accessing the data loading interface, make sure you have selected `Generic Data Source` as
  the `Boundary data source` option in the `Admin Boundary Settings`

  Go to `Boundary Data` > `Add Boundary`. The upload form should look like below

  ![Other Source Upload Form](screenshots/other_source_form.png)

  1. Select the country to upload data for
  2. Select the admin level
  3. Choose your `zipped shapefile` for the selected admin level
  4. Click on `Upload` to load

  If done correctly, you will be redirected to the preview page, and see the data loaded on the map.

  If an error was encountered during the upload process, an error message will show up with details of the error.

  Repeat the process for all the administrative levels datasets that you want to load for a country.



  - For consistency, you should decide on one data source and use it for all your countries
  - Re-uploading data for a given country and or level, will delete any existing data for that country and or level, and
    replace with the new uploaded one
  - Deleting a country from the settings will delete any previously loaded data for that country



  Wagtail Cache is invalidated automatically at the following points:

  - On Updating `AdminBoundarySettings`
  - On uploading or overwriting boundary data



  API endpoints are provided for searching, retrieving and serving vector tiles for the boundary data.



  `/api/admin-boundary/search?search=<name>`

  The search endpoint allows searching Admin Boundaries by `name_0`, `name_1`, `name_2` and `name_3`. This will give you
  results for all boundaries whose name match the search phrase.



  `/api/admin-boundary/<boundary_id>`

  The retrieve endpoint allows to get an admin boundary by ID. This assumes you already know the ID for the boundary
  instance you wish to retrieve.

  Usually you will use this endpoint in conjunction with the search API.

  **A sample use case will be:**

  - Use the `Search Endpoint` to search for an admin level by name in an autocomplete search input
  - Show the matching results in the result dropdown
  - Once the user selects a result item, you can use the the `Retrieve endpoint` to retrieve the detail of the boundary,
    using the ID of the selected boundary item.



  `/api/admin-boundary/tiles/<int:z>/<int:x>/<int:y>`

  The vector tiles endpoint can be used to serve the vector tiles from the boundary data. Usually, you will use this with
  a web mapping library that supports vector tiles, like [MapLibre GL JS](https://maplibre.org/maplibre-gl-js/docs/)

  Below is a quick snippet on how you can add boundary vector tile layers to your MapLibre web map:

  ```html

  <head>
      <link rel="stylesheet" href="https://unpkg.com/maplibre-gl/dist/maplibre-gl.css">
  </head>

  <body>
  <div id="map"></div>


  <script src="https://unpkg.com/maplibre-gl/dist/maplibre-gl.js"></script>
  <script>
      const map = new maplibregl.Map({
          container: 'map', // container id
          style: 'https://demotiles.maplibre.org/style.json', // style URL
          center: [0, 0], // starting position [lng, lat]
          zoom: 1 // starting zoom
      });


      const boundaryTilesUrl = "/api/admin-boundary/tiles/{z}/{x}/{y}"

      map.on("load", () => {

          // add source
          map.addSource("admin-boundary-source", {
                      type: "vector",
                      tiles: [boundaryTilesUrl],
                  }
          )

          // add fill layer
          map.addLayer({
              'id': 'admin-boundary-fill',
              'type': 'fill',
              'source': 'admin-boundary-source',
              "source-layer": "default",
              'paint': {
                  'fill-color': "#fff",
                  'fill-opacity': 0,
              }
          });

          // add line layer
          map.addLayer({
              'id': 'admin-boundary-line',
              'type': 'line',
              'source': 'admin-boundary-source',
              "source-layer": "default",
              'paint': {
                  "line-color": "#444444",
                  "line-width": 0.7,
              }
          });
      })


  </script>

  </body>
  ```

  `Note`: The vector tile `source-layer` is named as `default`

  All the fields are available in the vector tile data. This means you can show, on a popup for example, the data for a
  boundary on click.

  You can also use this to filter which data is shown on the map.

  For example if you only wanted to show data for admin level 0, (i.e Country Level), you can do it as in the example
  below:

  ```js
  const boundaryFilter = ["==", "level", 0]

  // add fill layer, with custom filter
  map.addLayer({
      'id': 'admin-boundary-fill',
      'type': 'fill',
      'source': 'admin-boundary-source',
      "source-layer": "default",
      'paint': {
          'fill-color': "#fff",
          'fill-opacity': 0,
      },
      "filter": boundaryFilter
  });

  ```


pkgId: a257402014c1003227e8054dea092b932b3683a865ee3a2bbcb02a6183fe2a6b
name: python-adman
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: Active Directory Automated Maintenance
url: https://gitlab.com/JonathonReinhart/adman
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adman-0.9.0-1.src.rpm
checksum_type: sha256
description:
  ADMan is a tool for performing automated Active Directory management.
  For more information, [Read the Docs](https://adman.readthedocs.io/).


pkgId: 343d4aca8f56adf0c86a8a62fac177a21769085db88cefc4a563f186f4741d97
name: python-admcycles
arch: src
version: 1.4
epoch: 0
release: 1
summary: Tautological ring on Mbar_g,n
url: https://gitlab.com/modulispaces/admcycles
rpm_license: GPLv2+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-admcycles-1.4-1.src.rpm
checksum_type: sha256
description:
  admcycles is a `SageMath <https://www.sagemath.org>`_ module to compute with
  the tautological ring of the moduli spaces of complex curves. You can install
  it on top of a SageMath installation on your computer (see the instructions
  below). You can alternatively use one of the online services below that have
  admcycles already installed:
  - `SageMathCell <https://sagecell.sagemath.org/>`_: An online service for
    SageMath computations that does not require authentification.
  - `CoCalc <https://cocalc.com/>`_: A complete computation environment that
    offers a free plan subscription (with limited resources).
  admcycles includes the `SageMath <https://www.sagemath.org>`_ module diffstrata
  to compute with the tautological ring of the moduli space of multi-scale
  differentials, a compactification of strata of flat surfaces. It is particularly
  tailored towards computing Euler characteristics of these spaces.
  Detailed information on the package is contained in the documents
  - `admcycles -- a Sage package for calculations in the tautological ring of the
    moduli space of stable curves [arXiv:2002.01709] <https://arxiv.org/abs/2002.01709>`_
  - `diffstrata -- a Sage package for calculations in the tautological ring of the
    moduli space of Abelian differentials [arXiv:2006.12815] <https://arxiv.org/abs/2006.12815>`_
  - `online documentation <https://modulispaces.gitlab.io/admcycles/>`_
  **NEW: Online database with tautological relations (Feb 2023)**
  The latest version of admcycles includes an automated `online lookup <https://gitlab.com/modulispaces/relations-database>`_ of pre-calculated tautological relations (see `the list of available cases <https://modulispaces.gitlab.io/relations-database/index.html>`_).
  By default, if you attempt a calculation that needs tautological relations, the program will first try to look them up in your local storage (in the folder ``.sage/admcycles``). If not found there, the program will check the above database and download the relations to your computer in case they are available. If this fails as well, the program will then calculate the relations itself.
  If you would like to deactivate this online lookup, execute the following lines in a Sage session::
      sage: from admcycles.admcycles import set_online_lookup_default
      sage: set_online_lookup_default(False)
  If you have calculated and stored relations that are not yet in our database, we would be happy if you reach out so we can integrate them!


pkgId: e8c1830b78aab98da4d12b33f658ec070c242be631bde4111eabef45064d2c17
name: python-admet-ai
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: admet_ai
url: https://github.com/swansonk14/admet_ai
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-admet-ai-1.3.1-1.src.rpm
checksum_type: sha256
description:
  This git repo contains the code for ADMET-AI, an ADMET prediction platform that
  uses [Chemprop-RDKit]((https://github.com/chemprop/chemprop)) models trained on ADMET datasets from the Therapeutics
  Data Commons ([TDC](https://tdcommons.ai/)). ADMET-AI can be used to make ADMET predictions on new molecules via the
  command line, via the Python API, or via a web server. A live web server hosting ADMET-AI is
  at [admet.ai.greenstonebio.com](https://admet.ai.greenstonebio.com)

  Please see the following paper and [this blog post](https://portal.valencelabs.com/blogs/post/admet-ai-a-machine-learning-admet-platform-for-evaluation-of-large-scale-QPEa0j5OTYYHTaA) for more
  details, and please cite us if ADMET-AI is useful in your work. Instructions to reproduce the results in our paper are in [docs/reproduce.md](docs/reproduce.md).

  [ADMET-AI: A machine learning ADMET platform for evaluation of large-scale chemical libraries](https://academic.oup.com/bioinformatics/advance-article/doi/10.1093/bioinformatics/btae416/7698030?utm_source=authortollfreelink&utm_campaign=bioinformatics&utm_medium=email&guestAccessKey=f4fca1d2-49ec-4b10-b476-5aea3bf37045)




  - [Installation](#installation)
  - [Predicting ADMET properties](#predicting-admet-properties)
      * [Command line tool](#command-line-tool)
      * [Python module](#python-module)
      * [Web server](#web-server)



  ADMET-AI can be installed in a few minutes on any operating system using pip (optionally within a conda environment). If
  a GPU is available, it will be used by default, but the code can also run on CPUs only.

  Optionally, create a conda environment.

  ```bash
  conda create -y -n admet_ai python=3.10
  conda activate admet_ai
  ```

  Install ADMET-AI via pip.

  ```bash
  pip install admet-ai
  ```

  Alternatively, clone the repo and install ADMET-AI locally.

  ```bash
  git clone https://github.com/swansonk14/admet_ai.git
  cd admet_ai
  pip install -e .
  ```

  By default, the pip installation only includes dependencies required for making ADMET predictions, either via the
  command line or via the Python API. To install dependencies required for processing TDC data or plotting TDC results,
  run `pip install admet-ai[tdc]`. To install dependencies required for hosting the ADMET-AI web server,
  run `pip install admet-ai[web]`.

  If there are version issues with the required packages, create a conda environment with specific working versions of the
  packages as follows.

  ```bash
  pip install -r requirements.txt
  pip install -e .
  ```

  Note: If you get the issue `ImportError: libXrender.so.1: cannot open shared object file: No such file or directory`,
  run `conda install -c conda-forge xorg-libxrender`.



  ADMET-AI can be used to make ADMET predictions in three ways: (1) as a command line tool, (2) as a Python module, or (3)
  as a web server.



  ADMET predictions can be made on the command line with the `admet_predict` command, as illustrated below.

  ```bash
  admet_predict \
      --data_path data.csv \
      --save_path preds.csv \
      --smiles_column smiles
  ```

  This command assumes that there exists a file called `data.csv` with SMILES strings in the column `smiles`. The
  predictions will be saved to a file called `preds.csv`.



  ADMET predictions can be made using the `predict` function in the `admet_ai` Python module, as illustrated below.

  ```python
  from admet_ai import ADMETModel

  model = ADMETModel()
  preds = model.predict(smiles="O(c1ccc(cc1)CCOC)CC(O)CNC(C)C")
  ```

  If a SMILES string is provided, then `preds` is a dictionary mapping property names to values. If a list of SMILES
  strings is provided, then `preds` is a Pandas DataFrame where the index is the SMILES and the columns are the
  properties.



  ADMET predictions can be made using the ADMET-AI web server, as illustrated below. Note: Running the following command
  requires additional web dependencies (i.e., `pip install admet-ai[web]`).

  ```bash
  admet_web
  ```

  Then navigate to http://127.0.0.1:5000 to view the website.



  The DrugBank reference plot and radial plots displayed on the ADMET-AI website can be generated locally using the
  `scripts/plot_drugbank_reference.py` and `scripts/plot_radial_summaries.py` scripts, respectively. Both scripts
  take as input a CSV file with ADMET-AI predictions along with other parameters.


pkgId: 67f3e91527431d55f9980b20a59fedcd843cc9584360e0bf42b854d80d00ce73
name: python-admin-custom-filter
arch: src
version: 1.0.8
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/i3z101/admin_custom_filter/tree/master
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-admin-custom-filter-1.0.8-1.src.rpm
checksum_type: sha256
description:
  Admin custom filter package is a package will let you customize the view for the data in admin panel for each model dynamically.



  Basically when you want to add custom filters, custom searches, and custom list displays, You need to add the values you want in hard coded. But if someone uses the admin panel and he has no technical knowledge to update the code. He will ask the developer each time to update the codes and wait the development process to finish.


  1. The admin custom filter package will help to play around with all models' fields dynamically. So, any update in the filter will be reflected directly and immediately in the platform.
  2. Let say there are more than one admin in the platform, each one of them will have its unique filter. So, no overlap between them.


  1. Install the package
  ```
  pip install admin-custom-filter
  ```
  2. Add the app name in installed apps in settings.py and configure the templates <br> Make sure to have APP_DIRS to True and add BASE_DIR / "admin_custom_filter" / "templates" to DIRS list
  ```
  INSTALLED_APPS = [
      'admin_custom_filter',
  ]
  TEMPLATES = [
      {
          'BACKEND': 'django.template.backends.django.DjangoTemplates',
          'DIRS': [
              BASE_DIR / "admin_custom_filter" / "templates"
          ],
          'APP_DIRS': True,
          'OPTIONS': {
              'context_processors': [
                  'django.template.context_processors.debug',
                  'django.template.context_processors.request',
                  'django.contrib.auth.context_processors.auth',
                  'django.contrib.messages.context_processors.messages',
              ],
          },
      },
  ]
  ```
  3. After installing the package, make sure to have AUTH_USER_MODEL from the settings file.
  ```
  EX:
  inside settings.py
  AUTH_USER_MODEL = "authentication.user"
  ```
  4. Run migration
  ```
  python manage.py makemigrations
  python manage.py migrate
  OR
  python3 manage.py makemigrations
  python3 manage.py migrate
  ```
  5. Add the custom filter class to the models you want as the parent class inside admin.py file.
  ```
  Ex:
  from admin_custom_filter.admin_filter import AdminCustomFilter
  class Countries(AdminCustomFilter):
      pass
  ```
  6. Save and go to the admin panel. Then select the model that has the admin custom filter.
  7. You will see button Custom filter.


pkgId: ea0160a8026adf47e3a1e18638799464414a286e9e6c56ef96b4f79cb792883c
name: python-admin-extra-urls
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Django mixin to easily add urls to any ModelAdmin
url: https://github.com/saxix/django-admin-extra-urls
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-admin-extra-urls-2.2.0-1.src.rpm
checksum_type: sha256
description:
  pluggable django application that offers one single mixin class ``ExtraUrlMixin``
  to easily add new url (and related buttons on the screen) to any ModelAdmin.
  It provides two decorators ``link()`` and ``action()``.
  - ``link()`` is intended to be used for multiple records. It will produce a button in the change list view.
  - ``action()`` works on a single record. It will produce a button in the change form view.


pkgId: 5f6b974348e42c245fd6dea0c910e54e229cf903acd1db93b1ec2ab073d9405e
name: python-admin-search-plus
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Mixin for Django's admin objects to enhance searching by limiting searchable fields
url: https://github.com/Lenders-Cooperative/django-admin-search-plus
rpm_license: bsd-3-clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-admin-search-plus-0.3.1-1.src.rpm
checksum_type: sha256
description:
  Admin Search Plus is a AdminMixin for Django that limits searches to specific fields which greatly enhances performance when working on large datasets.




  `$ pip install admin-search-plus`

  Or through github:

  `$ pip install -e git://github.com/Lenders-Cooperative/admin-search-plus#egg=admin-search-plus`



  `$ python -m build`

  `$ pip install admin_search_plus.whl`


  1. Add `admin_search_plus` to your `INSTALLED_APPS` before `django.contrib.admin`:

      ```
      INSTALLED_APPS = [
          'app_to_be_overrided',
          ...
          'admin_search_plus',
          ...
          'django.contrib.admin',
          'django.contrib.auth',
          'django.contrib.contenttypes',
          'django.contrib.sessions',
          'django.contrib.messages',
          'django.contrib.staticfiles',
      ]
      ```
      NOTE: To override a template, the app should be listed before `admin_search_plus`

  2. In `admin.py` import `AdminSearchPlusMixin` to add search functions to `ModelAdmin`.

      ```
      from admin_search_plus import AdminSearchPlusMixin

      class YourModelAdmin(AdminSearchPlusMixin, admin.ModelAdmin):
          admin_search_plus = True
          show_full_result_count = False
          show_result_count = False

      admin.site.register(YourModel, YourModelAdmin)

      ```


pkgId: d16846e7003497a8898e9459d810ac81939ee4bc1a771a88f2b7043568b6d0db
name: python-admin-totals
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Django Admin Totals, add totals to your columns in Django admin.
url: https://github.com/douwevandermeij/admin-totals
rpm_license: GNU General Public License v2 (GPLv2)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-admin-totals-1.0.1-1.src.rpm
checksum_type: sha256
description:
  Module to show totals in Django Admin List.

  [![codecov](https://codecov.io/gh/douwevandermeij/admin-totals/branch/master/graph/badge.svg)](https://codecov.io/gh/douwevandermeij/admin-totals)
  [![Build Status](https://travis-ci.org/douwevandermeij/admin-totals.svg?branch=master)](https://travis-ci.org/douwevandermeij/admin-totals)



      virtualenv .
      source bin/activate
      pip install admin-totals

  Or

      pip install git+https://github.com/douwevandermeij/admin-totals.git



  In settings.py
  ```python
  INSTALLED_APPS = [
      'admin_totals',
  ]
  ```
  In admin.py:
  ```python
  from admin_totals.admin import ModelAdminTotals
  from django.contrib import admin
  from django.db.models import Sum, Avg
  from django.db.models.functions import Coalesce

  @admin.register(MyModel)
  class MyModelAdmin(ModelAdminTotals):
      list_display = ['col_a', 'col_b', 'col_c']
      list_totals = [('col_b', lambda field: Coalesce(Sum(field), 0)), ('col_c', Avg)]
  ```
  Make sure to at least have the columns of `list_totals` in `list_display`.



      python runtests.py



  Please make sure to run the following commands before pushing and making a PR:

      pip install -r requirements/test-ci.txt
      isort --recursive admin_totals tests
      flake8

  `isort` will sort the imports and `flake8` will lint the code. Please fix any errors before committing. Also, make sure to write passing tests.


pkgId: d0e7799a36d775b7284baa72703943ed37779ceba7e588ef746929b701bfcce7
name: python-admindojo
arch: src
version: 0.1.28
epoch: 0
release: 1
summary: The admindojo client for VMs
url: https://github.com/admindojo/admindojo-client
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-admindojo-0.1.28-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">
    <p align="center">admindojo.org</p>
    <a href="https://admindojo.org"><img height="300" src="https://admindojo.org/img/dojo_round.png" alt="admindojo"></a>
  </h1>

  <p align="center">
    <a href="https://pypi.python.org/pypi/admindojo"><img src="https://img.shields.io/pypi/v/admindojo.svg" alt="pypi Version"></a>
    <a href="https://travis-ci.org/admindojo/admindojo-client"><img src="https://img.shields.io/travis/admindojo/admindojo-client.svg" alt="Travis Status"></a>
  </p>



  admindojo is a free, interactive Linux tutorial for (junior) sysadmins.
  Using local virtual machines, admindojo provides real-world scenarios in real environments.

  This repository contains the client that is used inside each training VM.

  Visit [admindojo.org](https://admindojo.org/getting-started) for more information.




  ``admindojo start`` : Start training

  ``admindojo check`` : Run check and calculate score

  ``admindojo --help``: help



  Free software: MIT license


  - Package templating tool [https://github.com/audreyr/cookiecutter](ookiecutter)
  - Package template [https://github.com/audreyr/cookiecutter-pypackage](audreyr/cookiecutter-pypackage)


pkgId: c8a45ca4dc733eba8886f6df028551247b5e9c40685feef95e7f34a7a90f76cb
name: python-ado-asana-sync
arch: src
version: 1.9.1
epoch: 0
release: 1
summary: Tool to sync work items from Azure DevOps to Asana
url: https://pypi.org/project/ado-asana-sync/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ado-asana-sync-1.9.1-1.src.rpm
checksum_type: sha256
description:
  [![Test and Lint](https://github.com/danstis/ado-asana-sync/actions/workflows/build.yml/badge.svg)](https://github.com/danstis/ado-asana-sync/actions/workflows/build.yml)
  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=danstis_ado-asana-sync&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=danstis_ado-asana-sync)
  [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=danstis_ado-asana-sync&metric=coverage)](https://sonarcloud.io/summary/new_code?id=danstis_ado-asana-sync)

  [![Release](https://img.shields.io/github/release/danstis/ado-asana-sync.svg?style=flat-square)](https://github.com/danstis/ado-asana-sync/releases/latest)
  [![PyPI - Version](https://img.shields.io/pypi/v/ado-asana-sync)](https://pypi.org/project/ado-asana-sync/)

  [![Open in Visual Studio Code](https://img.shields.io/static/v1?logo=visualstudiocode&label=&message=Open%20in%20Visual%20Studio%20Code&labelColor=2c2c32&color=007acc&logoColor=007acc)](https://open.vscode.dev/danstis/ado-asana-sync)

  This project aims to synchronize work items between Azure DevOps (ADO) and Asana. It's currently in development and not ready for use. Breaking changes will occur as needed.



  * Get the latest container image from the [Github Container Registry](https://github.com/danstis/ado-asana-sync/pkgs/container/ado-asana-sync).
  * Configure the environment variables with the relevant values:
    * `ADO_PAT` - Your Personal Access Token for ADO to accesst the work items.
    * `ADO_URL` - The full URL of your Azure DevOps instance.
    * `ASANA_TOKEN` - Your Personal Access Token for Asana to access the work items.
    * `ASANA_WORKSPACE_NAME` - Name of the Asana workspace to sync with.
    * `CLOSED_STATES` - Comma separated list of states that will be considered closed.
    * `THREAD_COUNT` - Number of projects to sync in parallel. Must be a positive integer.
    * `SLEEP_TIME` - Duration in seconds to sleep between sync runs. Must be a positive integer.
    * `SYNCED_TAG_NAME` - Name of the tag in Asana to append to all synced items. Must be a valid Asana tag name.
  * Run the container with the configured environment variables.
  * The application will start syncing work items between ADO and Asana based on the configured settings.





  This repo uses [Conventional Commits](https://www.conventionalcommits.org/) to ensure the build numbering is generated correctly



  To test the application manually, you can use the following steps:

  1. Create new ADO work item and ensure it is synced to Asana.
  1. Rename Asana task and ensure it is reverted back to the ADO name.
  1. Rename ADO task and ensure it is synced to Asana.
  1. Remove Synced tag from item in Asana and ensure it is replaced.
  1. Delete synced tag from Asana workspace and from appdata.json file and ensure it is re-created and assigned to all synced tasks.
  1. Mark Asana task as complete and ensure it is re-opened.
  1. Mark ADO task as complete and ensure it is marked as complete in Asana.
  1. Re-open ADO task and ensure it is re-opened in Asana.





  * [azure-devops PyPi](https://pypi.org/project/azure-devops/)
  * [azure-devops GitHub](https://github.com/microsoft/azure-devops-python-api)
  * [azure-devops API reference](https://learn.microsoft.com/en-us/rest/api/azure/devops/?view=azure-devops-rest-7.1&viewFallbackFrom=azure-devops-rest-5.1)
  * [azure-devops samples](https://github.com/microsoft/azure-devops-python-samples/blob/main/src/samples/work_item_tracking.py)



  * [Asana PyPi](https://pypi.org/project/asana/)
  * [Asana GitHub](https://github.com/asana/python-asana)
  * [Asana API Reference](https://developers.asana.com/docs/rich-text)


pkgId: 5e4b4fd0bdc56489edde73daaa4e0fdaf7bf8ef0b5f1c4b8840c0f51e481a01c
name: python-ado_wrapper
arch: src
version: 1.34.0
epoch: 0
release: 1
summary: A high level wrapper around the AzureDevops API including OOP principals and state management
url: https://pypi.org/project/ado_wrapper/
rpm_license: Proprietary
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ado_wrapper-1.34.0-1.src.rpm
checksum_type: sha256
description:
  This is a Python Package which works as an interface to the Azure DevOps API

  It is essentially a wrapper for the (horrible to work with) ADO API, and supports OOP principals.

  Any resource can be fetched by calling the `<resource>.get_by_id()` function.

  It also includes a solution for managing resources created by this script, which is extremely useful for testing the creation of random resources.
  To delete all resources created by this, run the main module with the "--delete-everything" flag.

  If you're reading this readme not from the code, here's a link to the [github repo](https://github.com/UP929312/ado-wrapper)



  pylint .
  mypy . --strict
  flake8 --ignore=E501,E126,E121,W503,W504,PBP --exclude=script.py
  bandit -c pyproject.toml -r .
  ruff check
  black . --line-length 140
  python3.11 -m pytest tests/ -vvvv -s


pkgId: 2c8c9c2fda47b2797d26f33855c3a189ecfaf12961e036982a35cf5136d3b212
name: python-adofaipy
arch: src
version: 3.2.3
epoch: 0
release: 1
summary: A library that makes automating events in ADOFAI levels more convenient.
url: https://github.com/M1n3c4rt/adofaipy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adofaipy-3.2.3-1.src.rpm
checksum_type: sha256
description:
  - Minor update and bugfixes
  - Cleaned stray debug statement
  - Fixed metadata getting reset on level write
  - Fixed bugs in `popAction()` and `popDecoration()`
  - Added `padmidspins` option to `getAnglesRelative()`


pkgId: 8d436093899e6a849c74b9ec1d3b8e10fbc1921b2204fd8d2cd8a96b80386fc4
name: python-adorable
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Make Text Adorable
url: https://pypi.org/project/adorable/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adorable-0.1.5-1.src.rpm
checksum_type: sha256
description:
  ```python
  import adorable
  from adorable import color
  RED = color.from_name("red")
  print(RED.fg("Hello adorable World"))
  BLUE = color.from_hex(0x0AF)
  DARK = color.from_rgb((38, 38, 38))
  col = BLUE.on(DARK)
  adorable.printc("Hello", "World", style = col)
  ```


pkgId: ffc33e1ec06e5a77ba4b402ab4e37567c703d8c8a659a7f7b0ce77fec60fcb9c
name: python-adp-connectors
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: connection clients for storage and database
url: https://pypi.org/project/adp-connectors/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adp-connectors-0.1.1-1.src.rpm
checksum_type: sha256
description:
  The current version supports 3 kind of API connections: AWS S3, Box, PostgreSQL.
  The required secret file formats are as follows.
  - S3 Connector
    ```
    {
      "aws_access_key_id": "",
      "aws_secret_access_key": ""
    }

  - Box Connector
    ```
      {
        "boxAppSettings": {
          "clientID": "",
          "clientSecret": "",
          "appAuth": {
            "publicKeyID": "",
            "privateKey": "",
            "passphrase": ""
            }
          },
          "enterpriseID": ""
        }

  - Postgresql Connector
    ```
    {
      "host": "",
      "port": 5432,
      "database": "",
      "user": "",
      "password": ""
    }


pkgId: ab86bddca6b3d34847b65b8baf5069707aacfa9cbe3a22bd380668e5afc0f75f
name: python-adpred
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: Prediction of Transcription Activation Domains from protein sequences
url: https://github.com/FredHutch/adpred-pkg
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adpred-1.3.1-1.src.rpm
checksum_type: sha256
description:
  ![PyPI](https://img.shields.io/pypi/v/adpred)
  ![Conda](https://img.shields.io/conda/dn/Bioconda/adpred)
  [![License](http://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/nebiolabs/tasmanian/blob/master/LICENSE)
  [![Language](https://img.shields.io/badge/Made%20with-Python-1f425f.svg)](https://www.python.org)



  A tool for prediction of Transcription Activation Domains from protein sequences.

  <!--toc start-->
   * [Goals](#goals)
   * [Documentation](https://adored.readthedocs.io/en/latest/)
   * [Contributing](#contributing)
   * [Authors](#authors)
   * [Licence](#licence)
  <!--toc end -->




  The main goal is to identify regions with high AD function probability in protein sequences. Moreover, at these observed regions, a saturated mutagenesis study can reveal insights into the important residues that confer the AD function to that region.



  Contributions are welcome and encouraged.




  * [Ariel Erijman](https://github.com/aerijman)


  `ADpred` is an open source software released under the [MIT licence](#)


pkgId: 1fb88c15722c06c39deb07f6520c6946f0db3fd79445f8a01a7e832b024a95f4
name: python-adqsetup
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: A pure Python tool and library to setup ADQ for Intel NICs
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adqsetup-2.0.2-1.src.rpm
checksum_type: sha256
description:
  _SPDX-License-Identifier: BSD-3-Clause_
  _Copyright (c) 2022, Intel Corporation_

  **Dependencies:** _Python 2.7-3.10_

  **Distro Support:**
  * Redhat: _7.1-9.x_
  * Fedora: _28-35_
  * Ubuntu: _19.04-22.04_
  * Debian: _11_



  Python Package Index (pip):

      python -m pip install adqsetup

  Included with driver:

      python scripts/adqsetup/adqsetup.py install



  The basic usage is: `adqsetup [options] <command> [parameters ...]`
  Please see the output of `adqsetup help` for a complete list of
  command line options.


  - **help**: _Show help message_
  - **examples**: _Create an 'examples' subdirectory_
    The examples subdirectory - created in the current directory -
    contains a set of sample config files
  - **apply {filename}**: _Apply a config file_
    - **{filename}**: _Config file (relative or full path)_
      If empty or '-', config file is read from stdin.
  - **create { [{name}] { {key} {value} }... }...**: _Create a config from the command line_
      Each section consisting of a bracketed name and one or more {key} {value} pairs.
      - **[{name}]**: _User-defined name of section_
        Must be unique within a configuration, '[globals]' is reserved but can be used.
      - **{key}** **{value}**: _Configuration Parameter_
      One or more space-seperated key and value pairs.
      See the above Class Configuration Parameter list for possible keys and values.
  - **reset**: _Remove ADQ traffic classes and filters_
    Attempts to perform a cleanup of any ADQ-related setup.
    Note: '--priority=skbedit' option must be included to remove the egress filters.
  - **persist {filename}**: _Persist a config file across reboots_
    Creates a systemd service unit set to run once on boot after the network is running.
    One config per network interface, new configs overwrite old ones.
    - **{filename}**: _Config file (relative or full path)_
      If empty or '-', config file is read from stdin.
  - **install**: _Install the adqsetup script_
    Installs the current script at /usr/local/bin




  - **arpfilter**: (bool) _Enable selective ARP activity_
  - **bpstop**: (bool) _Channel-packet-clean-bp-stop feature_
  - **bpstop-cfg**: (bool) _Channel-packet-clean-bp-stop-cfg feature_
  - **busypoll**: (integer) _busy_poll value_
  - **busyread**: (integer) _busy_read value_
  - **cpus**: (integer list|'auto') _CPUs to use for handling 'default'
  traffic, default 'auto'_
  - **numa**: (integer|'local'|'remote'|'all') _Numa node to use for 'default'
  traffic, default 'all' (prefer local)_
  - **dev**: (string) _Network interface device to configure_
  - **optimize**: (bool) _Channel-inspect-optimize feature_
  - **priority**: ('skbedit') _Method to use for setting socket priority, default none_
  - **queues**: (integer) _Number of queues in 'default' traffic class, default 2_
  - **txring**: (integer) _Transmit ring buffer size_
  - **txadapt**: (bool) _Adaptive transmit interrupt coalescing_
  - **txusecs**: (integer) _Usecs for transmit interrupt coalescing_
  - **rxring**: (integer) _Receive ring buffer size_
  - **rxadapt**: (bool) _Adaptive receive interrupt coalescing_
  - **rxusecs**: (integer) _Usecs for receive interrupt coalescing_


  - **addrs**: (string list) _Local IP addresses of traffic_
  - **cpus**: (integer list|'auto') _CPUs to use for handling traffic,
  default 'auto'_
  - **mode**: ('exclusive'|'shared') _Mode for traffic class_
  - **numa**: (integer|'local'|'remote'|'all') _Numa node to use for traffic,
  default 'all' (prefer local)_
  - **pollers**: (integer) _Number of independent pollers, default 0_
  - **poller-timeout**: (integer) _Independent poller timeout value,
  default 10000_
  - **ports**: (integer list) _Local IP ports of traffic_
  - **protocol**: ('tcp'|'udp') _IP Protocol of traffic_
  - **queues**: (integer) _Number of queues in traffic class_
  - **remote-addrs**: (string list) _Remote IP addresses of traffic_
  - **remote-ports**: (integer list) _Remote IP ports of traffic_



      adqsetup help
      adqsetup examples

      adqsetup apply memcached.conf
      adqsetup --dev=eth4 apply nginx.conf
      adqsetup --dev=eth3 persist eth3.conf

      cat memcached.conf | adqsetup apply

      adqsetup create [myapp] queues 4 ports 11211

      adqsetup --verbose create \
        [globals] priority skbedit \
        [myapp] queues 2 ports 11211

      adqsetup --verbose create \
        [app1] mode shared queues 4 ports 6379-6382
        [app2] queues 2 ports 11211 pollers 2



      
      QUEUES=8
      
      
      for BP in {10000..50000..5000}; do
          adqsetup create [globals] busypoll $BP [nginx] queues $QUEUES ports 80
          
      done



      
      QUEUES=8
      
      
      for BP in {10000..20000..5000}; do
      adqsetup apply <<EOF
          [globals]
          dev=eth2
          busypoll=$BP
          [nginx]
          queues=$QUEUES
          ports=80
      EOF
      
      done



      python makeconf.py | adqsetup --json apply



      import json
      conf = {
          "globals": {
              "dev": "eth2",
              "busypull": 10000
          },
          "app1": {
              "queues": 4,
              "ports": "80,443"
          }
      }
      print(json.dumps(conf))



  * To load/use a different device driver while creating the setup,
  the `--driver` parameter may be used. Device driver path is the full path
  to the .ko file (ex: ice-1.9.x/src/ice.ko). Interface _must_ be set to
  come up automatically with an ip address (via NetworkManager or other).
  adqsetup will wait up to three seconds for this to occur before erroring out.
  Conversely, you can load the driver and setup the interface manually
  before running the adqsetup.

  * The independent **pollers** argument passed to adqsetup doesn’t map directly
  to the **qps_per_poller** arguments passed to the driver. adqsetup
  allows the user to specify how many pollers for a particular TC instead of
  having to specify qps_per_poller.

  * adqsetup 1.x required updated versions of the 'tc', 'ethtool', and 'devlink'
  commands to be installed on the system. With adqsetup 2.x and onward, this
  requirement has been removed.



  * If you get a `/usr/bin/env: ‘python’: No such file or directory` error
  when you run the script, please install Python. If you have already installed
  Python, then try `whereis python` and you should see a message like:
  `python: /usr/bin/python2.7 /usr/bin/python3.6 /usr/bin/python3.6m /usr/bin/python3.9`
  on the first line of the output. Either run the version you wish to use
  manually: `python3.6 adqsetup.py help`, or create a 'python' symbolic
  link on the path: `ln -s /usr/bin/python3.6 /usr/local/bin/python`

  * Many advanced features, such as **pollers** and the per-tc flow director may
  not be supported by older versions of the driver or kernel. adqsetup
  will attempt to use an equivalent fallback feature, and if none are available
  a descriptive error will be provided. Please refer to the ADQ Config Guide for
  more information.



  Please run the malfunctioning config with the command line `--debug` option,
  which should include a short stack trace at the end of the output. Send the
  configuration file (if used), full commmand line, and program output to your
  Intel support contact.



  adqsetup accepts configurations in the JSON format from either a file or stdin
  with the `--json` option. Parameters are the same as listed above, using the
  following basic structure:

      {
          "globals": {
              "dev": "eth4",
              "priority": "skbedit"
          },
          "app1": {
              "queues": 2,
              "ports": 11211
          },
          "app2": {
              "queues": 4,
              "mode": "shared",
              "ports": "6379-6382"
          }
      }

url:
  https://www.intel.com/content/www/us/en/architecture-and-technology/ethernet/adq-resource-center.html


pkgId: c1dc955db60e4773deca7b22c521c7f3f88ba630be92226f0dd687f56d57eb3c
name: python-adr-viewer
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: A visualisation tool for Architecture Decision Records
url: https://github.com/mrwilson/adr-viewer
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adr-viewer-1.4.0-1.src.rpm
checksum_type: sha256
description:
  [![Latest Version](https://img.shields.io/pypi/v/adr-viewer)](https://pypi.org/project/adr-viewer/)

  Show off your Architecture Decision Records with an easy-to-navigate web page, either as a local web-server or generated static content.
  Include diagrams in [Mermaid](https://mermaid.js.org) format using code blocks/fences, e.g. [test ADR 5](test/adr/0005-has-mermaid.md).



  <img src="https://github.com/mrwilson/adr-viewer/raw/master/images/example.png" height="500px"/>

  * Example above using Nat Pryce's [adr-tools](https://github.com/npryce/adr-tools) project
  * This project exposes its own Architecture Decision Records [here](https://mrwilson.github.io/adr-viewer/index.html)





  ```bash
  $ pip install adr-viewer
  ```



  ```bash
  $ brew install adr-viewer
  ```

  See also the [`adr-viewer` formula page](https://formulae.brew.sh/formula/adr-viewer).



  adr-viewer requires Python 3.7 or higher (with Pip)

  ```bash
  $ git clone https://github.com/mrwilson/adr-viewer
  $ pip install -r requirements.txt
  $ python setup.py install
  ```



  ```bash
  Usage: adr-viewer [OPTIONS]

  Options:
    --adr-path TEXT  Directory containing ADR files.  [default: doc/adr/]
    --output TEXT    File to write output to.  [default: index.html]
    --title TEXT     The project title   [default: the basename of the current directory]
    --serve          Serve content at http://localhost:8000/
    --port INT       Custom server port [default: 8000]
    --help           Show this message and exit.
  ```

  The default for `--adr-path` is `doc/adr/` because this is the default path generated by `adr-tools`.



  <img src="https://github.com/mrwilson/adr-viewer/raw/master/images/record_types.png"/>


pkgId: be497fef0bbe00caed0bbac1e0238d9f2c3ac43efbf7f254a4fe2fcf3611a367
name: python-adr_writer
arch: src
version: 1.1.3
epoch: 0
release: 1
url: https://gitlab.com/fer1035_python/modules/pypi-adr_writer
rpm_license: GPL-2.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adr_writer-1.1.3-1.src.rpm
checksum_type: sha256
summary:
  Create Architecture Decision Records by answering questions to ensure consistency in formatting and thought processes.


pkgId: 3d150634f953ee1dea7c8a11f88d4d4911717695167d39301a7401032fea9e1f
name: python-adrenaline
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Keep your OS from sleeping (supports Windows and macOS)
url: https://github.com/ntamas/adrenaline
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adrenaline-3.0.0-1.src.rpm
checksum_type: sha256
description:
  Simple Python module to prevent your computer from going to sleep. Supports
  Windows and macOS at the moment; Linux support is coming soon (hopefully).


pkgId: 4fef7d3bfd77a496afab303b3bc88427f907e597245d899228fe73f2eda7bf27
name: python-adrf
arch: src
version: 0.1.8
epoch: 0
release: 1
summary: Async support for Django REST framework
url: https://github.com/em1208/adrf
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adrf-0.1.8-1.src.rpm
checksum_type: sha256
description:
  **Async support for Django REST framework**



  * Python 3.8+
  * Django 4.1+

  We **highly recommend** and only officially support the latest patch release of
  each Python and Django series.



  Install using `pip`...

      pip install adrf

  Add `'adrf'` to your `INSTALLED_APPS` setting.
  ```python
  INSTALLED_APPS = [
      ...
      'adrf',
  ]
  ```





  When using Django 4.1 and above, this package allows you to work with async class and function based views.

  For class based views, all handler methods must be async, otherwise Django will raise an exception. For function based views, the function itself must be async.

  For example:

  ```python
  from adrf.views import APIView

  class AsyncAuthentication(BaseAuthentication):
      async def authenticate(self, request) -> tuple[User, None]:
          return user, None

  class AsyncPermission:
      async def has_permission(self, request, view) -> bool:
          if random.random() < 0.7:
              return False

          return True

      async def has_object_permission(self, request, view, obj):
          if obj.user == request.user or request.user.is_superuser:
              return True

          return False

  class AsyncThrottle(BaseThrottle):
      async def allow_request(self, request, view) -> bool:
          if random.random() < 0.7:
              return False

          return True

      def wait(self):
          return 3

  class AsyncView(APIView):
      authentication_classes = [AsyncAuthentication]
      permission_classes = [AsyncPermission]
      throttle_classes = [AsyncThrottle]

      async def get(self, request):
          return Response({"message": "This is an async class based view."})

  from adrf.decorators import api_view

  @api_view(['GET'])
  async def async_view(request):
      return Response({"message": "This is an async function based view."})
  ```


  For viewsets, all handler methods must be async too.

  views.py
  ```python
  from django.contrib.auth import get_user_model
  from rest_framework.response import Response

  from adrf.viewsets import ViewSet


  User = get_user_model()


  class AsyncViewSet(ViewSet):

      async def list(self, request):
          return Response(
              {"message": "This is the async `list` method of the viewset."}
          )

      async def retrieve(self, request, pk):
          user = await User.objects.filter(pk=pk).afirst()
          return Response({"user_pk": user and user.pk})

  ```

  urls.py
  ```python
  from django.urls import path, include
  from rest_framework import routers

  from . import views

  router = routers.DefaultRouter()
  router.register(r"async_viewset", views.AsyncViewSet, basename="async")

  urlpatterns = [
      path("", include(router.urls)),
  ]

  ```



  serializers.py

  ```python
  from adrf.serializers import Serializer
  from rest_framework import serializers

  class AsyncSerializer(Serializer):
      username = serializers.CharField()
      password = serializers.CharField()
      age = serializers.IntegerField()
  ```

  views.py

  ```python
  from .serializers import AsyncSerializer
  from adrf.views import APIView

  class AsyncView(APIView):
      async def get(self, request):
          data = {
              "username": "test",
              "password": "test",
              "age": 10,
          }
          serializer = AsyncSerializer(data=data)
          serializer.is_valid()
          return await serializer.adata
  ```



  models.py

  ```python
  from django.db import models

  class Order(models.Model):
      name = models.TextField()
  ```

  serializers.py

  ```python
  from adrf.serializers import ModelSerializer
  from .models import Order

  class OrderSerializer(ModelSerializer):
      class Meta:
          model = Order
          fields = ('name', )
  ```

  views.py

  ```python
  from adrf.generics import ListCreateAPIView
  from .models import Order
  from .serializers import OrderSerializer

  class ListCreateOrderView(ListCreateAPIView):
      queryset = Order.objects.all()
      serializer_class = OrderSerializer
  ```


pkgId: c295f1acd800b00ccd695d3ff8233db5e58f7f36c473a9fdf6b1b017c21b42f3
name: python-ads
arch: src
version: 0.12.6
epoch: 0
release: 1
summary: A Python module for NASA's ADS that doesn't suck.
url: http://www.github.com/andycasey/ads/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ads-0.12.6-1.src.rpm
checksum_type: sha256
description:
  If you're in astro research, then you pretty much *need* NASA's ADS. It's tried, true, and people go crazy on the rare occasions when it goes down.

  * Docs: https://ads.readthedocs.io/
  * Repo: https://github.com/andycasey/ads
  * PyPI: https://pypi.python.org/pypi/ads

  [![Build Status](https://travis-ci.org/andycasey/ads.svg?branch=master)](https://travis-ci.org/andycasey/ads)
  [![Coverage Status](https://coveralls.io/repos/github/andycasey/ads/badge.svg?branch=master)](https://coveralls.io/github/andycasey/ads?branch=master)



  ```python
  import ads
  ads.config.token = 'secret token'

  papers = ads.SearchQuery(q="supernova", sort="citation_count")
  for paper in papers:
      print(paper.title[0])
  ```

  You can expect to see some titles like this:
  ```
  Maps of Dust Infrared Emission for Use in Estimation of Reddening and Cosmic Microwave Background Radiation Foregrounds
  Measurements of Omega and Lambda from 42 High-Redshift Supernovae
  Observational Evidence from Supernovae for an Accelerating Universe and a Cosmological Constant
  First-Year Wilkinson Microwave Anisotropy Probe (WMAP) Observations: Determination of Cosmological Parameters
  Abundances of the elements: Meteoritic and solar
  ```



  ```bash
  cd /path/to/ads
  pip install -e . "ads[tests]"
  python -m unittest discover
  ```


pkgId: ac7cade40e73987cf62e78d8c6e5345007e5128c563a996826fc19f6f459f617
name: python-ads1015
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Python library for the ADS1015 and ADS1115 4-channel ADC
description:
  * Enhancement: Repackage to pyproject.toml/hatchling
  * Isort and black code formatting

url: https://www.pimoroni.com
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ads1015-1.0.0-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2018 Pimoroni Ltd.  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: 057afa34d141491cc422fa6fc78044e8de15da402a333bf926d058e4e01db3d2
name: python-ads4gpts-langchain
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Ads for AI applications. Enabling the Freemium model for the AI era.
url: https://www.ads4gpts.com/
rpm_license: GNU AGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ads4gpts-langchain-0.1.0-1.src.rpm
checksum_type: sha256
description:
  - [Introduction](#introduction)
  - [Features](#features)
  - [Installation](#installation)
  - [Usage](#usage)
    - [Prerequisites](#prerequisites)
    - [Environment Variables](#environment-variables)
    - [Initialization](#initialization)
    - [Examples](#examples)
  - [API Reference](#api-reference)
    - [Ads4GPTsTool](#ads4gptstool)
    - [Ads4GPTsToolkit](#ads4gptstoolkit)
    - [get_ads4gpts_agent Function](#get_ads4gpts_agent-function)
  - [Contributing](#contributing)
  - [License](#license)


pkgId: cf746649ac95213db70a5dfd5bce51e58788e6840d334bd188c6779d47b1e06e
name: python-adsGenericFunctions
arch: src
version: 0.2.53
epoch: 0
release: 1
summary: Generic functions
url: https://pypi.org/project/adsGenericFunctions/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adsGenericFunctions-0.2.53-1.src.rpm
checksum_type: sha256
description:
  The purpose of this Python package is to group together all the generic functions used in Onyx development.






  This class is used to communicate with a postgres database. Initialising the class starts the connection, so it needs the database name, user, password, port and host. It also sets the default read buffer to 1000.



  This method just closes the connection to the database.



  This method belongs to the PostgresInput class. It reads the parameter query and yield the results in batches of size `batch_size`.



  This method belong to the PostgresInput class. It executes the parameter query, this query can be an insert, an update or a delete operation. We can add parameters to the execution by the parameter `params` set to None by default.



  This function sends an email to the `destinataire` from `from_email` with the subject `subject` and a message `msg`. It also needs the api key `sgApiClient`.
  It returns the send response.


pkgId: 4b27a55417da940a91fef79440db4bd6f7f68a51fa9c21f23de3cec8992ce9c6
name: python-adsb-tools
arch: src
version: 0.1.55
epoch: 0
release: 1
summary: ADS-B tools for reading Dump1090 messages
url: https://github.com/herereadthis/adsb_tools
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adsb-tools-0.1.55-1.src.rpm
checksum_type: sha256
description:
  Scripts and stuff to help you parse through data from [Dump1090] messages.

  Dump1090 is a Mode S decoder specifically designed for RTLSDR devices. It is a simple ADS-B (Automatic Dependent
  Surveillance - Broadcast) receiver, decoder and web-server. It requires a RTLSDR USB-stick and Osmocom's librtlsdr.
  FlightAware maintains the [current version of Dump1090](https://github.com/flightaware/dump1090).




  ```python
  from adsb_tools.aircraft import Aircraft
  """
  You must provide the base url for your ADS-B feeder,
  E.g., localhost:8080 or 192.x.x.x:8080
  Optional: provide base_latitude and base_longitude, which can be the
  coordinates of your receiver. By providing base coordinates, each aircraft
  message will be augmented with additional info, including distance from base
  coordinates, and direction. Nearest aircraft will be identified, and additional
  external info will be retrieved, e.g. registration, image
  """
  aircraft = Aircraft(base_adsb_url, base_latitude, base_longitude)

  nearest_aircraft = aircraft.nearest_aircraft
  ```


  This class has methods to augment and provide additional information about aircrafts based on ADS-B messages. The class takes in ADS-B messages from Dump1090 aircraft JSON and a base station's coordinates (latitude and longitude) as input. The class then calculates the distance and direction of each aircraft from the base station and adds this information to the ADS-B messages.

  The class has the following methods:

  * `__init__(self, base_adsb_url, base_latitude=None, base_longitude=None)`: The class constructor. It initializes the base_adsb_url, earth_radius_km, aircraft_list, and nearest_aircraft properties. If the base_latitude and base_longitude arguments are provided, the augment_aircraft_list() and set_nearest_aircraft() methods are called.
  * `augment_aircraft_list(self)`: This method adds additional options to the aircraft list based on aircraft properties. The new options include the aircraft's distance from the base station, the direction of the aircraft from the base station, and the aircraft's ICAO 24-bit address.
  * `set_nearest_aircraft(self)`: This method finds the nearest aircraft to the base station and adds links to various databases, such as the HEXDB and ADSB databases.
  * `retrieve_external_aircraft_options(self)`: This method retrieves external flight information and aircraft images for the nearest aircraft. It updates the nearest_aircraft dictionary with the aircraft image URL and the merged flight information.
  * `map_static_aircraft_options(self, stored_aircraft)`: This method maps static aircraft information from a stored aircraft dictionary to the nearest aircraft dictionary.
  * `get_aircraft_list(self)`: This method retrieves the aircraft messages and returns them as a list.
  * `add_aircraft_options(self)`: This method adds additional data to aircraft based on aircraft properties. It calculates the distance and direction of each aircraft from the base station and adds this information to the aircraft message. It also adds the aircraft's ICAO 24-bit address to the message.


pkgId: 0b12995ab254d508e7e319a0ae2d678691f4d80acabdf6c1a6c5786d2117c2a0
name: python-adsbcot
arch: src
version: 8.0.2
epoch: 0
release: 1
summary: Monitor and analyze aviation surveillance data with TAK.
url: https://github.com/snstac/adsbcot
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adsbcot-8.0.2-1.src.rpm
checksum_type: sha256
description:
  ![ATAK screenshot with PyTAK logo.](https://adsbcot.readthedocs.io/en/latest/media/atak_screenshot_with_pytak_logo-x25.png)



  ADSBCOT is software for monitoring and analyzing aviation surveillance data via the Team Awareness Kit (TAK) ecosystem of products.

  ADSBCOT captures & reports real-time ADS-B data received from aircraft (or other airbrone vehicles and drones) into TAK products using native TAK protocols, including Cursor on Target (CoT).

  ADSBCOT has been evaluated with WinTAK, iTAK, ATAK & TAK Server.

  ADSBCOT is in active use today in a variety of missions.

  [Documentation is available here.](https://adsbcot.rtfd.io)


     Use ADS-B Aggregators? Check out my sister software [ADSBXCOT](https://adsbxcot.rtfd.io).

     Want a turn-key ADS-B to TAK Gateway? Check out [AirTAK](https://www.snstac.com/store/p/airtak-v1).




  Copyright Sensors & Signals LLC https://www.snstac.com

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0

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


pkgId: d61e7e47dc9d4be0042a51d12f064e08f12a90608dd16eb87dbd7bd02bfba79a
name: python-adsg-core
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: Design Space Graph (ADSG Core)
url: https://pypi.org/project/adsg-core/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adsg-core-1.1.2-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/jbussemaker/adsg-core/workflows/Tests/badge.svg)](https://github.com/jbussemaker/adsg-core/actions/workflows/tests.yml?query=workflow%3ATests)
  [![PyPI](https://img.shields.io/pypi/v/adsg-core.svg)](https://pypi.org/project/adsg-core)
  [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
  [![Documentation Status](https://readthedocs.org/projects/adsg-core/badge/?version=latest)](https://adsg-core.readthedocs.io/en/latest/?badge=latest)

  [GitHub Repository](https://github.com/jbussemaker/adsg-core) |
  [Documentation](https://adsg-core.readthedocs.io/)

  The Design Space Graph (DSG) allows you to model design spaces using a directed graph that contains three
  types of architectural choices:

  - Selection choices (see example below): selecting among mutually-exclusive options, used for *selecting* which nodes
    are part of an architecture instance
  - Connection choices: connecting one or more source nodes to one or more target nodes, subject to connection constraints
    and optional node existence (due to selection choices)
  - Additional design variables: continuous or discrete, subject to optional existence (due to selection choices)

  ![DSG with selection](https://raw.githubusercontent.com/jbussemaker/adsg-core/main/docs/figures/adsg_ex_sel.svg)

  Modeling a design space like this allows you to:

  - Model hierarchical relationships between choices, for example only activating a choice when another choice has some
    option selected, or restricting the available options for choices based on higher-up choices
  - Formulate the design space as an optimization problem that can be solved using numerical optimization algorithms
  - Generate architecture instances for a given design vector, automatically correct incorrect design variables, and get
    information about which design variables were active
  - Implement an evaluation function (architecture instance --> metrics) and run the optimization problem

  *Note: due to historical reasons the package and code refer to the ADSG (Architecture DSG), because originally it had
  been developed to model system architecture design spaces. In the context of this library, the ADSG and DSG can be
  considered to be equivalent.*



  First, create a conda environment (skip if you already have one):
  ```
  conda create --name dsg python=3.10
  conda activate dsg
  ```

  Then install the package:
  ```
  conda install numpy scipy~=1.9
  pip install adsg-core
  ```

  Optionally also install optimization algorithms ([SBArchOpt](sbarchopt.readthedocs.io/)):
  ```
  pip install adsg-core[opt]
  ```

  If you want to interact with the DSG from a [Jupyter notebook](https://jupyter.org/):
  ```
  pip install adsg-core[nb]
  jupyter notebook
  ```



  Refer to the [documentation](https://adsg-core.readthedocs.io/) for more background on the DSG
  and how to implement architecture optimization problems.



  An example DSG with two selection choices:

  ![DSG with selection](https://raw.githubusercontent.com/jbussemaker/adsg-core/main/docs/figures/adsg_ex_sel.svg)

  An example DSG with a connection choice:

  ![DSG with connection](https://raw.githubusercontent.com/jbussemaker/adsg-core/main/docs/figures/adsg_ex_conn.svg)

  The DSG of the [Apollo problem](https://adsg-core.readthedocs.io/en/latest/example_apollo/):

  ![GNC DSG](https://raw.githubusercontent.com/jbussemaker/adsg-core/main/docs/figures/adsg_ex_apollo.svg)

  The DSG of the [GNC problem](https://adsg-core.readthedocs.io/en/latest/example_gnc/):

  ![GNC DSG](https://raw.githubusercontent.com/jbussemaker/adsg-core/main/docs/figures/adsg_ex_gnc.svg)



  If you use the DSG in your work, please cite it:

  J.H. Bussemaker, L. Boggero, and B. Nagel. "System Architecture Design Space Exploration: Integration with Computational
  Environments and Efficient Optimization". In: AIAA AVIATION 2024 FORUM. Las Vegas, NV, USA, July 2024.
  DOI: [10.2514/6.2024-4647](https://doi.org/10.2514/6.2024-4647)



  The project is coordinated by: Jasper Bussemaker (*jasper.bussemaker at dlr.de*)

  If you find a bug or have a feature request, please file an issue using the Github issue tracker.
  If you require support for using the DSG or want to collaborate, feel free to contact me.

  Contributions are appreciated too:
  - Fork the repository
  - Add your contributions to the fork
    - Update/add documentation
    - Add tests and make sure they pass (tests are run using `pytest`)
  - Read and sign the [Contributor License Agreement (CLA)](https://github.com/jbussemaker/adsg-core/blob/main/ADSG%20Core%20DLR%20Individual%20Contributor%20License%20Agreement.docx)
    , and send it to the project coordinator
  - Issue a pull request into the `dev` branch

  **NOTE:** Do *NOT* directly contribute to the `adsg_core.optimization.assign_enc` and `.sel_choice_enc` modules!
  Their development happens in separate repositories:
  - [AssignmentEncoding](https://github.com/jbussemaker/AssignmentEncoding)
  - [SelectionChoiceEncoding](https://github.com/jbussemaker/SelectionChoiceEncoding)

  Use `update_enc_repos.py` to update the code in this repository.



  ```
  pip install -r requirements-docs.txt
  mkdocs serve
  ```

  Refer to [mkdocs](https://www.mkdocs.org/) and [mkdocstrings](https://mkdocstrings.github.io/) documentation
  for more information.


pkgId: 2cfd12eac7df4495cc7d536f23196398ffae873f7f91969e0b6e8e2e26deb5c0
name: python-adspower
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: The package for interacting with API of anti-detect browser AdsPower.
url: https://github.com/CrocoFactory/adspower
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adspower-2.1.0-1.src.rpm
checksum_type: sha256
description:
  <a href="https://www.adspower.com"><h1 align="center"><img src="https://raw.githubusercontent.com/CrocoFactory/adspower/main/branding/adspower/banner.png" width="300" style="border-radius:7px;"></h1><br></a>

  [![Python versions](https://img.shields.io/pypi/pyversions/adspower?color=%231D4DFF)](https://pypi.org/project/adspower/)
  [![PyPi Version](https://img.shields.io/pypi/v/adspower?color=%231D4DFF)](https://pypi.org/project/adspower/)


  The package for interacting with API of anti-detect browser [AdsPower](https://www.adspower.com).

  - **[Overview](#quick-start)**
  - **[Installing](#installing-adspower)**
  - **[Bug reports](https://github.com/CrocoFactory/adspower/issues)**

  The project is made by the **[Croco Factory](https://github.com/CrocoFactory)** team

  adspower's source code is made available under the [MIT License](LICENSE)


  - Synchronous and asynchronous interaction with the local API
  - Interaction with the most popular libraries for browser automation in Python: Selenium and Playwright


  1. During using the package, AdsPower must be opened.
  2. The local API is available only in paid AdsPower subscriptions
  3. AdsPower has frequency control for all APIs, max. access frequency: 1 request/second




  *Example of interacting with synchronous API.*

  ```python
  from adspower.sync_api import Group, ProfileAPI
  group = Group.create(name='my_group', remark='The best group ever')

  profile_api = ProfileAPI.create(group=group)
  print(f'Profile {profile_api.name} was created in group {group.name}')
  ```

  **Use `ProfileAPI` only when** you don't need `Selenium` and `Playwright` interactions.

  Library provides ways to interact the most popular libraries for browser automation in Python: `Selenium` and `Playwright`.
  To get a browser, you can use `with` statement:

  - *Selenium*

  ```python
  from adspower.sync_api.selenium import Profile, Group
  my_group = Group.query(name='my_group')[0]
  profile = Profile.create(group=my_group, name='my_profile')

  with profile as browser:
     browser.get('https://github.com/blnkoff/adspower')
  ```

  - *Playwright*

  ```python
  from adspower.async_api.playwright import Profile, Group

  async def main() -> None:
      my_group = (await Group.query(name='my_group'))[0]
      profile = await Profile.create(group=my_group, name='my_profile')

      async with profile as browser:
         page = browser.pages[0]
         await page.goto('https://github.com/blnkoff/adspower')
  ```

  Both versions support sync and async API.

  Or manually call `get_browser` if you need specify part of behaviour.
  ```python
  from adspower.sync_api.selenium import Profile, Group

  my_group = Group.query(name='my_group')[0]
  profile = Profile.create(group=my_group, name='my_profile')
  browser = profile.get_browser(ip_tab=False, headless=True, disable_password_filling=True)
  browser.get('https://github.com/blnkoff/adspower')
  profile.quit()
  ```

  Notice that you must not call quitting methods of `Playwright` library or `Selenium` after `profile.quit()`, since
  it calls these methods automatically. An attempt to do so will lead to the error.

  *Example of setting proxy and fingerprint*

  ```python
  from adspower.sync_api.playwright import Profile, Group
  from adspower import ProxyConfig, FingerprintConfig

  proxy = ProxyConfig(
      soft='other',
      type='http',
      host='xx.xx.x.xx',
      port=1000,
      user='username',
      password='password'
  )

  fingerprint = FingerprintConfig(
      ua='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.6261.112 Safari/537.36'
  )

  group = Group.query(name='my_group')[0]
  profile = Profile.create(group=group, proxy_config=proxy, name='my_profile', fingerprint_config=fingerprint)
  ```

  There are extension categories, implemented as `Category` class. At the moment, it can`t be created, but can be retrieved.
  You can manually create extension category and used it for profile creation using API.

  *Example of querying category*

  ```python
  from adspower.sync_api.playwright import Profile, Category, Group

  category = Category.query(name='my_category')[0]
  group = Group.query(name='my_group')[0]

  profile = Profile.create(group=group, category=category)
  ```

  You can create anonymous profile that is deleted after last statement in context manager.

  *Example of anonymous profile*
  ```python
  from adspower.async_api.playwright import Profile, Group

  async def main() -> None:
      my_group = (await Group.query(name='my_group'))[0]
      profile = await Profile.anonymous(group=my_group)

      async with profile as browser:
          page = browser.pages[0]
          await page.goto('https://www.google.com')
  ```

  Each API entity, such as Profile, Group and Category, pretty formatted, can be compared and converted to dict

  *Example 1*

  ```python
  from adspower.sync_api.playwright import Category

  category = Category.query(name='my_category')[0]
  print(category)
  ```

  ```markdown
  Category(id=10515; name=my_category)
  ```

  *Example 2*

  ```python
  from adspower.sync_api.playwright import Profile, Group

  group = Group.query(name='my_group')[0]
  profile_created = Profile.create(group=group)

  profile_queried = Profile.query(id_=profile_created.id)
  print(profile_queried == profile_created)
  ```

  ```python
  True
  ```

  *Example 3*
  ```python
  from adspower.sync_api.playwright import Category

  category = Category.query(name='my_category')[0]
  print(category.to_dict())
  ```

  ```json
  {
      "id": 10515,
      "name": "my_category",
      "remark": "category remark"
  }
  ```


  To install the package from PyPi you can use that:

  ```sh
  pip install adspower
  ```

  You will probably want to use the pacakge with `Selenium` or `Playwright`. You can install it as extra-package:

  ```sh
  pip install adspower[playwright]
  ```

  ```sh
  pip install adspower[selenium]
  ```


pkgId: 2f64b0321542c77f6a3d71dd1db6548c2b37bcccc3f6e64b4c669bacaa5834c1
name: python-adsquery
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Query the ADS using python
url: https://github.com/cphyc/adsquery
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adsquery-0.1.1-1.src.rpm
checksum_type: sha256
description:
  This tool let you query the ADS using a simple CLI.


  You'll need an API key from NASA ADS labs. Sign up for the newest version of ADS search at https://ui.adsabs.harvard.edu, visit account settings and generate a new API token. The official documentation is available at https://github.com/adsabs/adsabs-dev-api.

  You can then install the tool through pip:
  ```
  $ pip install adsquery
  ```

  After that, you should be able to use it under the name `adsquery`:
  ```
  $ adsquery --help
  $ adsquery query --help
  ```


  To make a query to the ADS, try:
  ```
  $ adsquery query [my-query]
  ```
  The query can either be an ADS compatible query or a bashist one. For example:
  ```
  $ adsquery query --first-author Einstein 1915
  $ adsquery query ^Einstein 1915
  ```
  will result in the same results (papers by Einstein in 1915).



  Imagine we're looking at the original 1915 Einstein's paper that's explaining for the first time the advance of the perihelion of Mercury. Here's an example of how to use adsquery
  ```
  $ adsquery query --first-author Einstein --year 1915
  [0]: 1915, Annalen der Physik — Einstein, A., Antwort auf eine Abhandlung M. v. Laues Ein Satz der Wahrscheinlichkeitsrechnung und seine Anwendung auf die Strahlungstheorie
  [1]: 1915, Sitzungsberichte der Königlich Preußischen Akademie der Wissenschaften (Berlin — Einstein, Albert, Die Feldgleichungen der Gravitation
  [2]: 1915, Naturwissenschaften — Einstein, A., Experimenteller Nachweis der Ampèreschen Molekularströme
  [3]: 1915, Sitzungsber. preuss.Akad. Wiss — Einstein, A., Erklarung der Perihelionbewegung der Merkur aus der allgemeinen Relativitatstheorie
  [4]: 1915, Sitzungsberichte der Königlich Preußischen Akademie der Wissenschaften (Berlin — Einstein, Albert, Erklärung der Perihelbewegung des Merkur aus der allgemeinen Relativitätstheorie
  [5]: 1915, Sitzungsberichte der Königlich Preußischen Akademie der Wissenschaften (Berlin — Einstein, Albert, Zur allgemeinen Relativitätstheorie
  [6]: 1915, Koninklijke Nederlandse Akademie van Wetenschappen Proceedings Series B Physical Sciences — Einstein, A., de Haas, W. J., Experimental proof of the existence of Ampère's molecular currents
  [7]: 1915, Sitzungsberichte der Königlich Preußischen Akademie der Wissenschaften (Berlin — Einstein, Albert, Zur allgemeinen Relativitätstheorie (Nachtrag)
  [8]: 1915, Deutsche Physikalische Gesellschaft — Einstein, Albert, de Haas, Wander Johannes, Notiz zu unserer Arbeit "Experimenteller Nachweis der Ampèreschen Molekularströme"
  [9]: 1915, Deutsche Physikalische Gesellschaft — Einstein, Albert, Berichtigung zu meiner gemeinsam mit Herrn J. W. de Haas veröffentlichten Arbeit "Experimenteller Nachweis der Ampèreschen Molekularströme"
  ```
  Here we see we got a few papers from the period, let's keep only the ones matching the work `Merkur` (Mercury in German)
  ```
  Comma separated articles to download [e.g. 1-3, 4], [m] for more [q] to quit or add more parameters to request [e.g. year:2016]: Merkur
  [0]: 1915, Sitzungsberichte der Königlich Preußischen Akademie der Wissenschaften (Berlin — Einstein, Albert, Erklärung der Perihelbewegung des Merkur aus der allgemeinen Relativitätstheorie


  Comma separated articles to download [e.g. 1-3, 4], [m] for more [q] to quit or add more parameters to request [e.g. year:2016]: 0
  Download [d], bibtex[b], quit[q]? d
  ```
  The file is now located at `~/ADS/1915SPAW.......831E_Einstein.pdf`. If you wanted the bibtex entry, you should replace the last `d` by `b`.


  - [x] query the ADS
  - [x] interactively prompt the user
    - [x] show bibtex reference
    - [x] download pdf file


  Feel free to fill in an issue if you have any problem or suggestion


  Special thanks to andycasey for providing https://github.com/andycasey/ads and the ADS!


pkgId: 696e9bd0a0359555f878cfdb8709621e7fc82e4b21d5842b6e05d780db798bf0
name: python-adstex
arch: src
version: 0.5.3
epoch: 0
release: 1
url: https://github.com/yymao/adstex
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adstex-0.5.3-1.src.rpm
checksum_type: sha256
summary:
  Find all citation keys in your LaTeX documents and search NASA ADS to generate corresponding bibtex entries.


pkgId: e7229f3849b62eaaf8483e7f4dd5331d1a829059ed79d67a7a7c478dbf30b327
name: python-adstoolbox
arch: src
version: 1.0.13
epoch: 0
release: 1
summary: Generic functions
url: https://pypi.org/project/adstoolbox/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adstoolbox-1.0.13-1.src.rpm
checksum_type: sha256
description:
  `adsToolBox` est une librairie Python conçue pour regrouper toutes les fonctions génériques qui peuvent être utilisées au
  cours des développements liés à **Onyx**. Elle fournit un ensemble d'outils robustes pour :

  - **Gérer des connexions** à des bases de données PostgreSQL et SQL Server.
  - **Créer et gérer des pipelines** de données entre bases, ou encore de tableau vers base.
  - **Chronométrer les échanges de données** pour le suivi des performances.
  - **Journaliser les évènements** en console, en fichier et en base de données.
  - **Gérer l'environnement** via des fichiers `.env`.



  Vous pouvez installer la librairie directement depuis PyPI en utilisant `pip` :
  ```bash
  pip install adsToolBox
  ```



  Des exemple d'utilisation sont disponibles sur ce repo github : [Démo](https://github.com/AlchimieDataSolutions/DemoPy).



  Pour en savoir plus sur ce que fait chaque fonctionnalité du projet, voici le repo du projet
  [adsToolBox](https://github.com/AlchimieDataSolutions/adsGenericFunctions).


pkgId: 2204e37ded2e787a706309a0d654af2eb3742da85a70938279508a04dc5b9922
name: python-adtk
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: A package for unsupervised time series anomaly detection
url: https://github.com/arundo/adtk
rpm_license: Mozilla Public License 2.0 (MPL 2.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adtk-0.6.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/arundo/adtk.svg?branch=master)](https://travis-ci.com/arundo/adtk)
  [![Documentation Status](https://readthedocs.org/projects/adtk/badge/?version=stable)](https://adtk.readthedocs.io/en/stable)
  [![Coverage Status](https://coveralls.io/repos/github/arundo/adtk/badge.svg?branch=master&service=github)](https://coveralls.io/github/arundo/adtk?branch=master)
  [![PyPI](https://img.shields.io/pypi/v/adtk)](https://pypi.org/project/adtk/)
  [![Downloads](https://pepy.tech/badge/adtk)](https://pepy.tech/project/adtk)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/arundo/adtk/master?filepath=docs%2Fnotebooks%2Fdemo.ipynb)

  Anomaly Detection Toolkit (ADTK) is a Python package for unsupervised /
  rule-based time series anomaly detection.

  As the nature of anomaly varies over different cases, a model may not work
  universally for all anomaly detection problems. Choosing and combining
  detection algorithms (detectors), feature engineering methods (transformers),
  and ensemble methods (aggregators) properly is the key to build an effective
  anomaly detection model.

  This package offers a set of common detectors, transformers and aggregators
  with unified APIs, as well as pipe classes that connect them together into
  models. It also provides some functions to process and visualize time series
  and anomaly events.

  See https://adtk.readthedocs.io for complete documentation.



  Prerequisites: Python 3.5 or later.

  It is recommended to install the most recent **stable** release of ADTK from PyPI.

  ```shell
  pip install adtk
  ```

  Alternatively, you could install from source code. This will give you the **latest**, but unstable, version of ADTK.

  ```shell
  git clone https://github.com/arundo/adtk.git
  cd adtk/
  git checkout develop
  pip install ./
  ```



  Please see [Quick Start](https://adtk.readthedocs.io/en/stable/quickstart.html) for a simple example.

  For more detailed examples of each module of ADTK, please refer to
  [Examples](https://adtk.readthedocs.io/en/stable/examples.html)
  section in the documentation or [an interactive demo notebook](https://mybinder.org/v2/gh/arundo/adtk/master?filepath=docs%2Fnotebooks%2Fdemo.ipynb).



  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 unit tests as appropriate.

  Please see [Contributing](https://adtk.readthedocs.io/en/stable/developer.html) for more details.




  ADTK is licensed under the Mozilla Public License 2.0 (MPL 2.0). See the
  [LICENSE](LICENSE) file for details.


pkgId: e947708ce0a977f84ecf1685adcdddc127cc4a7b0bfd9d5c2d942e9a311dae10
name: python-adtl
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Another data transformation language
url: https://pypi.org/project/adtl/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adtl-0.6.1-1.src.rpm
checksum_type: sha256
description:
  [![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)

  [![tests](https://github.com/globaldothealth/adtl/actions/workflows/tests.yml/badge.svg)](https://github.com/globaldothealth/adtl/actions/workflows/tests.yml)
  [![codecov](https://codecov.io/gh/globaldothealth/adtl/branch/main/graph/badge.svg?token=QTD7HRR3TO)](https://codecov.io/gh/globaldothealth/adtl)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)


  adtl is a data transformation language (DTL) used by some applications in
  [Global.health](https://global.health), notably for the ISARIC clinical data pipeline at
  [globaldothealth/isaric](https://github.com/globaldothealth/isaric) and the InsightBoard
  project dashboard at [globaldothealth/InsightBoard](https://github.com/globaldothealth/InsightBoard)

  Documentation: [ReadTheDocs](https://adtl.readthedocs.io/en/latest/index.html)



  You can install this package using either [`pipx`](https://pypa.github.io/pipx/)
  or `pip`. Installing via `pipx` offers advantages if you want to just use the
  `adtl` tool standalone from the command line, as it isolates the Python
  package dependencies in a virtual environment. On the other hand, `pip` installs
  packages to the global environment which is generally not recommended as it
  can interfere with other packages on your system.

  * Installation via `pipx`:

    ```shell
    pipx install adtl
    ```

  * Installation via `pip`:

    ```shell
    python3 -m pip install adtl
    ```

  If you are writing code which depends on adtl (instead of using the
  command-line program), then it is best to add a dependency on `adtl` to your
  Python build tool of choice.

  To use the development version, replace `adtl` with the full GitHub URL:

  ```shell
  pip install git+https://github.com/globaldothealth/adtl
  ```



  Most existing data transformation languages are usually in a XML dialect, though
  there are recent variations in other file formats. In addition, many DTLs use a
  custom domain specific language. The primary utility of this DTL is to provide a
  easy to use library in Python for basic data transformations, which are
  specified in a JSON file. It is not meant to be a comprehensive, and adtl can
  be used as a step within a larger data processing pipeline.



  adtl can be used from the command line or as a Python library

  As a CLI:
  ```bash
  adtl specification-file input-file
  ```

  Here *specification-file* is the parser specification (as TOML or JSON)
  and *input-file* is the data file (not the data dictionary) that adtl
  will transform using the instructions in the specification.

  Python library:
  ```python
  import adtl

  parser = adtl.Parser(specification)
  print(parser.tables) # list of tables created

  for row in parser.parse().read_table(table):
      print(row)
  ```

  If adtl is not in your PATH, this may give an error. Either add the location
  where the adtl script is installed to your PATH, or try running adtl as a module

  ```shell
  python3 -m adtl specification-file input-file
  ```

  Running adtl will create output files with the name of the parser, suffixed with
  table names in the current working directory.



  Install [pre-commit](https://pre-commit.com) and setup pre-commit hooks
  (`pre-commit install`) which will do linting checks before commit.

rpm_license:
  MIT License  Copyright (c) 2022 Global.health  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: 42427ab6f2f5c3034635cb7f5dc2bdbf6d45dfbb601cb168558b2fc5a92744d1
name: python-adtoolbox
arch: src
version: 0.6.12
epoch: 0
release: 1
summary: A tool for modeling and optimization of anaerobic digestion process.
url: https://pypi.org/project/adtoolbox/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adtoolbox-0.6.12-1.src.rpm
checksum_type: sha256
description:
  Parsa Ghadermazi
  parsa96@colostate.edu

  AD Toolbox is developed in Chan Lab at Colorado State University. The main goal of this toolbox is to provide the tools that are useful for modeling and optimization of anaerobic digestion process.

  Interested in trying ADToolbox? Run the notebooks on Binder or Colab:

  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/chan-csu/ADToolbox/HEAD)
  <a target="_blank" href="https://colab.research.google.com/github/chan-csu/ADToolbox/blob/main/README.md">
    <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/>
  </a>
  [![PyPI version](https://badge.fury.io/py/adtoolbox.svg)](https://badge.fury.io/py/adtoolbox)

  ***NOTE***:Binder implementations don't offer escher map functionalities yet.

  ADToolbox comes with a detailed documentation website. You can access this website using the link below:

  ** [Full Documentation Here](https://chan-csu.github.io/ADToolbox/) **


pkgId: e3dcb92c074ea925aacb26cea5060bd8e7a0b44f634a7e7699fa6201919119a7
name: python-adtree-viz
arch: src
version: 0.0.10
epoch: 0
release: 1
summary: adtree-viz
url: https://github.com/julianghionoiu/adtree-viz
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adtree-viz-0.0.10-1.src.rpm
checksum_type: sha256
description:
  An Attack-Defense Tree modelling lib that allows user to model attack-defense scenarios using an internal DSL.

  Project inspired by https://github.com/hyakuhei/attackTrees and https://github.com/tahti/ADTool2.

  The main goals are:
  - add support for AND nodes
  - be able to break down a large tree into multiple subtrees.
  - keep it simple, only Attack and Defense nodes



  Requirements:
  - `Graphviz`
  - `Python 3.9`


  Install the library
  ```shell
  pip install adtree-viz
  ```

  Quick start

  ```python
  from adtree.models import Attack, Defence, AndGate, ADTree
  from adtree.renderer import Renderer
  from adtree.themes import RedBlueFillTheme

  tree = ADTree("REFS.01", Attack("the goal", [
      Attack("path1", [
          Defence("defend path1", [
              Attack("path1 defence defeated")
          ])
      ]),
      Attack("path2", [
          Attack("path2.1"),
          AndGate([
              Attack("path3.1"),
              Attack("path3.2"),
          ]),
      ]),
  ]))

  theme = RedBlueFillTheme()
  renderer = Renderer(theme=theme, output_format="png", view=True)
  renderer.render(tree=tree, filename="my-adtree")
  ```

  The above should produce an attack-defence tree like this:
  ![attack-defence tree](images/test_theme.test_render_outline.expected.dot.png)



  Trees can be composed of multiple subtrees.
  Which of the subtrees get expanded is decided at render time based on the `subtrees_to_expand` variable.
  ```python
  from adtree.models import Attack, ADTree, ExternalADTree
  from adtree.renderer import Renderer
  from adtree.themes import NoFormatTheme

  some_external_ref = ExternalADTree("EXT.01", "External resource covered by other docs")
  some_internal_ref1 = ADTree("INT.01", root_node=Attack("internal path1", [
      Attack("path 1.1", [
          ADTree("INT.01.A", Attack("nested path 1.1A"))
      ])
  ]))
  some_internal_ref2 = ADTree("INT.02", root_node=Attack("internal path2", [
      Attack("path 2.1")
  ]))
  tree = ADTree("REFS.01", Attack("node1", [
      some_external_ref,
      some_internal_ref1,
      some_internal_ref2
  ]))

  theme = NoFormatTheme()
  renderer = Renderer(theme=theme, output_format="png", view=False)


  renderer.render(tree=tree, filename="default")


  renderer.render(tree=tree, subtrees_to_expand=[some_internal_ref1], filename="partially_expanded")
  ```

  The above will render two files.

  One with all the subtrees collapsed (the default):
  ![attack-defence tree](images/test_trees.test_references_default.expected.dot.png)

  And another file with one subtree expanded:
  ![attack-defence tree](images/test_trees.test_references_some_toggled.expected.dot.png)




  Currently, there is only one analyser available, the IsDefendedAnalyser.
  Traverse the tree and mark each nodes as either defended or undefended
  A node is considered defended if:
  1. is a Defence node and has no children
  2. is an Attack node and has a direct defended Defence node as child
  3. is an Attack or Defence node and all child nodes are defended nodes
  4. is an AndGate and at least one child node is defended

  Example with custom rendering of the defended nodes
  ```python
  from adtree.models import NodeType, Node, Attack, ADTree, Defence, AndGate
  from adtree.analysers import IsDefendedAnalyser
  from adtree.renderer import Renderer
  from adtree.themes import NoFormatTheme

  class CustomIsDefendedTheme(NoFormatTheme):
      def get_node_attrs_for(self, node: Node):
          metadata_attrs = {
              "style": "filled"
          }
          if node.get_node_type() == NodeType.DEFENCE:
              metadata_attrs |= {
                  "shape": "box",
              }
          if node.get_node_type() == NodeType.AND_GATE:
              metadata_attrs |= {
                  "shape": "triangle",
              }
          if node.has_metadata(IsDefendedAnalyser.METADATA_KEY):
              fillcolor = "#C8FFCB" if node.get_metadata(IsDefendedAnalyser.METADATA_KEY) else "#FFD3D6"
              metadata_attrs |= {
                  "fillcolor": fillcolor,
              }
          return metadata_attrs

  tree = ADTree("REFS.01", Attack("the goal", [
      Attack("path1", [
          Defence("defend path1", [
              Attack("path1 defence defeated")
          ])
      ]),
      Attack("path2", [
          Attack("path2.1", [
              Defence("def2.1"),
              Attack("path2.1.1")
          ]),
          AndGate([
              Attack("path3.1"),
              Attack("path3.2", [
                  Defence("defended")
              ]),
          ]),
      ]),
  ]))

  analyser = IsDefendedAnalyser()
  analyser.analyse_tree(tree)

  theme = CustomIsDefendedTheme()
  renderer = Renderer(theme=theme, output_format="png", view=False)


  renderer.render(tree=tree, filename="default")
  ```

  The above should produce an attack-defence tree like this:
  ![attack-defence tree](images/test_analysers.test_is_defended.expected.dot.png)




  Create a venv
  ```shell
  python3.9 -m venv venv
  ```

  Activate
  ```shell
   . venv/bin/activate
  ```

  Install deps
  ```shell
  pip install -r requirements.txt
  ```

  Run tests
  ```shell
  PYTHONPATH=src python -m pytest
  ```

  Run individual test file
  ```shell
  PYTHONPATH=src python -m pytest ./test/adtree/test_theme.py
  ```

  Run individual test methods
  ```shell
  PYTHONPATH=src python  -m pytest --capture=no ./test/adtree/test_theme.py -k "metadata"
  ```




  Create tag and push
  ```
  ./release.sh
  ```



  Run the below to generate a distributable archive:
  ```bash
  python3 -m build
  ```

  The `adtree-viz-x.xx.x.tar.gz` archive can be found in the `dist` folder.

  Deploy to PyPi
  ```shell
  python3 -m twine upload -r pypi dist/*



  ```


pkgId: 18297df3e493fcf720093c3efacf53237ff79aa032aae46a190d9aca5c4b9e43
name: python-adutils
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: Helper and utilities for AppDaemon apps.
url: https://github.com/benleb/adutils
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adutils-0.6.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/adutils)](https://pypi.org/project/adutils/) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/adutils)](https://pypi.org/project/adutils/) [![PyPI - Downloads](https://img.shields.io/pypi/dm/adutils)](https://pypi.org/project/adutils/)

  Helper functions for AppDaemon apps. Currently there is just code, no documentation. Sorry ¯\\_(ツ)_/¯



  ```bash
  pip install adutils
  ```



  * [AutoMoLi](https://github.com/benleb/ad-automoli)
  * [EnCh](https://github.com/benleb/ad-ench)
  * [Notifreeze](https://github.com/benleb/ad-notifreeze)
  * [Healthcheck](https://github.com/benleb/ad-healthcheck)


pkgId: cb80142c806ff24eb9bb21b2101416eacb866d2097bea6538d7e8084d897e283
name: python-advance-common
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/advance-common/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-advance-common-1.3.1-1.src.rpm
checksum_type: sha256
description:
  If you are reading this outside of PyPi, this project is published:
  ```pip install advance-common```


pkgId: 4cc5614e5755c2e35105d2e60e3090bbf6d0be77670291415b6273d5c33bc8ad
name: python-advanced-aicode
arch: src
version: 1.2.16
epoch: 0
release: 1
summary: Front End for Aider.chat which makes it super simple to use
url: https://github.com/zackees/aicode
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-advanced-aicode-1.2.16-1.src.rpm
checksum_type: sha256
description:
  The most advanced ai coding tool on the planet.

  [![Linting](../../actions/workflows/lint.yml/badge.svg)](../../actions/workflows/lint.yml)

  [![MacOS_Tests](../../actions/workflows/push_macos.yml/badge.svg)](../../actions/workflows/push_macos.yml)
  [![Ubuntu_Tests](../../actions/workflows/push_ubuntu.yml/badge.svg)](../../actions/workflows/push_ubuntu.yml)
  [![Win_Tests](../../actions/workflows/push_win.yml/badge.svg)](../../actions/workflows/push_win.yml)




  Okay well `aider.chat` is by far the BEST aicoding assistant on the planet. But `aicode`, a front end for
  `aider.chat` is EASIER TO USE! So use this whenever you can for Windows/Linux/MacOS.
  Think of `aicode` as `aider.chat` but on easy mode.

  One foot gun here is that `aider.chat` only works on files in a git repo. therefore you must be in a git repo
  for `aicode` to work. This is required because `aider.chat` will generate a repo map as part of the query.




  ```bash
  pip install advanced-aicode
  aicode
  ```



  The package name is NOT the same as the command tool. The package is `advanced-aicode` and the tool is called `aicode`. Someone
  else grabbed package name `aicode` over a year ago and this is the best name I could come up with to get it into pypi.





    * `aicode` is easier to install. Like WAY easier. It will tell you what you need to do to complete the installation, such
      as setting the api key if none are detected.
    * `aicode` will not f@ck up your global pip environment. We fix this by lazily installing `aider.chat` using `pipx`
    * `aicode` will change the directory to a the project root containing a `.git` directory. `aider.chat` will just fail to run.
    * `aicode` will default to NOT creating a git commit on every change. Instead it will
      just raw dog it to your current repo. This simplifies usage because most of the time you will
      only be editing one file and if you don't like the change you can just invoke undo on the file.
      If you want to create a git commit on every change (so that you can use /undo)
      then pass in `aicode -a`. This works better if you are editing multiple files and want and want
      to step back in history, must most of the time it's better to just let `aicode` work on one file
      at a time.
    * `aicode` has the benefit of allowing easy upgrades to `aider.chat` from the command line using `aicode --update` which will
      invoke `pipx` update on the backend.
    * `aicode` will default to using `ChatGPT4-o` if it detects you have have an openapi key.
    * `aicode` will save and insert the environmental variables on demand. `aider.chat` requires that you
      insert these variables in your `~/.bashrc` file (linux) or the equivalent for Windows and MacOS.
    * `aicode` will check for new versions in the background and inform you of an update on the NEXT run of
      `aicode` and the command line you can use. This was a feature that `aider.chat` program actually implemented for this project.
    * `aicode` will ask you to modify the `.gitignore` file so that you aren't uploading your f*cking chat
      history to your repo by default.

  Happy CODING!


    * 1.2.16 - Linting is disable by default
    * 1.2.15 - Aider is now installed in a side package. This means Aider won't be cleared when you uninstall `advanced-aicode` but should resolve the issue with OSX throwing exceptions for locked files. See `aicode --purge`
    * 1.2.14 - Fixes wrong VIRTUAL ENV path.
    * 1.2.13 - Fixes KeyboardInterrupt exception in trampoline.
    * 1.2.12 - Final fixes (I hope) in this cycle.
    * 1.2.11 - Fixes some issues with warnings being emitted.
    * 1.2.10 - Adds missing `setuptools` dependency that was causing a non fatal error.
    * 1.2.9 - Now uses trampoline to re-root the cwd when calling the program. Fixes Linux/MacOS.
    * 1.2.8 - `aicode --upgrade` now more robust. Also fixed a path issue on windows.
    * 1.2.7 - `aicode --upgrade` has been fixed to work with `uv` package upgrades.
    * 1.2.6 - Re-rooting trick fails for mac/linux, only apply it for win32
    * 1.2.5 - Cwd directory is inserted so aider-chat backend is invoked from the current command line.
    * 1.2.4 - Switch isolated environment to an ad-hoc usage of `uv`. Much faster and better!
    * 1.2.3 - Fixes a win32 bug related to `isolated-environment`
    * 1.2.2 - Propagate fixes from `isolated-environment` to fix Mac/Linux
    * 1.2.1 - Buf fix for isolated-environment by using `shell=True`.
    * 1.2.0 - Aider is now installed with `isolated-environment` instead of `pipx` for better isolation. We now use `keyring` to securely store your api keys.
    * 1.1.8 - Custom path now set for pipx, should fix most pipx issues.
    * 1.1.7 - Version detection fixed now that the api has been made much better.
    * 1.1.6 - Fixes has update when the versions match
    * 1.1.5 - Fixes `--just-check-update` which had a typo in the last version as `--just-check-updated`
    * 1.1.4 - Fixes `aider --check-update` with `--just-check-update`
    * 1.1.3 - Fixes `aider --skip-check-update` which is now `--no-check-update`
    * 1.1.1 - Fix a infinit recursion loop while trying to find the .git directory.
    * 1.1.0 - The --slow, --fast, --claude3 are not long used. Now it's just --chatgpt and --claude.
    * 1.0.4 - If `--upgrade` fails, then attempt recovery by asking the user to upgrade `pipx` and then try again.
    * 1.0.3 - Improved version parsing so that stuff like X.X.X-dev can be parsed.
    * 1.0.2 - `--claude3`` now maps to sonnet mode. This is now the default if both keys are present for claude3 and openai.
    * 1.0.1 - Improve readme.
    * 1.0.0 - Initial release.


pkgId: 8849fffad532abbe612b9e09f3bcd05853cb9ecc9941860f379937d6d74d619c
name: python-advanced-aicode
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Front End for Aider.chat which makes it super simple to use
url: https://github.com/zackees/aicode
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-advanced-aicode-2.0.0-1.src.rpm
checksum_type: sha256
description:
  The most advanced ai coding tool on the planet.

  [![Linting](../../actions/workflows/lint.yml/badge.svg)](../../actions/workflows/lint.yml)

  [![MacOS_Tests](../../actions/workflows/push_macos.yml/badge.svg)](../../actions/workflows/push_macos.yml)
  [![Ubuntu_Tests](../../actions/workflows/push_ubuntu.yml/badge.svg)](../../actions/workflows/push_ubuntu.yml)
  [![Win_Tests](../../actions/workflows/push_win.yml/badge.svg)](../../actions/workflows/push_win.yml)




  Okay well `aider.chat` is by far the BEST aicoding assistant on the planet. But `aicode`, a front end for
  `aider.chat` is EASIER TO USE! So use this whenever you can for Windows/Linux/MacOS.
  Think of `aicode` as `aider.chat` but on easy mode.

  One foot gun here is that `aider.chat` only works on files in a git repo. therefore you must be in a git repo
  for `aicode` to work. This is required because `aider.chat` will generate a repo map as part of the query.




  ```bash
  pip install advanced-aicode
  aicode
  ```



  The package name is NOT the same as the command tool. The package is `advanced-aicode` and the tool is called `aicode`. Someone
  else grabbed package name `aicode` over a year ago and this is the best name I could come up with to get it into pypi.





    * `aicode` is easier to install. Like WAY easier. It will tell you what you need to do to complete the installation, such
      as setting the api key if none are detected.
    * `aicode` will not f@ck up your global pip environment. We fix this by lazily installing `aider.chat` using `pipx`
    * `aicode` will change the directory to a the project root containing a `.git` directory. `aider.chat` will just fail to run.
    * `aicode` will default to NOT creating a git commit on every change. Instead it will
      just raw dog it to your current repo. This simplifies usage because most of the time you will
      only be editing one file and if you don't like the change you can just invoke undo on the file.
      If you want to create a git commit on every change (so that you can use /undo)
      then pass in `aicode -a`. This works better if you are editing multiple files and want and want
      to step back in history, must most of the time it's better to just let `aicode` work on one file
      at a time.
    * `aicode` has the benefit of allowing easy upgrades to `aider.chat` from the command line using `aicode --update` which will
      invoke `pipx` update on the backend.
    * `aicode` will default to using `ChatGPT4-o` if it detects you have have an openapi key.
    * `aicode` will save and insert the environmental variables on demand. `aider.chat` requires that you
      insert these variables in your `~/.bashrc` file (linux) or the equivalent for Windows and MacOS.
    * `aicode` will check for new versions in the background and inform you of an update on the NEXT run of
      `aicode` and the command line you can use. This was a feature that `aider.chat` program actually implemented for this project.
    * `aicode` will ask you to modify the `.gitignore` file so that you aren't uploading your f*cking chat
      history to your repo by default.

  Happy CODING!


    * 2.0.0 - Implemented aider's new "architect" mode, which although is a small change in the code, does change how the product is used.
              Disable this by using `--no-architect` to get the old behavior.
    * 1.2.16 - Linting is disable by default
    * 1.2.15 - Aider is now installed in a side package. This means Aider won't be cleared when you uninstall `advanced-aicode` but should resolve the issue with OSX throwing exceptions for locked files. See `aicode --purge`
    * 1.2.14 - Fixes wrong VIRTUAL ENV path.
    * 1.2.13 - Fixes KeyboardInterrupt exception in trampoline.
    * 1.2.12 - Final fixes (I hope) in this cycle.
    * 1.2.11 - Fixes some issues with warnings being emitted.
    * 1.2.10 - Adds missing `setuptools` dependency that was causing a non fatal error.
    * 1.2.9 - Now uses trampoline to re-root the cwd when calling the program. Fixes Linux/MacOS.
    * 1.2.8 - `aicode --upgrade` now more robust. Also fixed a path issue on windows.
    * 1.2.7 - `aicode --upgrade` has been fixed to work with `uv` package upgrades.
    * 1.2.6 - Re-rooting trick fails for mac/linux, only apply it for win32
    * 1.2.5 - Cwd directory is inserted so aider-chat backend is invoked from the current command line.
    * 1.2.4 - Switch isolated environment to an ad-hoc usage of `uv`. Much faster and better!
    * 1.2.3 - Fixes a win32 bug related to `isolated-environment`
    * 1.2.2 - Propagate fixes from `isolated-environment` to fix Mac/Linux
    * 1.2.1 - Buf fix for isolated-environment by using `shell=True`.
    * 1.2.0 - Aider is now installed with `isolated-environment` instead of `pipx` for better isolation. We now use `keyring` to securely store your api keys.
    * 1.1.8 - Custom path now set for pipx, should fix most pipx issues.
    * 1.1.7 - Version detection fixed now that the api has been made much better.
    * 1.1.6 - Fixes has update when the versions match
    * 1.1.5 - Fixes `--just-check-update` which had a typo in the last version as `--just-check-updated`
    * 1.1.4 - Fixes `aider --check-update` with `--just-check-update`
    * 1.1.3 - Fixes `aider --skip-check-update` which is now `--no-check-update`
    * 1.1.1 - Fix a infinit recursion loop while trying to find the .git directory.
    * 1.1.0 - The --slow, --fast, --claude3 are not long used. Now it's just --chatgpt and --claude.
    * 1.0.4 - If `--upgrade` fails, then attempt recovery by asking the user to upgrade `pipx` and then try again.
    * 1.0.3 - Improved version parsing so that stuff like X.X.X-dev can be parsed.
    * 1.0.2 - `--claude3`` now maps to sonnet mode. This is now the default if both keys are present for claude3 and openai.
    * 1.0.1 - Improve readme.
    * 1.0.0 - Initial release.


pkgId: f8ae38be956ef1f837d3424389ff9aebc8aef328593f75f102ce7a829f425e0c
name: python-advanced-aicode
arch: src
version: 2.0.4
epoch: 0
release: 1
summary: Front End for Aider.chat which makes it super simple to use
url: https://github.com/zackees/aicode
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-advanced-aicode-2.0.4-1.src.rpm
checksum_type: sha256
description:
  The most advanced ai coding tool on the planet.

  [![Linting](../../actions/workflows/lint.yml/badge.svg)](../../actions/workflows/lint.yml)

  [![MacOS_Tests](../../actions/workflows/push_macos.yml/badge.svg)](../../actions/workflows/push_macos.yml)
  [![Ubuntu_Tests](../../actions/workflows/push_ubuntu.yml/badge.svg)](../../actions/workflows/push_ubuntu.yml)
  [![Win_Tests](../../actions/workflows/push_win.yml/badge.svg)](../../actions/workflows/push_win.yml)




  Okay well `aider.chat` is by far the BEST aicoding assistant on the planet. But `aicode`, a front end for
  `aider.chat` is EASIER TO USE! So use this whenever you can for Windows/Linux/MacOS.
  Think of `aicode` as `aider.chat` but on easy mode.

  One foot gun here is that `aider.chat` only works on files in a git repo. therefore you must be in a git repo
  for `aicode` to work. This is required because `aider.chat` will generate a repo map as part of the query.




  ```bash
  pip install advanced-aicode
  aicode
  ```



  The package name is NOT the same as the command tool. The package is `advanced-aicode` and the tool is called `aicode`. Someone
  else grabbed package name `aicode` over a year ago and this is the best name I could come up with to get it into pypi.





    * `aicode` is easier to install. Like WAY easier. It will tell you what you need to do to complete the installation, such
      as setting the api key if none are detected.
    * `aicode` will not f@ck up your global pip environment. We fix this by lazily installing `aider.chat` using `pipx`
    * `aicode` will change the directory to a the project root containing a `.git` directory. `aider.chat` will just fail to run.
    * `aicode` will default to NOT creating a git commit on every change. Instead it will
      just raw dog it to your current repo. This simplifies usage because most of the time you will
      only be editing one file and if you don't like the change you can just invoke undo on the file.
      If you want to create a git commit on every change (so that you can use /undo)
      then pass in `aicode -a`. This works better if you are editing multiple files and want and want
      to step back in history, must most of the time it's better to just let `aicode` work on one file
      at a time.
    * `aicode` has the benefit of allowing easy upgrades to `aider.chat` from the command line using `aicode --update` which will
      invoke `pipx` update on the backend.
    * `aicode` will default to using `ChatGPT4-o` if it detects you have have an openapi key.
    * `aicode` will save and insert the environmental variables on demand. `aider.chat` requires that you
      insert these variables in your `~/.bashrc` file (linux) or the equivalent for Windows and MacOS.
    * `aicode` will check for new versions in the background and inform you of an update on the NEXT run of
      `aicode` and the command line you can use. This was a feature that `aider.chat` program actually implemented for this project.
    * `aicode` will ask you to modify the `.gitignore` file so that you aren't uploading your f*cking chat
      history to your repo by default.

  Happy CODING!


    * 2.0.4 - New sonnet model anthropic/claude-3-5-sonnet-20241022 is now the default for claude mode.
    * 2.0.3 - Now using Semi secret instead of keyring, which encrypts the key at a secret location.
    * 2.0.2 - If there is chat history then aicode will ask if you want to restore it.
    * 2.0.1 - Implement disabling of git if a git directory can't be found.
    * 2.0.0 - Implemented aider's new "architect" mode, which although is a small change in the code, does change how the product is used.
              Disable this by using `--no-architect` to get the old behavior.
    * 1.2.16 - Linting is disable by default
    * 1.2.15 - Aider is now installed in a side package. This means Aider won't be cleared when you uninstall `advanced-aicode` but should resolve the issue with OSX throwing exceptions for locked files. See `aicode --purge`
    * 1.2.14 - Fixes wrong VIRTUAL ENV path.
    * 1.2.13 - Fixes KeyboardInterrupt exception in trampoline.
    * 1.2.12 - Final fixes (I hope) in this cycle.
    * 1.2.11 - Fixes some issues with warnings being emitted.
    * 1.2.10 - Adds missing `setuptools` dependency that was causing a non fatal error.
    * 1.2.9 - Now uses trampoline to re-root the cwd when calling the program. Fixes Linux/MacOS.
    * 1.2.8 - `aicode --upgrade` now more robust. Also fixed a path issue on windows.
    * 1.2.7 - `aicode --upgrade` has been fixed to work with `uv` package upgrades.
    * 1.2.6 - Re-rooting trick fails for mac/linux, only apply it for win32
    * 1.2.5 - Cwd directory is inserted so aider-chat backend is invoked from the current command line.
    * 1.2.4 - Switch isolated environment to an ad-hoc usage of `uv`. Much faster and better!
    * 1.2.3 - Fixes a win32 bug related to `isolated-environment`
    * 1.2.2 - Propagate fixes from `isolated-environment` to fix Mac/Linux
    * 1.2.1 - Buf fix for isolated-environment by using `shell=True`.
    * 1.2.0 - Aider is now installed with `isolated-environment` instead of `pipx` for better isolation. We now use `keyring` to securely store your api keys.
    * 1.1.8 - Custom path now set for pipx, should fix most pipx issues.
    * 1.1.7 - Version detection fixed now that the api has been made much better.
    * 1.1.6 - Fixes has update when the versions match
    * 1.1.5 - Fixes `--just-check-update` which had a typo in the last version as `--just-check-updated`
    * 1.1.4 - Fixes `aider --check-update` with `--just-check-update`
    * 1.1.3 - Fixes `aider --skip-check-update` which is now `--no-check-update`
    * 1.1.1 - Fix a infinit recursion loop while trying to find the .git directory.
    * 1.1.0 - The --slow, --fast, --claude3 are not long used. Now it's just --chatgpt and --claude.
    * 1.0.4 - If `--upgrade` fails, then attempt recovery by asking the user to upgrade `pipx` and then try again.
    * 1.0.3 - Improved version parsing so that stuff like X.X.X-dev can be parsed.
    * 1.0.2 - `--claude3`` now maps to sonnet mode. This is now the default if both keys are present for claude3 and openai.
    * 1.0.1 - Improve readme.
    * 1.0.0 - Initial release.


pkgId: cd034207c664a26555703b7def90f476aff3a8e5098a07053364a1b7e8bb36ea
name: python-advanced-alchemy
arch: src
version: 0.20.0
epoch: 0
release: 1
summary: Ready-to-go SQLAlchemy concoctions.
url: https://docs.advanced-alchemy.litestar.dev/latest/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-advanced-alchemy-0.20.0-1.src.rpm
checksum_type: sha256
description:
  <!-- markdownlint-disable -->
  <p align="center">
    <!-- github-banner-start -->
    <img src="https://raw.githubusercontent.com/litestar-org/branding/main/assets/Branding%20-%20SVG%20-%20Transparent/AA%20-%20Banner%20-%20Inline%20-%20Light.svg#gh-light-mode-only" alt="Litestar Logo - Light" width="100%" height="auto" />
    <img src="https://raw.githubusercontent.com/litestar-org/branding/main/assets/Branding%20-%20SVG%20-%20Transparent/AA%20-%20Banner%20-%20Inline%20-%20Dark.svg#gh-dark-mode-only" alt="Litestar Logo - Dark" width="100%" height="auto" />
    <!-- github-banner-end -->
  </p>
  <!-- markdownlint-restore -->

  <div align="center">

  <!-- prettier-ignore-start -->

  | Project   |     | Status                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
  |-----------|:----|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | CI/CD     |     | [![Latest Release](https://github.com/litestar-org/advanced-alchemy/actions/workflows/publish.yml/badge.svg)](https://github.com/litestar-org/advanced-alchemy/actions/workflows/publish.yml) [![ci](https://github.com/litestar-org/advanced-alchemy/actions/workflows/ci.yml/badge.svg)](https://github.com/litestar-org/advanced-alchemy/actions/workflows/ci.yml) [![Documentation Building](https://github.com/litestar-org/advanced-alchemy/actions/workflows/docs.yml/badge.svg?branch=main)](https://github.com/litestar-org/advanced-alchemy/actions/workflows/docs.yml)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
  | Quality   |     | [![Coverage](https://codecov.io/github/litestar-org/advanced-alchemy/graph/badge.svg?token=vKez4Pycrc)](https://codecov.io/github/litestar-org/advanced-alchemy) [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=litestar-org_advanced-alchemy&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=litestar-org_advanced-alchemy) [![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=litestar-org_advanced-alchemy&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=litestar-org_advanced-alchemy) [![Reliability Rating](https://sonarcloud.io/api/project_badges/measure?project=litestar-org_advanced-alchemy&metric=reliability_rating)](https://sonarcloud.io/summary/new_code?id=litestar-org_advanced-alchemy) [![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=litestar-org_advanced-alchemy&metric=security_rating)](https://sonarcloud.io/summary/new_code?id=litestar-org_advanced-alchemy)                                                                                                    |
  | Package   |     | [![PyPI - Version](https://img.shields.io/pypi/v/advanced-alchemy?labelColor=202235&color=edb641&logo=python&logoColor=edb641)](https://badge.fury.io/py/litestar) ![PyPI - Support Python Versions](https://img.shields.io/pypi/pyversions/litestar?labelColor=202235&color=edb641&logo=python&logoColor=edb641) ![Advanced Alchemy PyPI - Downloads](https://img.shields.io/pypi/dm/advanced-alchemy?logo=python&label=package%20downloads&labelColor=202235&color=edb641&logoColor=edb641)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
  | Community |     | [![Reddit](https://img.shields.io/reddit/subreddit-subscribers/litestarapi?label=r%2FLitestar&logo=reddit&labelColor=202235&color=edb641&logoColor=edb641)](https://reddit.com/r/litestarapi) [![Discord](https://img.shields.io/discord/919193495116337154?labelColor=202235&color=edb641&label=chat%20on%20discord&logo=discord&logoColor=edb641)](https://discord.gg/litestar) [![Matrix](https://img.shields.io/badge/chat%20on%20Matrix-bridged-202235?labelColor=202235&color=edb641&logo=matrix&logoColor=edb641)](https://matrix.to/#/#litestar:matrix.org) [![Medium](https://img.shields.io/badge/Medium-202235?labelColor=202235&color=edb641&logo=medium&logoColor=edb641)](https://blog.litestar.dev) [![Twitter](https://img.shields.io/twitter/follow/LitestarAPI?labelColor=202235&color=edb641&logo=twitter&logoColor=edb641&style=flat)](https://twitter.com/LitestarAPI) [![Blog](https://img.shields.io/badge/Blog-litestar.dev-202235?logo=blogger&labelColor=202235&color=edb641&logoColor=edb641)](https://blog.litestar.dev)                                                             |
  | Meta      |     | [![Litestar Project](https://img.shields.io/badge/Litestar%20Org-%E2%AD%90%20Advanced%20Alchemy-202235.svg?logo=python&labelColor=202235&color=edb641&logoColor=edb641)](https://github.com/litestar-org/advanced-alchemy) [![types - Mypy](https://img.shields.io/badge/types-Mypy-202235.svg?logo=python&labelColor=202235&color=edb641&logoColor=edb641)](https://github.com/python/mypy) [![License - MIT](https://img.shields.io/badge/license-MIT-202235.svg?logo=python&labelColor=202235&color=edb641&logoColor=edb641)](https://spdx.org/licenses/) [![Litestar Sponsors](https://img.shields.io/badge/Sponsor-%E2%9D%A4-%23edb641.svg?&logo=github&logoColor=edb641&labelColor=202235)](https://github.com/sponsors/litestar-org) [![linting - Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json&labelColor=202235)](https://github.com/astral-sh/ruff) [![code style - Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/format.json&labelColor=202235)](https://github.com/psf/black) |

  </div>



  Check out the [project documentation][project-docs] 📚 for more information.



  A carefully crafted, thoroughly tested, optimized companion library for SQLAlchemy,
  offering:

  - Sync and async repositories, featuring common CRUD and highly optimized bulk operations
  - Integration with major web frameworks including Litestar, Starlette, FastAPI, Sanic
  - Custom-built alembic configuration and CLI with optional framework integration
  - Utility base classes with audit columns, primary keys and utility functions
  - Optimized JSON types including a custom JSON type for Oracle
  - Integrated support for UUID6 and UUID7 using [`uuid-utils`](https://github.com/aminalaee/uuid-utils) (install with the `uuid` extra)
  - Integrated support for Nano ID using [`fastnanoid`](https://github.com/oliverlambson/fastnanoid) (install with the `nanoid` extra)
  - Pre-configured base classes with audit columns UUID or Big Integer primary keys and
    a [sentinel column](https://docs.sqlalchemy.org/en/20/core/connections.html#configuring-sentinel-columns).
  - Synchronous and asynchronous repositories featuring:
    - Common CRUD operations for SQLAlchemy models
    - Bulk inserts, updates, upserts, and deletes with dialect-specific enhancements
    - [lambda_stmt](https://docs.sqlalchemy.org/en/20/core/sqlelement.html#sqlalchemy.sql.expression.lambda_stmt) when possible
      for improved query building performance
    - Integrated counts, pagination, sorting, filtering with `LIKE`, `IN`, and dates before and/or after.
  - Tested support for multiple database backends including:
    - SQLite via [aiosqlite](https://aiosqlite.omnilib.dev/en/stable/) or [sqlite](https://docs.python.org/3/library/sqlite3.html)
    - Postgres via [asyncpg](https://magicstack.github.io/asyncpg/current/) or [psycopg3 (async or sync)](https://www.psycopg.org/psycopg3/)
    - MySQL via [asyncmy](https://github.com/long2ice/asyncmy)
    - Oracle via [oracledb (async or sync)](https://oracle.github.io/python-oracledb/) (tested on 18c and 23c)
    - Google Spanner via [spanner-sqlalchemy](https://github.com/googleapis/python-spanner-sqlalchemy/)
    - DuckDB via [duckdb_engine](https://github.com/Mause/duckdb_engine)
    - Microsoft SQL Server via [pyodbc](https://github.com/mkleehammer/pyodbc) or [aioodbc](https://github.com/aio-libs/aioodbc)
    - CockroachDB via [sqlalchemy-cockroachdb (async or sync)](https://github.com/cockroachdb/sqlalchemy-cockroachdb)
  - ...and much more





  ```shell
  pip install advanced-alchemy
  ```

  > [!IMPORTANT]\
  > Check out [the installation guide][install-guide] in our official documentation!



  Advanced Alchemy includes a set of asynchronous and synchronous repository classes for easy CRUD
  operations on your SQLAlchemy models.

  <details>
  <summary>Click to expand the example</summary>

  ```python
  from advanced_alchemy.base import UUIDBase
  from advanced_alchemy.filters import LimitOffset
  from advanced_alchemy.repository import SQLAlchemySyncRepository
  from sqlalchemy import create_engine
  from sqlalchemy.orm import Mapped, sessionmaker


  class User(UUIDBase):
      
      __tablename__ = "user_account"  # type: ignore[assignment]
      email: Mapped[str]
      name: Mapped[str]


  class UserRepository(SQLAlchemySyncRepository[User]):
      """User repository."""

      model_type = User



  engine = create_engine("duckdb:///:memory:")
  session_factory = sessionmaker(engine, expire_on_commit=False)


  with engine.begin() as conn:
      User.metadata.create_all(conn)

  with session_factory() as db_session:
      repo = UserRepository(session=db_session)
      
      bulk_users = [
          {"email": 'cody@litestar.dev', 'name': 'Cody'},
          {"email": 'janek@litestar.dev', 'name': 'Janek'},
          {"email": 'peter@litestar.dev', 'name': 'Peter'},
          {"email": 'jacob@litestar.dev', 'name': 'Jacob'}
      ]
      objs = repo.add_many([User(**raw_user) for raw_user in bulk_users])
      db_session.commit()
      print(f"Created {len(objs)} new objects.")

      
      created_objs, total_objs = repo.list_and_count(LimitOffset(limit=10, offset=0), name="Cody")
      print(f"Selected {len(created_objs)} records out of a total of {total_objs}.")

      
      deleted_objs = repo.delete_many([new_obj.id for new_obj in created_objs])
      print(f"Removed {len(deleted_objs)} records out of a total of {total_objs}.")

      
      remaining_count = repo.count()
      print(f"Found {remaining_count} remaining records after delete.")
  ```

  </details>

  For a full standalone example, see the sample [here][standalone-example]



  Advanced Alchemy includes an additional service class to make working with a repository easier.
  This class is designed to accept data as a dictionary or SQLAlchemy model,
  and it will handle the type conversions for you.

  <details>
  <summary>Here's the same example from above but using a service to create the data:</summary>

  ```python
  from advanced_alchemy.base import UUIDBase
  from advanced_alchemy.filters import LimitOffset
  from advanced_alchemy import SQLAlchemySyncRepository, SQLAlchemySyncRepositoryService
  from sqlalchemy import create_engine
  from sqlalchemy.orm import Mapped, sessionmaker


  class User(UUIDBase):
      
      __tablename__ = "user_account"  # type: ignore[assignment]
      email: Mapped[str]
      name: Mapped[str]


  class UserRepository(SQLAlchemySyncRepository[User]):
      """User repository."""

      model_type = User


  class UserService(SQLAlchemySyncRepositoryService[User]):
      """User repository."""

      repository_type = UserRepository



  engine = create_engine("duckdb:///:memory:")
  session_factory = sessionmaker(engine, expire_on_commit=False)


  with engine.begin() as conn:
      User.metadata.create_all(conn)

  with session_factory() as db_session:
      service = UserService(session=db_session)
      
      objs = service.create_many([
          {"email": 'cody@litestar.dev', 'name': 'Cody'},
          {"email": 'janek@litestar.dev', 'name': 'Janek'},
          {"email": 'peter@litestar.dev', 'name': 'Peter'},
          {"email": 'jacob@litestar.dev', 'name': 'Jacob'}
      ])
      print(objs)
      print(f"Created {len(objs)} new objects.")

      
      created_objs, total_objs = service.list_and_count(LimitOffset(limit=10, offset=0), name="Cody")
      print(f"Selected {len(created_objs)} records out of a total of {total_objs}.")

      
      deleted_objs = service.delete_many([new_obj.id for new_obj in created_objs])
      print(f"Removed {len(deleted_objs)} records out of a total of {total_objs}.")

      
      remaining_count = service.count()
      print(f"Found {remaining_count} remaining records after delete.")
  ```

  </details>



  Advanced Alchemy works with nearly all Python web frameworks.
  Several helpers for popular libraries are included, and additional PRs to support others are welcomed.



  Advanced Alchemy is the official SQLAlchemy integration for Litestar.

  In addition to installing with `pip install advanced-alchemy`,
  it can also be installed as a Litestar extra with `pip install litestar[sqlalchemy]`.

  <details>
  <summary>Litestar Example</summary>

  ```python
  from litestar import Litestar
  from litestar.plugins.sqlalchemy import SQLAlchemyPlugin, SQLAlchemyAsyncConfig




  alchemy = SQLAlchemyPlugin(
    config=SQLAlchemyAsyncConfig(connection_string="sqlite+aiosqlite:///test.sqlite"),
  )
  app = Litestar(plugins=[alchemy])
  ```

  </details>

  For a full Litestar example, check [here][litestar-example]



  <details>
  <summary>FastAPI Example</summary>

  ```python
  from fastapi import FastAPI

  from advanced_alchemy.config import SQLAlchemyAsyncConfig
  from advanced_alchemy.extensions.starlette import StarletteAdvancedAlchemy

  app = FastAPI()
  alchemy = StarletteAdvancedAlchemy(
      config=SQLAlchemyAsyncConfig(connection_string="sqlite+aiosqlite:///test.sqlite"), app=app,
  )
  ```

  </details>

  For a full FastAPI example, see [here][fastapi-example]



  <details>
  <summary>Pre-built Example Apps</summary>

  ```python
  from starlette.applications import Starlette

  from advanced_alchemy.config import SQLAlchemyAsyncConfig
  from advanced_alchemy.extensions.starlette import StarletteAdvancedAlchemy

  app = Starlette()
  alchemy = StarletteAdvancedAlchemy(
      config=SQLAlchemyAsyncConfig(connection_string="sqlite+aiosqlite:///test.sqlite"), app=app,
  )
  ```

  </details>



  <details>
  <summary>Pre-built Example Apps</summary>

  ```python
  from sanic import Sanic
  from sanic_ext import Extend

  from advanced_alchemy.config import SQLAlchemyAsyncConfig
  from advanced_alchemy.extensions.sanic import SanicAdvancedAlchemy

  app = Sanic("AlchemySanicApp")
  alchemy = SanicAdvancedAlchemy(
      sqlalchemy_config=SQLAlchemyAsyncConfig(connection_string="sqlite+aiosqlite:///test.sqlite"),
  )
  Extend.register(alchemy)
  ```

  </details>



  All [Litestar Organization][litestar-org] projects will always be a community-centered, available for contributions of any size.

  Before contributing, please review the [contribution guide][contributing].

  If you have any questions, reach out to us on [Discord][discord], our org-wide [GitHub discussions][litestar-discussions] page,
  or the [project-specific GitHub discussions page][project-discussions].

  <hr>

  <!-- markdownlint-disable -->
  <p align="center">
    <!-- github-banner-start -->
    <img src="https://raw.githubusercontent.com/litestar-org/branding/main/assets/Branding%20-%20SVG%20-%20Transparent/Organization%20Project%20-%20Banner%20-%20Inline%20-%20Dark.svg" alt="Litestar Logo - Light" width="40%" height="auto" />
    <br>An official <a href="https://github.com/litestar-org">Litestar Organization</a> Project
    <!-- github-banner-end -->
  </p>

  [litestar-org]: https://github.com/litestar-org
  [contributing]: https://docs.advanced-alchemy.litestar.dev/latest/contribution-guide.html
  [discord]: https://discord.gg/litestar
  [litestar-discussions]: https://github.com/orgs/litestar-org/discussions
  [project-discussions]: https://github.com/litestar-org/advanced-alchemy/discussions
  [project-docs]: https://docs.advanced-alchemy.litestar.dev
  [install-guide]: https://docs.advanced-alchemy.litestar.dev/latest/#installation
  [fastapi-example]: https://github.com/litestar-org/advanced-alchemy/blob/main/examples/fastapi.py
  [litestar-example]: https://github.com/litestar-org/advanced-alchemy/blob/main/examples/litestar.py
  [standalone-example]: https://github.com/litestar-org/advanced-alchemy/blob/main/examples/standalone.py


pkgId: c8ca6da534ec7437c1752c8ad23d5be35f9ce0203b59aa05edf153ede3e5049f
name: python-advanced-alchemy
arch: src
version: 0.24.0
epoch: 0
release: 1
summary: Ready-to-go SQLAlchemy concoctions.
url: https://docs.advanced-alchemy.litestar.dev/latest/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-advanced-alchemy-0.24.0-1.src.rpm
checksum_type: sha256
description:
  <!-- markdownlint-disable -->
  <p align="center">
    <!-- github-banner-start -->
    <img src="https://raw.githubusercontent.com/litestar-org/branding/main/assets/Branding%20-%20SVG%20-%20Transparent/AA%20-%20Banner%20-%20Inline%20-%20Light.svg#gh-light-mode-only" alt="Litestar Logo - Light" width="100%" height="auto" />
    <img src="https://raw.githubusercontent.com/litestar-org/branding/main/assets/Branding%20-%20SVG%20-%20Transparent/AA%20-%20Banner%20-%20Inline%20-%20Dark.svg#gh-dark-mode-only" alt="Litestar Logo - Dark" width="100%" height="auto" />
    <!-- github-banner-end -->
  </p>
  <div align="center">
  <!-- markdownlint-restore -->

  <!-- prettier-ignore-start -->

  | Project   |     | Status                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
  |-----------|:----|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | CI/CD     |     | [![Latest Release](https://github.com/litestar-org/advanced-alchemy/actions/workflows/publish.yml/badge.svg)](https://github.com/litestar-org/advanced-alchemy/actions/workflows/publish.yml) [![ci](https://github.com/litestar-org/advanced-alchemy/actions/workflows/ci.yml/badge.svg)](https://github.com/litestar-org/advanced-alchemy/actions/workflows/ci.yml) [![Documentation Building](https://github.com/litestar-org/advanced-alchemy/actions/workflows/docs.yml/badge.svg?branch=main)](https://github.com/litestar-org/advanced-alchemy/actions/workflows/docs.yml)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
  | Quality   |     | [![Coverage](https://codecov.io/github/litestar-org/advanced-alchemy/graph/badge.svg?token=vKez4Pycrc)](https://codecov.io/github/litestar-org/advanced-alchemy) [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=litestar-org_advanced-alchemy&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=litestar-org_advanced-alchemy) [![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=litestar-org_advanced-alchemy&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=litestar-org_advanced-alchemy) [![Reliability Rating](https://sonarcloud.io/api/project_badges/measure?project=litestar-org_advanced-alchemy&metric=reliability_rating)](https://sonarcloud.io/summary/new_code?id=litestar-org_advanced-alchemy) [![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=litestar-org_advanced-alchemy&metric=security_rating)](https://sonarcloud.io/summary/new_code?id=litestar-org_advanced-alchemy)                                                                                                    |
  | Package   |     | [![PyPI - Version](https://img.shields.io/pypi/v/advanced-alchemy?labelColor=202235&color=edb641&logo=python&logoColor=edb641)](https://badge.fury.io/py/litestar) ![PyPI - Support Python Versions](https://img.shields.io/pypi/pyversions/litestar?labelColor=202235&color=edb641&logo=python&logoColor=edb641) ![Advanced Alchemy PyPI - Downloads](https://img.shields.io/pypi/dm/advanced-alchemy?logo=python&label=package%20downloads&labelColor=202235&color=edb641&logoColor=edb641)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
  | Community |     | [![Reddit](https://img.shields.io/reddit/subreddit-subscribers/litestarapi?label=r%2FLitestar&logo=reddit&labelColor=202235&color=edb641&logoColor=edb641)](https://reddit.com/r/litestarapi) [![Discord](https://img.shields.io/discord/919193495116337154?labelColor=202235&color=edb641&label=chat%20on%20discord&logo=discord&logoColor=edb641)](https://discord.gg/litestar) [![Matrix](https://img.shields.io/badge/chat%20on%20Matrix-bridged-202235?labelColor=202235&color=edb641&logo=matrix&logoColor=edb641)](https://matrix.to/#/#litestar:matrix.org) [![Medium](https://img.shields.io/badge/Medium-202235?labelColor=202235&color=edb641&logo=medium&logoColor=edb641)](https://blog.litestar.dev) [![Twitter](https://img.shields.io/twitter/follow/LitestarAPI?labelColor=202235&color=edb641&logo=twitter&logoColor=edb641&style=flat)](https://twitter.com/LitestarAPI) [![Blog](https://img.shields.io/badge/Blog-litestar.dev-202235?logo=blogger&labelColor=202235&color=edb641&logoColor=edb641)](https://blog.litestar.dev)                                                             |
  | Meta      |     | [![Litestar Project](https://img.shields.io/badge/Litestar%20Org-%E2%AD%90%20Advanced%20Alchemy-202235.svg?logo=python&labelColor=202235&color=edb641&logoColor=edb641)](https://github.com/litestar-org/advanced-alchemy) [![types - Mypy](https://img.shields.io/badge/types-Mypy-202235.svg?logo=python&labelColor=202235&color=edb641&logoColor=edb641)](https://github.com/python/mypy) [![License - MIT](https://img.shields.io/badge/license-MIT-202235.svg?logo=python&labelColor=202235&color=edb641&logoColor=edb641)](https://spdx.org/licenses/) [![Litestar Sponsors](https://img.shields.io/badge/Sponsor-%E2%9D%A4-%23edb641.svg?&logo=github&logoColor=edb641&labelColor=202235)](https://github.com/sponsors/litestar-org) [![linting - Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json&labelColor=202235)](https://github.com/astral-sh/ruff) [![code style - Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/format.json&labelColor=202235)](https://github.com/psf/black) |

  </div>



  Check out the [project documentation][project-docs] 📚 for more information.



  A carefully crafted, thoroughly tested, optimized companion library for SQLAlchemy,
  offering:

  - Sync and async repositories, featuring common CRUD and highly optimized bulk operations
  - Integration with major web frameworks including Litestar, Starlette, FastAPI, Sanic
  - Custom-built alembic configuration and CLI with optional framework integration
  - Utility base classes with audit columns, primary keys and utility functions
  - Optimized JSON types including a custom JSON type for Oracle
  - Integrated support for UUID6 and UUID7 using [`uuid-utils`](https://github.com/aminalaee/uuid-utils) (install with the `uuid` extra)
  - Integrated support for Nano ID using [`fastnanoid`](https://github.com/oliverlambson/fastnanoid) (install with the `nanoid` extra)
  - Pre-configured base classes with audit columns UUID or Big Integer primary keys and
    a [sentinel column](https://docs.sqlalchemy.org/en/20/core/connections.html#configuring-sentinel-columns).
  - Synchronous and asynchronous repositories featuring:
      - Common CRUD operations for SQLAlchemy models
      - Bulk inserts, updates, upserts, and deletes with dialect-specific enhancements
      - Integrated counts, pagination, sorting, filtering with `LIKE`, `IN`, and dates before and/or after.
  - Tested support for multiple database backends including:
      - SQLite via [aiosqlite](https://aiosqlite.omnilib.dev/en/stable/) or [sqlite](https://docs.python.org/3/library/sqlite3.html)
      - Postgres via [asyncpg](https://magicstack.github.io/asyncpg/current/) or [psycopg3 (async or sync)](https://www.psycopg.org/psycopg3/)
      - MySQL via [asyncmy](https://github.com/long2ice/asyncmy)
      - Oracle via [oracledb (async or sync)](https://oracle.github.io/python-oracledb/) (tested on 18c and 23c)
      - Google Spanner via [spanner-sqlalchemy](https://github.com/googleapis/python-spanner-sqlalchemy/)
      - DuckDB via [duckdb_engine](https://github.com/Mause/duckdb_engine)
      - Microsoft SQL Server via [pyodbc](https://github.com/mkleehammer/pyodbc) or [aioodbc](https://github.com/aio-libs/aioodbc)
      - CockroachDB via [sqlalchemy-cockroachdb (async or sync)](https://github.com/cockroachdb/sqlalchemy-cockroachdb)
  - ...and much more





  ```shell
  pip install advanced-alchemy
  ```

  > [!IMPORTANT]\
  > Check out [the installation guide][install-guide] in our official documentation!



  Advanced Alchemy includes a set of asynchronous and synchronous repository classes for easy CRUD
  operations on your SQLAlchemy models.
  <!-- markdownlint-disable -->
  <details>
  <summary>Click to expand the example</summary>
  <!-- markdownlint-restore -->

  ```python
  from advanced_alchemy.base import UUIDBase
  from advanced_alchemy.filters import LimitOffset
  from advanced_alchemy.repository import SQLAlchemySyncRepository
  from sqlalchemy import create_engine
  from sqlalchemy.orm import Mapped, sessionmaker


  class User(UUIDBase):
      
      __tablename__ = "user_account"  # type: ignore[assignment]
      email: Mapped[str]
      name: Mapped[str]


  class UserRepository(SQLAlchemySyncRepository[User]):
      """User repository."""

      model_type = User



  engine = create_engine("duckdb:///:memory:")
  session_factory = sessionmaker(engine, expire_on_commit=False)


  with engine.begin() as conn:
      User.metadata.create_all(conn)

  with session_factory() as db_session:
      repo = UserRepository(session=db_session)
      
      bulk_users = [
          {"email": 'cody@litestar.dev', 'name': 'Cody'},
          {"email": 'janek@litestar.dev', 'name': 'Janek'},
          {"email": 'peter@litestar.dev', 'name': 'Peter'},
          {"email": 'jacob@litestar.dev', 'name': 'Jacob'}
      ]
      objs = repo.add_many([User(**raw_user) for raw_user in bulk_users])
      db_session.commit()
      print(f"Created {len(objs)} new objects.")

      
      created_objs, total_objs = repo.list_and_count(LimitOffset(limit=10, offset=0), name="Cody")
      print(f"Selected {len(created_objs)} records out of a total of {total_objs}.")

      
      deleted_objs = repo.delete_many([new_obj.id for new_obj in created_objs])
      print(f"Removed {len(deleted_objs)} records out of a total of {total_objs}.")

      
      remaining_count = repo.count()
      print(f"Found {remaining_count} remaining records after delete.")
  ```

  </details>

  For a full standalone example, see the sample [here][standalone-example]



  Advanced Alchemy includes an additional service class to make working with a repository easier.
  This class is designed to accept data as a dictionary or SQLAlchemy model,
  and it will handle the type conversions for you.
  <!-- markdownlint-disable -->
  <details>
  <summary>Here's the same example from above but using a service to create the data:</summary>
  <!-- markdownlint-restore -->

  ```python
  from advanced_alchemy.base import UUIDBase
  from advanced_alchemy.filters import LimitOffset
  from advanced_alchemy import SQLAlchemySyncRepository, SQLAlchemySyncRepositoryService
  from sqlalchemy import create_engine
  from sqlalchemy.orm import Mapped, sessionmaker


  class User(UUIDBase):
      
      __tablename__ = "user_account"  # type: ignore[assignment]
      email: Mapped[str]
      name: Mapped[str]


  class UserRepository(SQLAlchemySyncRepository[User]):
      """User repository."""

      model_type = User


  class UserService(SQLAlchemySyncRepositoryService[User]):
      """User repository."""

      repository_type = UserRepository



  engine = create_engine("duckdb:///:memory:")
  session_factory = sessionmaker(engine, expire_on_commit=False)


  with engine.begin() as conn:
      User.metadata.create_all(conn)

  with session_factory() as db_session:
      service = UserService(session=db_session)
      
      objs = service.create_many([
          {"email": 'cody@litestar.dev', 'name': 'Cody'},
          {"email": 'janek@litestar.dev', 'name': 'Janek'},
          {"email": 'peter@litestar.dev', 'name': 'Peter'},
          {"email": 'jacob@litestar.dev', 'name': 'Jacob'}
      ])
      print(objs)
      print(f"Created {len(objs)} new objects.")

      
      created_objs, total_objs = service.list_and_count(LimitOffset(limit=10, offset=0), name="Cody")
      print(f"Selected {len(created_objs)} records out of a total of {total_objs}.")

      
      deleted_objs = service.delete_many([new_obj.id for new_obj in created_objs])
      print(f"Removed {len(deleted_objs)} records out of a total of {total_objs}.")

      
      remaining_count = service.count()
      print(f"Found {remaining_count} remaining records after delete.")
  ```

  </details>



  Advanced Alchemy works with nearly all Python web frameworks.
  Several helpers for popular libraries are included, and additional PRs to support others are welcomed.



  Advanced Alchemy is the official SQLAlchemy integration for Litestar.

  In addition to installing with `pip install advanced-alchemy`,
  it can also be installed as a Litestar extra with `pip install litestar[sqlalchemy]`.

  <!-- markdownlint-disable -->
  <details>
  <summary>Litestar Example</summary>
  <!-- markdownlint-restore -->

  ```python
  from litestar import Litestar
  from litestar.plugins.sqlalchemy import SQLAlchemyPlugin, SQLAlchemyAsyncConfig




  alchemy = SQLAlchemyPlugin(
    config=SQLAlchemyAsyncConfig(connection_string="sqlite+aiosqlite:///test.sqlite"),
  )
  app = Litestar(plugins=[alchemy])
  ```

  </details>

  For a full Litestar example, check [here][litestar-example]



  <!-- markdownlint-disable -->
  <details>
  <summary>FastAPI Example</summary>
  <!-- markdownlint-restore -->

  ```python
  from fastapi import FastAPI

  from advanced_alchemy.config import SQLAlchemyAsyncConfig
  from advanced_alchemy.extensions.starlette import StarletteAdvancedAlchemy

  app = FastAPI()
  alchemy = StarletteAdvancedAlchemy(
      config=SQLAlchemyAsyncConfig(connection_string="sqlite+aiosqlite:///test.sqlite"), app=app,
  )
  ```

  </details>

  For a full FastAPI example, see [here][fastapi-example]



  <!-- markdownlint-disable -->
  <details>
  <summary>Pre-built Example Apps</summary>
  <!-- markdownlint-restore -->

  ```python
  from starlette.applications import Starlette

  from advanced_alchemy.config import SQLAlchemyAsyncConfig
  from advanced_alchemy.extensions.starlette import StarletteAdvancedAlchemy

  app = Starlette()
  alchemy = StarletteAdvancedAlchemy(
      config=SQLAlchemyAsyncConfig(connection_string="sqlite+aiosqlite:///test.sqlite"), app=app,
  )
  ```

  </details>



  <!-- markdownlint-disable -->
  <details>
  <summary>Pre-built Example Apps</summary>
  <!-- markdownlint-restore -->

  ```python
  from sanic import Sanic
  from sanic_ext import Extend

  from advanced_alchemy.config import SQLAlchemyAsyncConfig
  from advanced_alchemy.extensions.sanic import SanicAdvancedAlchemy

  app = Sanic("AlchemySanicApp")
  alchemy = SanicAdvancedAlchemy(
      sqlalchemy_config=SQLAlchemyAsyncConfig(connection_string="sqlite+aiosqlite:///test.sqlite"),
  )
  Extend.register(alchemy)
  ```

  </details>



  All [Litestar Organization][litestar-org] projects will always be a community-centered, available for contributions of any size.

  Before contributing, please review the [contribution guide][contributing].

  If you have any questions, reach out to us on [Discord][discord], our org-wide [GitHub discussions][litestar-discussions] page,
  or the [project-specific GitHub discussions page][project-discussions].

  <!-- markdownlint-disable -->
  <hr />
  <p align="center">
    <!-- github-banner-start -->
    <img src="https://raw.githubusercontent.com/litestar-org/branding/main/assets/Branding%20-%20SVG%20-%20Transparent/Organization%20Project%20-%20Banner%20-%20Inline%20-%20Dark.svg" alt="Litestar Logo - Light" width="40%" height="auto" />
    <br>An official <a href="https://github.com/litestar-org">Litestar Organization</a> Project
    <!-- github-banner-end -->
  </p>

  [litestar-org]: https://github.com/litestar-org
  [contributing]: https://docs.advanced-alchemy.litestar.dev/latest/contribution-guide.html
  [discord]: https://discord.gg/litestar
  [litestar-discussions]: https://github.com/orgs/litestar-org/discussions
  [project-discussions]: https://github.com/litestar-org/advanced-alchemy/discussions
  [project-docs]: https://docs.advanced-alchemy.litestar.dev
  [install-guide]: https://docs.advanced-alchemy.litestar.dev/latest/#installation
  [fastapi-example]: https://github.com/litestar-org/advanced-alchemy/blob/main/examples/fastapi.py
  [litestar-example]: https://github.com/litestar-org/advanced-alchemy/blob/main/examples/litestar.py
  [standalone-example]: https://github.com/litestar-org/advanced-alchemy/blob/main/examples/standalone.py


pkgId: 4cfbe0661518e5aab98c2ce85795624690e04a3f51a845a7857cab96645fdd2a
name: python-advanced-descriptors
arch: src
version: 4.0.3
epoch: 0
release: 1
summary: Advanced descriptors for special cases.
url: https://pypi.org/project/advanced-descriptors/
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-advanced-descriptors-4.0.3-1.src.rpm
checksum_type: sha256
description:
  This package includes helpers for special cases:
  * `SeparateClassMethod` - allow to have classmethod and normal method both with the same name.
  * `AdvancedProperty` - property with possibility to set class wide getter.
  * `LogOnAccess` - property with logging on successful get/set/delete or failure.


pkgId: 3439080cdfceb6d237901e56a95b2399643970efb27db64c72383bb24d3a7564
name: python-advanced-ssh-config
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Add some magic to SSH and .ssh/config
url: https://github.com/moul/advanced-ssh-config
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-advanced-ssh-config-1.1.0-1.src.rpm
checksum_type: sha256
description:
  |Travis| |PyPI version| |PyPI downloads| |License| |Requires.io|
  |Gitter|
  |ASSH logo - Advanced SSH Config logo|
  Enhances ``ssh_config`` file capabilities
  **NOTE**: This program is called by
  `ProxyCommand <http://en.wikibooks.org/wiki/OpenSSH/Cookbook/Proxies_and_Jump_Hosts#ProxyCommand_with_Netcat>`__


pkgId: 85e7c95078e5af98ac6e4b5163bcd8f983bd8dfa91617c60e81faed1d3b167b6
name: python-advanced-ta
arch: src
version: 0.1.8
epoch: 0
release: 1
summary: Python implementation of Lorentzian Classification algorithm.
url: https://bitbucket.org/lokiarya/advanced-ta
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-advanced-ta-0.1.8-1.src.rpm
checksum_type: sha256
description:
  This module is a python implementation of Lorentzian Classification algorithm developed by @jdehorty in pinescript. The original work can be found here - https://www.tradingview.com/script/WhBzgfDu-Machine-Learning-Lorentzian-Classification/



  At the most simplest, you can just do this:
  ```python
  from advanced_ta import LorentzianClassification
  .
  .
      
      lc = LorentzianClassification(df)
      lc.dump('output/result.csv')
      lc.plot('output/result.jpg')
  .
  .
  ```

  For advanced use, you can do:
  ```python
  from advanced_ta import LorentzianClassification
  from ta.volume import money_flow_index as MFI
  .
  .
      
      lc = LorentzianClassification(
          df,
          features=[
              LorentzianClassification.Feature("RSI", 14, 2),  # f1
              LorentzianClassification.Feature("WT", 10, 11),  # f2
              LorentzianClassification.Feature("CCI", 20, 2),  # f3
              LorentzianClassification.Feature("ADX", 20, 2),  # f4
              LorentzianClassification.Feature("RSI", 9, 2),   # f5
              MFI(df['open'], df['high'], df['low'], df['close'], df['volume'], 14) #f6
          ],
          settings=LorentzianClassification.Settings(
              source='close',
              neighborsCount=8,
              maxBarsBack=2000,
              useDynamicExits=False
          ),
          filterSettings=LorentzianClassification.FilterSettings(
              useVolatilityFilter=True,
              useRegimeFilter=True,
              useAdxFilter=False,
              regimeThreshold=-0.1,
              adxThreshold=20,
              kernelFilter = LorentzianClassification.KernelFilter(
                  useKernelSmoothing = False
                  lookbackWindow = 8
                  relativeWeight = 8.0
                  regressionLevel = 25
                  crossoverLag = 2
              )
          ))
      lc.dump('output/result.csv')
      lc.plot('output/result.jpg')
  .
  .
  ```





  ![generated](https://bitbucket.org/lokiarya/advanced-ta/raw/c8e21204e4c6a7009141c379ec32cd05ac2d49b6/sample.jpg "Sample Generated By Library")



  ![reference](https://bitbucket.org/lokiarya/advanced-ta/raw/c8e21204e4c6a7009141c379ec32cd05ac2d49b6/reference.png "TradingView Result For Indentical Settings")




  - Replacing dependency on [TA-Lib](https://pypi.org/project/TA-Lib/) with [ta](https://pypi.org/project/ta/) to simplify setup


pkgId: 3fb2a0ae74d569b0952dccb93fc213855be0918fa079c051dfd8395a7e416d9b
name: python-advantage-air
arch: src
version: 0.4.4
epoch: 0
release: 1
summary: API helper for Advantage Air's MyAir and e-zone API
url: https://github.com/Bre77/advantage_air
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-advantage-air-0.4.4-1.src.rpm
checksum_type: sha256
description:
  Advantage Air API Wrapper



  Returns the current state of all components.

  > async_get()



  Change attributes by sending the updated values to the relevant endpoint.



  Update values on the AC system



  Update values on a specific zone



  Update the state of a light. off|false = off, on|true = on



  Update the brightness of a light, and assumes 0 is off.



  Update the value of a thing. 0|false = off, 100|true = on



  Directly update with data to the endpoint.



  ```{.python}
  import asyncio
  import aiohttp
  from advantage_air import advantage_air


  async def main():
      async with aiohttp.ClientSession() as session:
          aa = advantage_air("192.168.1.24", port=2025, session=session, retry=5)
          if data := await aa.async_get(1):
              print(data)
              aa.aircon.async_update_ac("ac1",{"state": "on"})
              await asyncio.gather(
                  aa.aircon.async_update_zone("ac1","z01", {"value": 25}),
                  aa.aircon.async_update_zone("ac1","z02", {"value": 50}),
              )

  asyncio.run(main())
  ```


pkgId: 74632c7c41e27749a64d384100b930806932933399480df0bda5237d56ac910f
name: python-advent-of-code-data
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Get your puzzle data with a single import
url: https://github.com/wimglenn/advent-of-code-data
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-advent-of-code-data-2.0.1-1.src.rpm
checksum_type: sha256
description:
  |pyversions|_ |pypi|_ |womm|_ |actions|_ |codecov|_
  Speedhackers, get your puzzle data with a single import statement:
     from aocd import data
  If that sounds too magical, use a simple function call to return your data in a string:
     >>> from aocd import get_data
     >>> get_data(day=24, year=2015)
     '1\n2\n3\n7\n11\n13\n17\n19\n23\n31...
  If you'd just like to print or keep your own raw input files, there's a script for that:
     aocd > input.txt  # saves today's data
     aocd 13 2018 > day13.txt  # save some other day's data
  Note that ``aocd`` will cache puzzle inputs and answers (including incorrect guesses) clientside, to save unnecessary requests to the server.
  *New in version 2.0.0:* Get the example data (and corresponding answers). From `2022 day 5 <https://adventofcode.com/2022/day/5>`_ there was:


pkgId: 0d0dd8f51efb9d56aad378611f4e3e5e8e3566817d5add7ab5000457c50034db
name: python-advent-of-code-hhoppe
arch: src
version: 1.0.7
epoch: 0
release: 1
summary: Library for Advent of Code -- Hugues Hoppe.
url: https://pypi.org/project/advent-of-code-hhoppe/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-advent-of-code-hhoppe-1.0.7-1.src.rpm
checksum_type: sha256
description:
  Python library to process Advent-of-Code puzzles in a Jupyter notebook.
  See [a complete example](https://colab.research.google.com/github/hhoppe/advent_of_code_2021/blob/main/advent_of_code_2021.ipynb).

  Usage summary:

  - The **preamble** optionally specifies reference inputs and answers for the puzzles:
    ```
      BASE_URL = 'https://github.com/hhoppe/advent_of_code_2021/blob/main/data/google.Hugues_Hoppe.965276/'
      INPUT_URL = BASE_URL + '2021_{day:02}_input.txt'
      ANSWER_URL = BASE_URL + '2021_{day:02}{part_letter}_answer.txt'
      advent = advent_of_code_hhoppe.Advent(
          year=2021, input_url=INPUT_URL, answer_url=ANSWER_URL)
    ```


  - For **each day** (numbered 1..25), the first notebook cell defines a `puzzle` object:

    ```
      puzzle = advent.puzzle(day=1)
    ```
    The puzzle input string is automatically read into the attribute `puzzle.input`.
    This input string is unique to each Advent participant.

    For each of the two puzzle parts, a function (e.g. `process1`) takes an input string and returns a string or integer answer.
    Using calls like the following, we time the execution of each function and verify the answers:
    ```
      puzzle.verify(part=1, func=process1)
      puzzle.verify(part=2, func=process2)
    ```

  - At the end of the notebook, a table summarizes **timing** results.



  - The puzzle inputs and answers can be more efficiently downloaded using a single ZIP file:
    ```
      PROFILE = 'google.Hugues_Hoppe.965276'
      ZIP_URL = f'https://github.com/hhoppe/advent_of_code_2021/raw/main/data/{PROFILE}.zip'
      !if [[ ! -d {PROFILE} ]]; then wget -q {ZIP_URL} && unzip -q {PROFILE}; fi
      INPUT_URL = f'{PROFILE}/{{year}}_{{day:02d}}_input.txt'
      ANSWER_URL = f'{PROFILE}/{{year}}_{{day:02d}}{{part_letter}}_answer.txt'
      advent = advent_of_code_hhoppe.Advent(
          year=2021, input_url=INPUT_URL, answer_url=ANSWER_URL)
    ```

  - The puzzle inputs and answers can be obtained  directly from adventofcode.com using a web-browser session cookie and the `advent-of-code-data` PyPI package:

    ```
      !pip install -q advent-of-code-data
      import aocd
      
      mkdir -p ~/.config/aocd && echo 53616... >~/.config/aocd/token
      advent = advent_of_code_hhoppe.Advent(year=2021)
    ```


pkgId: 9e71fae01ab409fc6fd4a17fb37082fe82129b4e708f962d077346ac13f841bc
name: python-adversarial-insight-ml
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/adversarial-insight-ml/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adversarial-insight-ml-0.2.2-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://uoa-compsci399-s2-2023.github.io/capstone-project-team-7/">
      <img
        src="./images/logo.png"
        alt="AIML Logo"
        style="
          width: 418px;
          height: 418px;
          max-width: 100%;
          height: auto;
        "
      >
    </a>
  </p>

  <h2 align="center">Adversarial Insight ML (AIML)</h2>

  <p align="center">
    <a href="https://pypi.org/project/adversarial-insight-ml/">
      <img src="https://badge.fury.io/py/adversarial-insight-ml.svg" alt="PyPI version" />
    </a>
   <a href="https://www.python.org/downloads/">
      <img src="https://img.shields.io/badge/python-3.9-blue.svg" alt="Python version" />
    </a>
    <a href="https://opensource.org/licenses/MIT">
      <img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License"
    </a>
    <a href="https://github.com/psf/black">
      <img src="https://img.shields.io/badge/code%20style-black-000000.svg" alt="Code style" />
    </a>
    <a href="https://uoa-compsci399-s2-2023.github.io/capstone-project-team-7/">
      <img src="https://img.shields.io/badge/Documentation-Click%20Here-blue.svg" alt="Documentation" />
    </a>
  </p>

  > “Why does your machine lie?”

  Adversarial Insight ML (AIML) is a python package that evaluates the robustness of image classification models against adversarial attacks. AIML provides the functionality to automatically test your models against generated adversarial examples and outputs precise, insightful and robust feedback based on the several attack methods we have carefully chosen. Furthermore, AIML aims to be straightforward and beginner-friendly to allow non-technical users to take full advantage of its functionalities.

  For more information, you can also visit the [PyPI page](https://pypi.org/project/adversarial-insight-ml/) and the [documentation page](https://uoa-compsci399-s2-2023.github.io/capstone-project-team-7/).



  - [Installation](#installation)
  - [Usage](#usage)
  - [Features](#features)
  - [Contributing](#contributing)
  - [License](#license)



  To install Adversarial Insight ML, you can use pip:

  ```bash
  pip install adversarial-insight-ml
  ```



  Here's a simple overview of the usage of our package:
  <p align="center">
    <img src="images/workflow_overview.png" alt="img overview" width="390" height="360" align="center">
  </p>

  You can evaluate your model with the `evaluate()` function:

  ```python
  from aiml.evaluation.evaluate import evaluate

  evaluate(model, test_dataset)
  ```

  The `evaluate()` function has **two required parameters**:
  - `input_model (str or model)`: A string of the name of the machine learning model or the machine learning model itself.
  - `input_test_data (str or dataset)`: A string of the name of the testing dataset or the testing dataset itself.

  The `evaluate()` function has the following **optional parameters**:
  - `input_train_data (str or dataset, optional)`: A string of the name of the training dataset or the training dataset itself (default is None).
  - `input_shape (tuple, optional)`: Shape of input data (default is None).
  - `clip_values (tuple, optional)`: Range of input data values (default is None).
  - `nb_classes (int, optional)`: Number of classes in the dataset (default is None).
  - `batch_size_attack (int, optional)`: Batch size for attack testing (default is 64).
  - `num_threads_attack (int, optional)`: Number of threads for attack testing (default is 0).
  - `batch_size_train (int, optional)`: Batch size for training data (default is 64).
  - `batch_size_test (int, optional)`: Batch size for test data (default is 64).
  - `num_workers (int, optional)`: Number of workers to use for data loading (default is half of the available CPU cores).
  - `dry (bool, optional)`: When True, the code should only test one example.
  - `attack_para_list (list, optional)`: List of parameter combinations for the attack.

  See the demos in `examples/` directory for usage in action:
  - [demo_basic](examples/demo_basic.ipynb)
  - [demo_huggingface](examples/demo_huggingface.ipynb)
  - [demo_robustbench](examples/demo_robustbench.ipynb)



  After evaluating your model with `evaluate()` function, we provide
  the following insights:

  - Summary of adversarial attacks performed, found in a text file named `attack_evaluation_result.txt` followed by date. For example:
    ![Result Example](images/evaluation_example.png)
  - Samples of the images can be found in a directory `img/` followed by date, for example:
    <p align="center">
      <img src="images/img_overview.png" alt="img overview" width="300" height="200" align="center">
      <img src="images/image_sample.png" alt="sample image" width="200" height="100" align="center">
    </p>





  **Code Style**
  Always adhere to the [PEP 8](https://www.python.org/dev/peps/pep-0008/) style guide for writing Python code, allowing upto 99 characters per line as the absolute maximum. Alternatively, just use [black](https://github.com/psf/black).

  **Commit Messages**
  When making changes to the codebase, please refer to the [Documentation/SubmittingPatches](https://git.kernel.org/pub/scm/git/git.git/tree/Documentation/SubmittingPatches?h=v2.36.1#n181) in the Git repo:

  - Write commit messages in present tense and imperative mood, e.g., "Add feature" instead of "Added feature" or "Adding feature."
  - Craft your messages as if you're giving orders to the codebase to change its behaviour.

  **Branching**
  We conform to a variation of the "GitHub Flow'' convention, but not strictly. For example, see the following types of branches:

  - main: This branch is always deployable and reflects the production state.
  - bugfix/\*: For bug fixes.



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



  We extend our sincere appreciation to the following individuals who have been instrumental in the success of this project:

  Firstly, our client Mr. Luke Chang. His invaluable guidance and insights guided us from the beginning through every phase, ensuring our work remained aligned with practical needs. This project would not have been possible without his efforts.

  We'd also like to express our gratitude to Dr. Asma Shakil, who has coordinated and provided an opportunity for us to work together on this project.

  Thank you for being part of this journey.

  Warm regards,
  Team 7



  Sungjae Jang sjan260@aucklanduni.ac.nz
  Takuya Saegusa tsae032@aucklanduni.ac.nz
  Haozhe Wei hwei313@aucklanduni.ac.nz
  Yuming Zhou yzho739@aucklanduni.ac.nz
  Terence Zhang tzha820@aucklanduni.ac.nz

rpm_license:
  MIT License  Copyright (c) 2023 Team 7  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: 5446027ea95e4b9140ce9ee992394cc4a629fc2dd5752692f732b128cf2f9731
name: python-adversarial-robustness-toolbox
arch: src
version: 1.18.2
epoch: 0
release: 1
summary: Toolbox for adversarial machine learning.
url: https://github.com/Trusted-AI/adversarial-robustness-toolbox
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adversarial-robustness-toolbox-1.18.2-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="docs/images/art_lfai.png?raw=true" width="467" title="ART logo">
  </p>
  <br />

  ![CodeQL](https://github.com/Trusted-AI/adversarial-robustness-toolbox/workflows/CodeQL/badge.svg)
  [![Documentation Status](https://readthedocs.org/projects/adversarial-robustness-toolbox/badge/?version=latest)](http://adversarial-robustness-toolbox.readthedocs.io/en/latest/?badge=latest)
  [![PyPI](https://badge.fury.io/py/adversarial-robustness-toolbox.svg)](https://badge.fury.io/py/adversarial-robustness-toolbox)
  [![codecov](https://codecov.io/gh/Trusted-AI/adversarial-robustness-toolbox/branch/main/graph/badge.svg)](https://codecov.io/gh/Trusted-AI/adversarial-robustness-toolbox)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/adversarial-robustness-toolbox)](https://pypi.org/project/adversarial-robustness-toolbox/)
  [![slack-img](https://img.shields.io/badge/chat-on%20slack-yellow.svg)](https://ibm-art.slack.com/)
  [![Downloads](https://static.pepy.tech/badge/adversarial-robustness-toolbox)](https://pepy.tech/project/adversarial-robustness-toolbox)
  [![Downloads](https://static.pepy.tech/badge/adversarial-robustness-toolbox/month)](https://pepy.tech/project/adversarial-robustness-toolbox)
  [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/5090/badge)](https://bestpractices.coreinfrastructure.org/projects/5090)

  [中文README请按此处](README-cn.md)

  <p align="center">
    <img src="https://raw.githubusercontent.com/lfai/artwork/master/lfaidata-assets/lfaidata-project-badge/graduate/color/lfaidata-project-badge-graduate-color.png" alt="LF AI & Data" width="300"/>
  </p>

  Adversarial Robustness Toolbox (ART) is a Python library for Machine Learning Security. ART is hosted by the
  [Linux Foundation AI & Data Foundation](https://lfaidata.foundation) (LF AI & Data). ART provides tools that enable
  developers and researchers to defend and evaluate Machine Learning models and applications against the
  adversarial threats of Evasion, Poisoning, Extraction, and Inference. ART supports all popular machine learning frameworks
  (TensorFlow, Keras, PyTorch, MXNet, scikit-learn, XGBoost, LightGBM, CatBoost, GPy, etc.), all data types
  (images, tables, audio, video, etc.) and machine learning tasks (classification, object detection, speech recognition,
  generation, certification, etc.).



  <p align="center">
    <img src="docs/images/adversarial_threats_attacker.png?raw=true" width="400" title="ART logo">
    <img src="docs/images/adversarial_threats_art.png?raw=true" width="400" title="ART logo">
  </p>
  <br />



  <p align="center">
    <img src="docs/images/white_hat_blue_red.png?raw=true" width="800" title="ART Red and Blue Teams">
  </p>
  <br />



  | **[Get Started][get-started]**     | **[Documentation][documentation]**     | **[Contributing][contributing]**           |
  |-------------------------------------|-------------------------------|-----------------------------------|
  | - [Installation][installation]<br>- [Examples](examples/README.md)<br>- [Notebooks](notebooks/README.md) | - [Attacks][attacks]<br>- [Defences][defences]<br>- [Estimators][estimators]<br>- [Metrics][metrics]<br>- [Technical Documentation](https://adversarial-robustness-toolbox.readthedocs.io) | - [Slack](https://ibm-art.slack.com), [Invitation](https://join.slack.com/t/ibm-art/shared_invite/enQtMzkyOTkyODE4NzM4LTA4NGQ1OTMxMzFmY2Q1MzE1NWI2MmEzN2FjNGNjOGVlODVkZDE0MjA1NTA4OGVkMjVkNmQ4MTY1NmMyOGM5YTg)<br>- [Contributing](CONTRIBUTING.md)<br>- [Roadmap][roadmap]<br>- [Citing][citing] |

  [get-started]: https://github.com/Trusted-AI/adversarial-robustness-toolbox/wiki/Get-Started
  [attacks]: https://github.com/Trusted-AI/adversarial-robustness-toolbox/wiki/ART-Attacks
  [defences]: https://github.com/Trusted-AI/adversarial-robustness-toolbox/wiki/ART-Defences
  [estimators]: https://github.com/Trusted-AI/adversarial-robustness-toolbox/wiki/ART-Estimators
  [metrics]: https://github.com/Trusted-AI/adversarial-robustness-toolbox/wiki/ART-Metrics
  [contributing]: https://github.com/Trusted-AI/adversarial-robustness-toolbox/wiki/Contributing
  [documentation]: https://github.com/Trusted-AI/adversarial-robustness-toolbox/wiki/Documentation
  [installation]: https://github.com/Trusted-AI/adversarial-robustness-toolbox/wiki/Get-Started#setup
  [roadmap]: https://github.com/Trusted-AI/adversarial-robustness-toolbox/wiki/Roadmap
  [citing]: https://github.com/Trusted-AI/adversarial-robustness-toolbox/wiki/Contributing#citing-art

  The library is under continuous development. Feedback, bug reports and contributions are very welcome!


  This material is partially based upon work supported by the Defense Advanced Research Projects Agency (DARPA) under
  Contract No. HR001120C0013. Any opinions, findings and conclusions or recommendations expressed in this material are
  those of the author(s) and do not necessarily reflect the views of the Defense Advanced Research Projects Agency (DARPA).


pkgId: 5c75e738a76d113407209619e97597021bb3f414b9c0d98e610910dfcea89522
name: python-adversarial-vision-challenge
arch: src
version: 1.0.5
epoch: 0
release: 1
url: https://github.com/bethgelab/adversarial-vision-challenge
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adversarial-vision-challenge-1.0.5-1.src.rpm
checksum_type: sha256
summary:
  Tools for the NIPS Adversarial Vision Challenge. Includes an HTTP server and client that provides access to Foolbox models and attacks.


pkgId: a33b16e91cc054631faa87aac72e9c0b8727431e5fdea53ec6dfc46b7d6c0c0d
name: python-advertools
arch: src
version: 0.16.1
epoch: 0
release: 1
summary: Productivity and analysis tools for online marketing
url: https://github.com/eliasdabbas/advertools
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-advertools-0.16.1-1.src.rpm
checksum_type: sha256
description:
  | A digital marketer is a data scientist.
  | Your job is to manage, manipulate, visualize, communicate, understand,
    and make decisions based on data.
  You might be doing basic stuff, like copying and pasting text on spread
  sheets, you might be running large scale automated platforms with
  sophisticated algorithms, or somewhere in between. In any case your job
  is all about working with data.
  As a data scientist you don't spend most of your time producing cool
  visualizations or finding great insights. The majority of your time is spent
  wrangling with URLs, figuring out how to stitch together two tables, hoping
  that the dates, won't break, without you knowing, or trying to generate the
  next 124,538 keywords for an upcoming campaign, by the end of the week!
  ``advertools`` is a Python package that can hopefully make that part of your job a little easier.


pkgId: d4b9ef0ac3641f12c165e97d98b7febad61c62cb90bbbefc88cf7b7d238c6f9e
name: python-advice-animal
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Suggests incremental improvements for existing projects
url: https://github.com/advice-animal/advice-animal/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-advice-animal-0.4.1-1.src.rpm
checksum_type: sha256
description:
  Advice Animal answers the question of what do we do _after_ running
  cookiecutter, or how to we avoid telling people we support to run a `sed` script.



  Existing projects such as [cookiecutter](https://cookiecutter.readthedocs.io/en/stable/) do a pretty
  solid job of initial project generation, and ones such as [ruff](https://astral.sh/ruff),
  [fixit](https://github.com/instagram/fixit), and [pyupgrade](https://github.com/asottile/pyupgrade/)
  do a solid job of suggesting universal (that is, applicable to everyone) changes.



  Advice Animal is developed to serve a central team that has opinions, but wants to leave the
  application of that advice up to teams owning individual repos that have the interest and time to
  apply it.

  * The storage of fixes is decoupled from the release of the thing that runs them.
    * It's just a git repo, which gets pulled on each run.
    * But can also be a directory, if you want to manage distribution with puppet or your monorepo or
      are working on proposed changes.
  * Fixes are run with a trivial workflow engine.
    * Creates a branch-per-fix with git.
    * Expensive fixes can record that they're done, to avoid running again
    * Fixes can be manual (think "feature add")
    * Your fix repo can customize workflow, including branch naming and commands that get run (say you
      have a FUSE/mercurial setup or need to run `tox -e stylefix` and amend).
  * Your users choose what fixes they want (either by quality=their available time), or by declining a fix.
  * Third-party libraries are easy to use in your fixes, and they don't even need to be public.



  Using traffic light colors for simplicity:

  * `FixConfidence.GREEN` are high-confidence fixes that a) something is wrong and b) this won't make it
  worse (think, formatting).  Trust your tests and land these.

  * `FixConfidence.YELLOW` ought to have human review (and definitely make sure the tests run), but are
  low-effort to apply (think, renaming python modules that have uppercase in them, or bumping a
  version to avoid a known CVE).  Meets the bar for a passing mention in release notes.

  * `FixConfidence.RED` likely need a human to pick up the baton and finish it (think: you clearly use
  types, you probably should enable mypy in CI).




  Usage of this library should work back to 3.7, but development (and mypy
  compatibility) only on 3.10-3.12.  Linting requires 3.12 for full fidelity.



  This library follows [meanver](https://meanver.org/) which basically means
  [semver](https://semver.org/) along with a promise to rename when the major
  version changes.



  advice-animal is copyright [Tim Hatch](https://timhatch.com/), and licensed under
  the MIT license.  See the `LICENSE` file for details.


pkgId: d7b6785f08bd9425ab203a664942af7ece10df187c18b954d6dfbb54873859cb
name: python-advisory-parser
arch: src
version: 1.13
epoch: 0
release: 1
summary: Security flaw parser for upstream security advisories
url: https://github.com/RedHatProductSecurity/advisory-parser
rpm_license: LGPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-advisory-parser-1.13-1.src.rpm
checksum_type: sha256
description:
  This library allows you to parse data from security advisories of certain
  projects to extract information about security issues. The parsed
  information includes metadata such as impact, CVSS score, summary,
  description, and others; for a full list, see the
  ``advisory_parser/flaw.py`` file.
  **DISCLAIMER**: Much of the advisory parsing is fairly fragile. Because web
  pages change all the time, it is not uncommon for parsers to break when a
  page is changed in some way. Also, the advisory parsers only work with the
  latest version of the advisory pages.
  The need for parsing raw security advisories in this way could be avoided
  if vendors provided their security pages in a machine readable (and
  preferably standardized) format. An example of this would be Red Hat's
  security advisories that can be pulled in from a separate Security Data API
  (`RHSA-2016:1883.json <https://access.redhat.com/labs/securitydataapi/cvrf/RHSA-2016:1883.json>`_)
  or downloaded as an XML file
  (`cvrf-rhsa-2016-1883.xml <https://www.redhat.com/security/data/cvrf/2016/cvrf-rhsa-2016-1883.xml>`_),
  or OpenSSL's list of issues available in XML
  (`vulnerabilities.xml <https://www.openssl.org/news/vulnerabilities.xml>`_).
  If you are a vendor or an upstream project owner interested in providing
  your security advisories in a machine readable format and don't know where
  to start, feel free to reach out to mprpic@redhat.com.
  Currently available parsers include:
      "Google Chrome", `<https://chromereleases.googleblog.com/2017/06/stable-channel-update-for-desktop_15.html>`_
      "Adobe Flash", `<https://helpx.adobe.com/security/products/flash-player/apsb17-17.html>`_
      "Jenkins", `<https://www.jenkins.io/security/advisory/2023-04-12>`_
      "MySQL", `<http://www.oracle.com/technetwork/security-advisory/cpujul2017verbose-3236625.html>`_
      "phpMyAdmin", ""
      "Wireshark", ""


pkgId: 2ac9716286e45b2964984c788a133806cbfc1fffd5544738a74e550ab2eb5f7a
name: python-advocate
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: A wrapper around the requests library for safely making HTTP requests on behalf of a third party
url: https://github.com/JordanMilne/Advocate
rpm_license: Apache 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-advocate-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Advocate is a set of tools based around the `requests library <https://github.com/kennethreitz/requests>`_ for safely making
  HTTP requests on behalf of a third party. Specifically, it aims to prevent
  common techniques that enable `SSRF attacks <https://cwe.mitre.org/data/definitions/918.html>`_.
  Advocate was inspired by `fin1te's SafeCurl project <https://github.com/fin1te/safecurl>`_.


pkgId: 13c01155535f38d5c1ee3a716ab6cde2c92f2398b24c09397b5b706d802260cb
name: python-adzerk-decision-sdk
arch: src
version: 1.0.0b15
epoch: 0
release: 1
summary: Adzerk Decision SDK
url: https://github.com/adzerk/adzerk-decision-sdk-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-adzerk-decision-sdk-1.0.0b15-1.src.rpm
checksum_type: sha256
description:
      Adzerk Decision SDK
      Python Software Development Kit for Adzerk Decision & UserDB APIs
      https://github.com/adzerk/adzerk-decision-sdk-python


pkgId: 7ff7eacd1588845a0895c2cbbabfdb82905b1e5e62311304d398b5b7be791528
name: python-aec-cli
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: AWS EC2 CLI
url: https://pypi.org/project/aec-cli/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aec-cli-3.1.0-1.src.rpm
checksum_type: sha256
description:
  [![Build](https://github.com/seek-oss/aec/actions/workflows/ci.yml/badge.svg)](https://github.com/seek-oss/aec/actions/workflows/ci.yml)
  [![Release](https://github.com/seek-oss/aec/actions/workflows/release.yml/badge.svg)](https://github.com/seek-oss/aec/actions/workflows/release.yml)
  [![PyPI version](https://badge.fury.io/py/aec-cli.svg)](https://pypi.org/project/aec-cli/)

  _"Instead of using the console, use the cli!"_.

  Command-line tools for managing pet EC2 instances by name.

  Defaults only need to be supplied once via a [config file](src/aec/config-example/ec2.toml), which supports multiple profiles for different regions or AWS accounts.

  For examples see:

  - [EC2](docs/ec2.md) - manipulate EC2 instances by name, and launch them with tags and EBS volumes of any size, as per the settings in the configuration file (subnet, security group etc).
  - [AMI](docs/ami.md) - describe, delete and share images
  - [Compute Optimizer](docs/compute-optimizer.md) - show over-provisioned instances
  - [SSM](docs/ssm.md) - run commands on instances, and [ssm patch management](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-patch.html)



  - python 3.8+



  Run the following to install the latest master version using pip:

  ```
  pip install aec-cli
  ```

  If you have previously installed aec, run the following to upgrade to the latest version:

  ```
  pip install --upgrade aec-cli
  ```

  NB: Consider using [pipx](https://github.com/pipxproject/pipx) to install aec-cli into its own isolated virtualenv.



  Before you can use aec, you will need to create the config files in `~/.aec/`. The config files contain settings for your AWS account including VPC details and additional tagging requirements.

  To get started, run `aec configure example` to install the [example config files](src/aec/config-example/) and then update them as needed.



  For even faster access to aec subcommands, you may like to add the following aliases to your .bashrc:

  ```
  alias ec2='COLUMNS=$COLUMNS aec ec2'
  alias ami='COLUMNS=$COLUMNS aec ami'
  alias ssm='COLUMNS=$COLUMNS aec ssm'
  ```

  `COLUMNS=$COLUMNS` will ensure output is formatted to the width of your terminal when piped.





  To use aec with the named profile 'production':

  ```
  export AWS_DEFAULT_PROFILE=production
  aec ec2 describe
  ```



  [wallix/awless](https://github.com/wallix/awless) is written in Go, and is an excellent substitute for awscli with
  support for many AWS services. It has human friendly commands for use on the command line or in templates. Unlike `aec` its ec2 create instance command doesn't allow you to specify the EBS volume size, or add tags.

  [achiku/jungle](https://github.com/achiku/jungle) is written in Python, and incorporates a smaller subset of ec2 commands and doesn't launch new instances. It does however have an ec2 ssh command. It also supports other AWS services like ELB, EMR, RDS.



  See [CONTRIBUTING.md](CONTRIBUTING.md) to get started and develop in this repo.

rpm_license:
  MIT License  Copyright (c) 2019 SEEK  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: 520cbba946f89414bde45b50a54da89fe7353e8dc2a1a8566b24fcc91fde91e7
name: python-aecdata
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: A Python library designed to simplify access to the 2050-materials API
url: https://github.com/2050-Materials/aecdata
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aecdata-0.0.8-1.src.rpm
checksum_type: sha256
description:
  AECData is a Python library designed to facilitate seamless interaction with the 2050-materials platform API (see documentation [here](https://docs.2050-materials.com/getting-started-with-2050-materials/using-the-api)). By abstracting the complexities of authentication and data retrieval, this library empowers developers to focus on analyzing and utilizing environmental data about construction materials effectively.



  - **Simplified Authentication**: Manages API tokens automatically, streamlining the authentication process.
  - **Flexible Data Retrieval**: Supports fetching data using customizable filters to meet diverse analysis needs.
  - **Data Manipulation and Analysis**: Offers tools for transforming, scaling, and statistically analyzing the data.
  - **Visualization Support**: Provides functionalities for visualizing data distributions and product contributions.



  The library is structured to guide the user through a seamless process from authentication to data analysis:

  1. **Initialization**: Start by creating a `User` instance with your developer token ([see how to get a token here](https://docs.2050-materials.com/getting-started-with-2050-materials/using-the-api#get-a-developer-token)). This instance will manage your authentication and serve as your gateway to fetching data.

  2. **Fetching Data**: Utilize the `User` class to retrieve data from the API. You can apply various filters to narrow down the data according to your needs.

  3. **Data Manipulation**: Once you have fetched the data, you can construct a `ProductData` object. This object allows for extensive manipulation and transformation of the data, enabling you to prepare it for analysis or visualization in a format that suits your requirements.

  4. **Statistical Analysis and Visualization**: For advanced data analysis, the `ProductStatistics` class extends `ProductData` to provide statistical insights. It enables outlier removal, distribution analysis, and more, coupled with visualization capabilities to help interpret the data effectively.




  The AECData library can be installed directly from PyPI to ensure you have the latest version. Use the following pip command:

  ```
  pip install aecdata
  ```

  For source code, issues, and contributions, the project is hosted on GitHub at:

  ```
  git clone https://github.com/2050-Materials/aecdata.git
  ```





  The `Authenticator` class is designed to handle the authentication process for accessing the API. It is used internally to manage both API tokens and to ensure continued access.



  -   `__init__(self, developer_token, base_api_url = 'https://app.2050-materials.com/')`: Initializes the `Authenticator` instance.
      -   `developer_token`: The developer token provided for API access.
      -   `base_api_url` (optional): The base URL for the API endpoints.



  -   `get_token(self)`: Retrieves the API token using the developer token. This method is ideal for operations that only require a single API token without the need for a refresh token.
  -   `get_api_and_refresh_token(self)`: Retrieves both the API token and a refresh token. This is useful for long-running applications that may need to refresh the API token.
  -   `refresh_api_token(self)`: Refreshes the API token using the refresh token. This method should be used when the API token has expired and a new one is needed without re-authenticating using the developer token.



  The `User` class provides a high-level interface for interacting with the 2050-materials API, handling authentication, and performing API requests to fetch and manage data related to construction materials.



  - `base_api_url`: The base URL for the API endpoints. It defaults to the 2050-materials API but can be customized if necessary.
  - `authenticator`: An instance of the `Authenticator` class responsible for managing authentication tokens.
  - `api_token`: The current API token obtained through the `Authenticator`. It's used for authenticating API requests.
  - `refresh_token`: A token that can be used to refresh the `api_token` when it expires, ensuring continuous access without re-authentication.
  - `_filters`: A private attribute that caches filters available for querying the API.
  - `_field_description`: A private attribute that stores detailed descriptions of available fields for products, used for filtering and data retrieval.



  - `filters`: A property that lazily fetches and returns available filters for querying the API, caching the result.
  - `field_description`: A property that lazily fetches and returns detailed descriptions of available product fields, caching the result.





  - `__init__(self, developer_token, base_api_url="https://app.2050-materials.com/")`: Initializes a new `User` instance with a given developer token and optionally a custom API base URL.



  - `refresh_api_token(self)`: Utilizes the `Authenticator` to refresh the API token. Updates the `User` instance's `api_token` with the new value.
  - `get_filters(self)`: Fetches and caches filter options available for querying products from the API.
  - `get_field_description(self)`: Fetches and caches the descriptions of available fields for products, aiding in data manipulation and query customization.
  - `get_filters_template(self)`: Retrieves a template of filters available for product queries.
  - `get_input_lca_fields_description(self)`: Gets descriptions for input fields related to Life Cycle Assessment (LCA) data.
  - `get_output_lca_fields_description(self)`: Retrieves descriptions for output fields of LCA data.
  - `get_impact_lca_fields_description(self)`: Fetches descriptions of impact fields within LCA data.
  - `get_material_facts_fields_description(self)`: Provides descriptions of material facts fields, aiding in understanding data structure.
  - `get_physical_properties_fields_description(self)`: Details descriptions of fields related to the physical properties of materials.
  - `get_technical_parameters_fields_description(self)`: Retrieves descriptions of technical parameters fields.
  - `get_product_fields_description(self)`: Gets descriptions of product-related fields.
  - `get_unit_categories(self)`: Returns the categories of units used within the data.
  - `get_primary_units(self)`: Provides a list of primary units for data measurement.
  - `get_mf_num_fields(self)`: Lists numerical fields related to material facts.
  - `get_mf_perc_fields(self)`: Lists percentage fields within material facts data.
  - `get_physical_properties_fields(self)`: Returns a list of fields detailing the physical properties of materials.
  - `get_filters_mapping(self)`: Creates and returns a mapping of filter options to simplify query construction.
  - `get_products_page(self, page=1, openapi=False, **filters)`: Fetches a specific page of product data, optionally applying filters.
  - `get_products(self, openapi=False, **filters)`: Fetches all products, optionally applying filters, and handles pagination automatically. Use `openapi=False` to use the free Open API.



  ```

  user = User(developer_token = developer_token)


  user.filters


  user.refresh_api_token()


  all_mappings = user.get_filters_mapping()


  filters = {
      'material_type_family': all_mappings['material_types_family']['Ceramic'],
  }
  filtered_products = user.get_products(openapi=False, **filters) # Set openapi=True for the free version
  ```



  The `ProductData` class is designed to manage and manipulate the data fetched from the 2050-materials API. It offers functionalities for converting data between different formats, scaling product data based on units and amounts, and generating plots for product contributions.



  - `_data`: A private attribute that holds the original data passed to the instance, either as a list of dictionaries or a pandas DataFrame.
  - `_dataframe`: A private attribute that stores the data in a pandas DataFrame format, allowing for easy manipulation and analysis.



  - `__init__(self, data)`: Accepts data either as a list of product dictionaries or a pandas DataFrame and initializes the `ProductData` instance. The constructor ensures that `_data` and `_dataframe` are synchronized.



  - `data`: Provides access to the raw data. Setting this property updates both the `_data` attribute and the corresponding DataFrame in `_dataframe`.
  - `dataframe`: Allows access to the data in a pandas DataFrame format. Setting this property updates `_dataframe` and the raw data in `_data`.





  - `to_dataframe(self, data)`: Converts the list of dictionaries (or the raw data) into a pandas DataFrame with ordered columns, facilitating data analysis.
  - `to_csv(self, file_path)`: Exports the data to a CSV file, saving it to the specified path.
  - `to_json(self, file_path)`: Exports the data to a JSON file at the given path.
  - `to_json_string(self)`: Converts the data into a JSON-formatted string, useful for serialization or sending data over a network.



  - `get_available_units(self)`: Extracts and returns a set of available units for scaling based on the data's 'material_facts.scaling_factors' entries.
  - `convert_df_to_unit(self, df, unit='declared_unit', amount=1)`: Scales the DataFrame's numerical fields to the specified unit and amount.
  - `scale_products_by_unit_and_amount(self, products_info)`: Scales product data based on a dictionary mapping product UUIDs to units and amounts, facilitating comparisons and aggregations.



  - `get_product_contributions(self, products_info, field_name)`: Generates a pie chart illustrating the contributions of each product to the specified field (e.g., CO2 emissions).



  - `to_epdx(self)`: Converts the data into the EPDx format, suitable for environmental product declarations.




  ```

  product_data = ProductData(filtered_products)


  df = product_data.dataframe


  products_info = {
      '6aa6d32c-f8cf-11ed-9c01-0242ac120004' : {'amount': 0.2},
      'c0800dc0-f8cc-11ed-9c01-0242ac120004' : {'amount': 0.30},
      '6ab16fb2-f8cf-11ed-9c01-0242ac120004' : {'unit':'m2'},
      '6aab7152-f8cf-11ed-9c01-0242ac120004' : {'unit':'m2', 'amount': 1},
  }

  import matplotlib.pyplot as plt

  scale_df = product_data.scale_products_by_unit_and_amount(products_info)

  field_name =  'material_facts.manufacturing'
  contributions = product_data.get_product_contributions(products_info, 'material_facts.manufacturing')
  contributions


  plt.figure(figsize=(10, 8))
  contributions.plot(kind='pie', autopct='%1.1f%', startangle=90, counterclock=False, labels=contributions.index)
  plt.title(f'Contribution of Each Product by {field_name}')
  plt.ylabel('')  # Hide y-axis label for clarity
  plt.show()


  epdx_products = product_data.to_epdx()
  ```



  The `ProductStatistics` class extends the `ProductData` class, offering advanced statistical analysis capabilities for the product data obtained from the 2050-materials API. It enables users to perform detailed statistical analyses, including filtering based on various criteria, removing outliers, and plotting distributions.



  Inherits all attributes from the `ProductData` class.



  - `__init__(self, data, unit='declared_unit')`: Initializes a new instance of the `ProductStatistics` class. It accepts either a list of products, a pandas DataFrame, or an instance of `ProductData`. The `unit` parameter specifies the measurement unit for statistical analysis.





  - `get_lca_fields(self, fields='all', modules='all')`: Returns a DataFrame filtered to include only the specified LCA fields and modules, allowing for targeted analysis.
  - `get_available_groupings(self)`: Identifies possible groupings for the data based on its characteristics, aiding in segmented analysis.
  - `get_available_fields_dict(self)`: Lists all available fields within the data that can be used for statistical analysis.
  - `get_available_fields(self)`: Returns a list of all fields available for analysis, consolidating the information from `get_available_fields_dict`.
  - `filter_df_by_dict(self, df, filter_dict)`: Applies a dictionary of filters to the DataFrame, allowing for refined data selection.
  - `get_group_by_combinations(self, df, group_by, min_count)`: Determines valid combinations for grouping the data, based on specified criteria and a minimum count threshold for inclusion.
  - `get_group_by_dict(self, df, group_by)`: Generates a dictionary representing potential groupings for the data, based on the specified group_by criteria.
  - `get_statistics(self, group_by=None, fields=None, statistical_metrics=None, include_estimated_values=False, remove_outliers=True, method='IQR', sqrt_tranf=True, min_count=4)`: Computes statistical metrics for the specified fields and groupings, offering options to include estimated values, remove outliers, and adjust for small sample sizes.



  - `remove_outliers_from_df(self, filtered_df, field, method, sqrt_tranf)`: Removes outliers from the DataFrame based on the specified field and method, optionally applying a square root transformation for variance stabilization.
  - `filter_dataframe_based_on_field(self, field, filters=None, include_estimated_values=False, remove_outliers=True, method='IQR', sqrt_tranf=True)`: Filters the DataFrame based on specified criteria, including the treatment of estimated values and outliers.


  - `get_product_contributions(products_info, 'material_facts.manufacturing')`: Takes a dictionary with product ids as keys and values a dictionary with unit and amount and for an LCA field calculates the percentage contribution of carbon emissions.
  - `get_field_distribution(self, field, filters=None, include_estimated_values=False, remove_outliers=True, method='IQR', sqrt_tranf=True)`: Filters the DataFrame and returns the distribution of the specified field, offering insights into the data's structure.
  - `get_field_distribution_boxplot(self, field, group_by_field, filters=None, include_estimated_values=False, remove_outliers=True, method='IQR', sqrt_tranf=True)`: Filters the DataFrame and generates a boxplot for the specified field, providing a visual representation of statistical distributions.



  ```
  import matplotlib.pyplot as plt

  def plot_histogram(df, field):
      bin_count = min(len(df[field].unique()), 50)  # Limit the number of bins to a maximum of 50
      plt.figure(figsize=(10, 6))
      n, bins, patches = plt.hist(df[field], bins=bin_count, color='#2ab0ff', alpha=0.7, rwidth=0.85)
      plt.grid(axis='y', alpha=0.75)
      plt.xlabel('Value', fontsize=15)
      plt.ylabel('Frequency', fontsize=15)
      plt.xticks(fontsize=12)
      plt.yticks(fontsize=12)
      plt.title(f'Distribution of {field}', fontsize=15)
      plt.axvline(x=df[field].mean(), color='r', linestyle='-', label=f'Mean: {df[field].mean():.4f}')
      plt.axvline(x=df[field].median(), color='m', linestyle='-', label=f'Median: {df[field].median():.4f}')
      plt.legend(loc='upper right')
      plt.show()

  filters = {
      'material_type':'Ceramic',
      
  }
  field = 'material_facts.manufacturing'
  df = stats_obj.get_field_distribution(field=field, filters=filters, include_estimated_values=True, remove_outliers=False, method='IQR', sqrt_tranf=True)

  plot_histogram(df, field)


  field = 'material_facts.manufacturing'
  df = stats_obj.get_field_distribution(field=field, filters=filters, include_estimated_values=True, remove_outliers=True, method='IQR', sqrt_tranf=True)

  plot_histogram(df, field)


  field='material_facts.manufacturing'
  group_by_field = 'product_type'

  grouped_data_dict = stats_obj.get_field_distribution_boxplot(field=field, group_by_field=group_by_field, filters=None, include_estimated_values=True, remove_outliers=True, method='IQR', sqrt_tranf=True)


  plt.figure(figsize=(10, 6))
  plt.boxplot(grouped_data_dict.values(), patch_artist=True, labels=grouped_data_dict.keys())
  plt.grid(axis='y', alpha=0.75)
  plt.xlabel(group_by_field, fontsize=15)
  plt.ylabel('Value', fontsize=15)
  plt.xticks(fontsize=12, rotation=45)  # Rotate labels if there are many groups
  plt.yticks(fontsize=12)
  plt.title(f'Distribution of {field} by {group_by_field}', fontsize=15)
  plt.show()
  ```


pkgId: a782201b9cb76d1a0ac40b1a32a85abbba41ee5807e874f1ce061daf60dde047
name: python-aedificator
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Aedificator - Python project scaffolding tool
url: https://pypi.org/project/aedificator/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aedificator-2.1.0-1.src.rpm
checksum_type: sha256
description:
  Aedificator comes with preconfigured formatting, linting, type checking and testing
  options, leveraging the power of `tox`. If you do not have `tox` installed, type
  ```bash
  $ pip install tox
  ```
  Now, use
  ```bash
  $ tox -e linters
  ```
  for formatting, linting, and type checking (or `tox -e format|flake8|mypy` for just one
  of them) and
  ```bash
  $ tox -e py37|py38|py39|p310
  ```
  for your test suites.
  Use
  ```
  $ tox
  ```


pkgId: 38cd2bd5eddcd978e9d7a8330155c2c97e559ba5795015f08a6255b07904dd2b
name: python-aedttest
arch: src
version: 0.0.2
epoch: 0
release: 1
url: https://pypi.org/project/aedttest/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aedttest-0.0.2-1.src.rpm
checksum_type: sha256
summary:
  Ansys Electronics Desktop Testing Framework. Current module allows to setup and run automated tests and validate results across multiple versions of Ansys Electronics Desktop products, eg HFSS, Maxwell, Icepak, Q3D, etc

description:
  [![](https://img.shields.io/pypi/v/aedttest.svg)](https://pypi.python.org/pypi/aedttest/)
  [![](https://img.shields.io/pypi/pyversions/aedttest.svg)](https://pypi.python.org/pypi/aedttest/)



  This project aims to provide an Automated Framework to test Ansys Electronics Desktop (AEDT).
  Users can set up a suite of tests to validate stability/regression of results between
  different versions of Ansys Electronics Desktop.




  <!-- toc -->

  - [Features](#features)
  - [Installation](#installation)
  - [Usage](#usage)
    * [Configuration file](#configuration-file)
    * [CLI Commands](#cli-commands)
      + [Open CLI commands Help](#open-cli-commands-help)
    * [Examples](#examples)
      + [Local machine](#local-machine)
        - [Generate only reference results](#generate-only-reference-results)
        - [Run comparison between versions](#run-comparison-between-versions)
      + [Slurm](#slurm)
        - [Generate only reference results](#generate-only-reference-results-1)
        - [Run comparison between versions](#run-comparison-between-versions-1)
  - [Limitations](#limitations)
  - [Contributors](#contributors)

  <!-- tocstop -->


  The current framework provides the following features:
  * Compare results of XY plots, mesh statistics and simulation time.
  * Web page output format for visual comparison
  * JSON file output format to support automated workflows and use of test results downstream.
  * Parallel distribution of test projects
  * Cross-platform: support for Windows and Linux
  * Compatibility with local machine and most known cluster schedulers:
    LSF, SGE, Slurm, PBS, Windows HPC
  * Control of required resources for each project and optimized distribution of tasks
  * Automatic generation of reference results (AEDT versions 2019R1+)


  To install the package use:
  ```bash
  pip install aedttest
  ```


  Electronics Desktop testing framework automatically identifies environment where it was launched. In this chapter we
  will show basic examples of starting tests on local machine or on clusters with scheduler. In all scenarios we use
  Command Line Interface (CLI).


  Framework requires configuration file as input. Please see example of a configuration file
  [config_with_comments.toml][1] to understand how to create a file.

  You can use both [config_with_comments.toml][1] or [config_without_comments.toml][2] as template.

  [1]: examples/configs/config_with_comments.toml
  [2]: examples/configs/config_without_comments.toml


  To expose the available commands use the following command line


  ```bash
  aedt_test_runner -h
  ```




  To start test on local machine use following command line


  ```bash
  aedt_test_runner --config-folder=examples/configs --aedt-version=193 --only-reference
  ```


  ```bash
  aedt_test_runner --config-folder=examples/configs --aedt-version=231 --reference-folder=reference_folder
  ```



  ```bash
  sbatch \
    --job-name aedttest \
    --partition ottc01 \
    --export "ALL,ANSYSEM_ROOT193=/apps/software/ANSYS_EM_2019R1/AnsysEM19.3/Linux64,ANS_NODEPCHECK=1" \
    --nodes 2-2 --ntasks 56 \
    --wrap "aedt_test_runner --config-folder=examples/configs --aedt-version=193 --only-reference"
  ```


  ```bash
  sbatch \
    --job-name aedttest \
    --partition ottc01 \
    --export "ALL,ANSYSEM_ROOT222=/ott/apps/software/ANSYS_EM_2022R2_211129/v222/Linux64,ANS_NODEPCHECK=1" \
    --nodes 2-2 --ntasks 56 \
    --wrap "aedt_test_runner --config-folder=examples/configs --aedt-version=222 --reference-folder=~/reference_folder"
  ```


  Currently, project does not support or partially supports following features:
  * Automatic results creation is possible only for versions 2019R1+
  * LS-DSO is not supported


  If you would like to contribute to this project, please see [CONTRIBUTE](docs/CONTRIBUTE.md).


pkgId: 8c0ed4495fc1fabbdeb2805f08dfa67b516a288c5d43ade4d7d15d8ad71e51b7
name: python-aef-nattanon-py
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: Detector library
url: https://aef-nattanon-py-lib.readthedocs.io/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aef-nattanon-py-0.2.3-1.src.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/aef-nattanon-py-lib/badge/?version=latest)](https://aef-nattanon-py-lib.readthedocs.io/en/latest/?badge=latest)


  ```bash
  $ pip install aef-nattanon-py
  ```

  ![Demo](https://raw.githubusercontent.com/aef-nattanon/aef-nattanon-py-lib/35a487d6d7175c0b2ecf40e341af9513fee3aa00/docs/demo.gif)


  ```python

  import aef_nattanon_py as aef
  import cv2


  multiplication = aef.Multiplication(2)
  print(multiplication.multiply(5)) # 10


  myDetector = aef.Detector('coco.names', 'yolov3-tiny.cfg', 'yolov3-tiny.weights')
  myDetector.detact_by_img_path('my-photo.jpeg')
  cv2.imshow("Image", myDetector.detect_img)
  cv2.waitKey(100)


  cap = cv2.VideoCapture(0)
  while True:
      _, frame = cap.read()
      myDetector.detact_by_frame(frame)
      cv2.imshow("Image", myDetector.detect_img)
      cv2.waitKey(1)

  cv2.destroyAllWindows()


  myDetector = aef.YoloV3Detector()
  cap = cv2.VideoCapture(0)
  while True:
      _, frame = cap.read()
      myDetector.detect_by_frame(frame)
      cv2.imshow("Image", myDetector.detect_img)
      cv2.waitKey(1)

  cv2.destroyAllWindows()

  ```


pkgId: 030a0b90ef08b83756b7c9bcb3bac14d6354859ed641a88e8a3fd8be55412e0e
name: python-aegea
arch: src
version: 4.5.0
epoch: 0
release: 1
summary: Amazon Web Services Operator Interface
url: https://github.com/kislyuk/aegea
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aegea-4.5.0-1.src.rpm
checksum_type: sha256
description:
  *Aegea* is a command line interface (CLI) that provides a set of essential commands and terminal dashboards for
  operators of Amazon Web Services (AWS) accounts. Aegea lets you build AMIs and Docker images using the
  `cloud-init <http://cloudinit.readthedocs.io/>`_ config management package, manage config roles, launch and monitor
  instances and services, and manage AWS resources including ELB, RDS, and AWS Batch. Aegea is designed to be used in
  conjunction with the existing functionality of the `AWS CLI <https://aws.amazon.com/cli/>`_ and
  `boto3 <https://boto3.readthedocs.io/>`_. Aegea can be used in conjunction with tools like
  `MiniWDL <https://github.com/chanzuckerberg/miniwdl>`_ to orchestrate large-scale MLops and genomics workflows.
  Installation
  ~~~~~~~~~~~~
     pip install aegea
  Run ``aws configure`` to configure `IAM <https://aws.amazon.com/iam/>`_ access credentials that will be used by the
  ``aws`` and ``aegea`` commands. You can create a new IAM key at https://console.aws.amazon.com/iam/home#/users. See the
  `AWS CLI documentation <https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html>`_ for more details.
  Aegea commands
  ~~~~~~~~~~~~~~
  Below are some highlights from Aegea's suite of commands. Run ``aegea --help`` to see the full list of commands.
  +----------------------------+-----------------------------------------------------------------------------------------+
  | Command                    | Key functionality                                                                       |
  +============================+=========================================================================================+
  | `aegea ls`                 | List running EC2 instances                                                              |
  +----------------------------+-----------------------------------------------------------------------------------------+
  | `aegea launch`             | Launch EC2 instances and specify options such as spot tenancy, AMI, instance type, etc. |
  +----------------------------+-----------------------------------------------------------------------------------------+
  | `aegea ssh`, `aegea scp`   | Connect to running instances, transfer files using AWS Systems Manager or other options |
  +----------------------------+-----------------------------------------------------------------------------------------+
  | `aegea batch`              | Submit, manage and monitor AWS Batch jobs                                               |
  +----------------------------+-----------------------------------------------------------------------------------------+
  | `aegea ecs`                | Monitor ECS clusters and run Fargate tasks                                              |
  +----------------------------+-----------------------------------------------------------------------------------------+
  | `aegea build-ami`          | Build EC2 AMIs using cloud-init configuration scripts                                   |
  +----------------------------+-----------------------------------------------------------------------------------------+
  | `aegea build-docker-image` | Build AWS ECR docker images using Dockerfiles or cloud-init scripts                     |
  +----------------------------+-----------------------------------------------------------------------------------------+
  | `aegea logs`               | Download AWS CloudWatch Logs contents using S3 export                                   |
  +----------------------------+-----------------------------------------------------------------------------------------+
  | `aegea grep`               | Query AWS CloudWatch Logs contents using CloudWatch Logs Insights                       |
  +----------------------------+-----------------------------------------------------------------------------------------+
  | `aegea cost`               | List AWS cost reports generated by AWS Cost Explorer                                    |
  +----------------------------+-----------------------------------------------------------------------------------------+
  | `aegea secrets`            | List and manage secrets stored in AWS Secrets Manager                                   |
  +----------------------------+-----------------------------------------------------------------------------------------+
  | `aegea cloudtrail`         | Query AWS CloudTrail events to audit the security of your AWS account                   |
  +----------------------------+-----------------------------------------------------------------------------------------+


pkgId: 29bd911d1c724f9c183646de5f20b79fdaa580d22cf75c67774531596a5b8577
name: python-aegis-framework
arch: src
version: 0.1.12
epoch: 0
release: 1
summary: A framework for creating multi-agent colonies
url: https://github.com/metisos/aegis_framework.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aegis-framework-0.1.12-1.src.rpm
checksum_type: sha256
description:
  README.md
  This file gives an overview of your project, how to install it, and provides examples of how to use it. Here is a basic example for your aegis_framework package:

  README.md
  markdown
  Copy code


  Aegis Framework is a Python package designed to facilitate the creation of multi-agent colonies, making it easy to create, manage, and extend agents for various tasks.


  - Simple framework for creating multi-agent colonies
  - Customizable agents with built-in support for local models
  - Easy integration with custom LLMs or other components



  To install the package, use pip:

  ```bash
  pip install aegis-framework
  Usage
  Example
  Here's how you can use the MasterAIAgent from the framework:

  python
  Copy code
  from aegis_framework import MasterAIAgent


  agent = MasterAIAgent(name="Master Agent")


  response = agent.answer_question("What is the impact of AI on society?")
  print(response)
  Custom LLM Example
  You can also use a custom local LLM model:

  python
  Copy code
  from aegis_framework import OllamaLocalModel
  from aegis_framework import MasterAIAgent


  ollama_llm = OllamaLocalModel(model="gemma2:9b")


  agent = MasterAIAgent(name="Custom Master Agent", llm=ollama_llm)


  response = agent.answer_question("How is AI changing the world?")
  print(response)
  Contributing
  Contributions are welcome! Please read the contributing guidelines for more details.


pkgId: 3509bd05d9a2883b48aab1d1744c39b8a4e5058442e206481d630b785532298d
name: python-aegis-tools
arch: src
version: 2.9.2
epoch: 0
release: 1
summary: Aegis is a set of battle-tested tools and tricks to help everyone make better software
url: https://github.com/mdagosta/aegis
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aegis-tools-2.9.2-1.src.rpm
checksum_type: sha256
description:
  A combination of tools and framework, Aegis has multiple different uses. You can import it and use the thoroughly made and tested functions. You can use it as a natural extension for the tornado web framework. And you can use it to quickly create a new web application with the structure already built-in, and follow along.


pkgId: 9e0af025a7943d87c53f512a0b0367bbb35e25f5c0c8c28a8715641bd77edb69
name: python-aeiou
arch: src
version: 0.0.20
epoch: 0
release: 1
summary: audio engineering i/o utils
url: https://github.com/drscotthawley/aeiou/
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aeiou-0.0.20-1.src.rpm
checksum_type: sha256
description:
  <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
  Pronounced “[ayoo](https://youtu.be/Hv6RbEOlqRo?t=24)”

  It is recommended you install the latest version from GitHub via
  ``` sh
  pip install git+https://github.com/drscotthawley/aeiou.git
  ```
  However binaries will be occasionally updated on PyPI, installed via
  ``` sh
  pip install aeiou
  ```

  This is a series of utility routines developed in support of multiple
  projects within the [Harmonai](https://www.harmonai.org/) organization.
  See individual documentation pages for more specific instructions on how
  these can be used. Note that this is *research code*, so it’s a) in flux
  and b) in need of improvements to documenation.

  Documentation for this library is hosted on the [aeiou GitHub Pages
  site](https://drscotthawley.github.io/aeiou/).

  Contributions are welcome – especially for improvements to
  documentation! To contribute:
  1.  Fork this repo and then clone your fork to your local machine.
  2.  Create a new (local) branch: `git -b mybranch` (or whatever you want
      to call it).
  3.  This library is written entirely in [nbdev](https://nbdev.fast.ai/)
      version 2, using Jupyter notebooks.
  4.  [Install nbdev](https://nbdev.fast.ai/getting_started.html#install)
      and then you can edit the Jupyter notebooks.
  5.  After editing notebooks, run `nbdev_prepare`
  6.  If that succeeds, you can do
      `git add *.ipynb aeiou/*.py; git commit` and then `git push` to get
      your changes to back to your fork on GitHub.
  7.  Then send a Pull Request from your fork to the main `aeiou`
      repository.

  Please include attribution of this code if you reproduce sections of it
  in your own code:
      aeiou: audio engineering i/o utilities: Copyright (c) Scott H. Hawley, 2022-2023. https://github.com/drscotthawley/aeiou
  In research papers, please cite this software if you find it useful:
  ``` bibtex
  @misc{aeiou,
    author = {Scott H. Hawley},
    title = {aeiou: audio engineering i/o utilities},
    year  = {2022},
    url   = {https://github.com/drscotthawley/aeiou},
  }
  ```
  Copyright (c) Scott H. Hawley, 2022-2023.

  [License](https://github.com/drscotthawley/aeiou/blob/main/LICENSE) is
  APACHE 2.0.


pkgId: aacbe62415a809465a00529c0486d0bd83d1c9ee327082be20b168e3fc2a3e4d
name: python-aemeasure
arch: src
version: 0.2.9
epoch: 0
release: 1
summary: Simple tools for logging experiments in algorithm engineering
url: https://github.com/d-krupke/AeMeasure
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aemeasure-0.2.9-1.src.rpm
checksum_type: sha256
description:
  This module has been developed to save (macro-)benchmarks of algorithms in a simple and
  dynamic way. The primary features are:
  * Saving metadata such as Git-Revision, hostname, etc.
  * No requirement of a data scheme. This is important as often you add additional feature in later iterations but still want to compare it to the original data.
  * Compatibility with distributed execution, e.g., via slurm. If you want to use multi-processing, use separate `MeasurementSeries`.
  * Easy data rescue in case of data corruption (or non-availability of this library) as well as compression.
    * Data is saved in multiple json files (coherent json is not efficient) and compressed as zip.
  * Optional capturing of stdin and stdout.

  You can also consider this tool as a simple serverless but NFS-compatible object database with helpers for benchmarks.

  The motivation for this tool came from the need to **quickly compare different optimization models (MIP, CP, SAT, ...)**
  and analyze their performance.  Here it is more important to save the context (parameters, revision,...) than to
  be precise to a millisecond. If you need very precise measurements, you need to look for a micro-benchmarking tool.
  This is a **macro-benchmarking tool** with a **file-based database**.



  > *"They say the workman is only as good as his tools; in experimental algorithmics the workman must often build his tools."* - Catherine McGeoch, A Guide to Experimental Algorithmics

  AeMeasure is designed for flexibility and simplicity. If you don't have changing
  requirements every few weeks, you may be better off with
  using a proper database. If you are somewhere in between, you could take a look at, e.g.,
  [MongoDB](https://www.mongodb.com/), which is more flexible regarding the schema but
  still provides a proper database. If you want a very simple&flexible solution and the data
  in the repository (compressed of course, but still human-readable),
  AeMeasure may be the right tool for you.



  The easiest installation is via pip
  ```shell
  pip install -U aemeasure
  ```



  A simple application that runs an algorithm for a set of instances and saves the results to `./results` could look like this:

  ```python
  from aemeasure import MeasurementSeries

  with MeasurementSeries("./results") as ms:
      
      
      for instance in instances:
          with ms.measurement() as m:
              m["instance"] = str(instance)
              m["size"] = len(instance)
              m["algorithm"] = "fancy_algorithm"
              m["parameters"] = "asdgfdfgsdgf"
              solution = run_algorithm(instance)
              m["solution"] = solution.as_json()
              m["objective"] = 42
              m["lower_bound"] = 13
  ```

  You can then parse the database as pandas table via
  ```python
  from aemeasure import read_as_pandas_table

  table = read_as_pandas_table("./results", defaults={"uses_later_added_special_feature": False})
  ```



  If you are using MeasurementSeries, all possible information is automatically
  added to the measurements by default. You can deactivate this easily in
  the constructor. However, often it is useful to have this data (especially stderr
  and git revision) at hand, when you notice some oddities in your results. This
  can take up a lot of space, but the compression option of the database should
  help.

  The following data is saved:
  * Runtime (enter and exit of Measurement)
  * stdout/stderr
  * Git Revision
  * Timestamp of start
  * Hostname
  * Arguments
  * Python-File
  * Current working directory

  You can also activate individual metadata by just calling the corresponding member
  function of the measurement.



  This tool is excellent in combination with [Slurminade](https://github.com/d-krupke/slurminade) to automatically distribute
  your experiments to Slurm nodes. This also allows you to schedule the missing instances.

  An example could look like this:

  ```python
  import slurminade
  from aemeasure import MeasurementSeries, read_as_pandas_table, Database


  slurminade.update_default_configuration(partition="alg", constraint="alggen03")
  slurminade.set_dispatch_limit(200)  # just a safety measure in case you messed up


  result_folder = "./results"
  timelimit = 300


  @slurminade.slurmify()
  def run_for_instance(instance_name, timelimit):
      """
      Solve instance with different solvers.
      """
      instances = load_instances()
      instance = instances[instance_name]
      with MeasurementSeries(result_folder) as ms:
          models = (Model1(instance), Model2(instance))
          for model in models:
              with ms.measurement() as m:
                  ub, lb = model.optimize(timelimit)
                  m["instance"] = instance_name
                  m["timelimit"] = timelimit
                  m["ub"] = ub
                  m["lb"] = lb
                  m["n"] = len(instance)
                  m["Method"] = str(model)
                  m.save_seconds()

  if __name__ == "__main__":
      
      instances = load_instances()
      Database(result_folder).compress()  # compress prior results to make space
      t = read_as_pandas_table(result_folder)  # read prior results to check which instances are still missing

      
      finished_instances = t["instance"].to_list() if not t.empty else []
      print("Already finished instances:", finished_instances)
      missing_instances = [i for i in instances if i not in finished_instances]
      if finished_instances and missing_instances:
          assert isinstance(missing_instances[0], type(finished_instances[0]))
      print("Still missing instances:", missing_instances)

      
      for instance in missing_instances:
          run_for_instance.distribute(instance, timelimit)
  ```

  If you have a lot of instances, you may want to use `slurminade.AutoBatch` to automatically
  batch multiple instances into a single task.

  Important points of this example:
  * Extract the parameters as variables and put them at the top so you can easily copy and adapt such a template.
  * The `run_for_instance` function will read the instance itself as this is more efficient than to distribute it via slurm as an argument.
  * We compress the results at the beginning. As this is executed before distribution, it is threadsafe.
  * We quickly check, which instances are already solved and only distribute the missing ones.
  * To compress the final results, simply run this script again (it will also check if you may have missed some instances due to an error).

  I have often seen scripts that are simply started on each node that either use a complicated
  manual instance distribution, require an additional server, or need a lot of additional
  data collection in the end. The above's approach seems to be much more elegant to me, if
  you already have Slurm and an NFS.



  The serverless database allows to dump unstructured JSONs in a relatively threadsafe way (focus on Surm-node with NFS).
  ```python
  from aemeasure import Database

  db = Database("./db_folder")  # We use a folder, not a file, to make it NFS-safe.
  db.add({"key": "value"}, flush=False)  # save simple dict, do not write directly.
  db.flush()  # save to disk
  db.compress()  # compress data on disk via zip


  db2 = Database("./db_folder")
  data = db2.load()  # load all entries as a list of dicts.


  db2.clear()
  db2.dump([e for e in data if e["feature_x"]])  # write back only entries with 'feature_x'
  ```

  The primary points of the database are:
  * No server is needed, synchronization possible via NFS.
  * We are using a folder instead of a single file. Otherwise, the synchronization of different nodes via NFS would be difficult.
  * Every node uses a separate, unique file to prevent conflicts.
  * Every entry is a new line in JSON format appended to the current database file of the node. As this allows simply appending, this is much more efficient that keeping the whole structure in JSON. If something goes wrong, you can still easily repair it with a text editor and some basic JSON-skills.
  * The database has a very simple format, such that it can also be read without this tool.
  * As the nativ JSON format can need a signficant amount of disk, a compression option allows to significantly reduce the size via ZIP-compression.

  **This database is made for frequent writing, infrequent reading. Currently, there are no query options aside of list comprehensions. Use `clear` and `dump` for selective deletion.**



  * 0.2.9: Added pyproject.toml for PEP compliance.
  * 0.2.8: Saving Python-environment, too.
  * 0.2.7: Robust JSON serialization. It will save the data but print an error if the data is not JSON-serializable.
  * 0.2.6: Extended logging and exception if data could not be written.
  * 0.2.5: Skipping on zero size (probably not yet written, can be a problem with NFS)
  * 0.2.4: Added some logging.
  * 0.2.3: Setting LZMA as compression standard.
  * For some reason, the default keys for 'stdin' and 'stdout' were wrong. Fixed.


pkgId: f766ea71010e0094ff0bf92123b5e9bd05b9b79fc53d33d2866ed13a356dc6b3
name: python-aempsconn
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Library designed for interacting with the CIMA API (AEMPS)
url: https://github.com/fqlenos/aempsconn
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aempsconn-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Library designed for interacting with the CIMA REST API ([AEMPS](https://cima.aemps.es/cima/publico/home.html)).
  More information related to the official REST API can be found [here](https://cima.aemps.es/cima/resources/docs/CIMA_REST_API.pdf).

  *Note: AEMPSconn is developed to make use of it with [CIMA REST API v1.23](https://cima.aemps.es/cima/resources/docs/CIMA_REST_API.pdf).*



  **Unit-tests for this new version are under development.**




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

  ```bash
  pip install aempsconn
  ```


  Each module has embedded in it the only type of filter it supports.
  The filters are created dynamically so depending on the type of data you want to obtain, it will ask for the type of value required for it.

  If you want to filter by more than one value, simply concatenate all the desired filters, the query-builder will create the necessary query.

  ```python
  from aempsconn.aemps import AempsConn
  from aempsconn.filter import (
      MaterialFilter,
      MedicamentoFilter,
      MedicamentosFilter,
      NotaFilter,
      PresentacionesFilter,
      RegistroCambiosFilter,
      VmppFilter,
  )

  aemps = AempsConn()

  for med in aemps.medicamento.get(
      filter=MedicamentoFilter().nregistro.equals(value="62121")
  ):
      print(med.nombre)

  for med in aemps.medicamentos.get(
      filter=MedicamentosFilter().nombre.startswith(value="meto")
  ):
      print(med.nombre)

  for med in aemps.medicamentos.get(
      filter=MedicamentosFilter().nombre.startswith(value="")
  ):
      print(med.nombre)

  for med in aemps.presentaciones.get(
      filter=PresentacionesFilter().vmp.equals("270671000140106")
  ):
      print(med.nombre)

  for desc_cli in aemps.vmpp.get(filter=VmppFilter().nombre.contains("metotrexato")):
      print(desc_cli.vmpDesc)

  for change in aemps.registro_cambios.get(
      filter=RegistroCambiosFilter().fecha.equals(value="20/12/2023")
  ):
      print(change)

  for note in aemps.notas.get(filter=NotaFilter().nregistro.equals("69223")):
      print(note)

  for material in aemps.materiales.get(
      filter=MaterialFilter().nregistro.equals("78632")
  ):
      print(material)

  ```



  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.




  The use of Spanish words or descriptions **is intended** to facilitate consistency between the official CIMA API and this library, so that the programmer does not hesitate with the name of each of the filters or data received.

  This library is not official.


pkgId: 014c1e3d5492d77e2120f81e3249f3d7ae9265b67cb525b013cd0677385e4aa1
name: python-aeolis
arch: src
version: 2.1.1
epoch: 0
release: 1
summary: A process-based model for simulating supply-limited aeolian sediment transport
url: http://aeolis.readthedocs.io/
rpm_license: GNU GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aeolis-2.1.1-1.src.rpm
checksum_type: sha256
description:
  AeoLiS is a process-based model for simulating aeolian sediment
  transport in situations where supply-limiting factors are important,
  like in coastal environments. Supply-limitations currently supported
  are soil moisture contents, sediment sorting and armouring, bed slope
  effects, air humidity and roughness elements.
  The maintenance and development is done by the AEOLIS developer team:
  Current members are:
  `Bart van Westen <Bart.vanWesten@deltares.nl>`_ at Deltares,
  `Nick Cohn <nick.cohn@usace.army.mil>`_ at U.S. Army Engineer Research and Development Center (ERDC),
  `Sierd de Vries <Sierd.deVries@tudelft.nl>`_ (founder) at Delft University of Technology,
  `Christa van IJzendoorn <C.O.vanIJzendoorn@tudelft.nl>`_ at Delft University of Technology,
  `Caroline Hallin <E.C.Hallin@tudelft.nl>`_ at Delft University of Technology,
  `Glenn Strypsteen <glenn.strypsteen@kuleuven.be>`_ at Katholieke Universiteit Leuven and
  `Janelle Skaden <Janelle.E.Skaden@usace.army.mil>`_ at U.S. Army Engineer Research and Development Center (ERDC).
  Previous members are:
  `Bas Hoonhout <bas@hoonhout.com>`_ (founder), Tom Pak, Pieter Rauwoens and Lisa Meijer


pkgId: 4a9fbac04e9ff176dac64e345803b97599d620f2687bbe7a97f3457b3f6f4ab9
name: python-aeon
arch: src
version: 0.11.1
epoch: 0
release: 1
summary: A toolkit for machine learning from time series
url: https://www.aeon-toolkit.org
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aeon-0.11.1-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <a href="https://aeon-toolkit.org"><img src="https://raw.githubusercontent.com/aeon-toolkit/aeon/main/docs/images/logo/aeon-logo-blue-compact.png" width="50%" alt="aeon logo" /></a>
  </p>



  `aeon` is an open-source toolkit for learning from time series. It is compatible with
  [scikit-learn](https://scikit-learn.org) and provides access to the very latest
  algorithms for time series machine learning, in addition to a range of classical
  techniques for learning tasks such as forecasting and classification.

  We strive to provide a broad library of time series algorithms including the
  latest advances, offer efficient implementations using numba, and interfaces with other
  time series packages to provide a single framework for algorithm comparison.

  The latest `aeon` release is `v0.11.1`. You can view the full changelog
  [here](https://www.aeon-toolkit.org/en/stable/changelog.html).

  Our webpage and documentation is available at https://aeon-toolkit.org.

  The following modules are still considered experimental, and the [deprecation policy](https://www.aeon-toolkit.org/en/stable/developer_guide/deprecation.html)
  does not apply:

  `anomaly_detection`, `benchmarking`, `segmentation`, `similarity_search`,
  `testing`, `transformations/series`, `visualisation`

  | Overview      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
  |---------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | **CI/CD**     | [![github-actions-release](https://img.shields.io/github/actions/workflow/status/aeon-toolkit/aeon/release.yml?logo=github&label=build%20%28release%29)](https://github.com/aeon-toolkit/aeon/actions/workflows/release.yml) [![github-actions-main](https://img.shields.io/github/actions/workflow/status/aeon-toolkit/aeon/pr_pytest.yml?logo=github&branch=main&label=build%20%28main%29)](https://github.com/aeon-toolkit/aeon/actions/workflows/pr_pytest.yml) [![github-actions-nightly](https://img.shields.io/github/actions/workflow/status/aeon-toolkit/aeon/periodic_tests.yml?logo=github&label=build%20%28nightly%29)](https://github.com/aeon-toolkit/aeon/actions/workflows/periodic_tests.yml) [![docs-main](https://img.shields.io/readthedocs/aeon-toolkit/stable?logo=readthedocs&label=docs%20%28stable%29)](https://www.aeon-toolkit.org/en/stable/) [![docs-main](https://img.shields.io/readthedocs/aeon-toolkit/latest?logo=readthedocs&label=docs%20%28latest%29)](https://www.aeon-toolkit.org/en/latest/) [![!codecov](https://img.shields.io/codecov/c/github/aeon-toolkit/aeon?label=codecov&logo=codecov)](https://codecov.io/gh/aeon-toolkit/aeon) [![openssf-scorecard](https://api.scorecard.dev/projects/github.com/aeon-toolkit/aeon/badge)](https://img.shields.io/ossf-scorecard/github.com/aeon-toolkit/aeon?label=openssf%20scorecard&style=flat)|
  | **Code**      | [![!pypi](https://img.shields.io/pypi/v/aeon?logo=pypi&color=blue)](https://pypi.org/project/aeon/) [![!conda](https://img.shields.io/conda/vn/conda-forge/aeon?logo=anaconda&color=blue)](https://anaconda.org/conda-forge/aeon) [![!python-versions](https://img.shields.io/pypi/pyversions/aeon?logo=python)](https://www.python.org/) [![!black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) [![license](https://img.shields.io/badge/license-BSD%203--Clause-green?logo=style)](https://github.com/aeon-toolkit/aeon/blob/main/LICENSE) [![binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/aeon-toolkit/aeon/main?filepath=examples)                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
  | **Community** | [![!slack](https://img.shields.io/static/v1?logo=slack&label=Slack&message=chat&color=lightgreen)](https://join.slack.com/t/aeon-toolkit/shared_invite/zt-22vwvut29-HDpCu~7VBUozyfL_8j3dLA) [![!linkedin](https://img.shields.io/static/v1?logo=linkedin&label=LinkedIn&message=news&color=lightblue)](https://www.linkedin.com/company/aeon-toolkit/) [![!twitter](https://img.shields.io/static/v1?logo=twitter&label=Twitter&message=news&color=lightblue)](https://twitter.com/aeon_toolkit)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |



  `aeon` requires a Python version of 3.9 or greater. Our full installation guide is
  available in our [documentation](https://www.aeon-toolkit.org/en/stable/installation.html).

  The easiest way to install `aeon` is via pip:

  ```bash
  pip install aeon
  ```

  Some estimators require additional packages to be installed. If you want to install
  the full package with all optional dependencies, you can use:

  ```bash
  pip install aeon[all_extras]
  ```

  Instructions for installation from the [GitHub source](https://github.com/aeon-toolkit/aeon)
  can be found [here](https://www.aeon-toolkit.org/en/stable/developer_guide/dev_installation.html).



  The best place to get started for all `aeon` packages is our [getting started guide](https://www.aeon-toolkit.org/en/stable/getting_started.html).

  Below we provide a quick example of how to use `aeon` for forecasting,
  classification and clustering.



  *It's worth mentioning that the classifier used in the example can easily be
  swapped out for a regressor, and the labels for numeric targets. This flexibility
  allowing for seamless adaptation to different tasks and datasets while preserving
  API consistency.*

  ```python
  import numpy as np
  from aeon.classification.distance_based import KNeighborsTimeSeriesClassifier

  X = [[[1, 2, 3, 4, 5, 5]],  # 3D array example (univariate)
       [[1, 2, 3, 4, 4, 2]],  # Three samples, one channel, six series length,
       [[8, 7, 6, 5, 4, 4]]]
  y = ['low', 'low', 'high']  # class labels for each sample
  X = np.array(X)
  y = np.array(y)

  clf = KNeighborsTimeSeriesClassifier(distance="dtw")
  clf.fit(X, y)  # fit the classifier on train data
  >>> KNeighborsTimeSeriesClassifier()

  X_test = np.array(
      [[[2, 2, 2, 2, 2, 2]], [[5, 5, 5, 5, 5, 5]], [[6, 6, 6, 6, 6, 6]]]
  )
  y_pred = clf.predict(X_test)  # make class predictions on new data
  >>> ['low' 'high' 'high']
  ```



  ```python
  import numpy as np
  from aeon.clustering import TimeSeriesKMeans

  X = np.array([[[1, 2, 3, 4, 5, 5]],  # 3D array example (univariate)
       [[1, 2, 3, 4, 4, 2]],  # Three samples, one channel, six series length,
       [[8, 7, 6, 5, 4, 4]]])

  clu = TimeSeriesKMeans(distance="dtw", n_clusters=2)
  clu.fit(X)  # fit the clusterer on train data
  >>> TimeSeriesKMeans(distance='dtw', n_clusters=2)

  clu.labels_ # get training cluster labels
  >>> array([0, 0, 1])

  X_test = np.array(
      [[[2, 2, 2, 2, 2, 2]], [[5, 5, 5, 5, 5, 5]], [[6, 6, 6, 6, 6, 6]]]
  )
  clu.predict(X_test)  # Assign clusters to new data
  >>> array([1, 0, 0])
  ```



  | Type                                | Platforms                        |
  |-------------------------------------|----------------------------------|
  | 🐛 **Bug Reports**                  | [GitHub Issue Tracker]           |
  | ✨ **Feature Requests & Ideas**      | [GitHub Issue Tracker] & [Slack] |
  | 💻 **Usage Questions**              | [GitHub Discussions] & [Slack]   |
  | 💬 **General Discussion**           | [GitHub Discussions] & [Slack]   |
  | 🏭 **Contribution & Development**   | [Slack]                          |

  [GitHub Issue Tracker]: https://github.com/aeon-toolkit/aeon/issues
  [GitHub Discussions]: https://github.com/aeon-toolkit/aeon/discussions
  [Slack]: https://join.slack.com/t/aeon-toolkit/shared_invite/zt-22vwvut29-HDpCu~7VBUozyfL_8j3dLA

rpm_license:
  BSD 3-Clause License  Copyright (c) The aeon developers.  All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  * Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: d3446f5be220ff37205afdc30fa894ff7062e4146778795f8e099b7caa832f74
name: python-aeon
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: A toolkit for machine learning from time series
url: https://www.aeon-toolkit.org
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aeon-1.0.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <a href="https://aeon-toolkit.org"><img src="https://raw.githubusercontent.com/aeon-toolkit/aeon/main/docs/images/logo/aeon-logo-blue-compact.png" width="50%" alt="aeon logo" /></a>
  </p>



  `aeon` is an open-source toolkit for learning from time series. It is compatible with
  [scikit-learn](https://scikit-learn.org) and provides access to the very latest
  algorithms for time series machine learning, in addition to a range of classical
  techniques for learning tasks such as forecasting and classification.

  We strive to provide a broad library of time series algorithms including the
  latest advances, offer efficient implementations using numba, and interfaces with other
  time series packages to provide a single framework for algorithm comparison.

  The latest `aeon` release is `v1.0.0`. You can view the full changelog
  [here](https://www.aeon-toolkit.org/en/stable/changelog.html).

  Our webpage and documentation is available at https://aeon-toolkit.org.

  The following modules are still considered experimental, and the [deprecation policy](https://www.aeon-toolkit.org/en/stable/developer_guide/deprecation.html)
  does not apply:

  - `anomaly_detection`
  - `forecasting`
  - `segmentation`
  - `similarity_search`
  - `visualisation`

  | Overview        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
  |-----------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | **CI/CD**       | [![github-actions-release](https://img.shields.io/github/actions/workflow/status/aeon-toolkit/aeon/release.yml?logo=github&label=build%20%28release%29)](https://github.com/aeon-toolkit/aeon/actions/workflows/release.yml) [![github-actions-main](https://img.shields.io/github/actions/workflow/status/aeon-toolkit/aeon/pr_pytest.yml?logo=github&branch=main&label=build%20%28main%29)](https://github.com/aeon-toolkit/aeon/actions/workflows/pr_pytest.yml) [![github-actions-nightly](https://img.shields.io/github/actions/workflow/status/aeon-toolkit/aeon/periodic_tests.yml?logo=github&label=build%20%28nightly%29)](https://github.com/aeon-toolkit/aeon/actions/workflows/periodic_tests.yml) [![docs-main](https://img.shields.io/readthedocs/aeon-toolkit/stable?logo=readthedocs&label=docs%20%28stable%29)](https://www.aeon-toolkit.org/en/stable/) [![docs-main](https://img.shields.io/readthedocs/aeon-toolkit/latest?logo=readthedocs&label=docs%20%28latest%29)](https://www.aeon-toolkit.org/en/latest/) [![!codecov](https://img.shields.io/codecov/c/github/aeon-toolkit/aeon?label=codecov&logo=codecov)](https://codecov.io/gh/aeon-toolkit/aeon) [![openssf-scorecard](https://api.scorecard.dev/projects/github.com/aeon-toolkit/aeon/badge)](https://img.shields.io/ossf-scorecard/github.com/aeon-toolkit/aeon?label=openssf%20scorecard&style=flat) |
  | **Code**        | [![!pypi](https://img.shields.io/pypi/v/aeon?logo=pypi&color=blue)](https://pypi.org/project/aeon/) [![!conda](https://img.shields.io/conda/vn/conda-forge/aeon?logo=anaconda&color=blue)](https://anaconda.org/conda-forge/aeon) [![!python-versions](https://img.shields.io/pypi/pyversions/aeon?logo=python)](https://www.python.org/) [![!black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) [![license](https://img.shields.io/badge/license-BSD%203--Clause-green?logo=style)](https://github.com/aeon-toolkit/aeon/blob/main/LICENSE) [![binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/aeon-toolkit/aeon/main?filepath=examples)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
  | **Community**   | [![!slack](https://img.shields.io/static/v1?logo=slack&label=Slack&message=chat&color=lightgreen)](https://join.slack.com/t/aeon-toolkit/shared_invite/zt-22vwvut29-HDpCu~7VBUozyfL_8j3dLA) [![!linkedin](https://img.shields.io/static/v1?logo=linkedin&label=LinkedIn&message=news&color=lightblue)](https://www.linkedin.com/company/aeon-toolkit/) [![!x-twitter](https://img.shields.io/static/v1?logo=x&label=X/Twitter&message=news&color=lightblue)](https://twitter.com/aeon_toolkit)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
  | **Affiliation** | [![numfocus](https://img.shields.io/badge/NumFOCUS-Affiliated%20Project-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](https://numfocus.org/sponsored-projects/affiliated-projects)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |



  `aeon` requires a Python version of 3.9 or greater. Our full installation guide is
  available in our [documentation](https://www.aeon-toolkit.org/en/stable/installation.html).

  The easiest way to install `aeon` is via pip:

  ```bash
  pip install aeon
  ```

  Some estimators require additional packages to be installed. If you want to install
  the full package with all optional dependencies, you can use:

  ```bash
  pip install aeon[all_extras]
  ```

  Instructions for installation from the [GitHub source](https://github.com/aeon-toolkit/aeon)
  can be found [here](https://www.aeon-toolkit.org/en/stable/developer_guide/dev_installation.html).



  The best place to get started for all `aeon` packages is our [getting started guide](https://www.aeon-toolkit.org/en/stable/getting_started.html).

  Below we provide a quick example of how to use `aeon` for classification and clustering.



  Time series classification looks to predict class labels fore unseen series using a
  model fitted from a collection of time series. The framework for regression is similar,
  replace the classifier with a regressor and the labels with continuous values.

  ```python
  import numpy as np
  from aeon.classification.distance_based import KNeighborsTimeSeriesClassifier

  X = np.array([[[1, 2, 3, 4, 5, 5]],  # 3D array example (univariate)
               [[1, 2, 3, 4, 4, 2]],   # Three samples, one channel,
               [[8, 7, 6, 5, 4, 4]]])  # six series length
  y = np.array(['low', 'low', 'high'])  # class labels for each sample

  clf = KNeighborsTimeSeriesClassifier(distance="dtw")
  clf.fit(X, y)  # fit the classifier on train data
  >>> KNeighborsTimeSeriesClassifier()

  X_test = np.array(
      [[[2, 2, 2, 2, 2, 2]], [[5, 5, 5, 5, 5, 5]], [[6, 6, 6, 6, 6, 6]]]
  )
  y_pred = clf.predict(X_test)  # make class predictions on new data
  >>> ['low' 'high' 'high']
  ```



  Time series clustering groups similar time series together from a collection of
  time series.

  ```python
  import numpy as np
  from aeon.clustering import TimeSeriesKMeans

  X = np.array([[[1, 2, 3, 4, 5, 5]],  # 3D array example (univariate)
               [[1, 2, 3, 4, 4, 2]],   # Three samples, one channel,
               [[8, 7, 6, 5, 4, 4]]])  # six series length

  clu = TimeSeriesKMeans(distance="dtw", n_clusters=2)
  clu.fit(X)  # fit the clusterer on train data
  >>> TimeSeriesKMeans(distance='dtw', n_clusters=2)

  clu.labels_ # get training cluster labels
  >>> array([0, 0, 1])

  X_test = np.array(
      [[[2, 2, 2, 2, 2, 2]], [[5, 5, 5, 5, 5, 5]], [[6, 6, 6, 6, 6, 6]]]
  )
  clu.predict(X_test)  # Assign clusters to new data
  >>> array([1, 0, 0])
  ```



  | Type                               | Platforms                         |
  |------------------------------------|-----------------------------------|
  | 🐛 **Bug Reports**                 | [GitHub Issue Tracker]            |
  | ✨ **Feature Requests & Ideas**     | [GitHub Issue Tracker] & [Slack]  |
  | 💻 **Usage Questions**             | [GitHub Discussions] & [Slack]    |
  | 💬 **General Discussion**          | [GitHub Discussions] & [Slack]    |
  | 🏭 **Contribution & Development**  | [Slack]                           |

  [GitHub Issue Tracker]: https://github.com/aeon-toolkit/aeon/issues
  [GitHub Discussions]: https://github.com/aeon-toolkit/aeon/discussions
  [Slack]: https://join.slack.com/t/aeon-toolkit/shared_invite/zt-22vwvut29-HDpCu~7VBUozyfL_8j3dLA

  For enquiries about the project or collaboration, our email is
  [contact@aeon-toolkit.org](mailto:contact@aeon-toolkit.org).



  If you use `aeon` we would appreciate a citation of the following [paper](https://jmlr.org/papers/v25/23-1444.html):

  ```bibtex
  @article{aeon24jmlr,
    author  = {Matthew Middlehurst and Ali Ismail-Fawaz and Antoine Guillaume and Christopher Holder and David Guijo-Rubio and Guzal Bulatova and Leonidas Tsaprounis and Lukasz Mentel and Martin Walter and Patrick Sch{{\"a}}fer and Anthony Bagnall},
    title   = {aeon: a Python Toolkit for Learning from Time Series},
    journal = {Journal of Machine Learning Research},
    year    = {2024},
    volume  = {25},
    number  = {289},
    pages   = {1--10},
    url     = {http://jmlr.org/papers/v25/23-1444.html}
  }
  ```

  If you let us know about your paper using `aeon`, we will happily list it [here](https://www.aeon-toolkit.org/en/stable/papers_using_aeon.html).

rpm_license:
  BSD 3-Clause License  Copyright (c) The aeon developers. Copyright (c) 2022 The sktime developers.  All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  * Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: bf45f4be7c4f71bfa70f128ce682646a10b678afab538d38c7ba734836cba9e2
name: python-aepp
arch: src
version: 0.3.6.post2
epoch: 0
release: 1
summary: Package to manage AEP API endpoint and some helper functions
url: https://github.com/adobe/aepp
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aepp-0.3.6.post2-1.src.rpm
checksum_type: sha256
description:
  This repository will document the AEP wrapper on python.
  It is focusing on helping accessing the different endpoints of Adobe Experience Platform API.
  Documentation on the different endpoints can be found here : [AEP API doc](https://www.adobe.io/apis/experienceplatform/home/api-reference.html)
  The wrapper is currently named **aepp**, it stands for Adobe Experience Platform Python.



  You can install the module directly from a pypi command:

  ```shell
  pip install aepp
  ```

  The version of the wrapper can be seen by the following command (once loaded):

  ```python
  import aepp
  aepp.__version__

  ```

  **Consider upgrading regulary**

  ```shell
  pip install aepp --upgrade
  ```

  **NOTE TO PYTHON 3.10.X**

  At the moment, not all packages are supported on python 3.10.X, therefore, please use this module with a python 3.9.X version.\
  You can use pyenv to generate a local environment if required.



  In order to get started, I have compiled a guide to help you initialize this module and what is required.
  You can find this documentation [here](./docs/getting-started.md)



  At the moment the current wrapper is containing the following sub modules:

  * [schema](./docs/schema.md)
    * [SchemaManager](./docs/schemaManager.md)
    * [FieldGroupManager](./docs/fieldGroupManager.md)
    * [DataTypeManager](./docs/dataTypeManager.md)
  * [queryservice](./docs/queryservice.md)
  * [identity](./docs/identity.md)
  * [sandboxes](./docs/sandboxes.md)
  * [dataaccess](./docs/dataaccess.md)
  * [catalog](./docs/catalog.md)
  * [customerprofile](./docs/customerprofile.md)
  * [segmentation](./docs/segmentation.md)
  * [dataprep](./docs/dataprep.md)
  * [flowservice](./docs/flowservice.md)
  * [policy](./docs/policy.md)
  * [datasets](./docs/datasets.md)
  * [ingestion](./docs/ingestion.md)
  * [destination Authoring](./docs/destination.md)
  * [destination Instance](./docs/destinationinstanceservice.md)
  * [observability](./docs/observability.md)
  * [accesscontrol](./docs/accesscontrol.md)
  * [privacyservice](./docs/privacyservice.md) (see 2nd note below)
  * [data hygiene](./docs/hygiene.md)
  * [edge](./docs/edge.md)

  Last but not least, the core methods are described here: [main](./docs/main.md)



  The wrapper is having a class in all submodule in order to connect to the different service APIs.\
  In addition to that, there are other classes that are provided in order to help you working with the API.



  These classes are implemented in the `queryservice` modulebased on the pyGreSQL and psycopg2 module for python.\
  It provides you the capability to realize query directly from your local Jupyter notebook and returns a dataframe.
  In order to use these classes, you would need to install these module and a PSQL server.
  On top of that, you would need to the psql server accessible in the environment path.



  These classes are available from the `schema` module and alloy you to handle the different elements of the schema definition.
  You can use them to extract information on your schema definition.



  The FlowManager is part of the `flowservice` module and allows you to group every aspect of a flow in a single class and simplify the search for the relationship between `sourceFlows`, `targetFlow` and the main flow elements.



  The privacy service module is part of the AEP python wrapper (`aepp`) but requires a different JWT connection in console.adobe.io.
  Be careful that your JWT connection has the correct setup to access this API endpoints.



  Release notes are accessible [here](./docs/releases.md).


pkgId: 0867eec4dadd0c095b7c58283157e93bfe69f1aeb2b1defe1a784db123c71642
name: python-aepp-sdk
arch: src
version: 7.0.0
epoch: 0
release: 1
summary: Python SDK to interact with the Æternity blockchain
url: https://github.com/aeternity/aepp-sdk-python
rpm_license: ISC
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aepp-sdk-7.0.0-1.src.rpm
checksum_type: sha256
description:
  [![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
  [![Build Status](https://travis-ci.com/aeternity/aepp-sdk-python.svg?branch=develop)](http://travis-ci.com/aeternity/aepp-sdk-python?branch=develop)
  [![PyPI version](https://badge.fury.io/py/aepp-sdk.svg)](https://badge.fury.io/py/aepp-sdk)
  [![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/aeternity/aepp-sdk-python.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/aeternity/aepp-sdk-python/context:python)
  [![Documentation Status](https://readthedocs.org/projects/aepp-sdk-python/badge/?version=latest)](https://aepp-sdk-python.readthedocs.io/en/latest/?badge=latest)

  Welcome to the [Aeternity](https://aeternity.com) SDK for Python

  For support visit the [forum](https://forum.aeternity.com), for bug reports or feature requests visit open an [issue](https://github.com/aeternity/aepp-sdk-python/issues).



  - [Stable](https://aepp-sdk-python.readthedocs.io/en/stable/) for the `master` branch (current release).
  - [Latest](https://aepp-sdk-python.readthedocs.io/en/latest/) for the `develop` branch


  - [Aeternity node](https://github.com/aeternity/aeternity)
  - [Protocol documentation](https://github.com/aeternity/protocol)


  - [Mainnet API Gateway](https://mainnet.aeternity.io/v2/status)
  - [Mainnet frontend and middleware](https://mainnet.aeternal.io) (Aeternal)
  - [Testnet API Gateway](https://mainnet.aeternity.io/v2/status)
  - [Testnet frontend and middleware](https://testnet.aeternal.io) (Aeternal)
  - [Testnet faucet](https://testnet.faucet.aepps.com)


pkgId: 08a8d81b368359c47dc0e5bb22da452953f4a8e8e3125a466f64d5f328b1811d
name: python-aeppl-nightly
arch: src
version: 0.0.40
epoch: 0
release: 1
summary: PPL tools for Aesara
url: https://github.com/aesara-devs/aeppl
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aeppl-nightly-0.0.40-1.src.rpm
checksum_type: sha256
description:
  - Convert graphs containing Aesara ``RandomVariable``\s into joint
    log-probability graphs
  - Transforms for ``RandomVariable``\s that map constrained support spaces to
    unconstrained spaces (e.g. the extended real numbers), and a rewrite that
    automatically applies these transformations throughout a graph
  - Tools for traversing and transforming graphs containing ``RandomVariable``\s
  - ``RandomVariable``-aware pretty printing and LaTeX output


pkgId: f26df056bede3cfe622a32a62a3d57668565507c03a2071bdcb7879b68fda971
name: python-aepsych
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Adaptive experimetation for psychophysics
url: https://pypi.org/project/aepsych/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aepsych-0.5.0-1.src.rpm
checksum_type: sha256
description:
  AEPsych is a framework and library for adaptive experimetation in psychophysics and related domains.


  `AEPsych` only supports python 3.10+. We recommend installing `AEPsych` under a virtual environment like
  [Anaconda](https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html).
  Once you've created a virtual environment for `AEPsych` and activated it, you can install `AEPsych` using pip:

  ```
  pip install aepsych
  ```

  If you're a developer or want to use the latest features, you can install from GitHub using:

  ```
  git clone https://github.com/facebookresearch/aepsych.git
  cd aepsych
  pip install -e .[dev]
  ```


  **See the code examples [here](https://github.com/facebookresearch/aepsych/tree/main/examples).**

  The canonical way of using AEPsych is to launch it in server mode (you can run `aepsych_server` --help to see additional arguments):

  ```
  aepsych_server --port 5555 --ip 0.0.0.0 --db mydatabase.db
  ```

  The server accepts messages over a unix socket, and
  all messages are formatted using [JSON](https://www.json.org/json-en.html). All messages
  have the following format:

  ```
  {
       "type":<TYPE>,
       "message":<MESSAGE>,
  }
  ```

  There are five message types: `setup`, `resume`, `ask`, `tell` and `exit` (see [aepsych/server/message_handlers](https://github.com/facebookresearch/aepsych/tree/main/aepsych/server/message_handlers) for the full set of messages).

  The `setup` message prepares the server for making suggestions and accepting data. The setup
  message can be formatted as either INI or a python dict (similar to JSON) format, and an example
  for psychometric threshold estimation is given in `configs/single_lse_example.ini`. It looks like this:

  ```
  {
      "type":"setup",
      "message":{"config_str":<PASTED CONFIG STRING>}
  }
  ```
  After receiving a setup message, the server responds with a strategy index that can be used
  to resume this setup (for example, for interleaving multiple experiments).


  The `resume` message tells the server to resume a strategy from earlier in the same run. It looks like this:
  ```
  {
      "type":"resume",
      "message":{"strat_id":"0"}
  }
  ```
  After receiving a resume message, the server responds with the strategy index resumed.


  The `ask` message queries the server for the next trial configuration. It looks like this:

  ```
  {
      "type":"ask",
      "message":""
  }
  ```
  After receiving an ask message, the server responds with a configuration in JSON format, for example
  `{"frequency":100, "intensity":0.8}`


  The `tell` message updates the server with the outcome for a trial configuration. Note that the
  `tell` does not need to match with a previously `ask`'d trial. For example, if you are interleaving
  AEPsych runs with a classical staircase, you can still feed AEPsych with the staircase data. A message
  looks like this:
  ```
  {
      "type":"tell",
      "message":{
          "config":{
                  "frequency":100,
                  "intensity":0.8
              },
          "outcome":"1",
      }
  }
  ```

  The `exit` message tells the server to close the socket connection, write strats into the database and terminate current session.
  The message is:
  ```
  {
      "type":"exit",
  }
  ```
  The server closes the connection.


  The data is logged to a SQLite database on disk (by default, `databases/default.db`). The database
  has one table containing all experiment sessions that were run. Then, for each experiment there
  is a table containing all messages sent and received by the server, capable of supporting a
  full replay of the experiment from the server's perspective. This table can be summarized
  into a data frame output (docs forthcoming) and used to visualize data (docs forthcoming).


  See the [CONTRIBUTING](CONTRIBUTING.md) file for how to help out.


  AEPsych licensed CC-BY-NC 4.0, as found in the [LICENSE](LICENSE) file.


  The AEPsych paper is currently under review. In the meanwhile, you can cite our [preprint](https://arxiv.org/abs/2104.09549):

      Owen, L., Browder, J., Letham, B., Stocek, G., Tymms, C., & Shvartsman, M. (2021). Adaptive Nonparametric Psychophysics. http://arxiv.org/abs/2104.09549


pkgId: 0013052d27b34aefe6f6c9ef64510bc23ffc145fc755696fad1562961283ffc1
name: python-aerforge
arch: src
version: 0.3.5
epoch: 0
release: 1
summary: A game engine made with pygame.
url: https://github.com/Aermoss/AerForge
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aerforge-0.3.5-1.src.rpm
checksum_type: sha256
description:
  A game engine made with pygame.


  1) Install Python
  2) Open cmd/terminal and type:

  ```
  pip install AerForge
  ```



  ``` python
  from aerforge import *

  forge = Forge()

  @forge.event
  def update():
      pass

  forge.run()
  ```


  ``` python
  from aerforge import *

  forge = Forge()

  class Cube(Entity):
      def __init__(self):
          super().__init__(
              window = forge,
              shape = shape.Rect,
              width = 20,
              height = 20,
              x = 0,
              y = 0,
              color = color.Color(0, 255, 255)
          )

          self.center()

  cube = Cube()

  @forge.event
  def update():
      pass

  forge.run()
  ```


pkgId: 81a960a2b614b44d3ab6817b123a506d8bd95c40b22b1f1d0a727d8dfa2e515d
name: python-aerich
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: A database migrations tool for Tortoise ORM.
url: https://github.com/tortoise/aerich
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aerich-0.7.2-1.src.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/pypi/v/aerich.svg?style=flat)](https://pypi.python.org/pypi/aerich)
  [![image](https://img.shields.io/github/license/tortoise/aerich)](https://github.com/tortoise/aerich)
  [![image](https://github.com/tortoise/aerich/workflows/pypi/badge.svg)](https://github.com/tortoise/aerich/actions?query=workflow:pypi)
  [![image](https://github.com/tortoise/aerich/workflows/ci/badge.svg)](https://github.com/tortoise/aerich/actions?query=workflow:ci)

  English | [Русский](./README_RU.md)



  Aerich is a database migrations tool for TortoiseORM, which is like alembic for SQLAlchemy, or like Django ORM with
  it\'s own migration solution.



  Just install from pypi:

  ```shell
  pip install aerich
  ```



  ```shell
  > aerich -h

  Usage: aerich [OPTIONS] COMMAND [ARGS]...

  Options:
    -V, --version      Show the version and exit.
    -c, --config TEXT  Config file.  [default: pyproject.toml]
    --app TEXT         Tortoise-ORM app name.
    -h, --help         Show this message and exit.

  Commands:
    downgrade  Downgrade to specified version.
    heads      Show current available heads in migrate location.
    history    List all migrate items.
    init       Init config file and generate root migrate location.
    init-db    Generate schema and generate app migrate location.
    inspectdb  Introspects the database tables to standard output as...
    migrate    Generate migrate changes file.
    upgrade    Upgrade to specified version.
  ```



  You need add `aerich.models` to your `Tortoise-ORM` config first. Example:

  ```python
  TORTOISE_ORM = {
      "connections": {"default": "mysql://root:123456@127.0.0.1:3306/test"},
      "apps": {
          "models": {
              "models": ["tests.models", "aerich.models"],
              "default_connection": "default",
          },
      },
  }
  ```



  ```shell
  > aerich init -h

  Usage: aerich init [OPTIONS]

    Init config file and generate root migrate location.

  Options:
    -t, --tortoise-orm TEXT  Tortoise-ORM config module dict variable, like
                             settings.TORTOISE_ORM.  [required]
    --location TEXT          Migrate store location.  [default: ./migrations]
    -s, --src_folder TEXT    Folder of the source, relative to the project root.
    -h, --help               Show this message and exit.
  ```

  Initialize the config file and migrations location:

  ```shell
  > aerich init -t tests.backends.mysql.TORTOISE_ORM

  Success create migrate location ./migrations
  Success write config to pyproject.toml
  ```



  ```shell
  > aerich init-db

  Success create app migrate location ./migrations/models
  Success generate schema for app "models"
  ```

  If your Tortoise-ORM app is not the default `models`, you must specify the correct app via `--app`,
  e.g. `aerich --app other_models init-db`.



  ```shell
  > aerich migrate --name drop_column

  Success migrate 1_202029051520102929_drop_column.py
  ```

  Format of migrate filename is
  `{version_num}_{datetime}_{name|update}.py`.

  If `aerich` guesses you are renaming a column, it will ask `Rename {old_column} to {new_column} [True]`. You can choose
  `True` to rename column without column drop, or choose `False` to drop the column then create. Note that the latter may
  lose data.



  ```shell
  > aerich upgrade

  Success upgrade 1_202029051520102929_drop_column.py
  ```

  Now your db is migrated to latest.



  ```shell
  > aerich downgrade -h

  Usage: aerich downgrade [OPTIONS]

    Downgrade to specified version.

  Options:
    -v, --version INTEGER  Specified version, default to last.  [default: -1]
    -d, --delete           Delete version files at the same time.  [default:
                           False]

    --yes                  Confirm the action without prompting.
    -h, --help             Show this message and exit.
  ```

  ```shell
  > aerich downgrade

  Success downgrade 1_202029051520102929_drop_column.py
  ```

  Now your db is rolled back to the specified version.



  ```shell
  > aerich history

  1_202029051520102929_drop_column.py
  ```



  ```shell
  > aerich heads

  1_202029051520102929_drop_column.py
  ```



  Currently `inspectdb` support MySQL & Postgres & SQLite.

  ```shell
  Usage: aerich inspectdb [OPTIONS]

    Introspects the database tables to standard output as TortoiseORM model.

  Options:
    -t, --table TEXT  Which tables to inspect.
    -h, --help        Show this message and exit.
  ```

  Inspect all tables and print to console:

  ```shell
  aerich --app models inspectdb
  ```

  Inspect a specified table in the default app and redirect to `models.py`:

  ```shell
  aerich inspectdb -t user > models.py
  ```

  For example, you table is:

  ```sql
  CREATE TABLE `test`
  (
      `id`       int            NOT NULL AUTO_INCREMENT,
      `decimal`  decimal(10, 2) NOT NULL,
      `date`     date                                    DEFAULT NULL,
      `datetime` datetime       NOT NULL                 DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
      `time`     time                                    DEFAULT NULL,
      `float`    float                                   DEFAULT NULL,
      `string`   varchar(200) COLLATE utf8mb4_general_ci DEFAULT NULL,
      `tinyint`  tinyint                                 DEFAULT NULL,
      PRIMARY KEY (`id`),
      KEY `asyncmy_string_index` (`string`)
  ) ENGINE = InnoDB
    DEFAULT CHARSET = utf8mb4
    COLLATE = utf8mb4_general_ci
  ```

  Now run `aerich inspectdb -t test` to see the generated model:

  ```python
  from tortoise import Model, fields


  class Test(Model):
      date = fields.DateField(null=True, )
      datetime = fields.DatetimeField(auto_now=True, )
      decimal = fields.DecimalField(max_digits=10, decimal_places=2, )
      float = fields.FloatField(null=True, )
      id = fields.IntField(pk=True, )
      string = fields.CharField(max_length=200, null=True, )
      time = fields.TimeField(null=True, )
      tinyint = fields.BooleanField(null=True, )
  ```

  Note that this command is limited and can't infer some fields, such as `IntEnumField`, `ForeignKeyField`, and others.



  ```python
  tortoise_orm = {
      "connections": {
          "default": expand_db_url(db_url, True),
          "second": expand_db_url(db_url_second, True),
      },
      "apps": {
          "models": {"models": ["tests.models", "aerich.models"], "default_connection": "default"},
          "models_second": {"models": ["tests.models_second"], "default_connection": "second", },
      },
  }
  ```

  You only need to specify `aerich.models` in one app, and must specify `--app` when running `aerich migrate` and so on.



  In some cases, such as broken changes from upgrade of `aerich`, you can't run `aerich migrate` or `aerich upgrade`, you
  can make the following steps:

  1. drop `aerich` table.
  2. delete `migrations/{app}` directory.
  3. rerun `aerich init-db`.

  Note that these actions is safe, also you can do that to reset your migrations if your migration files is too many.



  You can use `aerich` out of cli by use `Command` class.

  ```python
  from aerich import Command

  command = Command(tortoise_config=config, app='models')
  await command.init()
  await command.migrate('test')
  ```



  This project is licensed under the
  [Apache-2.0](https://github.com/long2ice/aerich/blob/master/LICENSE) License.


