# packages

pkgId: 6838404659e79952d975200cc471cb04150fe6497a5149770583f263417f3f96
name: python-abarms
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: abarms is now hoardy-adb
url: https://pypi.org/project/abarms/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abarms-1.1.3-1.src.rpm
checksum_type: sha256
description:
  This package has been renamed. Use `pip install hoardy-adb` instead.

  New package: https://pypi.org/project/hoardy-adb/


pkgId: 9b567c6ad117f153ade057383d06881c6fb366c44336b0799f97910c918b1a12
name: python-abarorm
arch: src
version: 3.2.1
epoch: 0
release: 1
url: https://github.com/prodbygodfather/abarorm
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abarorm-3.2.1-1.src.rpm
checksum_type: sha256
summary:
  abarorm is a lightweight and easy-to-use Object-Relational Mapping (ORM) library for SQLite & PostgreSQL and MySQL databases in Python. It aims to provide a simple and intuitive interface for managing database models and interactions.

description:
  | ![abarorm Logo](https://prodbygodfather.github.io/abarorm/images/logo.png) | **abarorm** is a lightweight and easy-to-use Object-Relational Mapping (ORM) library for SQLite, MySQL, and PostgreSQL databases in Python. It provides a simple and intuitive interface for managing database models and interactions. |
  |----------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|



  - Define models using Python classes.
  - Automatically handle database schema creation and management.
  - Support for basic CRUD (Create, Read, Update, Delete) operations.
  - Manage foreign key relationships effortlessly.
  - Custom field types with validation and constraints.
  - **New in v1.0.0**: Automatic table creation and updates without needing explicit `create_table()` calls.
  - **New in v2.0.0**: Added support for PostgreSQL databases.
  - **New in v2.0.0**: Ordering by fields in the `all()` method.
  - **New in v3.0.0**: Fixed table naming bugs to ensure consistent naming conventions.
  - **New in v3.0.0**: Updated return values for methods to improve clarity and usability.
  - **New in v3.0.0**: Enhanced `filter` method now supports `order_by` functionality for result ordering.
  - **New in v3.2.0**: Added `__gte` and `__lte` functionality in the filter section.




  You can install [**abarorm**](https://pypi.org/project/abarorm/) from PyPI using pip:

  ```bash
  pip install abarorm
  ```
  For MySQL support, you also need to install `mysql-connector-python`:

  ```bash
  pip install mysql-connector-python
  ```
  For PostgreSQL support, you need to install `psycopg2-binary`:
  ```bash
  pip install psycopg2-binary
  ```


  For detailed documentation, examples, and advanced usage, please visit the [official abarorm documentation website](https://prodbygodfather.github.io/abarorm/).


  Before defining models, you need to set up your database configuration. This involves specifying connection parameters for the database you are using (SQLite, MySQL, or PostgreSQL). Here’s an example of how to configure the database:
  ```python

  DATABASE_CONFIG = {
      'sqlite': {
          'db_name': 'example.db',  # Name of the SQLite database file
      },
      'mysql': {
          'host': 'localhost',
          'user': 'your_mysql_user',
          'password': 'your_mysql_password',
          'database': 'example_db',
      },
      'postgresql': {
          'host': 'localhost',
          'user': 'your_pg_user',
          'password': 'your_pg_password',
          'database': 'example_db',
      }
  }
  ```

  After setting up the database configuration, you can define your models. A model is a representation of a database table. Here’s how to create a model using abarorm:
  ```python
  from abarorm import SQLiteModel, MySQLModel, PostgreSQLModel
  from abarorm.fields import CharField, DateTimeField, ForeignKey


  class Category(SQLiteModel):
      class Meta:
          db_config = DATABASE_CONFIG['sqlite']
          table_name = 'categories'  # Name of the table for storing the Category model data

      title = CharField(max_length=200, null=False)  # Title of the category, must be unique and not null
      create_time = DateTimeField(auto_now=True, auto_now_add=True)  # Automatically set to current datetime
      update_time = DateTimeField(auto_now=True)  # Automatically set to current datetime



  class Post(MySQLModel):
      class Meta:
          db_config = DATABASE_CONFIG['mysql']

      title = CharField(max_length=100, null=False)  # Title of the post, must be unique and not null
      create_time = DateTimeField(auto_now=True)  # Automatically set to current datetime
      category = ForeignKey(to=Category)  # Foreign key referring to the Category model
  ```

  Now that you have defined your models, you can perform CRUD operations. Here’s a breakdown of each operation:

  To create new records in the database, use the `create()` method. For example:
  ```python

  Category.create(title='Movies')


  category = Category.get(id=1)  # Fetch the category with ID 1
  if category:
      Post.create(title='Godfather', category=category.id)  # Create a new post associated with the fetched category
  ```

  To read records from the database, use the `all()` or `get()` methods:
  ```python

  all_posts = Post.all()


  post_data = Post.get(id=1)
  ```

  The `filter()` method allows you to retrieve records based on specified criteria. You can use keyword arguments to filter by field values and sort the results using `order_by`.
  ```python

  filtered_posts = Post.filter(category=category.id, order_by='-create_time')
  ```

  You can also use special lookup expressions like `__gte` (greater than or equal to) and `__lte` (less than or equal to) for more complex queries:
  ```python

  filtered_posts = Post.filter(create_time__gte='2024-01-01 00:00:00')
  ```


  To update existing records, fetch the record, modify its attributes, and then save it:
  ```python
  if post_data:
      post_data.title = "The Godfather"
      post_data.save()  # Save the updated post data
  ```
  Or:
  ```python
  Post.update(1, title='Updated Godfather')  # Update the title of the post with ID 1 to 'Updated Godfather'
  ```

  To delete a record from the database, use the `delete()` method:
  ```python
  Post.delete(1)  # Delete the post with ID 1
  ```





  - **Fixed Table Naming**: Resolved issues related to inconsistent table naming conventions.
  - **Return Values Updated**: Methods now return values that enhance clarity and usability.
  - **Filter Enhancements**: The `filter` method now includes support for `order_by`, allowing for more flexible queries.

  **Important for Developers:** When adding new fields to models, they will default to `NULL`. It’s recommended to recreate the database schema after development is complete to ensure fields have appropriate constraints and default values.



  Contributions are welcome! If you find any issues or have suggestions for improvements, please open an issue or submit a pull request on GitHub.



  This project is licensed under the [Apache-2.0 License](https://github.com/ProdByGodfather/abarorm/blob/main/LICENSE) - see the LICENSE file for details.



  - **Python**: The language used for this project.
  - **SQLite & MySQL**: The databases supported by this project.
  - **setuptools**: The tool used for packaging and distributing the library.
  - **psycopg2-binary**: The PostgreSQL adapter used for connecting to PostgreSQL databases.


pkgId: 5b4e6d37114fe0b02566b29a29d7462a5e1810ef6b0521b7407bd45d3dfc273d
name: python-abarorm
arch: src
version: 4.2.3
epoch: 0
release: 1
url: https://github.com/prodbygodfather/abarorm
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abarorm-4.2.3-1.src.rpm
checksum_type: sha256
summary:
  abarorm is a lightweight and easy-to-use Object-Relational Mapping (ORM) library for SQLite & PostgreSQL and MySQL databases in Python. It aims to provide a simple and intuitive interface for managing database models and interactions.

description:
  | ![abarorm Logo](https://prodbygodfather.github.io/abarorm/images/logo.png) | **abarorm** is a lightweight and easy-to-use Object-Relational Mapping (ORM) library for SQLite, MySQL, and PostgreSQL databases in Python. It provides a simple and intuitive interface for managing database models and interactions. |
  |----------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|



  - Define models using Python classes.
  - Automatically handle database schema creation and management.
  - Support for basic CRUD (Create, Read, Update, Delete) operations.
  - Manage foreign key relationships effortlessly.
  - Custom field types with validation and constraints.
  - **New in v1.0.0**: Automatic table creation and updates without needing explicit `create_table()` calls.
  - **New in v2.0.0**: Added support for PostgreSQL databases.
  - **New in v2.0.0**: Ordering by fields in the `all()` method.
  - **New in v3.0.0**: Fixed table naming bugs to ensure consistent naming conventions.
  - **New in v3.0.0**: Updated return values for methods to improve clarity and usability.
  - **New in v3.0.0**: Enhanced `filter` method now supports `order_by` functionality for result ordering.
  - **New in v3.2.0**: Added `__gte` and `__lte` functionality in the filter section.
  - **New in v4.0.0**: Added `__repr__`, `count`, and `to_dict` methods for easier data manipulation and debugging.
  - **New in v4.2.3**: Added `first()`, `last()`, `exists()`, and `paginate()` methods to the QuerySet class for more powerful querying capabilities.






  You can install [**abarorm**](https://pypi.org/project/abarorm/) from PyPI using pip:

  ```bash
  pip install abarorm
  ```
  For MySQL support, you also need to install `mysql-connector-python`:

  ```bash
  pip install mysql-connector-python
  ```
  For PostgreSQL support, you need to install `psycopg2-binary`:
  ```bash
  pip install psycopg2-binary
  ```


  For detailed documentation, examples, and advanced usage, please visit the [official abarorm documentation website](https://prodbygodfather.github.io/abarorm/).


  Before defining models, you need to set up your database configuration. This involves specifying connection parameters for the database you are using (SQLite, MySQL, or PostgreSQL). Here’s an example of how to configure the database:
  ```python

  DATABASE_CONFIG = {
      'sqlite': {
          'db_name': 'example.db',  # Name of the SQLite database file
      },
      'mysql': {
          'host': 'localhost',
          'user': 'your_mysql_user',
          'password': 'your_mysql_password',
          'database': 'example_db',
      },
      'postgresql': {
          'host': 'localhost',
          'user': 'your_pg_user',
          'password': 'your_pg_password',
          'database': 'example_db',
      }
  }
  ```

  After setting up the database configuration, you can define your models. A model is a representation of a database table. Here’s how to create a model using abarorm:
  ```python
  from abarorm import SQLiteModel, MySQLModel, PostgreSQLModel
  from abarorm.fields import CharField, DateTimeField, ForeignKey


  class Category(SQLiteModel):
      class Meta:
          db_config = DATABASE_CONFIG['sqlite']
          table_name = 'categories'  # Name of the table for storing the Category model data

      title = CharField(max_length=200, null=False)  # Title of the category, must be unique and not null
      create_time = DateTimeField(auto_now=True, auto_now_add=True)  # Automatically set to current datetime
      update_time = DateTimeField(auto_now=True)  # Automatically set to current datetime



  class Post(MySQLModel):
      class Meta:
          db_config = DATABASE_CONFIG['mysql']

      title = CharField(max_length=100, null=False)  # Title of the post, must be unique and not null
      create_time = DateTimeField(auto_now=True)  # Automatically set to current datetime
      category = ForeignKey(to=Category)  # Foreign key referring to the Category model
  ```

  Now that you have defined your models, you can perform CRUD operations. Here’s a breakdown of each operation:

  To create new records in the database, use the `create()` method. For example:
  ```python

  Category.create(title='Movies')


  category = Category.get(id=1)  # Fetch the category with ID 1
  if category:
      Post.create(title='Godfather', category=category.id)  # Create a new post associated with the fetched category
  ```

  To read records from the database, use the `all()` or `get()` methods:
  ```python

  all_posts = Post.all()


  post_data = Post.get(id=1)
  ```

  The `filter()` method allows you to retrieve records based on specified criteria. You can use keyword arguments to filter by field values and sort the results using `order_by`.
  ```python

  filtered_posts = Post.filter(category=category.id, order_by='-create_time')
  ```

  You can also use special lookup expressions like `__gte` (greater than or equal to) and `__lte` (less than or equal to) for more complex queries:
  ```python

  filtered_posts = Post.filter(create_time__gte='2024-01-01 00:00:00')
  ```


  To update existing records, fetch the record, modify its attributes, and then save it:
  ```python
  if post_data:
      post_data.title = "The Godfather"
      post_data.save()  # Save the updated post data
  ```
  Or:
  ```python
  Post.update(1, title='Updated Godfather')  # Update the title of the post with ID 1 to 'Updated Godfather'
  ```

  To delete a record from the database, use the `delete()` method:
  ```python
  Post.delete(1)  # Delete the post with ID 1
  ```

  After performing operations on the model, you can convert records to dictionaries using the `to_dict()` method and count the number of records using the `count()` method.


  The `to_dict()` method converts a model instance into a dictionary, making it easier to manipulate and serialize the data.

  **Example:**
  ```python

  post = Post.get(id=1)


  post_dict = post.all().to_dict()
  print(post_dict)

  ```


  The `count()` method allows you to get the number of records in a model's table.

  **Example:**
  ```python

  num_posts = Post.count()
  print(num_posts)  # Output: 10 (if there are 10 posts in the database)
  ```


  - `first():` Returns the first result or None if no results are present.
  - `last():` Returns the last result or None if no results are present.
  - `exists():` Checks if any records exist in the `QuerySet`.
  - `paginate():` Handles pagination of results, allowing you to retrieve subsets of data based on page and page size.

  **Example:**
  ```python

  exists = Post.all().exists()


  first_post = Post.all().first()


  last_post = Post.all().last()


  paginated_posts = Post.all().paginate(1, 5)  # Page 1, 5 results per page


  posts = Post.filter(title='Godfather').order_by('create_time').paginate(1, 4).to_dict()
  ```

  These methods are particularly useful for data manipulation and debugging, as they provide a simple way to view and interact with your database records.



  - `first():` Added to return the first result in a `QuerySet`.
  - `last():` Added to return the last result in a `QuerySet`.
  - `exists():` Added to check if any records exist.
  - `paginate():` Added to handle pagination for large result sets.


  **Important for Developers:** When adding new fields to models, they will default to `NULL`. It’s recommended to recreate the database schema after development is complete to ensure fields have appropriate constraints and default values.



  Contributions are welcome! If you find any issues or have suggestions for improvements, please open an issue or submit a pull request on GitHub.



  This project is licensed under the [Apache-2.0 License](https://github.com/ProdByGodfather/abarorm/blob/main/LICENSE) - see the LICENSE file for details.



  - **Python**: The language used for this project.
  - **SQLite & MySQL**: The databases supported by this project.
  - **setuptools**: The tool used for packaging and distributing the library.
  - **psycopg2-binary**: The PostgreSQL adapter used for connecting to PostgreSQL databases.


pkgId: 65d4af2577ac00408419692fc7d5f5ddb5be6797aea8dce7fe2668b440669880
name: python-abba-python
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Aligning Big Brains and Atlases, controlled from Python.
url: https://github.com/BIOP/abba_python
rpm_license: GNU General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abba-python-0.8.0-1.src.rpm
checksum_type: sha256
description:
  [![](https://img.shields.io/pypi/v/abba_python.svg)](https://pypi.python.org/pypi/abba_python)

  [![](https://img.shields.io/travis/nicoKiaru/abba_python.svg)](https://travis-ci.com/nicoKiaru/abba_python)

  Aligning Big Brains and Atlases, controlled from Python.

  * Free software: GNU General Public License v3
  * Documentation: https://biop.github.io/ijp-imagetoatlas/



  Aligning Big Brains & Atlases, abbreviated as ABBA, allows you to register thin serial sections to multiple atlases in coronal, sagittal, and horizontal orientations. It is mainly a Java application, but this repo makes all of its API accessible in Python.

  With ABBA Python, you can control ABBA API from python, and get some additional perks. In particular you get access to all [BrainGlobe atlases](https://brainglobe.info/documentation/bg-atlasapi/usage/atlas-details.html).


  > [!WARNING]
  > Due to some threading issues, the GUI does not work with MacOSX



  1. Install [miniconda](https://docs.conda.io/projects/miniconda/en/latest/miniconda-install.html) or [miniforge](https://github.com/conda-forge/miniforge).
  2. Create a conda environment with Python 3.8, pyimagej, OpenJDK 8 and maven and activate it
  3. Install abba_python
  ```
  mamba create -c conda-forge -n abba-env python=3.8 openjdk=8 pip maven pyimagej

  conda activate abba-env

  pip install abba_python
  ```




  In the created environment, launch Python and run the following commands:

  ```
  from abba_python import abba
  abba.start_imagej()
  ```

  You can then use ABBA within Fiji; for more details, visit https://biop.github.io/ijp-imagetoatlas/.
  ABBA is typically used in conjunction with [QuPath](https://qupath.github.io/): a QuPath project can serve as input for ABBA, and the registration results can be imported back into QuPath for further processing.



  In the created environment, install `jupyterlab` and `ipywidgets`:

  ```
  pip install jupyterlab
  pip install ipywidgets
  ```

  You can now run `jupyter lab` and start using notebooks, like the ones provided in examples in the github repo.





  ABBA's automated in-plane registration relies on [elastix 5.0.1](https://github.com/SuperElastix/elastix). To utilize all of ABBA's functionalities, you need to separately install elastix and transformix on your operating system. During the initial run of ABBA, you will be prompted to specify their executable locations. Alternatively, you can set their paths using the API (refer to the [first example notebook](example_notebooks/0.%20Register%20And%20Save%20State.ipynb)).



  ABBA can leverage the deep-learning registration tool [DeepSlice](https://github.com/PolarBean/DeepSlice), either through the web interface (in the GUI) or by running it locally. To use DeepSlice locally, you must install it in a separate conda environment and specify its path to ABBA, either through the GUI or the API (as explained in the [first example notebook](example_notebooks/0.%20Register%20And%20Save%20State.ipynb)).

  Note that DeepSlice can also be used locally with the pure Java version thanks to this (new) design.

  To install DeepSlice, please refer to the documentation.

  In Sept 2023, this was working:

  ```
  conda create -n deepslice python=3.7
  conda activate deepslice
  conda install pip
  pip install DeepSlice==1.1.5
  pip install urllib3==1.26.6 # see https://github.com/PolarBean/DeepSlice/issues/46
  ```

  You also need to make conda available at the system level:
  You need to follow this two steps procedure to enable Windows to use conda from cmd.exe:
  * Into the environment variable, edit PATH, add path to your ..\Anaconda3\condabin default would be C:\ProgramData\Anaconda3\condabin
  * Open a new PowerShell (and/or PowerShell (x86) ), run the following command once to initialize conda:  `conda init`




  OpenJDK versions above 8 can work, but they have been less tested, so there may be unexpected bugs. To avoid [certificate issues](https://pyimagej.readthedocs.io/en/latest/Troubleshooting.html#unable-to-find-valid-certification-path), it is recommended to have openjdk installed from conda-forge.



  This package was created with Cookiecutter and the `audreyr/cookiecutter-pypackage` project template.

  [Cookiecutter](https://github.com/audreyr/cookiecutter)

  [audreyr/cookiecutter-pypackage](https://github.com/audreyr/cookiecutter-pypackage)


pkgId: 0b41d7c638ef7e17364ebb9d368cd76204d33c878cad94043882ed41582c494d
name: python-abbrev
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: 🐜 Expand abbreviations 🐜
url: https://github.com/rec/abbrev
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abbrev-1.2.1-1.src.rpm
checksum_type: sha256
description:
  Expand a `Sequence` or `Mapping` of string abbreviations.

  Handy when the user has a choice of commands with long names.



      import abbrev

      a = ['one', 'two', 'three']

      assert abbrev(a, 'one') == 'one'
      assert abbrev(a, 'o') == 'one'
      assert abbrev(a, 'tw') == 'two'

      abbrev(a, 'four')  # Raises a KeyError: no such key
      abbrev(a, 't')  # Raises a KeyError: ambiguous key ('two' or 'three'?)




      import abbrev

      d = {'one': 100, 'two': 200, 'three': 300}

      assert abbrev(d, 'one') == 100
      assert abbrev(d, 'o') == 100
      assert abbrev(d, 'tw') == 200



      import abbrev

      d = {'one': 100, 'two': 200, 'three': 300}

      abbreviator = abbrev(d)

      assert abbreviator('one') == my_abbrevs('o') == 100
      assert abbreviator('tw') == 200



      import abbrev

      a = ['one', 'two, 'three'}

      multi = abbrev(a, multi=True)  # Make an abbreviator

      assert multi('t') == abbrev(d, 't', multi=True) == ('two', three')
      assert multi('o') == abbrev(d, 'o', multi=True) == ('one', )

      multi('four')  # Still raises a key error



      import abbrev

      d = {'one': 100, 'two': 200, 'three': 300}

      assert abbrev(d, 't', unique=False) == (200, 300)


pkgId: cb56004b42b14cb69a411b3f210458dc203a492efbfc9dbdf6b89bbdc3a5cf39
name: python-abbreviation-uhh-what-is-word-for-tearing-apart-an-abbreviation
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: no, this page doesn't exist
url: https://pypi.org/project/abbreviation-uhh-what-is-word-for-tearing-apart-an-abbreviation/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abbreviation-uhh-what-is-word-for-tearing-apart-an-abbreviation-2.3.0-1.src.rpm
checksum_type: sha256
description:
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-green)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-blue)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-orange)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-yellow)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-red)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-pink)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-purple)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-white)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-black)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-teal)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-aquamarine)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-magenta)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-violet)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-indigo)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-silver)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-gold)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-beige)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-brown)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-gray)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-navy)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-brightgreen)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-yellowgreen)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-lightgray)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-blueviolet)
  ![Trivago hotel](https://img.shields.io/badge/hotel-Trivago-9cf)

  i swear dont look
  <br>
  please
  <br>
  i just made this for my friend

rpm_license:
  The MIT License (MIT) Copyright (c) 2022-present SqdNoises 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: a0b7bf844699be3622bc407d19929fe7f8f00216ac7aa3775f482bdd08c17f25
name: python-abbreviations
arch: src
version: 0.2.5
epoch: 0
release: 1
url: https://github.com/philgooch/abbreviation-extraction
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abbreviations-0.2.5-1.src.rpm
checksum_type: sha256
summary:
  Python3 implementation of the Schwartz-Hearst algorithm for extracting abbreviation-definition pairs


pkgId: d639260c503501402034d99dd1ed500d499f0d70dc20cd57949c28399ffc4bfd
name: python-abbu
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: AI Code Generation
url: https://pypi.org/project/abbu/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abbu-0.1.0-1.src.rpm
checksum_type: sha256
description:
  abbu is a python library for easy code generation with ChatGPT.


  `pip install abbu`



  To use `abbu`, there's three simple key components:
  * `setup`: This function initializes abbu by setting up the necessary configuration. Provide your OpenAI API key, a file path for caching, and optional settings. This step prepares everything abbu needs to generate and manage code.
  * `FunctionSpec`: This class defines what you want your function to do. You specify the function name, input parameters, and the desired functionality.
  * `create_function`: This function generates the code based on your FunctionSpec. It checks if the function is already in the cache; if not, it generates the code using the OpenAI API and saves it to the cache. The function is then returned, ready for use.

  An example of how these come together is in the

  ```python

  import os
  import sys
  import abbu

  abbu.setup(
      api_key = os.getenv("OPENAI_API_KEY"),
      cache_file = "/Users/jawada/Documents/CC/jawad_cache.py",
      reset_cache=True
  )

  spec = abbu.FunctionSpec(
      name = "number_adder_2",
      params = ["num1", "num2"],
      description = "takes as input two numbers and returns their sum"
  )

  def add_three_numbers(a, b, c):
      f = abbu.create_function(spec=spec)
      return f(a, b) + c

  add_three_numbers(1,2,3)
  ```

  As an example of how this would get run:
  ```
  $ python3 /path/to/my_example.py
  Creating function for spec: <abbu.spec.FunctionSpec object at 0x108a8b8f0>
  Loaded cache: {}
  Generating code for spec: <abbu.spec.FunctionSpec object at 0x108a8b8f0>
  Cache saved to /Users/jawada/Documents/CC/jawad_cache.py.
  6
  ```

  abbu will create a cache file at `/path/to/your/cache.py` so that you can see what was generated.


pkgId: 374b8c5943ca34401f1d5df5e42b9127d76a163b92f55336f2d5e2eee49045b1
name: python-abc-analysis
arch: src
version: 0.1.23
epoch: 0
release: 1
summary: ABC analysis with automated limit detection
url: https://pypi.org/project/abc-analysis/
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abc-analysis-0.1.23-1.src.rpm
checksum_type: sha256
description:
  Performs and visualizes an ABC analysis with automated limit detection.
  This package is a Python implementation of the R package `ABCanalysis <https://CRAN.R-project.org/package=ABCanalysis>`_.
  The package is based on "Computed ABC Analysis for rational Selection of most informative Variables in multivariate Data", PLoS One. Ultsch. A., Lotsch J. (2015) `doi:10.1371/journal.pone.0129767 <https://doi.org/10.1371/journal.pone.0129767>`_.
  Basic Usage
  ^^^^^^^^^^^
      from abc_analysis import abc_analysis, abc_plot
      
      dctAnalysis = abc_analysis([1, 15, 25, 17, 2, 3, 5, 6, 2, 3, 22])
      
      dctAnalysis = abc_analysis([1, 15, 25, 17, 2, 3, 5, 6, 2, 3, 22], True)
      
      abc_plot(dctAnalysis)


pkgId: 247ac7b4de999898ee66365daa06cc1873ee12418dedc033e87f94d76fc401ca
name: python-abc-delegation
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: A tool for automated delegation with abstract base classes
url: https://github.com/monomonedula/abc-delegation
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abc-delegation-0.3.1-1.src.rpm
checksum_type: sha256
description:
  [![Codeship Status for monomonedula/abc-delegation](https://app.codeship.com/projects/5be7b410-92cb-0138-678c-1680fac8559a/status?branch=master)](https://app.codeship.com/projects/400234)
  [![codecov](https://codecov.io/gh/monomonedula/abc-delegation/branch/master/graph/badge.svg)](https://codecov.io/gh/monomonedula/abc-delegation)
  [![PyPI version](https://badge.fury.io/py/abc-delegation.svg)](https://badge.fury.io/py/abc-delegation)

  A tool for automated delegation with abstract base classes.

  This metaclass enables creation of delegating classes
  inheriting from an abstract base class.

  This technique is impossible with regular `__getattr__` approach for delegation,
  so normally, you would have to define every delegated method explicitly.
  Not any more

  The metaclasses also enable optional validation of the delegate attributes
  to ensure they have all of the methods required by the parent object.


  `pip install abc-delegation`



  ```python
  from abc import ABCMeta

  from abc_delegation import delegation_metaclass

  class A(metaclass=ABCMeta):
      @abstractmethod
      def bar(self):
          pass

      @abstractmethod
      def foo(self):
          pass

  class B:
      def bar(self):
          return "B bar"

      def foo(self):
          return "B foo"

  class C(A, metaclass=delegation_metaclass("my_delegate")):
      def __init__(self, b):
          self.my_delegate = b

      def foo(self):
          return "C foo"

  c = C(B())
  assert c.foo() == "C foo"
  assert c.bar() == "B bar"
  ```


  ```python
  class A(metaclass=ABCMeta):
      @abstractmethod
      def bar(self):
          pass

      @abstractmethod
      def foo(self):
          pass

  class B:
      pass


  class C(A, metaclass=delegation_metaclass("_delegate")):
      def __init__(self, b):
          self._delegate = b

      def foo(self):
          return "C foo"

  C(B())



  ```



  ```python
  from abc import ABCMeta

  from abc_delegation import multi_delegation_metaclass


  class A(metaclass=ABCMeta):
      @abstractmethod
      def bar(self):
          pass

      @abstractmethod
      def foo(self):
          pass

      @abstractmethod
      def baz(self):
          pass

  class B:
      def bar(self):
          return "B bar"

      def foo(self):
          return "B foo"

  class X:
      def baz(self):
          return "X baz"

  class C(A, metaclass=multi_delegation_metaclass("_delegate1", "_delegate2")):
      def __init__(self, d1, d2):
          self._delegate1 = d1
          self._delegate2 = d2

      def foo(self):
          return "C foo"

  c = C(B(), X())
  assert c.bar() == "B bar"
  assert c.foo() == "C foo"
  assert c.baz() == "X baz"
  ```

  Please refer to the unit tests for more examples.


pkgId: 48d7d3bd09d82e4d24d3cc51e25c51affd40fba580e24811268349919869c390
name: python-abc-tsp
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: Artificial Bee Colony TSP solver
url: https://github.com/AngelS017/ABC-algorithm-for-TSP
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abc-tsp-2.0.2-1.src.rpm
checksum_type: sha256
description:
  ![Artificial Bee Colony](https://img.shields.io/badge/Artificial%20Bee%20Colony-ABC%20Algorithm-blue.svg)
  ![Python](https://img.shields.io/badge/Python-3.8%2B-brightgreen.svg)
  ![TSP](https://img.shields.io/badge/Problem-TSP-orange.svg)
  ![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)


  This project implements an Artificial Bee Colony (ABC) algorithm for solving the Traveling Salesman Problem (TSP), where the goal is to find the shortest possible route that visits a set of cities exactly once and returns to the starting point.


  - [Author and contact](#author-and-contact)
  - [Version History](#version-history)
  - [Overview](#overview)
  - [Algorithm Workflow](#algorithm-workflow)
  - [Folder Structure](#folder-structure)
  - [Installation](#installation)
  - [Classes and Functions](#classes-and-functions)
  - [Usage](#usage)
  - [Tuning Parameters](#tuning-parameters)
  - [Contributing](#contributing)
  - [License](#license)




  Author: Angel Sanz Gutierrez\
  Contact: sanzangel017@gmail.com\
  GitHub: AngelS017\
  License: MIT License




  - Changes on how to pass the hyperparameters for the different employed and onlooker bee mutation strategies.
  - Eliminated the search for unnecessary hyperparameter combinations from the ABC algorithm thanks to the new hyperparameter step in the mutation strategies.
  - Updated documentation (README and comments on functions)



  - Added new functionality in ArtificialBeeColonyOptimizer: grid_search_abc()
  - Updated the minimum required Python version to 3.8


  - Initial release of the Artificial Bee Colony for TSP,



  The Artificial Bee Colony (ABC) algorithm is a bio-inspired optimization technique modeled after the intelligent foraging behavior of honeybees. This algorithm is highly effective for solving complex optimization problems like the Traveling Salesman Problem (TSP), where the objective is to find the shortest path that visits all cities exactly once and returns to the starting city.

  In this implementation, bees are divided into three roles: employed bees, onlooker bees, and scout bees.
  Each role contributes to exploring the search space and improving potential solutions.

  * Employed bees focus on exploitation new food sources (solutions).

  * Onlooker bees focus on selective exploitation, probabilistically select and improve upon the best-found solutions.

  * Scout bees introduce exploration by abandoning poor solutions.

  This implementation provides a flexible ABC framework, allowing users to:

  * Customize the mutation strategies for exploring different paths.

  * Customize the porcentage of bees of each role (Employed and Onlooker).

  * Adjust the colony size, exploitation limits and the number of epochs to optimize the problem.




  1. Initialization:

      A population of bees (solutions) is randomly initialized. The population is divided into employed bees and onlooker bees.
      Each employed bee is assigned a random TSP route, and the initial distance for each route is calculated.

  2. Employed Bee Phase:

      Employed bees explore new routes by applying mutation strategies.
      If the new route is shorter, the employed bee updates its current route.

  3. Onlooker Bee Phase:

      Onlooker bees choose solutions based on the probability proportional to the solution’s quality (distance).
      Onlookers explore new routes and improve upon the best ones found by employed bees.

  4. Scout Bee Phase:

      If an employed bee fails to find a better route for a predefined number of trials, it becomes a scout bee and is reinitialized with a new random route.

  5. Convergence:

      The algorithm is executed for a defined number of epochs, constantly trying to improve the routes and recording the best solution found.




      ArtificialBeeColony_TSP
      ├── abc_tsp
      |   ├── ArtificialBeeColony_TSP.py
      |   └── __init__.py
      ├── README.md
      ├── LICENSE
      └── setup.py



  The following open source packages are used to develop this algorithm:
  * numpy >= 1.22
  * tqdm
  * joblib

  Additionally, the software requires the Python 3.8 or higher version, as this is the minimum version supported by the tqmd packages.

  However, it is recommended that the most recent versions of Numpy and Python be installed in order to achieve optimal performance and the fastest results.



  To install the ABC algorithm for the TSP, you just need to:

      pip install abc-tsp



  * Bee
    * Attributes:
      * **role:** Defines whether the bee is Employed, Onlooker, or Scout.
      * **path:** The current TSP path the bee is exploring.
      * **path_len:** The len of the path - 2 (used to select the indexes of the   path for the mutation strategy)
      * **path_distance:** The total distance of the current path.
      * **trial:** Number of unsuccessful attempts to improve the current path.
      * **mutation_strategy:** The mutation startegy used by the bees to generate new solutions.

    * Methods:

      * **_select_mutation_strategy():** Selects the appropriate mutation strategy based on the provided strategy name
      * **swap():** The swap strategy
      * **insertion():** The insertion strategy
      * **k_opt():** The k-opt strategy
      * **mutate_path():** Applies a mutation strategy (e.g., swap, insertion, k-opt) to generate new paths.
      * **distance_path():** Calculates the total distance of the given path using the distance matrix.

  * ArtificialBeeColonyOptimizer
    * Attributes:
      * **ini_end_city:** The city where the path starts and ends.
      * **population:** Total number of bees in the colony.
      * **employed_percentage:** Percentage of employed bees in the colony.
      * **limit:** Trial limit before a bee becomes a scout.
      * **epochs:** Number of iterations the algorithm will run.
      * **distance_matrix:** Matrix containing the distances between cities.
      * **employed_mutation_strategy:** The mutation strategy used by the employed bees.
      * **onlooker_mutation_strategy:** The mutation strategy used by the onlooker bees.
      * **mutation_params:** All the parametrs needed for the employed_mutation_strategy and the onlooker_mutation_strategy in an dictionary format.
      * **seed:** The seed for the random numbers.
      * **verbose:** If you want to see the information after de training of the algorithm.

    * Methods:
      * **initialize_colony_with_roles():** Initializes the bee colony with random paths and their roles.
      * **employed_bee_behavior():** The logic behind employed bees improving their solutions.
      * **caclulate_probabilities():** Compute the probability of choosing each solution in the colony.
      * **roulette_wheel_selection():** Apply the roulet wheel selction to choose the best solution in the colony for the onlooker bee.
      * **onlooker_bee_behavior():** Onlooker bees probabilistically select solutions and improve them.
      * **scout_bee_behavior():** Resets bees that haven’t improved after several trials.
      * **find_best_path():** Finds and returns the best path in the current colony.
      * **fit():** The main loop for optimizing the TSP solution using the ABC algorithm.
      * **run_single_params():** Runs the ABC algorithm with a single set of parameters, returning parameters, the best path and its distance for that specific configuration.
      * **grid_search_abc():** Performs a grid search over a range of parameters to find the best configuration of the algorithm for solving the TSP, allowing users to optimize performance.
      * **print_colony():** Print information (Bee number, role, path distance and trials) about the colony.




  To use this implementation of the Artificial Bee Colony (ABC) algorithm for solving TSP, follow the basic structure provided below:

  ~~~python

  from abc_tsp import ArtificialBeeColonyOptimizer


  distance_matrix = np.array([...]) #Square matrix of distances: cities x cities


  abc_optimizer = ArtificialBeeColonyOptimizer(
      ini_end_city=0,
      population=15,
      employed_percentage=0.5,
      limit=2000,
      epochs=60000,
      distance_matrix=distance_matrix,
      employed_mutation_strategy='k_opt',
      onlooker_mutation_strategy='k_opt',
      mutation_params = {'k_employed':5, 'k_onlooker':5},
      seed=1234,
      verbose=1
  )


  execution_time, paths_distances, final_best_path, final_best_path_distance = abc_optimizer.fit()


  print(f"Best Path: {final_best_path}")
  print(f"Best Path Distance: {final_best_path_distance}")
  print(f"Execution Time: {execution_time} seconds")
  ~~~




  The ArtificialBeeColonyOptimizer class allows you to customize key parameters for tuning the algorithm:

  * population
  * employed_percentage
  * limit
  * epochs
  * employed_mutation_strategy and onlooker_mutation_strategy
  * mutation_params:
      * k_employed
      * k_onlooker

  Depending on the data, you may need to search for the optimal values of these parameters in order to get the best result (probably taking into account the time and the path distance).




  If you wish to contribute, please fork the repository and create a pull request with a detailed description of the changes.

  Contributions for adding new features, fixing bugs, or improving performance are welcome!




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

  <div align="center"> <img src="https://img.shields.io/badge/License-MIT-blue.svg"> </div>


pkgId: 13b27806f6d62af04810113170bb0f9fec2fae98a832dcde31364591c381a7c6
name: python-abcai
arch: src
version: 1.8.2
epoch: 0
release: 1
summary: AI lab just import and run ⚡⚡⚡
url: https://pypi.org/project/abcai/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abcai-1.8.2-1.src.rpm
checksum_type: sha256
description:
  [Project on Github](https://github.com/Esai-Keshav/principles-of-ai-lab)

  To Run the modue

  ```python
      from abcai import run

      run()
  ```



  - Breadth-First Search (BFS)
  - Depth-First Search (DFS)
  - A* Algorithm

  - Crypto-Arithmetic Problems

  - Predicate Logic

  - Semantic Network

  - Naive Bayes

  - Game Playing

  - Min-Max
  - Alpha-Beta Pruning
  - NLP: Tokenization

  - Spell Checking

  - Expert System


pkgId: 1353c4e19a67ea4b9e176952b1b822b6d00cccf68cebe79c042e96eaed071998
name: python-abcattrs
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Abstract class attributes
url: https://github.com/antonagestam/abcattrs/
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abcattrs-0.4.0-1.src.rpm
checksum_type: sha256
description:
  <h1 align=center>abcattrs</h1>

  <p align=center>
      <a href=https://github.com/antonagestam/abcattrs/actions?query=workflow%3ACI+branch%3Amain><img src=https://github.com/antonagestam/abcattrs/workflows/CI/badge.svg alt="CI Build Status"></a>
      <a href="https://codecov.io/gh/antonagestam/abcattrs"><img src="https://codecov.io/gh/antonagestam/abcattrs/branch/main/graph/badge.svg?token=QY7CX7C73R"/></a>
      <br>
      <a href=https://pypi.org/project/abcattrs/><img src=https://img.shields.io/pypi/v/abcattrs.svg?color=informational&label=PyPI alt="PyPI Package"></a>
      <a href=https://pypi.org/project/abcattrs/><img src=https://img.shields.io/pypi/pyversions/abcattrs.svg?color=informational&label=Python alt="Python versions"></a>
  </p>

  Abstract class attributes for ABCs.

  ```python
  import abc
  from abcattrs import abstractattrs, Abstract


  @abstractattrs
  class A(abc.ABC):
      foo: Abstract[int]



  @abstractattrs
  class B(A, abc.ABC):
      bar: Abstract[str]


  class C(B):
      
      foo = 1
      bar = "str"
  ```

  The `Abstract` qualifier can be combined with other PEP 593 annotations.

  ```python
  from typing import Annotated
  import abc
  from abcattrs import abstractattrs, Abstract


  @abstractattrs
  class A(abc.ABC):
      
      bar: Annotated[str, Abstract, "other info"]
  ```


pkgId: d431e6347c8f400626e130a0a991180196bffec2dab062c3f6d4221fbdbe7c3b
name: python-abcattrs
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Abstract class attributes
url: https://pypi.org/project/abcattrs/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abcattrs-0.5.0-1.src.rpm
checksum_type: sha256
description:
  <h1 align=center>abcattrs</h1>

  <p align=center>
      <a href=https://github.com/antonagestam/abcattrs/actions?query=workflow%3ACI+branch%3Amain><img src=https://github.com/antonagestam/abcattrs/workflows/CI/badge.svg alt="CI Build Status"></a>
      <a href="https://codecov.io/gh/antonagestam/abcattrs"><img src="https://codecov.io/gh/antonagestam/abcattrs/branch/main/graph/badge.svg?token=QY7CX7C73R"/></a>
      <br>
      <a href=https://pypi.org/project/abcattrs/><img src=https://img.shields.io/pypi/v/abcattrs.svg?color=informational&label=PyPI alt="PyPI Package"></a>
      <a href=https://pypi.org/project/abcattrs/><img src=https://img.shields.io/pypi/pyversions/abcattrs.svg?color=informational&label=Python alt="Python versions"></a>
  </p>

  Abstract class attributes for ABCs.



  ```python
  import abc
  from abcattrs import abstractattrs, Abstract


  @abstractattrs
  class A(abc.ABC):
      foo: Abstract[int]



  class B(A, abc.ABC):
      bar: Abstract[str]


  class C(B):
      
      foo = 1
      bar = "str"



  class MissingBar(B):
      foo = 1



  class MissingFoo(B):
      bar = "str"
  ```

  The `Abstract` qualifier can be combined with other PEP 593 annotations.

  ```python
  from typing import Annotated
  import abc
  from abcattrs import abstractattrs, Abstract


  @abstractattrs
  class A(abc.ABC):
      
      bar: Annotated[str, Abstract, "other info"]
  ```


pkgId: 02017de4dadce3edff4fed5083e7a15b3c8fdb5a487a9d2e866d27a03fd9f03a
name: python-abcd-graph
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: A python library for generating ABCD graphs.
url: https://github.com/AleksanderWWW/abcd-graph
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abcd-graph-0.3.0-1.src.rpm
checksum_type: sha256
description:
  A python library for generating ABCD graphs.




  ```bash
  pip install abcd-graph
  ```
  Project available at [PyPI](https://pypi.org/project/abcd-graph/).


  ```bash
  git clone https://github.com/AleksanderWWW/abcd-graph.git


  cd abcd-graph
  pip install .
  ```




  ```python
  from abcd_graph import ABCDGraph, ABCDParams

  params = ABCDParams()
  graph = ABCDGraph(params, n=1000, logger=True).build()
  ```



  - `params`: An instance of `ABCDParams` class.
  - `n`: Number of nodes in the graph.
  - `logger` A boolean to enable or disable logging to the console. Default is `False` - no logs are shown.
  - `callbacks`: A list of instances of `Callback` class. Default is an empty list.



  The `ABCDGraph` object with the generated graph.



  The `ABCDParams` class is used to set the parameters for the graph generation.

  Arguments:

  | Name    | Type    | Description                                              | Default |
  |---------|---------|----------------------------------------------------------|---------|
  | `gamma` | `float` | Power-law parameter for degrees, between 2 and 3         | 2.5     |
  | `delta` | `int`   | Min degree                                               | 5       |
  | `zeta`  | `float` | Parameter for max degree, between 0 and 1                | 0.5     |
  | `beta`  | `float` | Power-law parameter for community sizes, between 1 and 2 | 1.5     |
  | `s`     | `int`   | Min community size                                       | 20      |
  | `tau`   | `float` | Parameter for max community size, between zeta and 1     | 0.8     |
  | `xi`    | `float` | Noise parameter, between 0 and 1                         | 0.25    |

  Parameters are validated when the object is created. If any of the parameters are invalid, a `ValueError` will be raised.



  The `ABCDGraph` object has two properties that can be used to access the communities and edges of the graph.

  - `communities` - A list of `ABCDCommunity` objects.
  - `edges` - A list of tuples representing the edges of the graph.

  Example:

  ```python

  from abcd_graph import ABCDGraph, ABCDParams

  params = ABCDParams()

  graph = ABCDGraph(params, n=1000, logger=True).build()

  print(graph.communities)
  print(graph.edges)
  ```

  Communities have the following properties:
  - vertices - A list of vertices in the community.
  - average_degree - The average degree of the community.
  - degree_sequence - The degree sequence of the community.
  - empirical_xi - The empirical xi of the community.



  Exporting the graph to different formats is done via the `exporter` property of the `Graph` object.

  Possible formats are:

  | Method                         | Description                                                                               | Required packages | Installation command         |
  |--------------------------------|-------------------------------------------------------------------------------------------|-------------------|------------------------------|
  | `to_networkx()`                | Export the graph to a `networkx.Graph` object.                                            | `networkx`        | `pip install abcd[networkx]` |
  | `to_igraph()`                  | Export the graph to an `igraph.Graph` object.                                             | `igraph`          | `pip install abcd[igraph]`   |
  | `adj_matrix`                   | Export the graph to a `numpy.ndarray` object representing the adjacency matrix.           |                   |                              |
  | `to_sparse_adjacency_matrix()` | Export the graph to a `scipy.sparse.csr_matrix` object representing the adjacency matrix. | `scipy`           | `pip install abcd[scipy]`    |


  Example:

  ```python
  from abcd_graph import ABCDGraph, ABCDParams

  params = ABCDParams()
  graph = ABCDGraph(params, n=1000, logger=True).build()
  graph_networkx = graph.exporter.to_networkx()
  ```




  Callbacks are used to handle diagnostics and visualization of the graph generation process. They are instances of the `ABCDCallback` class.

  Out of the box, the library provides three callbacks:
  - `StatsCollector` - Collects statistics about the graph generation process.
  - `PropertyCollector` - Collects properties of the graph.
  - `Visualizer` - Visualizes the graph generation process.

  Example:

  ```python

  from abcd_graph import ABCDGraph, ABCDParams

  from abcd_graph.callbacks import StatsCollector, Visualizer, PropertyCollector

  stats = StatsCollector()
  vis = Visualizer()
  props = PropertyCollector()
  params = ABCDParams()
  g = ABCDGraph(params, n=1000, logger=True, callbacks=[stats, vis, props]).build()

  print(stats.statistics)

  print(props.xi_matrix)

  vis.draw_community_cdf()
  ```



  To build a docker image containing the library, run:

  ```bash
  docker build -t abcd-graph .
  ```

  To run the image, use:

  ```bash
  docker run -it abcd-graph /bin/bash
  ```
  This will give you a terminal inside a container with the library installed.

  Available are also installation commands for the additional packages:

  ```bash
  docker build -t abcd-test --build-arg INSTALL_TYPE=igraph .
  ```

  Possible values for `INSTALL_TYPE` are `dev`, `matplotlib`,  `networkx`, `igraph`, `scipy`, `all` and `extended`.

  | Value        | Packages installed                                                                |
  |--------------|-----------------------------------------------------------------------------------|
  | `dev`        | `pytest`, `pre-commit`, `pytest-cov`                                              |
  | `matplotlib` | `matplotlib`                                                                      |
  | `networkx`   | `networkx`                                                                        |
  | `igraph`     | `igraph`                                                                          |
  | `scipy`      | `scipy`                                                                           |
  | `all`        | `networkx`, `igraph`, `scipy`, `pytest`, `pre-commit`, `pytest-cov`, `matplotlib` |
  | `extended`   | `scipy`, `matplotlib`                                                             |

  > [!NOTE]
  > Combinations of the above values are also possible, e.g. `igraph,networkx`.

  > [!WARNING]
  > If you choose and option outside the available ones, the installation will still succeed,
  > but only the base package will be installed.




  The library comes with a set of examples that show how to use the library in different scenarios.
  You can find them in the `examples` directory in the format of Jupyter Notebooks.


pkgId: 9dd1b181d305c586e55b1b81b0ebb6f078fd35d7d2cd2c6be7085a85b5896f6a
name: python-abch-tree-sitter
arch: src
version: 1.1.4
epoch: 0
release: 1
summary: Python bindings to the Tree-sitter parsing library
url: https://github.com/Ackee-Blockchain/py-tree-sitter
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abch-tree-sitter-1.1.4-1.src.rpm
checksum_type: sha256
description:
  This module provides Python bindings to the [tree-sitter](https://github.com/tree-sitter/tree-sitter) parsing library.

  This package currently only works with Python 3. There are no library dependencies, the package is distributed as a CPython-compiled wheel.
  ```sh
  pip3 install abch-tree-sitter
  ```

  This is a fork of [py-tree-sitter](https://github.com/tree-sitter/py-tree-sitter) by Max Brunsfeld with UTF-16 support added and distributed as CPython-compiled wheels.


  First you'll need a Tree-sitter language implementation for each language that you want to parse. You can clone some of the [existing language repos](https://github.com/tree-sitter) or [create your own](http://tree-sitter.github.io/tree-sitter/creating-parsers):
  ```sh
  git clone https://github.com/tree-sitter/tree-sitter-go
  git clone https://github.com/tree-sitter/tree-sitter-javascript
  git clone https://github.com/tree-sitter/tree-sitter-python
  ```
  Use the `Language.build_library` method to compile these into a library that's usable from Python. This function will return immediately if the library has already been compiled since the last time its source code was modified:
  ```python
  from tree_sitter import Language, Parser
  Language.build_library(
    
    'build/my-languages.so',
    
    [
      'vendor/tree-sitter-go',
      'vendor/tree-sitter-javascript',
      'vendor/tree-sitter-python'
    ]
  )
  ```
  Load the languages into your app as `Language` objects:
  ```python
  GO_LANGUAGE = Language('build/my-languages.so', 'go')
  JS_LANGUAGE = Language('build/my-languages.so', 'javascript')
  PY_LANGUAGE = Language('build/my-languages.so', 'python')
  ```

  Create a `Parser` and configure it to use one of the languages:
  ```python
  parser = Parser()
  parser.set_language(PY_LANGUAGE)
  ```
  Parse some source code:
  ```python
  tree = parser.parse(bytes("""
  def foo():
      if bar:
          baz()
  """, "utf8"))
  ```
  If you have your source code in some data structure other than a bytes object,
  you can pass a "read" callable to the parse function.
  The read callable can use either the byte offset or point tuple to read from
  buffer and return source code as bytes object. An empty bytes object or None
  terminates parsing for that line. The default encoding is utf8.
  For example, to use the byte offset:
  ```python
  src = bytes("""
  def foo():
      if bar:
          baz()
  """, "utf8")
  def read_callable(byte_offset, point):
      return src[byte_offset:byte_offset+1]
  tree = parser.parse(read_callable)
  ```
  And to use the point:
  ```python
  src_lines = ["def foo():\n", "    if bar:\n", "        baz()"]
  def read_callable(byte_offset, point):
      row, column = point
      if row >= len(src_lines) or column >= len(src_lines[row]):
          return None
      return src_lines[row][column:].encode('utf8')
  tree = parser.parse(read_callable)
  ```
  Or with utf16 encoding:
  ```python
  tree = parser.parse(bytes("""
  def foo():
      if bar:
          baz()
  """, "utf16"), encoding="utf16")
  ```
  ```python
  src = bytes("""
  def foo():
      if bar:
          baz()
  """, "utf16")
  def read_callable(byte_offset, point):
      return src[byte_offset:byte_offset+2]
  tree = parser.parse(read_callable, encoding="utf16")
  ```
  ```python
  src_lines = ["def foo():\n", "    if bar:\n", "        baz()"]
  def read_callable(byte_offset, point):
      row, column = point
      if row >= len(src_lines) or column >= len(src_lines[row].encode("utf-16-le")):
          return None
      ret = src_lines[row].encode("utf-16-le")[column:]
      return ret
  tree = parser.parse(read_callable, encoding="utf16")
  ```
  Inspect the resulting `Tree`:
  ```python
  root_node = tree.root_node
  assert root_node.type == 'module'
  assert root_node.start_point == (1, 0)
  assert root_node.end_point == (3, 13)
  function_node = root_node.children[0]
  assert function_node.type == 'function_definition'
  assert function_node.child_by_field_name('name').type == 'identifier'
  function_name_node = function_node.children[1]
  assert function_name_node.type == 'identifier'
  assert function_name_node.start_point == (1, 4)
  assert function_name_node.end_point == (1, 7)
  assert root_node.sexp() == "(module "
      "(function_definition "
          "name: (identifier) "
          "parameters: (parameters) "
          "body: (block "
              "(if_statement "
                  "condition: (identifier) "
                  "consequence: (block "
                      "(expression_statement (call "
                          "function: (identifier) "
                          "arguments: (argument_list))))))))"
  ```

  If you need to traverse a large number of nodes efficiently, you can use
  a `TreeCursor`:
  ```python
  cursor = tree.walk()
  assert cursor.node.type == 'module'
  assert cursor.goto_first_child()
  assert cursor.node.type == 'function_definition'
  assert cursor.goto_first_child()
  assert cursor.node.type == 'def'

  assert not cursor.goto_first_child()
  assert cursor.goto_next_sibling()
  assert cursor.node.type == 'identifier'
  assert cursor.goto_next_sibling()
  assert cursor.node.type == 'parameters'
  assert cursor.goto_parent()
  assert cursor.node.type == 'function_definition'
  ```

  When a source file is edited, you can edit the syntax tree to keep it in sync with the source:
  ```python
  tree.edit(
      start_byte=5,
      old_end_byte=5,
      new_end_byte=5 + 2,
      start_point=(0, 5),
      old_end_point=(0, 5),
      new_end_point=(0, 5 + 2),
  )
  ```
  Then, when you're ready to incorporate the changes into a new syntax tree,
  you can call `Parser.parse` again, but pass in the old tree:
  ```python
  new_tree = parser.parse(new_source, tree)
  ```
  This will run much faster than if you were parsing from scratch.
  The `Tree.get_changed_ranges` method can be called on the *old* tree to return
  the list of ranges whose syntactic structure has been changed:
  ```python
  for changed_range in tree.get_changed_ranges(new_tree):
      print('Changed range:')
      print(f'  Start point {changed_range.start_point}')
      print(f'  Start byte {changed_range.start_byte}')
      print(f'  End point {changed_range.end_point}')
      print(f'  End byte {changed_range.end_byte}')
  ```

  You can search for patterns in a syntax tree using a *tree query*:
  ```python
  query = PY_LANGUAGE.query("""
  (function_definition
    name: (identifier) @function.def)
  (call
    function: (identifier) @function.call)
  """)
  captures = query.captures(tree.root_node)
  assert len(captures) == 2
  assert captures[0][0] == function_name_node
  assert captures[0][1] == "function.def"
  ```
  The `Query.captures()` method takes optional `start_point`, `end_point`,
  `start_byte` and `end_byte` keyword arguments which can be used to restrict the
  query's range. Only one of the `..._byte` or `..._point` pairs need to be given
  to restrict the range. If all are omitted, the entire range of the passed node
  is used.


pkgId: b446be2a6339859ea41db1337341603534f8f402f121ed05eef84ffdf7c796c1
name: python-abci
arch: src
version: 0.8.3
epoch: 0
release: 1
summary: Python based ABCI Server for Tendermint
url: https://github.com/davebryson/py-abci
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abci-0.8.3-1.src.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/abci.svg)](https://pypi.python.org/pypi/abci)
  [![build](https://travis-ci.org/davebryson/py-abci.svg?branch=master)](https://https://travis-ci.org/davebryson/py-abci)
  [![codecoverage](https://codecov.io/gh/davebryson/py-abci/branch/master/graph/badge.svg)](https://codecov.io/gh/davebryson/py-abci)


  Build Tendermint blockchain applications in Python.  It's fun.  This library provides the core functionality needed to create Tendermint ABCI applications.


  * Tendermint *0.34.11*
  * ABCI *0.17.0*


  Requires Python >= 3.9

  `pip install abci`

  You'll need a binary version of the Tendermint engine.
  Available here: https://github.com/tendermint/tendermint/releases

  **Make sure the Tendermint version you download matches the current support version of this library**



  A very simple demo application is included and available from the command line as `counter`. You can find the code here: https://github.com/davebryson/py-abci/blob/master/src/example/counter.py

  To try it out:
  1. Make sure you have the Tendermint binary setup locally and in your path.  To test it's working
  open a terminal window and type:
  ```text
  >> tendermint version
  ```
  It should output your version of Tendermint that should match the currently supported version
  of this library.

  2. Next, initialize Tendermint by running:
  ```text
  >> tendermint init
  ```

  3. Start the Tendermint node:
  ```text
  >> tendermint node
  ```
  The node will start, but will be waiting for you application to start.

  4. Open another terminal, and start the `counter` application. The `counter` will be available
  from within the Python environment where you installed `abci`
  ```text
  >> counter
  ```
  You'll see the application start, and in the Tendermint terminal, you'll see the output of
  blocks being produced

  5. Now, open a 3rd terminal window to send some transaction to the blockchain.  To do this we'll
  use the `curl` application to send transaction to the local blockchain over http. For example:
  ```text
  >> curl http://localhost:26657/broadcast_tx_commit?tx=0x01
  >> curl http://localhost:26657/broadcast_tx_commit?tx=0x02
  ```
  The counter application expects you to send `transactions` as numbers encoded as hex in order: 1,2,3...
  It will reject and out-of-order numbers.  You can always see the latest accepted value by sending the
  request:
  ```text
  >> curl http://localhost:26657/abci_query
  ```

  To shut down the application enter `CTRL-C`


  To start building your own application:
  1. Extend the `abci.application.BaseApplication` class
  2. Implement the Tendermint ABCI callbacks - see https://docs.tendermint.com/v0.34/spec/abci for details on how they work
  3. Start it:
  ```python
  from abci.server import ABCIServer

  app = ABCIServer(app=MyApplication())
  app.run()
  ```
  See the ``counter.py`` application in the ``example`` directory https://github.com/davebryson/py-abci/blob/master/src/example/counter.py for a full example.



  If you're working directly on the code base.  Install a local editable version:

  `pip install --editable '.[test]'`



  **You should only re-generate the protobuf code if you're updating the associated protobuf files,
  and/or contributing to this code base.  You do not need to rebuild protos to create apps.**

  A note on protobuf:  The primary code directory is `abci`, but you'll notice additional
  directories: `gogoproto`, `tendermint`, and `protos`.

  The `gogoproto` and `tendermint` directories are the protobuf generated code used by ``abci``. It adds proper Python modules and preserves all the import statements used by Tendermint for the various protobuf files spread
  across their codebase.  The ``protos`` directory is the source .proto files.

  To (re)build the protobuf files:

  1. Install `protoc` so it's available in your PATH as a command
  2. Run `make update-proto`


pkgId: d488df64cdd806161076c76537959e523610164b2c53dae0ec2247e0cd56a960
name: python-abcmeta
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Python meta class and abstract method library with restrictions.
url: https://github.com/mortymacs/abcmeta
rpm_license: AGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abcmeta-2.2.0-1.src.rpm
checksum_type: sha256
description:
  [![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/mortymacs/abcmeta/python-test.yml?style=flat-square)](https://github.com/mortymacs/abcmeta/actions/workflows/python-test.yml)
  [![PyPi version](https://img.shields.io/pypi/v/abcmeta?style=flat-square)](https://pypi.org/project/abcmeta)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/abcmeta?style=flat-square)](https://pypi.python.org/pypi/abcmeta/)
  [![PyPI download month](https://img.shields.io/pypi/dm/abcmeta?style=flat-square)](https://pypi.python.org/pypi/abcmeta/)

  Python meta class and abstract method library with restrictions.

  This library provides a restricted way to validate abstract methods.
  The Python's default abstract method library only validates the methods
  that exist in the derived classes and nothing else.
  What this library provides is apart from that validation it provides
  validations over the method's signature.
  All you need is to import `ABCMeta` and `abstractmethod` from this library.

  It works on both annotations and without annotations methods.



  You can install the package by `pip`:

  ```bash
  $ pip install abcmeta
  ```

  > Note: abcmeta supports Python3.6+.



  ```python
  from typing import Dict, Text

  from abcmeta import ABC, abstractmethod


  class Base(ABC):
      @abstractmethod
      def method_2(self, name: Text, age: int) -> Dict[Text, Text]:
          """Abstract method."""

      @abstractmethod
      def method_3(self, name, age):
          """Abstract method."""

  class Drived(Base):
      def method_2(self, name: Text, age: int) -> Dict[Text, Text]:
          return {"name": "test"}

      def method_3(self, name, age):
          pass
  ```

  If you put a different signature, it will raise an error with 'diff' format with hints about what you've missed:

  ```python
  class Drived(Base):
      def method_2(self, name: Text, age: int) -> List[Text]:
          return {"name": "test"}
  ```

  And it will raise:

  ```python
  Traceback (most recent call last):
    File "/Workspaces/test.py", line 41, in <module>
      class Drived(Base):
    File "/usr/lib/python3.9/abc.py", line 85, in __new__
      cls = super().__new__(mcls, name, bases, namespace, **kwargs)
    File "/abcmeta/__init__.py", line 179, in __init_subclass__
      raise AttributeError(
  AttributeError: Signature of the derived method is not the same as parent class:
  - method_2(self, name: str, age: int) -> Dict[str, str]
  ?                                        ^ ^     -----

  + method_2(self, name: str, age: int) -> List[str]
  ?                                        ^ ^

  Derived method expected to return in 'typing.Dict[str, str]' type, but returns 'typing.List[str]'
  ```

  For different parameter names:

  ```python
  class Drived(Base):
      def method_2(self, username: Text, age: int) -> List[Text]:
          return {"name": "test"}
  ```

  And it will raise:

  ```python
  Traceback (most recent call last):
    File "/Workspaces/test.py", line 41, in <module>
      class Drived(Base):
    File "/usr/lib/python3.9/abc.py", line 85, in __new__
      cls = super().__new__(mcls, name, bases, namespace, **kwargs)
    File "/abcmeta/__init__.py", line 180, in __init_subclass__
      raise AttributeError(
  AttributeError: Signature of the derived method is not the same as parent class:
  - method_2(self, name: str, age: int) -> Dict[str, str]
  + method_2(self, username: str, age: int) -> Dict[str, str]
  ?                ++++

  Derived method expected to get name paramter, but gets username
  ```



  If you're faced with a problem, please file an [issue](https://github.com/mortymacs/abcmeta/issues/new) on Github.




  You're always welcome to contribute to the project! Please file an issue and send your great PR.



  Please read the [LICENSE](./LICENSE) file.


pkgId: 0ac29daa081573281705573ae9abcdcaa7772fab895592e9c9929e8a39715b9d
name: python-abcmeta
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: Python meta class and abstract method library with restrictions.
url: https://github.com/mortymacs/abcmeta
rpm_license: AGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abcmeta-2.2.1-1.src.rpm
checksum_type: sha256
description:
  [![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/mortymacs/abcmeta/python-test.yml?style=flat-square)](https://github.com/mortymacs/abcmeta/actions/workflows/python-test.yml)
  [![PyPi version](https://img.shields.io/pypi/v/abcmeta?style=flat-square)](https://pypi.org/project/abcmeta)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/abcmeta?style=flat-square)](https://pypi.python.org/pypi/abcmeta/)
  [![PyPI download month](https://img.shields.io/pypi/dm/abcmeta?style=flat-square)](https://pypi.python.org/pypi/abcmeta/)

  Python meta class and abstract method library with restrictions.

  This library provides a restricted way to validate abstract methods.
  The Python's default abstract method library only validates the methods
  that exist in the derived classes and nothing else.
  What this library provides is apart from that validation it provides
  validations over the method's signature.
  All you need is to import `ABCMeta` and `abstractmethod` from this library.

  It works on both annotations and without annotations methods.



  You can install the package by `pip`:

  ```bash
  $ pip install abcmeta
  ```

  > Note: abcmeta supports Python3.6+.



  ```python
  from typing import Dict, Text

  from abcmeta import ABC, abstractmethod


  class Base(ABC):
      @abstractmethod
      def method_2(self, name: Text, age: int) -> Dict[Text, Text]:
          """Abstract method."""

      @abstractmethod
      def method_3(self, name, age):
          """Abstract method."""

  class Drived(Base):
      def method_2(self, name: Text, age: int) -> Dict[Text, Text]:
          return {"name": "test"}

      def method_3(self, name, age):
          pass
  ```

  If you put a different signature, it will raise an error with 'diff' format with hints about what you've missed:

  ```python
  class Drived(Base):
      def method_2(self, name: Text, age: int) -> List[Text]:
          return {"name": "test"}
  ```

  And it will raise:

  ```python
  Traceback (most recent call last):
    File "/Workspaces/test.py", line 41, in <module>
      class Drived(Base):
    File "/usr/lib/python3.9/abc.py", line 85, in __new__
      cls = super().__new__(mcls, name, bases, namespace, **kwargs)
    File "/abcmeta/__init__.py", line 179, in __init_subclass__
      raise AttributeError(
  AttributeError: Signature of the derived method is not the same as parent class:
  - method_2(self, name: str, age: int) -> Dict[str, str]
  ?                                        ^ ^     -----

  + method_2(self, name: str, age: int) -> List[str]
  ?                                        ^ ^

  Derived method expected to return in 'typing.Dict[str, str]' type, but returns 'typing.List[str]'
  ```

  For different parameter names:

  ```python
  class Drived(Base):
      def method_2(self, username: Text, age: int) -> List[Text]:
          return {"name": "test"}
  ```

  And it will raise:

  ```python
  Traceback (most recent call last):
    File "/Workspaces/test.py", line 41, in <module>
      class Drived(Base):
    File "/usr/lib/python3.9/abc.py", line 85, in __new__
      cls = super().__new__(mcls, name, bases, namespace, **kwargs)
    File "/abcmeta/__init__.py", line 180, in __init_subclass__
      raise AttributeError(
  AttributeError: Signature of the derived method is not the same as parent class:
  - method_2(self, name: str, age: int) -> Dict[str, str]
  + method_2(self, username: str, age: int) -> Dict[str, str]
  ?                ++++

  Derived method expected to get name paramter, but gets username
  ```



  If you're faced with a problem, please file an [issue](https://github.com/mortymacs/abcmeta/issues/new) on Github.




  You're always welcome to contribute to the project! Please file an issue and send your great PR.



  If you find this project useful and want to support its development, consider [buying me a coffee!](https://buymeacoffee.com/mortymacs)



  Please read the [LICENSE](./LICENSE) file.


pkgId: e5d23c91a568249a17d67e28b98792b5882c4587f2e8c15c6d63d6dc70cb6c50
name: python-abconfig
arch: src
version: 1.0.12
epoch: 0
release: 1
summary: Simple and powerful configuration manager for Python projects
url: https://github.com/kudato/abconfig.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abconfig-1.0.12-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/kudato/abconfig.svg?branch=master)](https://travis-ci.org/kudato/abconfig) [![Coverage Status](https://coveralls.io/repos/github/kudato/abconfig/badge.svg?branch=master)](https://coveralls.io/github/kudato/abconfig?branch=master)

  The configuration should be simple, this project aims to give you all the power while maintaining ease of use.




  - Json or Yaml files and environment variables are supported as source;

  - Correct data types (even for environment variables);

  - Create configurations in django models style;

  - The result object is a regular dictionary;




  **Documentation**: http://abconfig.readthedocs.io/

  > Also strongly recommend that you read ["The twelve-factor app" for config](https://12factor.net/ru/config) before starting.


pkgId: 5c959af4d27a2a4a9e0ff2c2e404637158ec34943aee5db522c98ba5e7f82d89
name: python-abcvlib
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: Python server for the OIST smartphone-robot Android-2-Python API
url: https://github.com/oist/smartphone-robot-python-server
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abcvlib-0.0.7-1.src.rpm
checksum_type: sha256
description:
  This repo was created by mistake and I don't have admin rights to remove it due to the way it was created (I transfered ownership from my personal account rather than creating it within the OIST account).


pkgId: 2103f073b14319f7777a85e7099e3907eb42b5aacd4130938584bb0c6c1bf442
name: python-abd-clam
arch: src
version: 0.22.3
epoch: 0
release: 1
summary: Clustered Learning of Approximate Manifolds
url: https://pypi.org/project/abd-clam/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abd-clam-0.22.3-1.src.rpm
checksum_type: sha256
description:
  CLAM is a Rust/Python library for learning approximate manifolds from data.
  It is designed to be fast, memory-efficient, easy to use, and scalable for big data applications.

  CLAM provides utilities for fast search (CAKES) and anomaly detection (CHAODA).

  As of writing this document, the project is still in a pre-1.0 state.
  This means that the API is not yet stable and breaking changes may occur frequently.



  ```shell
  > python3 -m pip install "abd_clam==0.22.3"
  ```



  ```python
  from abd_clam.search import CAKES
  from abd_clam.utils import synthetic_data


  data, _ = synthetic_data.bullseye()




  model = CAKES(data, 'euclidean')



  model.build(max_depth=50)



  query, radius, k = data[0], 0.5, 10

  rnn_results = model.rnn_search(query, radius)



  knn_results = model.knn_search(query, k)





  ```

  <!-- TODO: Provide snippets for using CHAODA -->



  [MIT](LICENSE)



  TODO


pkgId: f2597267e942f4be96e3df13464ed4cba10f6804da6cd13545f93ac0df24defb
name: python-abdoTheBest
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: A small example package
url: https://github.com/gituser/example-pkg
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abdoTheBest-1.0.0-1.src.rpm
checksum_type: sha256
description:
  [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/FahedSabellioglu/genn/blob/master/LICENSE.txt)

  GeNN (generative neural networks) is a high-level interface for text applications using PyTorch RNN's.




  1.  Preprocessing:
  	- Parsing txt, json, and csv files.
  	- NLTK, regex and spacy tokenization support.
  	- GloVe and fastText pretrained embeddings, with the ability to fine-tune for your data.
  2. Architectures and customization:
  	- GPT2 with small, medium, and large variants.
  	- LSTM and GRU, with variable size.
  	- Variable number of layers and batches.
  	- Dropout.
  3. Text generation:
  	- Random seed sampling from the n first tokens in all instances, or the most frequent token.
  	- Top-K sampling for next token prediction with variable K.
  	- Nucleus sampling for next token prediction with variable probability threshold.
  4. Text Summarization:
  	- All GPT2 variants can be trained to perform text summarization.




  ```bash
  pip install genn
  ```

  * PyTorch 1.4.0
  ```bash
  pip install torch==1.4.0
  ```
  * Pytorch Transformers
  ```bash
  pip install pytorch_transformers
  ```
  * NumPy
  ```bash
  pip install numpy
  ```
  * fastText
  ```bash
  pip install fasttext
  ```
  Use the package manager [pip](https://pypi.org/project/genn) to install genn.




  ```python
  from genn import Preprocessing, LSTMGenerator, GRUGenerator

  ds = Preprocessing("data.txt")
  gen = LSTMGenerator(ds, nLayers = 2,
                          batchSize = 16,
                          embSize = 64,
                          lstmSize = 16,
                          epochs = 20)


  gen.run()


  print(gen.generate_document(5))
  ```

  ```python

  gen = GPT2("data.txt",
   	    taskToken = "Movie:",
  	    epochs = 7,
  	    variant = "medium")

  gen.run()


  print(gen.generate_document(10))
  ```


  ```python

  from genn import GPT2Summarizer
  summ = GPT2Summarizer("data.txt",
  					epochs=3,
  					batch_size=8)


  summ.run()


  src_doc = "This is the source document to summarize"
  print(summ.summarize_document(n=5, setSeed = src_doc))
  ```








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

  Distributed under the MIT License. See [LICENSE](https://github.com/FahedSabellioglu/genn/blob/master/LICENSE.txt) for more information.


pkgId: 413565eac6f76d6767528aed98f6d4aa8fa13feff65ab4e33be2d95d9111e6ec
name: python-abduct
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Capture stdout/stderr and optionally release when an exception occurs.
url: https://github.com/themattrix/python-abduct
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abduct-2.0.1-1.src.rpm
checksum_type: sha256
description:
  |Compatibility| |Implementations| |Format| |Downloads|
  Capture stdout/stderr and optionally release when an exception occurs.
      from abduct import captured, out, err
      with captured(out()) as stdout:
      with captured(out(), err()) as (stdout, stderr):
      @captured(out(), err())
  Installation:
      $ pip install abduct
  When stdout or stderr is captured, the related ``sys.stdout`` or
  ``sys.stderr`` object is replaced with a ``StringIO`` object for the
  life of the context.


pkgId: 823b9adc5f09fe7044d665636e3c7f6074a03d5f256a4cbcdf1a6f8204478538
name: python-abdutils
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: A bag of utility functions.
url: https://github.com/abdkhanstd/abdutils
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abdutils-0.0.2-1.src.rpm
checksum_type: sha256
description:
  Are you tired of dealing with complex Python libraries and struggling with unclear learning examples? We've been there too, which is why we created `abdutils`.



  `abdutils` is a Python utility module that aims to simplify common file and folder operations, making Python programming more efficient and intuitive. We understand that Python libraries can sometimes feel overly complicated, and learning from existing examples can be challenging. That's why we're building `abdutils` to provide a straightforward and user-friendly solution.



  - **Simplicity**: We believe in keeping things simple. `abdutils` offers easy-to-use functions for various file-related tasks, eliminating the need to reinvent the wheel when working with files and directories.

  - **Clarity**: Our code and documentation are designed with clarity in mind. We want you to understand how everything works, making your Python development experience smoother.

  - **Open to Suggestions**: We value your input! If you have suggestions, ideas, or improvements to make `abdutils` even better, please don't hesitate to [open an issue](https://github.com/abdkhanstd/abdutils/issues) or submit a [pull request](https://github.com/abdkhanstd/abdutils/pulls).



  To get started with `abdutils`, you can install it easily using `pip`. Here's how:

  ```bash
  pip install --upgrade git+https://github.com/abdkhanstd/abdutils.git

  ```


  - **Ease of Programming:** `abdutils` strives to streamline Python programming by providing a collection of utility functions, which currently encompass fundamental file and directory operations.

  - **Enhanced File Handling:** It provides tools to perform file creation, reading, and writing tasks effortlessly.

  - **Time-Saving:** By using `abdutils`, you can save time on routine file operations, allowing you to focus on the core aspects of your projects.

  Whether you're a beginner or an experienced developer, `abdutils` is here to make your Python coding experience smoother and more enjoyable.



  You can install `abdutils` directly from its GitHub repository using pip:

  ```bash
  pip install --upgrade git+https://github.com/abdkhanstd/abdutils.git

  ```

  To verify the installation of a Python package installed via `pip` and to provide installation instructions in a GitHub README file, follow these steps:



  1. Open your terminal or command prompt.

  2. Run the following command to verify if the package "abdutils" has been installed successfully:

     ```
     pip show abdutils
     ```

     This command will display information about the installed package, including its version, location, and other details. If the package is installed correctly, you'll see its information. If it's not installed, you'll receive an error message.



  To install the `abdutils` package, you can use `pip`. Run the following command in your terminal or command prompt:

     ```bash
     pip install git+https://github.com/abdkhanstd/abdutils.git
     ```

     This will install the latest version of the package directly from the GitHub repository.

     If you prefer to install manually, you can follow these steps:

     1. Clone the GitHub repository:

        ```bash
        git clone https://github.com/abdkhanstd/abdutils.git
        ```

     2. Change your current directory to the cloned repository:

        ```bash
        cd abdutils
        ```

     3. Install the package using `pip`:

        ```bash
        pip install .
        ```



  - [CreateFolder](#createfolder)
  - [RenameFileFolder](#renamefilefolder)
  - [Copy](#copy)
  - [Move](#move)
  - [Delete](#delete)
  - [ReadFile](#readfile)
  - [WriteFile](#writefile)
  - [ReadImage](#readimage-function)
  - [SaveImage](#saveimage-function)
  - [ConvertToGrayscale](#converttograyscale-function)
  - [ConvertToRGB](#converttorgb-function)
  - [CropImage](#cropimage-function)
  - [GetImageSize](#getimagesize-function)
  - [ResizeImage](#resizeimage-function)
  - [GaussianBlurImage](#gaussianblurimage-function)
  - [ConvertImageToGrayscale](#convertimagetograyscale-function)
  - [SharpenImage](#sharpenimage-function)
  - [DetectEdgesInImage](#detectedgesinimage-function)
  - [ConvolveImage](#convolveimage-function)
  - [ApplyFilter](#applyfilter-function)
  - [ShowImage](#showimage-function)
  - [CV2PIL](#cv2pil-function)
  - [PIL2CV2](#pil2cv2-function)
  - [GetSystemUsage](#GetSystemUsage)
  - [GetConsoleHeight](#GetConsoleHeight)
  - [ClearScreen](#ClearScreen)
  - [ExitHandler](#ExitHandler)
  - [SelectGPU](#SelectGPU)
  - [LookForKeys](#LookForKeys)





  The `CreateFolder` function allows you to create folders with various modes.



  ```python
  CreateFolder(path, mode="a", verbose=True)
  ```

  - `path` (str): The path to the folder to be created.
  - `mode` (str): The mode for folder creation ('f', 'o', 'c', or 'a'). Defaults to 'a' (ask_user).
  - `verbose` (bool): Whether to display verbose messages. Defaults to True.





  ```python
  import abdutils as abd

  abd.CreateFolder("my_folder", verbose=True)

  ```



  ```python
  import abdutils as abd

  abd.CreateFolder("parent/child/grandchild", verbose=False)

  ```



  ```python
  import abdutils as abd

  abd.CreateFolder("folder_to_force_create", mode="f", verbose=True)

  ```



  ```python
  import abdutils as abd

  abd.CreateFolder("folder_to_overwrite", mode="o", verbose=True)

  ```



  ```python
  import abdutils as abd

  abd.CreateFolder("folder_to_create_if_not_exist", mode="c", verbose=True)

  ```



  ```python
  import abdutils as abd


  abd.CreateFolder("folder_to_ask_user")


  abd.CreateFolder("folder_to_ask_user", mode="a", verbose=True)

  ```





  The `Copy` function allows you to copy files based on a source pattern to a destination folder or filename.



  ```python
  Copy(src_pattern=None, dest_path=None, verbose=True)
  ```

  - `src_pattern` (str): The source file pattern. Supports regular expressions like '/path/to/files/*.txt'.
  - `dest_path` (str): The destination path including both folder and filename.
  - `verbose` (bool): Whether to display verbose messages. Defaults to True.





  ```python
  import abdutils as abd

  abd.Copy("source_file.txt", "destination_folder/destination_file.txt", verbose=True)

  ```



  ```python
  import abdutils as abd

  abd.Copy("files_to_copy/*.txt", "destination_folder/", verbose=True)

  ```



  ```python
  import abdutils as abd

  abd.Copy("files_to_copy/*.txt", "destination_folder/specific_file.txt", verbose=True)

  ```



  ```python
  import abdutils as abd

  abd.Copy("files_to_copy/*.txt", "non_existent_folder/", verbose=True)

  ```



  ```python
  import abdutils as abd

  abd.Copy("files_to_copy/*.txt", "non_existent_folder/", verbose=False)

  ```



  The `Move` function allows you to move (cut and paste) files based on a source pattern to a destination path.



  ```python
  Move(src_pattern=None, dest_path=None, verbose=True)
  ```

  - `src_pattern` (str): The source file pattern.
  - `dest_path` (str): The destination path.
  - `verbose` (bool): Whether to display verbose messages. Defaults to True.





  ```python
  import abdutils as abd

  abd.Move("source_file.txt", "destination_folder/destination_file.txt", verbose=True)

  ```



  ```python
  import abdutils as abd

  abd.Move("files_to_move/*.txt", "destination_folder/", verbose=True)

  ```



  ```python
  import abdutils as abd

  abd.Move("files_to_move/*.txt", "destination_folder/specific_file.txt", verbose=True)

  ```



  ```python
  import abdutils as abd

  abd.Move("files_to_move/*.txt", "non_existent_folder/", verbose=True)

  ```



  ```python
  import abdutils as abd

  abd.Move("files_to_move/*.txt", "non_existent_folder/", verbose=False)

  ```



  The `Delete` function allows you to delete files or folders based on the given path. It supports wildcard patterns.



  ```python
  Delete(path=None, verbose=True)
  ```

  - `path` (str): The path to the file or folder to be deleted. Supports wildcard patterns.
  - `verbose` (bool): Whether to display verbose messages. Defaults to True.





  ```python
  import abdutils as abd


  abd.Delete("file_to_delete.txt", verbose=True)
  ```



  ```python
  import abdutils as abd


  abd.Delete("folder_to_delete/", verbose=True)
  ```



  ```python
  import abdutils as abd


  abd.Delete("*.txt", verbose=True)
  ```



  ```python
  import abdutils as abd


  abd.Delete("parent_folder/nested_folder/*.jpg", verbose=True)
  ```



  ```python
  import abdutils as abd


  abd.Delete("non_existent_file.txt", verbose=True)

  ```



  ```python
  import abdutils as abd


  abd.Delete("symlink_to_file.txt", verbose=True)

  ```

  These examples demonstrate how to use the `Delete` function to delete files and folders based on the provided path and support for wildcard patterns.



  The `Rename` function allows you to rename a file or folder based on the given source path and new name.



  ```python
  Rename(src_path=None, new_name=None, verbose=True)
  ```

  - `src_path` (str): The source path of the file or folder to be renamed.
  - `new_name` (str): The new name for the file or folder.
  - `verbose` (bool): Whether to display verbose messages. Defaults to True.





  ```python
  import abdutils as abd

  abd.Rename("old_filename.txt", "new_filename.txt", verbose=True)

  ```



  ```python
  import abdutils as abd

  abd.Rename("old_folder", "new_folder", verbose=True)

  ```



  ```python
  import abdutils as abd

  abd.Rename("non_existent_file.txt", "new_name.txt", verbose=True)

  ```



  ```python
  import abdutils as abd

  abd.Rename("existing_file.txt", "new_name.txt", verbose=False)

  ```



  The `ReadFile` function allows you to read a file line by line and return one line at a time with each function call.



  ```python
  ReadFile(file_path)
  ```

  - `file_path` (str): The path to the file to be read.





  ```python
  import abdutils as abd

  line1 = abd.ReadFile("sample.txt")
  print(line1)

  ```



  ```python
  import abdutils as abd

  line1 = abd.ReadFile("sample.txt")
  line2 = abd.ReadFile("sample.txt")
  print(line1)
  print(line2)

  ```



  ```python
  from abdutils import ReadFile

  line1 = ReadFile("imported_file.txt")
  print(line1)

  ```



  ```python
  import abdutils as abd

  file_path = "sample.txt"
  line = abd.ReadFile(file_path)

  while line is not None:
      print(line)
      line = abd.ReadFile(file_path)

  ```



  The `WriteFile` function enables you to write lines to a file in either append or write mode.



  ```python
  WriteFile(file_path, line)
  ```

  - `file_path` (str): The path to the file to be written.
  - `line` (str): The line to be written to the file.





  ```python
  import abdutils as abd

  abd.WriteFile("my.txt", "Hello, World!")

  ```



  ```python
  import abdutils as abd

  lines_to_write = ["Line 1", "Line 2", "Line 3"]
  abd.WriteFile("my.txt", lines_to_write)

  ```



  ```python
  from abdutils import WriteFile

  WriteFile("imported_file.txt", "This is an imported file.")

  ```



  ```python
  import abdutils as abd

  lines_to_write = ["Line 1", "Line 2", "Line 3"]
  for line in lines_to_write:
      abd.WriteFile("looped_file.txt", line, mode="a")


  ```



  ```python
  import abdutils as abd

  line_to_write = "Looped line"
  counter = 0
  while counter < 3:
      abd.WriteFile("looped_file.txt", line_to_write, 'a')
      counter += 1

  ```





  The `ReadImage` function is a Python utility for reading images from specified file paths. This function offers flexibility by allowing you to specify the desired image loading mode and method. It can load images using either the Pillow (PIL) library or OpenCV (cv2) library, depending on the method specified. Additionally, it performs checks on the image mode and handles various error scenarios gracefully.



  ```python
  from abdutils import *
  def ReadImage(image_path, mode='RGB', method='auto'):
  ```



  - `image_path` (str): The path to the image file.
  - `mode` (str): The desired mode for loading the image ('RGB', 'L', etc.). Defaults to 'RGB'.
  - `method` (str): The method to use for loading the image ('auto', 'PIL', or 'CV2'). Defaults to 'auto'.



  - `PIL.Image.Image` or `numpy.ndarray`: The loaded image.



  The function includes error handling for various scenarios, such as invalid modes, unsupported methods, permission errors, and file not found errors. It gracefully handles these errors and provides informative error messages.





  ```python
  from abdutils import *

  image = ReadImage("example.jpg")
  ```

  In this example, the function loads an RGB image ("example.jpg") using the default settings, which use the Pillow library for image loading.



  ```python
  from abdutils import *

  grayscale_image = ReadImage("example.png", mode='L', method='CV2')
  ```

  This example loads a grayscale image ("example.png") using OpenCV (cv2) for image loading. The method is explicitly set to 'CV2'.



  ```python
  from abdutils import *

  unsupported_image = ReadImage("example.gif")
  ```

  In this case, the function attempts to load an unsupported image format ("example.gif"). Since it's a GIF format and the method is set to 'auto', the function will use Pillow for loading.



  ```python
  from abdutils import *

  non_existent_image = ReadImage("non_existent.jpg")
  ```

  This example demonstrates handling a file not found error. The function attempts to load an image ("non_existent.jpg") that doesn't exist in the specified path and will handle the error gracefully.



  ```python
  from abdutils import *

  image_with_permission_error = ReadImage("protected.jpg")
  ```

  In this example, the function attempts to open an image ("protected.jpg") but encounters a permission error due to restricted access. The function handles the permission error gracefully.

  These examples showcase the versatility of the `ReadImage` function, including loading images in different modes and handling various error scenarios. Customize the file paths and parameters according to your specific image loading requirements.




  The `SaveImage` function is a Python utility for saving images to a specified file path. This function provides flexibility in choosing the method for saving the image and handles various error scenarios gracefully.



  ```python
  def SaveImage(image, save_path, method='auto'):
  ```



  - `image`: The image to be saved (PIL.Image.Image or numpy.ndarray).
  - `save_path`: The path where the image should be saved.
  - `method` (str): The method to use for saving the image ('auto', 'PIL', or 'CV2'). Defaults to 'auto'.



  - `True` if the image is saved successfully; `False` if there is an error.



  The function includes error handling for various scenarios, such as unsupported image types, permission errors, and other exceptions. It gracefully handles these errors and provides informative error messages.





  ```python

  import abdutils as abd


  image = abd.ReadImage("input.jpg")


  result = abd.SaveImage(image, "output.jpg")
  if result:
      print("Image saved successfully.")
  else:
      print("Failed to save the image.")
  ```

  In this example, the function saves a PIL image using the default 'auto' method, which detects the image type.



  ```python
  import abdutils as abd


  image = abd.ReadImage("input.png")


  result = abd.SaveImage(image, "output.png", method='CV2')
  if result:
      print("Image saved successfully.")
  else:
      print("Failed to save the image.")
  ```

  This example demonstrates saving a cv2 image using the 'CV2' method explicitly.



  The `ConvertToGrayscale` function is a Python utility for converting images to grayscale. This function allows you to specify the method for conversion and supports both PIL and cv2 image types.



  ```python
  def ConvertToGrayscale(image, method='auto'):
  ```



  - `image`: The input image (PIL.Image.Image or numpy.ndarray).
  - `method` (str): The method to use for conversion ('auto', 'PIL', or 'CV2'). Defaults to 'auto'.



  - Grayscale image (PIL.Image.Image or numpy.ndarray).



  The function includes error handling for various scenarios, such as unsupported image types or formats, and provides informative error messages.





  ```python

  import abdutils as abd


  image = abd.ReadImage("input.jpg")


  grayscale_image = abd.ConvertToGrayscale(image)


  ```

  In this example, the function converts an image to grayscale using the default 'auto' method, which automatically detects the image type.



  ```python
  import abdutils as abd


  image = abd.ReadImage("input.png")


  grayscale_image = abd.ConvertToGrayscale(image, method='CV2')


  ```

  This example explicitly converts a cv2 image to grayscale using the 'CV2' method.



  The `ConvertToRGB` function is a Python utility that allows you to convert an image to the RGB color mode. This function supports both PIL (Pillow) and cv2 (OpenCV) image types and provides flexibility in choosing the conversion method.



  ```python
  def ConvertToRGB(image, method='auto'):
  ```



  - `image`: The input image (PIL.Image.Image or numpy.ndarray).
  - `method` (str): The method to use for conversion ('auto', 'PIL', or 'CV2'). Defaults to 'auto'.



  - RGB image (PIL.Image.Image or numpy.ndarray).



  The function includes error handling for various scenarios, such as unsupported image types, modes, or formats, and provides informative error messages.





  ```python

  import abdutils as abd


  image = abd.ReadImage("input.jpg")


  rgb_image = abd.ConvertToRGB(image)


  ```

  In this example, the function converts an image to RGB color mode using the default 'auto' method, which automatically detects the image type and mode.



  ```python
  import abdutils as abd


  image = abd.ReadImage("input.png")


  rgb_image = abd.ConvertToRGB(image, method='CV2')


  ```

  This example explicitly converts an  image to RGB using the 'CV2' method.



  The `CropImage` function is a Python utility for cropping a region of interest (ROI) from an image. It accepts a PIL (Pillow) image and a list of coordinates to define the cropping area.



  ```python
  def CropImage(image, coordinates):
  ```



  - `image`: The input image (PIL.Image.Image).
  - `coordinates` (list): A list containing the left, top, right, and bottom coordinates.



  - Cropped image (PIL.Image.Image).



  The function includes error handling for cases where the input image or coordinates are invalid, and it provides informative error messages.



  ```python

  import abdutils as abd


  image = abd.ReadImage("input.jpg")


  crop_coordinates = [0, 0, 50, 50]


  cropped_image = abd.CropImage(image, crop_coordinates)


  ```

  In this example, the function crops a region of interest from the input image based on the specified coordinates.



  The `GetImageSize` function is a Python utility that allows you to retrieve the size (width and height) of an image. This function supports both PIL (Pillow) and cv2 (OpenCV) image types and provides flexibility in choosing the method for reading the image size.



  ```python
  def GetImageSize(image, method='auto'):
  ```



  - `image`: The input image (PIL.Image.Image or numpy.ndarray).
  - `method` (str): The method to use for reading the image ('auto', 'PIL' for Pillow, 'CV2' for OpenCV).
                        Defaults to 'auto'.



  - A tuple containing the width and height of the image.



  The function includes error handling for various scenarios, such as unsupported image types or methods, and provides informative error messages.





  ```python

  import abdutils as abd


  image = abd.ReadImage("input.jpg")


  width, height = abd.GetImageSize(image)


  ```

  In this example, the function retrieves the size of an image using the default 'auto' method, which automatically detects the image type.



  ```python

  import abdutils as abd


  image = abd.ReadImage("input.png")


  width, height = abd.GetImageSize(image, method='CV2')


  ```

  This example explicitly retrieves the size of a cv2 image using the 'CV2' method.



  The `ResizeImage` function is a Python utility that allows you to resize an image to the specified size while preserving the aspect ratio. This function utilizes the Pillow (PIL) library to perform the resizing.



  ```python
  def ResizeImage(image, size, verbose=True):
  ```



  - `image`: The input image (PIL.Image.Image).
  - `size` (tuple): The target size (width, height).
  - `verbose` (bool): Whether to display verbose messages. Defaults to True.



  - The resized image (PIL.Image.Image).



  The function includes error handling for scenarios where the input image is not a PIL Image object or the size parameter is not a valid tuple of two integers.





  ```python

  import abdutils as abd


  image = abd.ReadImage("input.jpg")


  resized_image = abd.ResizeImage(image, (300, 200))


  ```

  In this example, the function resizes the input image to a width of 300 pixels and a height of 200 pixels while preserving the aspect ratio.



  ```python

  import abdutils as abd


  image = abd.ReadImage("input.jpg")


  resized_image = abd.ResizeImage(image, (640, 480), verbose=False)


  ```

  This example resizes the image to a width of 640 pixels and a height of 480 pixels without displaying verbose messages.



  The `GaussianBlurImage` function is a Python utility for applying Gaussian blur to an image. This function utilizes the Pillow (PIL) library to perform the blurring operation.



  ```python
  def GaussianBlurImage(image, sigma=1.0, verbose=True):
  ```



  - `image`: The input image (PIL.Image.Image).
  - `sigma` (float): The standard deviation of the Gaussian kernel.
  - `verbose` (bool): Whether to display verbose messages. Defaults to True.



  - The blurred image (PIL.Image.Image).



  The function includes error handling for scenarios where the input image is not a PIL Image object or the sigma parameter is not a positive number.



  ```python

  import abdutils as abd


  image = abd.ReadImage("input.jpg")


  blurred_image = abd.GaussianBlurImage(image, sigma=2.0)


  ```

  In this example, the function applies Gaussian blur to the input image with a sigma value of 2.0.



  The `ConvertImageToGrayscale` function is a Python utility that allows you to convert a color image to grayscale. This function utilizes the Pillow (PIL) library to perform the conversion.



  ```python
  def ConvertImageToGrayscale(image, verbose=True):
  ```



  - `image`: The input image (PIL.Image.Image).
  - `verbose` (bool): Whether to display verbose messages. Defaults to True.



  - The grayscale image (PIL.Image.Image).



  The function includes error handling for scenarios where the input image is not a PIL Image object.



  ```python

  import abdutils as abd


  image = Image.open("color_image.jpg")


  grayscale_image = abd.ConvertImageToGrayscale(image)


  ```

  In this example, the function converts a color image to grayscale.



  The `SharpenImage` function is a Python utility for sharpening an image. This function utilizes the Pillow (PIL) library to perform the sharpening operation.



  ```python
  def SharpenImage(image, factor=2.0, verbose=True):
  ```



  - `image`: The input image (PIL.Image.Image).
  - `factor` (float): The sharpening factor.
  - `verbose` (bool): Whether to display verbose messages. Defaults to True.



  - The sharpened image (PIL.Image.Image).



  The function includes error handling for scenarios where the input image is not a PIL Image object or the factor parameter is not a positive number.



  ```python

  import abdutils as abd


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


  sharpened_image = abd.SharpenImage(image, factor=1.5)


  ```

  In this example, the function sharpens the input image with a factor of 1.5.

  Feel free to customize the file paths, parameters, and examples according to your specific image processing needs.



  The `DetectEdgesInImage` function is a Python utility for detecting edges in an image using various edge detection methods. It provides flexibility in choosing the edge detection method and offers customizable threshold values for the Canny edge detection method. This function supports both Pillow (PIL) and NumPy image types.



  ```python
  def DetectEdgesInImage(image, method='canny', threshold1=100, threshold2=200, verbose=True):
  ```



  - `image` (PIL.Image.Image or numpy.ndarray): The input image.
  - `method` (str): The edge detection method to use ('canny', 'sobel', 'laplacian', 'prewitt', or 'scharr'). Defaults to 'canny'.
  - `threshold1` (int): The first threshold for the hysteresis procedure (only for the 'canny' method). Defaults to 100.
  - `threshold2` (int): The second threshold for the hysteresis procedure (only for the 'canny' method). Defaults to 200.
  - `verbose` (bool): Whether to display verbose messages. Defaults to True.



  - `PIL.Image.Image`: The edge-detected image.



  The function includes error handling for various scenarios, such as checking if the input image is a valid PIL Image object and validating threshold values for the Canny method. It gracefully handles these errors and provides informative error messages.





  ```python
  import abdutils as abd


  image = abd.ReadImage("input.jpg")


  edge_image = abd.DetectEdgesInImage(image)


  abd.ShowImage(edge_image)


  ```

  In this example, the function detects edges in an image using the default Canny edge detection method and displays the edge-detected image using `abd.ShowImage`.



  ```python
  import abdutils as abd


  image = abd.ReadImage("input.jpg")


  edge_image = abd.DetectEdgesInImage(image, method='sobel')


  abd.ShowImage(edge_image)


  ```

  This example explicitly uses the Sobel edge detection method to detect edges in an image and displays the edge-detected image using `abd.ShowImage`.



  ```python
  import abdutils as abd


  image = abd.ReadImage("input.jpg")


  edge_image = abd.DetectEdgesInImage(image, threshold1=50, threshold2=150, verbose=False)


  abd.ShowImage(edge_image)


  ```

  In this example, the function uses custom threshold values for the Canny method, disables verbose messages during edge detection, and displays the edge-detected image using `abd.ShowImage`.



  ```python
  import abdutils as abd


  image = abd.ReadImage("input.jpg")


  edge_image = abd.DetectEdgesInImage(image, method='unsupported_method')


  ```

  This example demonstrates handling an unsupported edge detection method, which will result in an error message.



  ```python
  import abdutils as abd


  image = "invalid_image.jpg"


  edge_image = abd.DetectEdgesInImage(image)


  ```

  In this case, the function attempts to detect edges in an invalid image (not a PIL Image object) and handles the error gracefully.

  These examples demonstrate the versatility of the `DetectEdgesInImage` function, including choosing different edge detection methods, customizing threshold values, and displaying the edge-detected image using `abd.ShowImage`. Customize the file paths and parameters according to your specific edge detection requirements.


  You can adjust or expand upon the documentation as needed to provide more details or examples.




  The `ConvolveImage` function is a Python utility for applying convolution to an image using a given kernel. This function supports both Pillow (PIL) and NumPy image types, allowing you to perform convolution operations on images.



  ```python
  def ConvolveImage(image, kernel, verbose=True):
  ```



  - `image` (PIL.Image.Image): The input image.
  - `kernel` (numpy.ndarray): The convolution kernel.
  - `verbose` (bool): Whether to display verbose messages. Defaults to True.



  - `PIL.Image.Image`: The convolved image.



  The function includes error handling for various scenarios, such as checking if the input image is a valid PIL Image object and verifying the kernel's data type and shape. It gracefully handles these errors and provides informative error messages.





  ```python
  import abdutils as abd
  import numpy as np


  image = abd.ReadImage("input.jpg")


  custom_kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])


  convolved_image = abd.ConvolveImage(image, custom_kernel)


  abd.ShowImage(convolved_image)


  ```

  In this example, the function applies convolution to an image using a custom kernel and displays the convolved image using `abd.ShowImage`.



  ```python
  import abdutils as abd
  import numpy as np


  image = abd.ReadImage("input.jpg")


  custom_kernel = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])


  convolved_image = abd.ConvolveImage(image, custom_kernel, verbose=False)


  abd.ShowImage(convolved_image)


  ```

  This example applies convolution to an image using a custom kernel but disables verbose messages during the convolution process.



  The `ApplyFilter` function is a Python utility for applying a convolution filter to an image using a custom kernel. This function supports both Pillow (PIL) and NumPy image types, allowing you to apply custom filters to images.



  ```python
  def ApplyFilter(image, kernel):
  ```



  - `image` (PIL.Image.Image or numpy.ndarray): The input image to apply the filter to.
  - `kernel` (numpy.ndarray): The custom convolution kernel.



  - `PIL.Image.Image` or `numpy.ndarray`: The filtered image.



  The function includes error handling for various scenarios, such as checking if the input image is a valid PIL Image object or a NumPy array (cv2 image). It gracefully handles these errors and provides informative error messages.





  ```python
  import abdutils as abd
  import numpy as np


  image = abd.ReadImage("input.jpg")


  custom_kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])


  filtered_image = abd.ApplyFilter(image, custom_kernel)


  abd.ShowImage(filtered_image)


  ```

  In this example, the function applies a custom filter to an image using a custom convolution kernel and displays the filtered image using `abd.ShowImage`.



  ```python
  import abdutils as abd
  import numpy as np


  image = abd.ReadImage("input.png")


  custom_kernel = np.array([[1, 2, 1], [2, 4, 2], [1, 2, 1]])


  filtered_image = abd.ApplyFilter(image, custom_kernel)


  abd.ShowImage(filtered_image)


  ```

  This example demonstrates applying a custom filter to a NumPy array (cv2 image) and displaying the filtered image using `abd.ShowImage`.

  These examples showcase the functionality of the `ConvolveImage` and `ApplyFilter` functions, allowing you to perform convolution operations and apply custom filters to images with ease. Customize the kernel and image paths as needed for your specific image processing tasks.


  You can customize or expand upon this documentation as necessary to provide more details or examples for your functions.



  The `ShowImage` function is a Python utility for displaying an image using Matplotlib. This function is useful for visualizing images during image processing tasks.



  ```python
  def ShowImage(image, title="Image", verbose=True):
  ```



  - `image` (PIL.Image.Image): The input image.
  - `title` (str): The title of the displayed image.
  - `verbose` (bool): Whether to display verbose messages. Defaults to True.



  - None



  The function includes error handling to ensure that the input `image` is a valid PIL Image object. If the input is not a PIL Image, it raises an error.



  ```python
  import abdutils as abd


  image = abd.ReadImage("input.jpg")


  abd.ShowImage(image, title="My Image")


  ```

  In this example, the `ShowImage` function is used to display an image with a custom title. The image can be loaded using the `abd.ReadImage` function or obtained from any other source.



  The `CV2PIL` function is a Python utility for converting an OpenCV image (in BGR format) to a PIL Image (in RGB format). This conversion is useful when working with both OpenCV and PIL for image processing tasks.



  ```python
  def CV2PIL(cv2_image):
  ```



  - `cv2_image` (numpy.ndarray): The OpenCV image (BGR format).



  - PIL.Image.Image or None: The PIL Image if the conversion is successful; otherwise, it returns None.



  ```python
  import abdutils as abd


  cv2_image = abd.ReadImage("input.jpg")


  pil_image = abd.CV2PIL(cv2_image)


  ```

  In this example, the `CV2PIL` function is used to convert an OpenCV image to a PIL Image, enabling further image processing using PIL.



  The `PIL2CV2` function is a Python utility for converting a PIL Image (in RGB format) to an OpenCV image (in BGR format). This conversion is useful when working with both PIL and OpenCV for image processing tasks.



  ```python
  def PIL2CV2(pil_image):
  ```



  - `pil_image` (PIL.Image.Image): The PIL Image (RGB format).



  - numpy.ndarray or None: The OpenCV image if the conversion is successful; otherwise, it returns None.



  ```python
  import abdutils as abd


  pil_image = abd.ReadImage("input.jpg")


  cv2_image = abd.PIL2CV2(pil_image)


  ```

  In this example, the `PIL2CV2` function is used to convert a PIL Image to an OpenCV image, enabling further image processing using OpenCV.

  These utility functions (`ShowImage`, `CV2PIL`, and `PIL2CV2`) provide essential functionality for displaying images and performing conversions between common image formats, making them valuable tools for image processing and analysis tasks.


  This function retrieves the current system's CPU, GPU, and Disk usage statistics.

  ```python
  def GetSystemUsage():
  ```

  ```python
  import abdutils as abd

  cpu, gpu_usages, gpu_memory, disk = abd.GetSystemUsage()
  print(f"CPU Usage: {cpu}%, Disk Usage: {disk}%")
  for i, usage in enumerate(gpu_usages):
      print(f"GPU {i} Usage: {usage}%")
  for i, memory in enumerate(gpu_memory):
      print(f"GPU {i} Memory Usage: {memory}%")
  ```

  This function returns the height of the console in lines.

  ```python
  def GetConsoleHeight():
  ```

  ```python
  import abdutils as abd
  height = abd.GetConsoleHeight()
  print(f"Console Height: {height} lines")
  ```

  Clears the console screen.

  ```python
  def ClearScreen():
  ```
  *No input parameters*

  ```python
  import abdutils as abd

  abd.ClearScreen()
  ```

  The `LookForKeys` function is designed to handle proper program exit, ensuring the freeing of GPU resources. It sets up signal handlers to capture Ctrl+C and Ctrl+Z signals.


  ```python
  def LookForKeys():
  ```
  *No input parameters*


  ```python
  import abdutils as abd

  abd.LookForKeys()


  ```

  *Note:* This function should be called at the beginning of your program to ensure the proper setup of signal handlers for graceful termination and resource management.


  The `SelectGPU` function automatically selects a GPU that is available and has the most free memory. This is particularly useful for optimizing GPU resource allocation in environments with multiple GPUs.


  ```python
  def SelectGPU():
  ```
  *No input parameters*


  ```python
  import abdutils as abd

  selected_gpu = abd.SelectGPU()
  if selected_gpu:
      print(f"Automatically selected GPU: {selected_gpu.name}")
  ```

  *Note:* This function is ideal for scenarios where optimal GPU utilization is crucial, such as in machine learning or data processing tasks that are GPU-intensive. It simplifies the process of selecting the most appropriate GPU based on current memory availability.



  The `ShowUsage` function displays real-time system usage statistics, including CPU, GPU, and Disk usage. It's typically implemented to run in a separate thread, continuously updating these statistics on the console.


  ```python
  def ShowUsage():
      
  ```
  *No input parameters*


  ```python
  import abdutils as abd


  abd.ShowUsage()


  ```

  *Note:* This function is useful for monitoring the performance of your system in real-time, especially during resource-intensive operations.


pkgId: 00316b53cdde427272a8aef835b80cf5c50633ed22b816b44d7ee75113ad6802
name: python-abeec
arch: src
version: 0.3
epoch: 0
release: 1
summary: abeec: a library to perform approximate bayesian computation
url: http://github.com/nespinoza/abec
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abeec-0.3-1.src.rpm
checksum_type: sha256
description:
  `abeec` is a sampler to perform Approximate Bayesian Computation (ABC) --- i.e., likelihood free posterior inference! It is based on the algorithm presented in [Ishida et al. (2015)](https://arxiv.org/abs/1504.06129).
  **Author**: Nestor Espinoza (nespinoza@stsci.edu)

  While for Cosmological applications an ABC sampler has already been published by the team of Ishida et al (`cosmoabc` --- [check their repository!](https://github.com/COINtoolbox/CosmoABC)),
  there was a need to develop a more general scheme to allow some flexibility to the sampler. For instance, doing arbitrary prior distributions (e.g., with priors that might be correlated)
  was not straightforward to implement, as well as have external functions for distances and simulators that could all benefit from a common parallelization scheme. On top of that, I wanted
  a simple sampler that used the most basic `python` libraries (e.g., `numpy` and `scipy`) at its core. That's where `abeec` comes into place.

  To perform ABC on a given dataset, you need three ingredients:
  1. A `prior` from which to draw points.
  2. A `distance` to compute distances from simulated datasets to your dataset.
  3. And a `simulator`, to simulate datasets to compare against your dataset.
  In `abeec`, it is expected the user will provide **_classes_** defining the `prior`, the `distance` and the `simulator`. All the sampler does it take those and apply the iterative importance
  sampling scheme outlined in [Ishida et al. (2015)](https://arxiv.org/abs/1504.06129), giving back a sample from the posterior. Once those classes are written, one might simply run the
  sampler as:
          import abeec
          from your_script import prior, distance, simulator
          samples = abeec.sample(prior, distance, simulator)
  The best is to check the examples under `examples`.

  Installation is as simple as:
          python setup.py install
  Or via PyPi:
          pip install abeec

  Read the `LICENCE` file for licencing details on how to use the code. If you make use of this code, please cite [Ishida et al. (2015)](https://arxiv.org/abs/1504.06129) and link back
  to this repository.


pkgId: 88230bdd7f7517426b0aa870881927df8d7dc24ec20813eed160c44f881574f0
name: python-abel
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: Machine learning components
url: https://github.com/hunan-rostomyan/abel
rpm_license: BSD 3-clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abel-0.0.6-1.src.rpm
checksum_type: sha256
description:
  ```python
  from abel.linalg.vector import Vector

  a, b = Vector([1, 2]), Vector([3, 4])
  c, d = Vector([1, 2, 3]), Vector([4, 5, 6])

  assert a.shape == b.shape == (1, 2)
  assert c.shape == d.shape == (1, 3)
  ```



  ```python
  assert a + a == Vector([2, 4])
  assert a + b == Vector([4, 6])
  assert b + b == Vector([6, 8])
  ```



  ```python
  assert a - b == Vector([-2, -2])
  assert b - a == Vector([2, 2])
  ```



  ```python
  assert a * 5 == Vector([5, 10])
  assert 5 * a == Vector([5, 10])
  assert a / 2 == Vector([0.5, 1.0])
  ```



  ```python
  assert a @ b == 11
  assert a @ a == 5
  ```



  ```python
  assert a.norm() - 2.236 < 0.001
  assert b.norm() - 5 < 0.001
  ```



  ```python
  assert Vector.angle(a, a) < 0.001
  assert Vector.angle(a, b) - 0.1799 < 0.001
  assert Vector.angle(a, b) == Vector.angle(b, a)
  ```



  ```python
  assert Vector.proj(a, a) == a
  assert Vector.proj(a, b) == Vector([1.32, 1.76])
  assert Vector.proj(b, a) == Vector([2.2, 4.4])
  ```



  ```python
  assert Vector.scalproj(a, b) - 4.919 < 0.01
  assert Vector.scalproj(b, a) - 2.2 < 0.01
  assert Vector.scalproj(a, a) - 2.236 < 0.01
  assert Vector.scalproj(b, b) - 5 < 0.1
  ```



  ```python
  assert Vector.cross(c, d) == Vector([-3, 6, -3])
  ```



  ```python
  assert Vector.average(Vector([2, 1]), Vector([4, 2])) == Vector([3.0, 1.5])
  ```



  Vectors are collinear iff one is a scalar multiple of the other.

  ```python
  assert Vector.collinear(Vector([2, 1]), Vector([4, 2]))
  assert Vector.collinear(Vector([-3, 4, 1]), Vector([-15, 20, 5]))
  assert not Vector.collinear(Vector([0, 1]), Vector([1, 0]))
  ```



  A set of vectors is linearly independent iff all vectors in it are pairwise non-collinear.

  ```python
  assert Vector.linindep(Vector([0, 1]), Vector([1, 0]))
  assert Vector.linindep(Vector([1, 1]), Vector([2, 1]))
  assert not Vector.linindep(Vector([1, 2, 3]), Vector([0, 0, 1]), Vector([0, 0, 2]))
  ```


pkgId: 646390e641de128d580b671d95449ae4ff249a2776290070d13f9a298426bac6
name: python-abeluna
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: A simple GUI to-do/task manager with CalDAV support.
url: https://github.com/Ninjaclasher/abeluna
rpm_license: GNU Affero General Public License v3 or later (AGPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abeluna-1.1.3-1.src.rpm
checksum_type: sha256
description:
  A simple GUI to-do/task manager with CalDAV support. In theory, Abeluna should support any CalDAV server, but currently only [Nextcloud](https://apps.nextcloud.com/apps/tasks) and [Radicale](https://radicale.org/3.0.html) are tested.
  The goal of this application is to become a desktop version of Nextcloud's Tasks app. As such, not all functionality in the [icalendar's VTODO](https://icalendar.org/iCalendar-RFC-5545/3-6-2-to-do-component.html) are supported, only those that are used by Nextcloud. On the other hand, there some non-standard fields used by Nextcloud that are supported by Abeluna, such as the ability to hide subtasks.

  ![Main window](https://i.imgur.com/8WP2OPj.png)
  ![Settings window](https://i.imgur.com/d29WsE2.png)
  ![Custom theme main window](https://i.imgur.com/rZWjWt2.png)


  First, install two packages, `libnotify` and `gobject-introspection`. On other distributions besides Arch Linux, these names may be different. For example, on Debian-based systems, `gobject-introspection` is `libgirepository1.0-dev`.
  ```sh
  $ pip install abeluna
  $ abeluna
  ```

  If you are using Arch Linux and do not wish to install through PIP, you can install the AUR package [abeluna](https://aur.archlinux.org/packages/abeluna/) for the latest version.

  ```sh
  $ abeluna
  ```
  In the GUI, calendars can be added through `Settings > Calendar settings`. General settings, such as the timezone and synchronization schedule can be accessed through `Settings > General settings`.

   - Support for desktop notifications.
   - Support for recurring tasks.
   - Add common keyboard shortcuts.


pkgId: 7e77213a284620675525799c8390681a3d3f4e58ba79de15665427a410449133
name: python-abeona
arch: src
version: 0.45.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/winni2k/abeona
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abeona-0.45.0-1.src.rpm
checksum_type: sha256
description:
  abeona v0.45.0
  A simple transcriptome assembler based on kallisto and Cortex graphs.
  Abeona consists of the following stages:
  1. Assembly of reads into a De Bruijn graph
  2. Pruning of tips and low-coverage unitigs
  3. Partitioning of the De Bruijn graph into subgraphs
  4. Generation of candidate transcripts by simple path traversal
  5. Filtering of candidate transcripts by kallisto


pkgId: 34d54458bde419859cb04f32c92b751311c1f59e097bfb37c6c94fa481ec2f3e
name: python-abg-python
arch: src
version: 1.1.5
epoch: 0
release: 1
summary: shared python utilities for http://github.com/agurvich 's packages.
url: https://github.com/agurvich/abg_python
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abg-python-1.1.5-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/agurvich/abg_python.svg?branch=master)](https://travis-ci.com/agurvich/abg_python)
  [![PyPI](https://img.shields.io/pypi/v/abg_python)](https://pypi.org/project/abg_python)
  [![DOI](https://zenodo.org/badge/132956776.svg)](https://zenodo.org/badge/latestdoi/132956776)

  Some Python utilities common to a lot of my packages and repositories (perhaps most notably [FIREstudio](https://github.com/agurvich/FIRE_studio) and, in part, [Firefly](https://github.com/ageller/Firefly)).

  If you use any part of this code for direct calculation please put a nice thank you in your acknowledgements ("Some of the calculations presented in this work rely on public code developed by Alex Gurvich, available at github.com/agurvich/abg_python" or something like that). If you use it as a dependency for something else I've built, acknowledge that codebase instead (e.g. FIRE studio or Firefly).


   `abg_python` is available from PyPi by
   ```bash
   pip install abg_python
   ```

   or you can build the source yourself by cloning this repository and, from the top level directory, executing
   ```bash
   pip install -e .
   ```


pkgId: d847be037ff906f5e7d5fef707969421cd1497cfb2af0b1e842004aa779a12eb
name: python-abgleich
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: zfs sync tool
url: https://github.com/pleiszenburg/abgleich
rpm_license: LGPLv2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abgleich-0.0.8-1.src.rpm
checksum_type: sha256
description:
  [`abgleich`](https://dict.leo.org/englisch-deutsch/abgleich?side=right) is a simple ZFS sync tool. It displays source and target ZFS zpool, dataset and snapshot trees. It creates meaningful snapshots only if datasets have actually been changed. It compares a source zpool tree to a target, backup zpool tree. It pushes backups from a source to a target. It cleanes up older snapshots on the source side if they are present on the target side. It runs on a command line and produces nice, user-friendly, human-readable, colorized output. It also includes a GUI.



  ![demo](https://github.com/pleiszenburg/abgleich/blob/master/docs/demo.png?raw=true "demo")



  | snap | backup | cleanup |
  |:----:|:------:|:-------:|
  | ![snap](https://github.com/pleiszenburg/abgleich/blob/master/docs/demo_gui01.png?raw=true "snap") | ![backup](https://github.com/pleiszenburg/abgleich/blob/master/docs/demo_gui02.png?raw=true "backup") | ![cleanup](https://github.com/pleiszenburg/abgleich/blob/master/docs/demo_gui03.png?raw=true "cleanup") |



  The base CLI tool can be installed as follows:

  ```bash
  pip install -vU abgleich
  ```

  An installation also including a GUI can be triggered by running:

  ```bash
  pip install -vU abgleich[gui]
  ```

  Requires [CPython](https://en.wikipedia.org/wiki/CPython) 3.6 or later, a [Unix shell](https://en.wikipedia.org/wiki/Unix_shell) and [ssh](https://en.wikipedia.org/wiki/Secure_Shell). GUI support requires [Qt5](https://en.wikipedia.org/wiki/Qt_(software)) in addition. Tested with [OpenZFS](https://en.wikipedia.org/wiki/OpenZFS) 0.8.x on Linux.

  `abgleich`, CPython and the Unix shell must only be installed on one of the involved systems. Any remote system will be contacted via ssh and provided with direct ZFS commands.



  All actions involving a remote host assume that `ssh` with public key authentication instead of passwords is correctly configured and working.

  Let's assume that everything in `source_tank/data` and below should be synced with `target_tank/some_backup/data`. `source_tank` and `target_tank` are zpools. `data` is the "prefix" for the source zpool, `some_backup/data` is the corresponding "prefix" for the target zpool. For `abgleich` to work, `source_tank/data` and `target_tank/some_backup` must exist. `target_tank/some_backup/data` must not exist. The latter will be created by `abgleich`. It is highly recommended to set the mountpoint of `target_tank/some_backup` to `none` before running `abgleich` for the first time.

  Rights to run the following commands are required:

  | command        | source | target |
  |----------------|:------:|:------:|
  | `zfs list`     |    x   |    x   |
  | `zfs get`      |    x   |    x   |
  | `zfs snapshot` |    x   |        |
  | `zfs send`     |    x   |        |
  | `zfs receive`  |        |    x   |
  | `zfs destroy`  |    x   |        |



  Complete example configuration file:

  ```yaml
  source:
      zpool: tank_ssd
      prefix:
      host: localhost
      user:
      port:
  target:
      zpool: tank_hdd
      prefix: BACKUP_SOMEMACHINE
      host: bigdata
      user: zfsadmin
      port:
  include_root: yes
  keep_snapshots: 2
  keep_backlog: True
  always_changed: no
  written_threshold: 1048576
  check_diff: yes
  suffix: _backup
  digits: 2
  ignore:
      - home/user/CACHE
      - home/user/CCACHE
  ssh:
      compression: no
      cipher: aes256-gcm@openssh.com
  compatibility:
      target_samba_noshare: yes
      target_autosnapshot_ignore: yes
  ```

  `zpool` defines the name of the zpools on source and target sides. The `prefix` value defines a "path" to a dataset underneath the `zpool`, so the name of the zpool itself is not part of the `prefix`. The `prefix` can be empty on either side. Prefixes can differ between source and target side. `host` specifies a value used by `ssh`. It does not have to be an actual host name. It can also be an alias from ssh's configuration. If a `host` is set to `localhost`, `ssh` wont be used and the `user` field can be left empty or omitted. Both source and target can be remote hosts or `localhost` at the same time. The `port` parameter specifies a custom `ssh` port. It can be left empty or omitted. `ssh` will then use its defaults or configuration to determine the correct port.

  `include_root` indicates whether `{zpool}{/{prefix}}` should be included in all operations. `keep_snapshots` is an integer and must be greater or equal to `1`. It specifies the number of snapshots that are kept per dataset on the source side when a cleanup operation is triggered. `keep_backlog` is either an integer or a boolean. It specifies if (or how many) snapshots are kept on the target side if the target side is cleaned. Snapshots that are part of the overlap with the source side are never considered for removal. `suffix` contains the name suffix for new snapshots.

  Whether or not snapshots are generated is based on the following sequence of checks:

  - Dataset is ignored: NO
  - Dataset has no snapshot: YES
  - If the `always_changed` configuration option is set to `yes`: YES
  - If the `tagging` configuration option underneath `compatibility` is set to yes and the last snapshot of the dataset has not been tagged by `abgleich` as a backup: YES
  - `written` property of dataset equals `0`: NO
  - Dataset is a volume: YES
  - If the `written_threshold` configuration is set and the `written` property of dataset is larger than the value of `written_threshold`: YES
  - If the `check_diff` configuration option is set to `no`: YES
  - If `zfs diff` produces any output relative to the last snapshot: YES
  - Otherwise: NO

  Setting `always_changed` to `yes` causes `abgleich` to beliefe that all datasets have always changed since the last snapshot, completely ignoring what ZFS actually reports. No diff will be produced & checked for values of `written` lower than `written_threshold`. Checking diffs can be completely deactivated by setting `check_diff` to `no`.

  `digits` specifies how many digits are used for a decimal number describing the n-th snapshot per dataset per day as part of the name of new snapshots. `ignore` lists stuff underneath the `prefix` which will be ignored by this tool, i.e. no snapshots, backups or cleanups.

  `ssh` allows to fine-tune the speed of backups. In fast local networks, it is best to set `compression` to `no` because the compression is usually slowing down the transfer. However, for low-bandwidth transmissions, it makes sense to set it to `yes`. For significantly better speed in fast local networks, make sure that both the source and the target system support a common cipher, which is accelerated by [AES-NI](https://en.wikipedia.org/wiki/AES_instruction_set) on both ends. The `ssh` port can be specified per side via the `port` configuration option, i.e. for source and/or target.

  Custom pre- and post-processing can be applied after `send` and before `receive` per side via shell commands specified in the `processing` configuration option (underneath `source` and `target`). This can be useful for a custom transfer compression based on e.g. `lzma` or `bzip2`.

  `compatibility` adds options for making `abgleich` more compatible with other tools. If `target_samba_noshare` is active, the `sharesmb` property will - as part of backup operations - be set to `off` for `{zpool}{/{prefix}}` on the target side, preventing sharing/exposing backup datasets by accident. If `target_autosnapshot_ignore` is active, the `com.sun:auto-snapshot` property will - similarly as part of backup operations - be set to `false` for `{zpool}{/{prefix}}` on the target side, telling `zfs-auto-snapshot` to ignore the dataset.



  All potentially changing or destructive actions are listed in detail before the user is asked to confirm them. None of the commands listed below create, change or destroy a zpool, dataset or snapshot on their own without the user's explicit consent.



  Show ZFS tree with snapshots, disk space and compression ratio. Append `source` or `target` (optional).



  Determine which datasets on the source side have been changed since last snapshot. Generate snapshots on the source side where applicable.



  Compare source ZFS tree with target ZFS tree. See what is missing where.



  Send (new) datasets and new snapshots from source to target.



  Cleanup older local snapshots on source side if they are present on both sides. Of those snapshots present on both sides, keep at least `keep_snapshots` number of snapshots on source side. Or: Cleanup older snapshots on target side. Beyond the overlap with source, keep at least `keep_backlog` snapshots. If `keep_backlog` is `False`, all snapshots older than the overlap will be removed. If `keep_backlog` is `True`, no snapshots will be removed. If `abgleich clean` runs against the target side, an extra warning will be displayed and must be confirmed by the user before any dangerous actions are attempted.



  Runs a sequence of `snap`, `backup` and `cleanup` in a wizard GUI. This command is only available if `abgleich` was installed with GUI support.



  `abgleich` uses Python's [type hints](https://docs.python.org/3/library/typing.html) and enforces them with [typeguard](https://github.com/agronholm/typeguard) at runtime. It furthermore makes countless assertions.

  The enforcement of types and assertions can be controlled through the `PYTHONOPTIMIZE` environment variable. If set to `0` (the implicit default value), all checks are activated. `abgleich` will run slow. For safety, this mode is highly recommended. For significantly higher speed, all type checks and most assertions can be deactivated by setting `PYTHONOPTIMIZE` to `1` or `2`, e.g. `PYTHONOPTIMIZE=1 abgleich tree config.yaml`. This is not recommended. You may want to check if another tool or configuration has altered this environment variable by running `echo $PYTHONOPTIMIZE`.


pkgId: 4624fd94a0fd5c5dca465160a5be87a6b5c9e51984b6794eb311b3818df0a2c7
name: python-abgpt
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: AbGPT: De Novo B-Cell Receptor Design via Generative Language Modeling
url: https://github.com/deskk/AbGPT
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abgpt-0.1.2-1.src.rpm
checksum_type: sha256
description:
  Official repository for AbGPT: [De Novo B-Cell Receptor Design via Generative Language Modeling](https://www.biorxiv.org/xxxxxxxxxx).


  To use AbGPT, install via pip:
  ```bash
  pip install abgpt
  ```

  <!-- Alternatively, you can clone this repository and install the package locally:
  ```bash
  $ git clone git@github.com:BaratiLab/AbGPT.git
  $ pip install AbGPT
  ``` -->




  To generate 1000 light chain sequences starting with "QLQL":
  ```bash
  abgpt_generate --chain_type light --starting_residue QLQL --num_seqs 1000
  ```

  To generate a BCR library with 1000 sequences for a number of starting residue (e.g., "QVQL", "EVQL", "VQLV") in the heavy chain:
  ```bash
  abgpt_generate --chain_type heavy --starting_residue QVQL,EVQL,VQLV --num_seqs_each_starting_residue 1000
  ```

  To generate a BCR library with 1000 sequences for a number of starting residue (e.g., "EIVL", "EIVM", "DIQM") in the light chain:
  ```bash
  abgpt_generate --chain_type light --starting_residue EIVL,EIVM,DIQM --num_seqs_each_starting_residue 1000
  ```


pkgId: dc27f4621eb8c2795a2caf6605a0345a5f0f2836a07567e47475fbbbbac494b7
name: python-abi-markdowner
arch: src
version: 0.1.15
epoch: 0
release: 1
summary: A tool to convert MultiversX Smart Contract ABI files into Markdown documentation.
url: https://github.com/0xk0stas/abi-markdowner
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abi-markdowner-0.1.15-1.src.rpm
checksum_type: sha256
description:
  **`abi-markdowner`** is a Python tool that converts MultiversX Smart Contract ABI files into structured and detailed Markdown documentation. This makes it easy to document, share, understand, and interact with smart contracts.




  Discover how `abi-markdowner` effortlessly transforms complex and cumbersome *abi.json* files into clear, structured documentation. Check out these examples:

  - The simple yet illustrative [Ping-Pong SC](https://github.com/0xk0stas/abi-markdowner/blob/main/examples/ping-pong-egld/output/ABI.md).
  - The more advanced [Hatom Liquid Staking SC](https://github.com/0xk0stas/abi-markdowner/blob/main/examples/hatom-liquid-staking-release/liquid-staking/output/ABI.md).




  - **Convert ABI to Markdown:** Generates comprehensive Markdown documentation from smart contract ABI files.
  - **Customizable Output:** Organizes endpoints, views, events, and types with formatted tables and detailed descriptions based on documentations in the contracts.
  - **Matrix-Style Input/Output Tables:** Automatically formats function inputs and outputs into a clear matrix with support for optional and multi-value parameters.
  - **Automatic Table of Contents:** Includes a TOC for easy navigation within the generated documentation.
  - **Deployment Links:** Supports including multiple mainnet and devnet addresses with customizable labels from a `deployments.json` file.



  Install `abi-markdowner` using pip

  ```bash
  pip install abi-markdowner
  ```

  or pipx

  ```bash
  pipx install abi-markdowner
  ```



  Simply run the tool from your SC main directory:

  ```bash
  abi-markdowner
  ```

  Alternatively, you can pass another project directory as argument. For more information, check the `Parameters` section.



  - `--sc-path`:

    (Optional - default is the current working directory)

    Specify the path to your smart contract project containing the Cargo.toml and optionally the deployments.json files. The ABI file will be read from the output directory within this path.

  - `--output-file`:

    (Optional - default is ABI.md in the `sc-path/output` directory)

    Specify the output file path for the generated Markdown.

  - `--cargo-toml`:

    (Optional - default is Cargo.toml in the `sc-path` directory)

    Specify the path to the Cargo.toml file.

  - `--deployments-json`:

    (Optional - default is deployments.json in the `sc-path` directory)

    Specify the path to the deployments.json file containing deployment addresses.

  **Important**:
  ABI file is obtained from the `/output` folder in the `sc-path` directory.



  ```bash
  abi-markdowner --sc-path path_to_sc/
  ```

  This will generate a Markdown document summarizing your smart contract's structure, including types, endpoints, views, and events, along with links to the specified deployment addresses.



  The existence of this file is not mandatory. If found, a `Links` section will be created in the documentation.

  Here’s an example of how your deployments.json file can be structured:

  ```json
  {
    "mainnet": [
      {
        "address": "erd1qqqqqqqqqqqqqpgqvc7gdl0p4s97guh498wgz75k8sav6sjfjlwqh679jy",
        "label": "Shard 0"
      },
      {
        "address": "erd1qqqqqqqqqqqqqpgqhe8t5jewej70zupmh44jurgn29psua5l2jps3ntjj3",
        "label": "Shard 1"
      }
    ],
    "devnet": [
      {
        "address": "erd1qqqqqqqqqqqqqpgqvn9ew0wwn7a3pk053ezex98497hd4exqdg0q8v2e0c"
      }
    ]
  }
  ```

  The above would result in something similar to the following:

  ```css
  Links
      - Mainnet Deployments:
          - Shard 0: erd1qqqqqqqqqqqqqpgqvc7gdl0p4s97guh498wgz75k8sav6sjfjlwqh679jy
          - Shard 1: erd1qqqqqqqqqqqqqpgqhe8t5jewej70zupmh44jurgn29psua5l2jps3ntjj3
      - Devnet Deployments:
          - Address: erd1qqqqqqqqqqqqqpgqvn9ew0wwn7a3pk053ezex98497hd4exqdg0q8v2e0c
  ```



  Tests have not been added yet.



  `abi-markdowner` is licensed under the MIT License. See the LICENSE file for more information.



  Contributions are welcome! Please fork the repository and submit a pull request.


pkgId: 2644a8bd8baf1528731da042778afc2c2c001656c833e9c6b8a3829f220b52d6
name: python-abi3info
arch: src
version: 2024.10.26
epoch: 0
release: 1
summary: A library for abi3 and other CPython API information
url: https://pypi.org/project/abi3info/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abi3info-2024.10.26-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/woodruffw/abi3info/actions/workflows/ci.yml/badge.svg)](https://github.com/woodruffw/abi3info/actions/workflows/ci.yml)
  [![PyPI version](https://badge.fury.io/py/abi3info.svg)](https://pypi.org/project/abi3info)
  abi3info exposes information about CPython's "limited API" (including the
  stable ABI, called `abi3`) as a Python library.

  abi3info is available via `pip`:
  ```console
  $ pip install abi3info
  ```

  abi3info exposes limited API and stable ABI information in the form of a set
  of top-level dictionaries, namely:
  ```python
  import abi3info
  abi3info.FEATURE_MACROS
  abi3info.MACROS
  abi3info.STRUCTS
  abi3info.TYPEDEFS
  abi3info.FUNCTIONS
  abi3info.DATAS
  ```
  Each of these is a mapping of a name (either as `str` or `Symbol`) to
  a data model describing the kind of item (e.g. `FeatureMacro` or `Function`).
  [See the generated documentation](https://woodruffw.github.io/abi3info) for
  more details, including comprehensive type hints and explanations of each data
  model.
  [See also the `stable_abi.toml` file](./codegen/stable_abi.toml), taken from
  the CPython sources, which describes each model and their semantics.

  Get information about a particular function:
  ```python
  from abi3info import FUNCTIONS
  from abi3info.models import Symbol
  func = FUNCTIONS[Symbol("_Py_NegativeRefcount")]
  print(func.symbol, func.added, func.ifdef, func.abi_only)
  ```
  Get information about the feature macros that control the limited API:
  ```python
  from abi3info import FEATURE_MACROS
  print(fm for fm in FEATURE_MACROS.values())
  ```

  abi3info is licensed under the MIT license.
  abi3info is partially generated from metadata retrieved from the
  [CPython sources](https://github.com/python/cpython/blob/main/Misc/stable_abi.toml),
  which is licensed under the [PSF license](https://docs.python.org/3/license.html#psf-license).


pkgId: ce2d8e36bcb6180e15f251a5d7c8de7edb622d4d6639b1f4216774688f5cd0d5
name: python-abics
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: ab-Initio Configuration Sampling tool kit
url: https://github.com/issp-center-dev/abICS
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abics-2.2.1-1.src.rpm
checksum_type: sha256
description:
  abICS is a software framework for training a machine learning model to
  reproduce first-principles energies and then using the model to perform
  configurational sampling in disordered systems.
  Specific emphasis is placed on multi-component solid state systems such as metal and oxide alloys.
  The current version of abics can use neural network models implemented in aenet to be used as
  the machine learning model. As of this moment, abICS can also generate Quantum Espresso, VASP,
  and OpenMX input files for obtaining the reference training data for the machine learning model.



  - python3 (>=3.9)
  - numpy
  - scipy
  - toml (for parsing input files)
  - mpi4py (for parallel tempering)
    - This requires one of the MPI implementation
  - pymatgen (>=2022.1.20) (for using Structure as a configuration)
    - This requires Cython
  - qe-tools (for parsing QE I/O)



  Pymatgen requires Cython but Cython will not be installed automatically,
  please make sure that this is installed,

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

  mpi4py requires one of the MPI implementations such as OpenMPI,
  please make sure that this is also installed.
  In the case of using homebrew on macOS, for example,

  ``` bash
  $ brew install open-mpi
  ```

  After installing Cython and MPI,

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

  will install abICS and dependencies.

  If you want to change the directory where abICS is installed,
  add `--user` option or `--prefix=DIRECTORY` option to the above command as

  ``` bash
  $ python3 -m pip install --user abics
  ```

  For details of `pip` , see the manual of `pip` by `python3 -m pip help install`

  If you want to install abICS from source, see [wiki page](https://github.com/issp-center-dev/abICS/wiki/Install)



  The distribution of the program package and the source codes follow GNU General Public License version 3 ([GPL v3](http://www.gnu.org/licenses/gpl-3.0.en.html)).

  We hope that you cite the following article when you publish the results using abICS.

  Shusuke Kasamatsu, Yuichi Motoyama, Kazuyoshi Yoshimi, Tatsumi Aoyama, “Configuration sampling in multi-component multi-sublattice systems enabled by ab Initio Configuration Sampling Toolkit (abICS)”, [accepted in STAM: Methods](https://doi.org/10.1080/27660400.2023.2284128) ([arXiv:2309.04769](https://arxiv.org/abs/2309.04769).)

  Bibtex:

  ```
  @article{kasamatsu2023configuration,
  author = {Shusuke Kasamatsu, Yuichi Motoyama, Kazuyoshi Yoshimi and Tatsumi Aoyama},
  title = {Configuration sampling in multi-component multi-sublattice systems enabled by ab initio Configuration sampling toolkit ({abICS})},
  journal = {Science and Technology of Advanced Materials: Methods},
  volume = {0},
  number = {ja},
  pages = {2284128},
  year = {2023},
  publisher = {Taylor & Francis},
  doi = {10.1080/27660400.2023.2284128},
  URL = {https://doi.org/10.1080/27660400.2023.2284128},
  eprint = {https://doi.org/10.1080/27660400.2023.2284128}
  }
  ```



  https://www.pasums.issp.u-tokyo.ac.jp/abics



  Shusuke Kasamatsu, Yuichi Motoyama, Tatsumi Aoyama, Kazuyoshi Yoshimi



  [English online manual](https://issp-center-dev.github.io/abICS/docs/master/en/html/index.html)

  [Japanese online manual](https://issp-center-dev.github.io/abICS/docs/master/ja/html/index.html)

  [API reference](https://issp-center-dev.github.io/abICS/docs/api/master/html/index.html)


pkgId: 4a090e989213bb5f03b7ee66b1c3e88ca9ce5413eb13fb989418bb9c903de552
name: python-abilian-core
arch: src
version: 0.11.24
epoch: 0
release: 1
summary: A framework for enterprise applications (CRM, ERP, collaboration...).
url: https://github.com/abilian/abilian-core
rpm_license: LGPL-2.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abilian-core-0.11.24-1.src.rpm
checksum_type: sha256
description:
  Abilian Core is an enterprise application development platform based on the `Flask micro-framework <http://flask.pocoo.org/>`_, the `SQLAlchemy ORM <http://www.sqlalchemy.org/>`_, good intentions and best practices (for some value of "best").
  The full documentation is available on http://docs.abilian.com/.


pkgId: 831c3f90eb2e01db74cbe3ccb1d11c7407e5044016350187ec698c46b151ffb2
name: python-abilian-devtools
arch: src
version: 0.6.6
epoch: 0
release: 1
summary: A curated set of dependencies for quality software development
url: https://github.com/abilian/abilian-devtools
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abilian-devtools-0.6.6-1.src.rpm
checksum_type: sha256
description:
  Abilian Development Tools (ADT) is a curated collection of Python development tools that includes formatters, testing frameworks, style checkers, type checkers, and supply chain audit tools. By adding `abilian-devtools = '*'` to your project's `requirements.in` or `pyproject.toml`, you can access over 40+ curated projects and plugins.
  Proper configuration and usage in your project is still required.
  Additionally, the package provides a command-line interface (CLI) called adt to help users get started with various development tasks such as running tests, security audits, and code formatting.
  ADT was developped at [Abilian](https://abilian.com/) as a tool to help manage dozens of Python projects (open source or not). We hope it can be useful to others too.


pkgId: 6ccf34602cf7307f9ac6fce2f8ce2b68ffa579480548513ba95aa50eecab4082
name: python-abilian-sbe
arch: src
version: 1.1.12
epoch: 0
release: 1
summary: Social Business platform (entreprise collaboration and information management)
url: https://github.com/abilian/abilian-sbe
rpm_license: LGPL-2.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abilian-sbe-1.1.12-1.src.rpm
checksum_type: sha256
description:
  Abilian SBE (Social Business Engine) is a versatile platform designed for social business applications, particularly in the realm of collaborative or enterprise 2.0 business applications. It is ideal for creating enterprise social networks (ESN) and similar applications.



  - **Community-Centric:** Focuses on 'communities' as collaborative spaces, offering services like document management, discussions, wikis, and user timelines.
  - **Robust Foundation:** Built upon the `Abilian Core` project, which integrates Flask and SQLAlchemy, providing essential services.
  - **Proven Track Record:** Reliably used by several major customers in production environments since mid-2013.





  You will need:

  - Python 3.9 or more
  - A running postgresql database (e.g. `createdb sbe-demo`)
  - A redis server
  - ImageMagick (for image processing)
  - Poppler (for PDF processing)
  - LibreOffice (for document conversion)
  - Java (what?!? - yes, for Closure)
  - Node + npm
  - Some libraries: libpq (for Postgres), libjpeg, libxslt, libxml2, libffi, libssl, libmagic, libsqlite3, libbz2...

  On Debian/Ubuntu, the following packages is a good starting point (TODO: check what is missing, what is not really needed):

  ```python
  PACKAGES = [
      
      "build-essential",
      "python-dev",
      "libpq-dev",
      "libxslt1-dev",
      "libjpeg-dev",
      "libffi-dev",
      "libsqlite3-dev",
      "libbz2-dev",
      
      "postgresql",
      "redis",
      
      "poppler-utils",
      "imagemagick",
      "libreoffice",
      "default-jdk-headless",
      
      "curl",
  ]
  ```

  Now, create a virtualenv and install the app and its dependencies:

  ```bash
  poetry shell
  poetry install
  npm install # or npm i
  ```

  Set up the following environment variables (you may put these in a `.env` or `.envs` file and use an environment variable manager like [direnv](https://direnv.net/).

  An example of configured `.env` is available: see `example_config/dot_env` file.

  ```bash
  export FLASK_SECRET_KEY=<your secret key>
  export FLASK_SQLALCHEMY_DATABASE_URI=postgres://localhost/sbe-demo # or whatever


  export FLASK_SERVER_NAME=127.0.0.1:5000
  export FLASK_DEBUG=true
  export FLASK_MAIL_DEBUG=1


  export FLASK_REDIS_URI=redis://localhost:6379/0 # or whatever
  export FLASK_DRAMATIQ_BROKER_URL=redis://localhost:6379/0
  ```


  Then run:

  ```bash
  flask db initdb # Or flask db upgrade if you already have a database
  flask createuser admin <some email address> <username>
  flask run
  ```




  In production, you will need additionally:

  - An email server (running locally on the server, e.g. like postfix, that's probably overridable)

  ```bash

  export FLASK_PRODUCTION = True

  export FLASK_SECRET_KEY=<your secret key>
  export FLASK_SQLALCHEMY_DATABASE_URI=postgres://localhost/sbe-demo # or whatever

  export FLASK_SITE_NAME="<your site name>"
  export FLASK_SERVER_NAME="<your server name>" # i.e. hostname www.mydomain.com...


  export FLASK_MAIL_SERVER=<your email server>








  export FLASK_REDIS_URI=redis://localhost:6379/0 # or whatever
  export FLASK_DRAMATIQ_BROKER_URL=redis://localhost:6379/0
  ```

  You can start the server with:

  ```bash
  gunicorn 'abilian.sbe.app.create_app()'
  ```

  If you are using a web server as a reverse proxy, for instance nginx, you can use the `proxy_pass` option to forward requests to the gunicorn server.



  A step by step configuration example using `honcho`, `.env` and `Python 3.12` is available in the `example_config` folder.



  Click on the button:

  [![Deploy](https://www.herokucdn.com/deploy/button.svg)](https://heroku.com/deploy?template=https://github.com/abilian/abilian-sbe-monorepo)

  (Doesn't fully work - needs to be debugged).




  This project is compliant with the REUSE Specification version 3.2.

  ```
  * Bad licenses: 0
  * Deprecated licenses: 0
  * Licenses without file extension: 0
  * Missing licenses: 0
  * Unused licenses: 0
  * Used licenses: CC-BY-4.0, LGPL-3.0-only
  * Read errors: 0
  * Files with copyright information: 1692 / 1692
  * Files with license information: 1692 / 1692

  Congratulations! Your project is compliant with version 3.2 of the REUSE Specification :-)
  ```


pkgId: 0b27da8ff21018413f15e62750428777f4a18f27727b0801ee3dcfb7ee9762a0
name: python-abin-sim
arch: src
version: 1.2.10
epoch: 0
release: 1
url: https://pypi.org/project/abin-sim/
rpm_license: Beerware
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abin-sim-1.2.10-1.src.rpm
checksum_type: sha256
summary:
  ABIN é um CLI para interagir com a API do Vault e auxiliar os Desenvolvedores nos projetos da SIMTech

description:
  [![CI](https://github.com/SIM-Rede/abin-sim/actions/workflows/pipeline.yaml/badge.svg)](https://github.com/SIM-Rede/abin-sim/actions/workflows/pipeline.yaml)
  [![PyPI version](https://badge.fury.io/py/abin-sim.svg)](https://badge.fury.io/py/abin-sim)



  Utilize o pipx para instalar o abin no seu computador.
  ```
  sudo apt install pipx
  pipx install abin_sim
  ```
  A versão da aplicação no README será atualizada sempre que um novo build rodar.

  Se você estiver rodando no PopOS precisa criar um link simbólico para a aplicação ou adicionar $HOME/.local/bin no path do SO
  ```
  sudo ln -s $HOME/.local/bin/abin /usr/local/bin/abin
  ```




  Após realizar a instalação do App, será necessário iniciar o arquivo de configuração
  Para isso execute a instrução abaixo:
  ```
  abin --configure
  ```

  A instrução acima criará um arquivo chamado 'settings.toml' em $HOME/abin/
  Com o arquivo em mãos, altere o valor de **vault_token** para o seu token, o valor deverá focar entre " "

  *vault_token* -> Seu token de autenticação no Vault

  Para ter acesso seu token basta autenticar no Web UI do Vault.
  Acesse no seu navegador o endereço https://aspirina.simtech.solutions
  *PS*: O acesso devera ser solicitado ao time de SRE da SIMTech

  Na tela de login:

  * Mude **Method** para ***Username***
  * Entre com o seu usuário em **Username**
  * Entre com a sua senha em **Password**
  * Clique em **More Options**
  * Em **Mount Path** digite ***simtech***
  * Clique em **Sign in**

  Após o login clique no boneco localizao no canto superior direito e, após, clique em **Copy Token**

  **Importante:** O Token é válido por 30 dias, portanto lembre de renová-lo.




      Uso: abin

      Retorna uma breve explicação sobre a funcionalidade do CLI.
      Traz exemplos de uso e link para projeto no GitHub


      Uso: abin --version

      Retorna a versão atualmente instalada no SO.
      Para atualizá-la:

      pipx upgrade abin_sim


      Uso: abin --configure

      Gera o arquivo de configuração da aplicação.


      Uso: abin list

      Retorna a árvore de Secrets cadastradas no Path obedecendo a referência abaixp
      ╭─ Referência ──────────────────╮
      │                               │
      │ Vault Environment:            │
      │     ├── (env)-(proj)          │
      │     │    ├── (api)            │
      │                               │
      ╰─ Referência ──────────────────╯


      Uso: abin get [OPTIONS]

      ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
      │ *  --app                  TEXT  Nome da aplicação que deseja recuperar os secrets. [default: None] [required]                                        │
      │ *  --env                  TEXT  Ambiente da aplicação que deseja recuperar (Envs possíveis: dev, qa, main). [default: None] [required]               │
      │ *  --proj                 TEXT  Projeto que deseja conectar para recuperar os secrets (Projs possíveis: sim, charrua) [default: None] [required]     │
      │    --file    --no-file          Cria um arquivo para cada path cadastrada no secrets. [default: file]                                                │
      │    --help                       Show this message and exit.                                                                                          │
      ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

      Examplo:
      * Imprime os dados no StdOut (Tela)
          abin get --app api-auth --env dev --proj sim --no-file
      * Imprime os dados em arquivo (Com base no arquivo $HOME/abin/settings.toml)
          abin get --app api-auth --env dev --proj sim


      Uso: abin update [OPTIONS]

      ╭─ Options─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
      │ *  --app         TEXT  Nome da aplicação que deseja recuperar os secrets. [default: None]  [required]                                        │
      │ *  --env         TEXT  Ambiente da aplicação que deseja recuperar (Envs possíveis: dev, qa, main). [default: None] [required]                │
      │ *  --proj        TEXT  Projeto que deseja conectar para recuperar os secrets (Projs possíveis: sim, charrua) [default: None] [required]      │
      │    --secret      TEXT  Secret que será atualizada no Vault (Ex.: env, gcp.json, config.yaml ...) [default: env]                              │
      │ *  --file        TEXT  Arquivo com variárias de ambiente [default: None] [required]                                                          │
      │    --help              Show this message and exit.                                                                                           │
      ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

      Eexamplo:
          abin update --app api-auth --env dev --proj sim --file .env  (para atualizar outro secret use --secret NOME)


      Uso: abin compare [OPTIONS]

      ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
      │ *  --app                  TEXT  Nome da aplicação que deseja recuperar os secrets. [default: None] [required]                                            │
      │ *  --env                  TEXT  Ambiente da aplicação que deseja recuperar (Envs possíveis: dev, qa, main). [default: None] [required]                   │
      │ *  --proj                 TEXT  Projeto que deseja conectar para recuperar os secrets (Projs possíveis: sim, charrua) [default: None] [required]         │
      │    --help                       Show this message and exit.                                                                                              │
      ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

      Eexamplo:
          abin compare --app api-auth --env qa,dev --proj sim


pkgId: c3367c012423ab94f0a2e7245b89f950a71e74d4792a2327326053218769559f
name: python-abipy
arch: src
version: 0.9.8
epoch: 0
release: 1
summary: Python package to automate ABINIT calculations and analyze the results.
url: https://github.com/abinit/abipy
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abipy-0.9.8-1.src.rpm
checksum_type: sha256
description:
  AbiPy is a Python library to analyze the results produced by `ABINIT <https://www.abinit.org>`_,
  an open-source program for the ab-initio calculations of the physical properties of materials
  within Density Functional Theory and Many-Body perturbation theory.
  AbiPy also provides tools to generate input files and workflows to automate
  ab-initio calculations and typical convergence studies.
  AbiPy is interfaced with `Pymatgen <http://www.pymatgen.org>`_ allowing users to
  benefit from the different tools and python objects available in the pymatgen ecosystem.
  The official documentation is hosted on `github pages <http://abinit.github.io/abipy>`_.
  AbiPy can be used in conjunction with `matplotlib <http://matplotlib.org>`_, `pandas <http://pandas.pydata.org>`_,
  `ipython <https://ipython.org/index.html>`_ and `jupyter <http://jupyter.org/>`_
  thus providing a powerful and user-friendly environment for data analysis and visualization.
  Check out our `gallery of plotting scripts <http://abinit.github.io/abipy/gallery/index.html>`_
  and the `gallery of AbiPy workflows <http://abinit.github.io/abipy/flow_gallery/index.html>`_.
  To learn more about the integration between jupyter and AbiPy, visit our collection of `notebooks
  <http://nbviewer.ipython.org/github/abinit/abipy/blob/master/abipy/examples/notebooks/index.ipynb>`_ and the
  `AbiPy lessons <http://nbviewer.ipython.org/github/abinit/abipy/blob/master/abipy/examples/notebooks/lessons/index.ipynb>`_.
  The latest development version is always available from <https://github.com/abinit/abipy>


pkgId: 401b83a23c688f004bb2507b2cb7ca15b6b0e2b6c1b2d7189f5836a0786ce04c
name: python-abjad
arch: src
version: 3.19
epoch: 0
release: 1
summary: Abjad is a Python API for building LilyPond files.
url: https://abjad.github.io
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abjad-3.19-1.src.rpm
checksum_type: sha256
description:
  Abjad helps composers build up complex pieces of music notation in iterative and
  incremental ways. Use Abjad to create a symbolic representation of all the notes, rests,
  chords, tuplets, beams and slurs in any score. Because Abjad extends the Python
  programming language, you can use Abjad to make systematic changes to music as you work.
  Because Abjad wraps the LilyPond music notation package, you can use Abjad to control the


pkgId: c7283984719cc229ec96f9416cb8c7cc62f0cc8d8db3e37e5f1aa9f1d746b8d3
name: python-abjad-ext-rmakers
arch: src
version: 3.19
epoch: 0
release: 1
summary: Rhythm-makers extend Abjad with tools for rhythmic construction.
url: http://abjad.github.io
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abjad-ext-rmakers-3.19-1.src.rpm
checksum_type: sha256
description:
  Abjad's rhythm-maker extension package.
  ![Build Status](
      https://github.com/Abjad/abjad-ext-rmakers/actions/workflows/main.yml/badge.svg)
  [![Code style: black](
      https://img.shields.io/badge/code%20style-black-000000.svg)](
      https://github.com/ambv/black)


pkgId: 9611d582e49f988a71b29d0ae55b26926da48f37e698a520126ce4d873d515bc
name: python-abl-quantconnect-stubs
arch: src
version: 13987.7
epoch: 0
release: 1
summary: Type stubs for QuantConnect's Lean
url: https://github.com/QuantConnect/quantconnect-stubs-generator
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abl-quantconnect-stubs-13987.7-1.src.rpm
checksum_type: sha256
description:
  This package contains type stubs for QuantConnect's [Lean](https://github.com/QuantConnect/Lean) algorithmic trading engine and for parts of the .NET library that are used by Lean.

  These stubs can be used by editors to provide type-aware features like autocomplete and auto-imports in QuantConnect strategies written in Python.

  After installing the stubs, you can copy the following line to the top of every Python file to have the same imports as the ones that are added by default in the cloud:
  ```py
  from AlgorithmImports import *
  ```

  This line imports [all common QuantConnect members](https://github.com/QuantConnect/Lean/blob/master/Common/AlgorithmImports.py) and provides autocomplete for them.


pkgId: d9055e0c5008ebebcb17989bcca9b341b23f4ef0c39886287a27aaad07b598e0
name: python-abl.util
arch: src
version: 0.2
epoch: 0
release: 1
url: https://github.com/AbletonAG/abl.util
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abl.util-0.2-1.src.rpm
checksum_type: sha256
summary:
  A package that contains various helpful classes and functions used widely in the Ableton Python code base.


pkgId: d9898d20129e77b3c7d4e88f4dea43d736558f746847562248f7545f4b3f4299
name: python-ablang2
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: AbLang2: An antibody-specific language model focusing on NGL prediction.
url: https://pypi.org/project/ablang2/
rpm_license: BSD 3-clause license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ablang2-0.2.1-1.src.rpm
checksum_type: sha256
description:
  <div align="center">


  [![DOI:10.1101/2022.01.20.477061](http://img.shields.io/badge/DOI-10.1101/2022.01.20.477061-B31B1B.svg)](https://doi.org/10.1101/2024.02.02.578678)
  </div>
  **Motivation:** The versatile binding properties of antibodies have made them an extremely important class of biotherapeutics. However, therapeutic antibody development is a complex, expensive and time-consuming task, with the final antibody needing to not only have strong and specific binding, but also be minimally impacted by any developability issues. The success of transformer-based language models in protein sequence space and the availability of vast amounts of antibody sequences, has led to the development of many antibody-specific language models to help guide antibody discovery and design. Antibody diversity primarily arises from V(D)J recombination, mutations within the CDRs, and/or from a small number of mutations away from the germline outside the CDRs. Consequently, a significant portion of the variable domain of all natural antibody sequences remains germline. This affects the pre-training of antibody-specific language models, where this facet of the sequence data introduces a prevailing bias towards germline residues. This poses a challenge, as mutations away from the germline are often vital for generating specific and potent binding to a target, meaning that language models need be able to suggest key mutations away from germline.
  **Results:** In this study, we explore the implications of the germline bias, examining its impact on both general-protein and antibody-specific language models. We develop and train a series of new antibody-specific language models optimised for predicting non-germline residues. We then compare our final model, AbLang-2, with current models and show how it suggests a diverse set of valid mutations with high cumulative probability. AbLang-2 is trained on both unpaired and paired data, and is freely available (https://github.com/oxpig/AbLang2.git).
  **Availability and implementation:** AbLang2 is a python package available at https://github.com/oxpig/AbLang2.git.


pkgId: 03ea4cc92726c99f2b69cd834e5b7d8206119353bac0c9527f799c8c92eaa916
name: python-ablerConfig
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: 配置信息处理包
url: https://github.com/hanlaohan/abler-config
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ablerConfig-0.1.2-1.src.rpm
checksum_type: sha256
description:
  简介
  --
  这是一个用于处理配置信息的Python包。它可以帮助应用程序读取、写入和验证配置文件。该包暂时只供彭彭项目组自用。
  特点
  --
  *   支持JSON5格式的配置文件。
  *   可以验证配置文件的格式和内容。
  *   可以使用默认值填充缺失的配置项。
  *   可以将配置文件转换为Python对象，以便更方便地访问和修改。
  *   支持内部配置文件和本地外部配置文件。


pkgId: a7ea3b8d70a4cabc12a15af777107dd18ea2507d836bf97f5247aa2d9b38c374
name: python-ableton-control-surface-core
arch: src
version: 0.0.7
epoch: 0
release: 1
url: https://github.com/oslo1989/ableton-control-surface-toolkit
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ableton-control-surface-core-0.0.7-1.src.rpm
checksum_type: sha256
summary:
  Decompiled core packages from Ableton Live's Python API to help developers build custom control surfaces.


pkgId: 9508a8e57be7922b29818718a04cc7e2d821038ff684c28ed8d2f7fb5982da95
name: python-ableton-control-surface-scripts
arch: src
version: 0.0.7
epoch: 0
release: 1
url: https://github.com/oslo1989/ableton-control-surface-toolkit
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ableton-control-surface-scripts-0.0.7-1.src.rpm
checksum_type: sha256
summary:
  Decompiled control surface scripts from Ableton Live's Python API to help with reverse engineering and how other well known interfaces work.


pkgId: 4df92d0624bd60bfe266b57cd4556d28afb9271c47450b30e55ed2eba415d8b1
name: python-ablog
arch: src
version: 0.11.11
epoch: 0
release: 1
url: https://ablog.readthedocs.io/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ablog-0.11.11-1.src.rpm
checksum_type: sha256
summary:
  A Sphinx extension that converts any documentation or personal website project into a full-fledged blog.

description:
  [![CI](https://github.com/sunpy/ablog/actions/workflows/ci.yml/badge.svg)](https://github.com/sunpy/ablog/actions/workflows/ci.yml)
  [![Upload Python Package](https://github.com/sunpy/ablog/actions/workflows/pythonpublish.yml/badge.svg)](https://github.com/sunpy/ablog/actions/workflows/pythonpublish.yml)
  ABlog is a Sphinx extension that converts any documentation or personal website project into a full-fledged blog
  `Please check our documentation for information on how to get started. <https://ablog.readthedocs.io/>`__


pkgId: 3a5c87210cf635affc7bacbe1a3fcbb7471e585c0d5a1d786759fd0bda3ed99b
name: python-ablog
arch: src
version: 0.11.12
epoch: 0
release: 1
url: https://ablog.readthedocs.io/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ablog-0.11.12-1.src.rpm
checksum_type: sha256
summary:
  A Sphinx extension that converts any documentation or personal website project into a full-fledged blog.

description:
  |CI| |Upload Python Package|
  ABlog is a Sphinx extension that converts any documentation or personal website project into a full-fledged blog.
  `Please check our documentation for information on how to get started. <https://ablog.readthedocs.io/>`__


pkgId: 270cf3314e110e9aa3955b26a4e47e1e3441a205b4c8ee8f77980e2725196da3
name: python-ablt-python-api
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: aBLT Python API
url: https://docs.ablt.ai/api_docs/overview
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ablt-python-api-0.0.6-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/ablt-python-api.svg)](https://badge.fury.io/py/ablt-python-api) [![Linters](https://github.com/ablt-ai/ablt_python_api/actions/workflows/master_linters.yml/badge.svg?branch=master)](https://github.com/ablt-ai/ablt_python_api/actions/workflows/master_linters.yml) [![Tests](https://github.com/ablt-ai/ablt_python_api/actions/workflows/master_tests.yml/badge.svg?branch=master)](https://github.com/ablt-ai/ablt_python_api/actions/workflows/master_tests.yml) ![PyPI - License](https://img.shields.io/pypi/l/ablt-python-api) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ablt-python-api)[![Downloads](https://static.pepy.tech/badge/ablt-python-api)](https://pepy.tech/project/ablt-python-api) [![Downloads](https://static.pepy.tech/badge/ablt-python-api/month)](https://pepy.tech/project/ablt-python-api)



  This is Python aBLT API wrapper. It is used to communicate with aBLT API. You may use it to create your own aBLT client using asynchronous or synchronous Python. You can find more information about aBLT API [here](https://docs.ablt.ai/api_docs/overview).

  At first, you need obtain aBLT API Token. You can do it [here](https://ablt.ai/) by get in touch and contact with support for paid plans. Next, you may use any existing ready-made bots or templates or create your own bot via UI interface.



  API wrapper is available on PyPI. You can install it with pip (recommended to use Python 3.9+):

  ```bash
  pip install ablt-python-api
  ```



  Then you can import it and use it:

  ```python

  from ablt_python_api import ABLTApi  # this is synchronous API wrapper



  api = ABLTApi(bearer_token=YOUR_ABLT_API_TOKEN)


  api = ABLTApi()
  ```

  For some reason you may want to use your own logger, then you can initialize API wrapper with logger:

  ```python

  api = ABLTApi(logger=your_logger)
  ```







  You may get list of bots:

  ```python

  bots = api.api.get_bots()
  ```

  Or you may use actual schema:

  ```python
  from ablt_python_api.schemas import BotsSchema



  bots = [BotsSchema.model_validate(bot_dict) for bot_dict in api.get_bots()]
  ```



  You may get bot by UID:

  ```python
  bot = api.find_bot_by_uid(bot_uid='F0b98A09-c5ed-1197-90F3-BBfF1DBb28ee')
  ```

  Alternatively, you may get bot by slug:

  ```python
  bot = api.find_bot_by_slug(bot_slug='omni')
  ```

  Or by name (but it's not recommended, because name may be not unique):

  ```python
  bot = api.find_bot_by_name(bot_name='Miles Hiker')
  ```

  In case if no bot found, then `None` will be returned.



  To chat with bot you may use `chat' method:

  ```python

  response = api.chat(bot_uid=BOT_UID, prompt='Hello, bot!')

  response = api.chat(bot_slug=BOT_SLUG, prompt='Hello, bot!')

  str_response = response.__next__()

  ```

  Most probably, you will use `messages` list instead of `prompt` to save context. In this case, you may call method like
  following:

  ```python
  messages = [
      {"content": "I like to eat pizza", "role": "user"},
      {"content": "Hello, I like pizza too!", "role": "assistant"},
      {"content": "What do I like to eat?", "role": "user"},
  ]

  response = api.chat(bot_uid=BOT_UID, messages=messages)
  ```

  You need ensure, that your prompt is last message in `messages` list.



  Additionally, you may extend \ override system context with passing `system` instruction to bot:

  ```python


  messages = [
                 {"content": "You are a bibliophile bot, you know everything about literature", "role": "system"},
                 {"content": "Who is author of 'The Sirens of Titan'?", "role": "user"},
             ],
  ```

  You may call `chat` method with params to override system settings, if you want:

  ```python
  response = api.chat(bot_uid=BOT_UID,
                      prompt='Hello, bot!',
                      language='Arabic',  # may be: "Arabic", "French", "English", "Spanish", "Russian"
                      max_words=100,  # any integer, values less than 100 and greater than 2000 not recommended
                      user_id=42,  # unique user ID, used to split up usage statistics per user
                      use_search=False)  # use search mode, if True, then bot will try to find answer in internet
  ```

  _Notes_:
  In general, you may to try to use unusual values for:
  * `language`, like "Serbian", but it's not guaranteed that it will work as you expected.
  * `max_words` - you may try to use values less than 100 words to save tokens, but you may be experienced with cut-offs. For values greater than 2000 words you may be experienced with timeouts or errors for regular, not 32k or 128k models.
  * `user_id` - you may use any integer value, but it's recommended to use your own unique user ID, because it's used to split up usage statistics per user.
  * `use_search` - it's special feature for premium plans, you may try to manage it from API, and not from UI, but it's highly not recommended to use with smaller `max_words` values, so, while using search, please use values at least 100 or more for `max words`.



  By default, bots are working in streaming mode (as in UI), so, you may use `chat` method to chat with bot in streaming mode, but you may to switch it off by:

  ```python
  response = api.chat(bot_uid=BOT_UID, prompt='Hello, bot!', stream=False)
  ```

  In case if you prefer to use streaming mode, you need to get response from generator:

  ```python
  import sys

  from ablt_python_api import DoneException


  try:
      for response in api.chat(bot_uid=BOT_UID, prompt='Hello, bot!', stream=True):
          
          sys.stdout.write(response)
          
          sys.stdout.flush()
  except DoneException:
      pass  # DoneException is raised when bot finished conversation
  ```



  Statistics may be used to obtain data for words and tokens usage for period of time.



  ```python

  statistics_for_today = api.get_usage_statistics()

  statistics_for_range = api.get_usage_statistics(start_date='2022-02-24',
                                                  end_date='2023-11-17')

  statistics_for_user = api.get_usage_statistics(user_id=42)
  ```

  You may use schema to validate statistics:

  ```python
  from ablt_python_api.schemas import StatisticsSchema


  statistics = StatisticsSchema.model_validate(api.get_usage_statistics())
  ```



  ```python

  statistics_for_today = api.get_usage_statistics_for_day()

  statistics_for_specific_day = api.get_usage_statistics_for_day(date='2022-02-24')

  statistics_for_user = api.get_usage_statistics_for_day(user_id=42)
  ```

  With schema:

  ```python
  from ablt_python_api.schemas import StatisticItemSchema


  statistics = StatisticItemSchema.model_validate(api.get_usage_statistics_for_day())
  ```



  ```python

  statistics_for_today = api.get_total_usage_statistics()

  statistics_for_specific_day = api.get_total_usage_statistics(date='2022-02-24')

  statistics_for_user = api.get_total_usage_statistics(user_id=42)
  ```

  With schema:

  ```python
  from ablt_python_api.schemas import StatisticTotalSchema


  statistics = StatisticTotalSchema.model_validate(api.get_usage_statistics_for_day())
  ```



  You can always [contact support](mailto:contact@aBLT.ai) or contact us in [Discord channel](https://discord.com/channels/1097998898506760392/1104055996302766120).



  In some cases, you may be experienced with SSL errors, then you may disable certificate verification:

  ```python
  import ssl


  sslcontext = ssl.create_default_context()
  sslcontext.check_hostname = False
  sslcontext.verify_mode = ssl.CERT_NONE

  ABLTApi_async(ssl_context=sslcontext)  # for async
  ABLTApl(ssl_verify=False)  # for sync
  ```



  Never try to flood API with requests, because you may be experienced with rate limit errors. In this case, you need to wait for some time and retry your request. Especially, never try to flood API with simultaneous requests for more users than allowed in your plan.



  In some cases, you may be experienced with timeout errors, then you may decrease `max_words` value or use `stream = True` to get response on-the-fly.



  In vary rare cases, you may be experienced with other errors, like rebooting of API itself. To check-up API health, you may use `health_check` method:

  ```python

  api.health_check()
  ```



  Always check-up and follow [Guides](https://docs.ablt.ai/guides/overview), [References](https://docs.ablt.ai/reference/overview) and [Examples](https://docs.ablt.ai/examples) from ABLT documentation.

rpm_license:
  MIT License  Copyright (c) 2023 aBLT  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: f1b6ffb7ca95a696e8e9d66881b085f9bdfb25d602f86acbd62f96b328d532a4
name: python-abm-colony-collection
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Collection of tasks for analyzing colony dynamics.
url: https://pypi.org/project/abm-colony-collection/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abm-colony-collection-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![Build status](https://allen-cell-animated.github.io/abm-colony-collection/_badges/build.svg)](https://github.com/allen-cell-animated/abm-colony-collection/actions?query=workflow%3Abuild)
  [![Lint status](https://allen-cell-animated.github.io/abm-colony-collection/_badges/lint.svg)](https://github.com/allen-cell-animated/abm-colony-collection/actions?query=workflow%3Alint)
  [![Documentation](https://allen-cell-animated.github.io/abm-colony-collection/_badges/documentation.svg)](https://allen-cell-animated.github.io/abm-colony-collection/)
  [![Coverage](https://allen-cell-animated.github.io/abm-colony-collection/_badges/coverage.svg)](https://allen-cell-animated.github.io/abm-colony-collection/_coverage/)
  [![Code style](https://allen-cell-animated.github.io/abm-colony-collection/_badges/style.svg)](https://github.com/psf/black)
  [![Version](https://allen-cell-animated.github.io/abm-colony-collection/_badges/version.svg)](https://pypi.org/project/abm-colony-collection/)
  [![License](https://allen-cell-animated.github.io/abm-colony-collection/_badges/license.svg)](https://github.com/allen-cell-animated/abm-colony-collection/blob/main/LICENSE)

  Collection of tasks for analyzing colony dynamics.
  Designed to be used both in [Prefect](https://docs.prefect.io/latest/) workflows and as modular, useful pieces of code.



  The collection can be installed using:

  ```bash
  pip install abm-colony-collection
  ```

  We recommend using [Poetry](https://python-poetry.org/) to manage and install dependencies.
  To install into your Poetry project, use:

  ```bash
  poetry add abm-colony-collection
  ```





  All tasks in this collection are wrapped in a Prefect `@task` decorator, and can be used directly in a Prefect `@flow`.
  Running tasks within a [Prefect](https://docs.prefect.io/latest/) flow enables you to take advantage of features such as automatically retrying failed tasks, monitoring workflow states, running tasks concurrently, deploying and scheduling flows, and more.

  ```python
  from prefect import flow
  from abm_colony_collection import <task_name>

  @flow
  def run_flow():
      <task_name>()

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

  See [cell-abm-pipeline](https://github.com/allen-cell-animated/cell-abm-pipeline) for examples of using tasks from different collections to build a pipeline for simulating and analyzing agent-based model data.



  Not all use cases require a full workflow.
  Tasks in this collection can be used without the Prefect `@task` decorator by simply importing directly from the module:

  ```python
  from abm_colony_collection.<task_name> import <task_name>

  def main():
      <task_name>()

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

  or using the `.fn()` method:

  ```python
  from abm_colony_collection import <task_name>

  def main():
      <task_name>.fn()

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


pkgId: 8ac8e3531b54c55ff2f1408b5f56b3b97fe1645e60040223b26daf0682853b2f
name: python-abmap
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: AbMAP: Antibody Mutagenesis Augmented Processing
url: https://pypi.org/project/abmap/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abmap-0.1.4-1.src.rpm
checksum_type: sha256
description:
  ![image](https://user-images.githubusercontent.com/6614489/235450484-2ad78557-0deb-43fb-ba8d-6fb570c3a052.png)

  *This repository is a work in progress.*

  This repository contains code and pre-trained model checkpoints for AbMAP, a Protein Language Model (PLM) customized for antibodies as featured in **Learning the Language of Antibody Hypervariability** ([_Singh, Im et al. 2023_](https://www.biorxiv.org/content/10.1101/2023.04.26.538476)). AbMAP leverages information from foundational PLMs as well as antibody structure and function, offering a multi-functional tool useful for predicting structure, functional properties, and analyzing B-cell repertoires.


  AbMAP relies on ANARCI to assign IMGT labels to antibody sequences. Please see the [ANARCI](https://github.com/oxpig/ANARCI/blob/master/INSTALL) repo or run the following in a new conda environment:
  ```bash
  conda install -c biocore hmmer # Can also install using `brew/port/apt/yum install hmmer`
  git clone https://github.com/oxpig/ANARCI.git
  cd ANARCI
  python setup.py install
  ```

  Then install abmap using:
  ```bash
  pip install abmap  # (recommended) latest release from PyPI
  pip install git+https://github.com/rs239/ablm.git  # the live main branch
  ```


  After installation, AbMAP can be easily imported into your python projects or run from the command line. Please see [examples/demo.ipynb](examples/demo.ipynb/) for common use cases. Instructions for running via CLI are below.


  *Instructions In Progress*


  Given a sequence, generate a foundational PLM embedding augmented with in-silico mutagenesis and CDR isolation.

  Given a dataset of labeled pairs of sequences and their augmented embeddings, train the AbMAP model on downstream prediction tasks.

  Given fasta sequences and a pre-trained AbMAP model, generate their AbMAP embeddings (fixed or variable).

  Please provide feedback on the issues page or by opening a pull request. If AbMAP is useful in your work, please consider citing our [bioRxiv preprint](https://www.biorxiv.org/content/10.1101/2023.04.26.538476).


pkgId: 42223d87d0176ecdaa310e28aad61d898ad4f1b476a145babb5583f79223bbf7
name: python-abnf
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Parsers for ABNF grammars.
url: https://github.com/declaresub/abnf
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abnf-2.2.0-1.src.rpm
checksum_type: sha256
description:
  ABNF generates parsers for ABNF grammars. Though intended for use with RFC grammars, ABNF should handle any valid grammar.


pkgId: b25fbf493a721f5dac40e4754bfc4077c28935d40ddd10f78f4038a38c026dd5
name: python-abnosql
arch: src
version: 0.0.26
epoch: 0
release: 1
summary: NoSQL Abstraction Library
url: https://github.com/rog555/abnosql
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abnosql-0.0.26-1.src.rpm
checksum_type: sha256
description:
  p1           p1.1      5  {'foo': 'bar', 'num': 5, 'list': [1, 2, 3]}  [1, 2, 3]  str
  p2           p2.1      5  {'foo': 'bar', 'num': 5, 'list': [1, 2, 3]}  [1, 2, 3]  str
  p2           p2.2      5  {'foo': 'bar', 'num': 5, 'list': [1, 2, 3]}  [1, 2, 3]  str
  ```

  - [x] client side encryption
  - [x] test pagination & exception handling
  - [x] [Google Firestore](https://cloud.google.com/python/docs/reference/firestore/latest) support, ideally in the core library (though could be added outside via use of the plugin system).  Would need something like [FireSQL](https://firebaseopensource.com/projects/jsayol/firesql/) implemented for python, maybe via sqlglot
  - [x] [Google Vault](https://cloud.google.com/python/docs/reference/cloudkms/latest/) KMS support
  - [ ] [Hashicorp Vault](https://github.com/hashicorp/vault-examples/blob/main/examples/_quick-start/python/example.py) KMS support
  - [ ] Simple caching (maybe) using globals (used for AWS Lambda / Azure Functions)
  - [ ] PostgresSQL support using JSONB column (see [here](https://medium.com/geekculture/json-and-postgresql-using-json-to-mimic-nosqls-storage-benefits-1564c69f61fc) for example).  Would be nice to avoid an ORM and having to define a model for each table...
  - [ ] blob storage backend? could use something similar to [NoDB](https://github.com/Miserlou/NoDB) but maybe combined with [smart_open](https://github.com/RaRe-Technologies/smart_open) and DuckDB's [Hive Partitioning](https://duckdb.org/docs/data/partitioning/hive_partitioning.html)
  - [ ] Redis..
  - [ ] Hook implementations to write to ElasticSearch / OpenSearch for better searching.  Useful when not able to use [AWS Stream Processors](https://aws.amazon.com/blogs/compute/indexing-amazon-dynamodb-content-with-amazon-elasticsearch-service-using-aws-lambda/) [Azure Change Feed](https://learn.microsoft.com/en-us/azure/cosmos-db/change-feed), or [Elasticstore](https://github.com/acupofjose/elasticstore). Why? because not all databases support stream processing, and if they do you don't want the hastle of using [CDC](https://berbagimadani.medium.com/sync-postgresql-to-elasticsearch-and-cdc-change-data-capture-b847e8bcf568)


pkgId: eacfc985918f284190d65553336d0362dddbd770cdc628aa79fd14fc5a9833f3
name: python-abo-generator
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: ABO banking format generator
url: UNKNOWN
rpm_license: MPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abo-generator-0.2.2-1.src.rpm
checksum_type: sha256
description:
  ABO banking format generator.
  https://github.com/ViktorStiskala/python-abo-generator
  Currently supports only "CSOB" compatible format.
  Specification sources: http://www.fio.cz/docs/cz/struktura-abo.pdf and http://www.equabank.cz/files/doc/13-format-abo.pdf (available only in czech).
  Thanks to Lukas Hurych for providing generator code.
      from datetime import datetime, timedelta
      from abo import ABO
      tomorrow = datetime.now() + timedelta(days=1)
      abo_export = ABO(client_account_number='123456789/0300', client_name='Super company a.s.', due_date=tomorrow)
      abo_export.add_transaction('123456789/0100', 500.34, variable_symbol='123456', message='Hello world!')
      abo_export.add_transaction('155-987523423/2010', 1234.55, variable_symbol='789654321', message='Test transaction')
      with file('example.pkc', 'w') as f:
          abo_export.save(f)


pkgId: d1432659e73ffddbf750ec0bb4ba6010d0b86f3328d20ed5d1b0426a2e2fe9cb
name: python-abode
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Python Environment and Package Manager
url: https://github.com/mcleonard/abode
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abode-0.1.4-1.src.rpm
checksum_type: sha256
description:
  Most experienced Python users know that Python packaging is rough. Abode is an attempt to make things nicer by extending [Conda](https://docs.conda.io/en/latest/index.html). It uses Conda under the hood, but makes things a bit easier and robust.

  Conda is by far my preferred packaging solution. It works as an environment manager (better than virtualenv in my opinion) as well as a package manager. The default repository is focused on data science software. However, Conda also installs packages from PyPI with pip. Also, unlike pip, Conda installs non-Python libraries such as MKL and CUDA that often increase operation speeds by 10-100x.

  **An aside:** I recommend installing [Miniconda](https://docs.conda.io/en/latest/miniconda.html) instead of the full Anaconda distribution. The vast majority of people won't need every single package in the Anaconda distribution. So save yourself some time, bandwidth, and storage. Install Miniconda, then create environments and install packages as needed.



  The biggest issue with Conda is saving an environment's dependencies and sharing it across platforms. You can get the dependencies using `conda env export > environment.yml`. Say I have an environment where I have installed Flask, Numpy, and PyTorch. Even though those are the only packages I intentionally installed, Conda installs all the dependencies as well. Conda exports the environment to a YAML file that looks like:

  ```
  name: flask
  channels:
    - pytorch
    - defaults
  dependencies:
    - blas=1.0=mkl
    - ca-certificates=2019.5.15=1
    - certifi=2019.6.16=py37_1
    - cffi=1.12.3=py37hb5b8e2f_0
    - intel-openmp=2019.4=233
    - libcxx=4.0.1=hcfea43d_1
    - libcxxabi=4.0.1=hcfea43d_1
    - libedit=3.1.20181209=hb402a30_0
    - libffi=3.2.1=h475c297_4
    - libgfortran=3.0.1=h93005f0_2
    - mkl=2019.4=233
    - mkl-service=2.0.2=py37h1de35cc_0
    - mkl_fft=1.0.14=py37h5e564d8_0
    - mkl_random=1.0.2=py37h27c97d8_0
    - ncurses=6.1=h0a44026_1
    - ninja=1.9.0=py37h04f5b5a_0
    - numpy=1.16.4=py37hacdab7b_0
    - numpy-base=1.16.4=py37h6575580_0
    - openssl=1.1.1c=h1de35cc_1
    - pip=19.1.1=py37_0
    - pycparser=2.19=py37_0
    - python=3.7.4=h359304d_1
    - pytorch=1.2.0=py3.7_0
    - readline=7.0=h1de35cc_5
    - setuptools=41.0.1=py37_0
    - six=1.12.0=py37_0
    - sqlite=3.29.0=ha441bb4_0
    - tk=8.6.8=ha441bb4_0
    - wheel=0.33.4=py37_0
    - xz=5.2.4=h1de35cc_4
    - zlib=1.2.11=h1de35cc_3
    - pip:
      - click==7.0
      - flask==1.1.1
      - itsdangerous==1.1.0
      - jinja2==2.10.1
      - markupsafe==1.1.1
      - werkzeug==0.15.5
  prefix: /Users/mat/miniconda3/envs/flask
  ```

  The issue here is that defining the versions potentially breaks the environment on platforms other than the original one. I created this environment on my MacBook. It is not guaranteed that all these dependencies are available for Linux or Windows, likely breaking the environment on these platforms.

  Also, a lot of the time we're not concerned with the exact versions of our packages. Instead we are okay with the newest versions, or any version greater than some release with a specific feature. In these cases, locking to specific versions is overly strict.

  You can create essentially the same environment with this file:

  ```
  name: flask
  channels:
    - pytorch
    - defaults
  dependencies:
    - numpy
    - pip
    - python=3
    - pytorch
    - pip:
      - flask
  prefix: /Users/mat/miniconda3/envs/flask
  ```

  Conda will take this file and solve all the necessary dependencies on whatever platform you're using. Of course if there are specific versions you want (like `python=3` here) you can define those.

  Abode manages Conda environments by creating and editing minimal environment files like these. Hopefully this will allow users to take advantage of the great things Conda is doing, while making the environments portable.


  - Python 3.6+ because I like f-strings
  - PyYAML
  - Conda, as noted above, I suggest installing Miniconda instead of the full Anaconda distribution



  Abode is available from PyPI:

  ```
  pip install abode
  ```



  **Warning:** This is very early. Use at your own risk.

  So far this is what I have implemented.



  To create a new environment with Python 3 installed:
  ```
  abode create -n env_name python=3
  ```

  Behind the scenes this creates an environment file and uses Conda to create an environment *from the file*.


  To create an environment from an environment file (a YAML file created by Abode or Conda):
  ```
  abode create -f FILE
  ```



  I haven't figure out how to do this without using conda in the shell, so for now:

  ```
  conda activate env_name
  ```
  This is pretty high priority for me. It's awkward to switch between abode and conda commands.



  Installing packages is the same as Conda:

  ```
  abode install numpy matplotlib
  ```

  Behind the scenes, Abode is adding these dependencies to the environment file, then updating the environment *from the file*.




  Use the `--pip` flag to install a package with pip.

  ```
  abode install flask --pip
  ```



  The channel option `-c` adds the channel to the environment file.

  ```
  abode install pytorch -c pytorch
  ```



  This updates all the packages in the environment without locked versions.

  ```
  abode update
  ```



  ```
  abode export > environment.yml
  ```

  This just copies the active environment's dependency file to the new file.



  To print out the list of all installed packages, equivalent to `conda list`:
  ```
  abode list
  ```

  If you want to see which packages have been installed with Abode:
  ```
  abode list -f
  ```
  or

  ```
  abode list --file
  ```



  ```
  abode env list
  ```



  Happy to work with you on this. Create an issue or a pull request. Say hi.


pkgId: e9b3e36b0c1fc6f839fff37e6b1e388f6f079feb72fa80fdcbaae513bd1332a8
name: python-abook
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: Python library to convert between Abook and vCard
url: https://github.com/jspricke/python-abook
rpm_license: GPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abook-0.9.1-1.src.rpm
checksum_type: sha256
description:
  * Reads and writes `Abook <http://abook.sourceforge.net/>`_ files.
  * Saves photo to ~/.abook/photo/NAME.jpeg (if directory is present).


pkgId: 1f39ec3e94c5170d59664fa14d62cc19e8be50ead696db0e919cca850d34851f
name: python-abotaleb1
arch: src
version: 1.0.0
epoch: 0
release: 1
url: https://github.com/abotalebmostafa11/GLDMHO
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abotaleb1-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  A Python library for modeling univariate time series using the Generalized Least Deviation Method (GLDM) First, and Second orders.Generalized Least Deviation Method High Order (GLDMHO) Third, Fourth, and Fifth orders.

description:
  - **Input**:
    - Time series data $S = \{S_t \in \mathbb{R}^n\}_{t \in T}$.
    - Gradient function $\nabla \mathcal{L}$.
    - Historical observations $\{y_t\}_{t=1-m}^T$.
  - **Weights**:


pkgId: d3b60ab5ae96e62facfb358ba7a3eb8447cc95b96e2cac9a60f1b681bab6c7eb
name: python-aboutcode-toolkit
arch: src
version: 11.0.0
epoch: 0
release: 1
url: https://github.com/nexB/aboutcode-toolkit
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aboutcode-toolkit-11.0.0-1.src.rpm
checksum_type: sha256
summary:
  AboutCode-toolkit is a tool to document the provenance (origin and license) of third-party software using small text files. Collect inventories and generate attribution documentation.


pkgId: 0ef9d080cfcd5eb7bdb3ed0c4df1d2444c6e7f3de20c33e33ebebfa97cd4c338
name: python-abpandas
arch: src
version: 0.0.34
epoch: 0
release: 1
summary: Agent Based Pandas tool (ABPandas)
url: https://pypi.org/project/abpandas/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abpandas-0.0.34-1.src.rpm
checksum_type: sha256
description:
  An Agent Based Modelling (ABM) package that can generate grid spatial shape files or work with predefined shape files.
  The package focuses on simplicity by assigning Agents to spatial Polygons instead of assigning x and y locations for each agents.
  This makes it useful in situations where granual movement of agents in space is not necessary (e.g. residentail location models).
  For documentation visit https://github.com/YahyaGamal/ABPandas_Documentation


pkgId: 557d0859d494da97457e7fac77b09126fee061e3e342b945f28d11d1cd4af0a8
name: python-abqcy
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: Write Abaqus Subroutines in Python
url: https://pypi.org/project/abqcy/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abqcy-0.0.5-1.src.rpm
checksum_type: sha256
description:
  Write Abaqus Subroutines in Cython

  - GitHub repository: [https://github.com/haiiliin/abqcy](https://github.com/haiiliin/abqcy)
  - PyPI: [https://pypi.org/project/abqcy](https://pypi.org/project/abqcy)
  - Documentation: [https://abqcy.readthedocs.io](https://abqcy.readthedocs.io)
  - Read the Docs: [https://readthedocs.org/projects/abqcy](https://readthedocs.org/projects/abqcy)
  - Bug Report: [https://github.com/haiiliin/abqcy/issues](https://github.com/haiiliin/abqcy/issues)


pkgId: ce2a63ad1548449fbdc170be72afd50479a0694c1afd7acadf2d5ea64c7e1cac
name: python-abqpy
arch: src
version: 2024.7.8
epoch: 0
release: 1
summary: Type hints for Abaqus/Python scripting
url: https://abqpy.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abqpy-2024.7.8-1.src.rpm
checksum_type: sha256
description:
  [![tests](https://github.com/haiiliin/abqpy/actions/workflows/tests.yml/badge.svg)](https://github.com/haiiliin/abqpy/actions/workflows/tests.yml)
  [![rtd](https://readthedocs.org/projects/abqpy/badge/?version=latest)](https://readthedocs.org/projects/abqpy/)
  [![coveralls](https://coveralls.io/repos/github/haiiliin/abqpy/badge.svg?branch=2024)](https://coveralls.io/github/haiiliin/abqpy?branch=2024)
  [![python](https://img.shields.io/badge/Python-3.7%2B-brightgreen)](https://www.python.org/downloads/)
  [![abaqus](https://img.shields.io/badge/Abaqus-2016%2B-brightgreen)](https://www.3ds.com/products-services/simulia/products/abaqus/)
  [![Crowdin](https://badges.crowdin.net/abqpy-locale/localized.svg)](https://crowdin.com/project/abqpy-locale)

  Read this in other languages: [English](README.md), [简体中文](README-zh-cn.md).

  Type hints for Abaqus/Python scripting

  `abqpy` is a Python package providing type hints for Python scripting of Abaqus, you can
  use it to write your Python script of Abaqus fluently, even without doing anything in Abaqus.
  It also provides some simple APIs to execute the Abaqus commands so that you can run your
  Python script to build the model, submit the job and extract the output data in just one
  Python script, even without opening the Abaqus/CAE.

  - GitHub repository: [https://github.com/haiiliin/abqpy](https://github.com/haiiliin/abqpy)
  - PyPI: [https://pypi.org/project/abqpy](https://pypi.org/project/abqpy)
  - Documentation: [https://haiiliin.github.io/abqpy](https://haiiliin.github.io/abqpy)



  Make sure <a href="https://www.python.org/downloads/"> <img src="https://img.shields.io/badge/Python-3.7%2B-brightgreen" align=center /> </a> and
  <a href="https://www.3ds.com/products-services/simulia/products/abaqus/"> <img src="https://img.shields.io/badge/Abaqus-2016%2B-brightgreen" align=center /> </a>
  are installed on your computer,
  open `cmd` or `terminal`, type:

  ```
  pip install -U abqpy==2024.*  # change the major version to match your Abaqus version
  ```

  Then, open your Abaqus/Python script in your favorite IDE with Python language support,
  run the script with Python 3.7+ (just do it!), see the magic happens.
  For more information, please refer to the [documentation](https://haiiliin.github.io/abqpy).



  Since `abqpy` is reconstructed from the official Abaqus documentation,
  many of the docstrings are not well formatted, for example, the Raises section,
  the math equations, the attributes of the objects, due to the limitation of
  my time, those things are left behind, if anyone is willing to make any
  contributions, please feel free to create your pull requests.

  Please refer [CONTRIBUTING](https://github.com/haiiliin/abqpy/blob/main/.github/CONTRIBUTING.md) for contribution guidelines.



  ![screenshot](https://raw.githubusercontent.com/haiiliin/abqpy/main/docs/source/images/model-code.gif)

  ![screenshot](https://raw.githubusercontent.com/haiiliin/abqpy/main/docs/source/images/output-code.gif)


pkgId: 2f2b6fbd1758a3b9a99d17d06475b5883f24303dc562c89a9b71b280cd1baa1a
name: python-abqpy
arch: src
version: 2025.7.9
epoch: 0
release: 1
summary: Type hints for Abaqus/Python scripting
url: https://abqpy.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abqpy-2025.7.9-1.src.rpm
checksum_type: sha256
description:
  [![tests](https://github.com/haiiliin/abqpy/actions/workflows/tests.yml/badge.svg)](https://github.com/haiiliin/abqpy/actions/workflows/tests.yml)
  [![rtd](https://readthedocs.org/projects/abqpy/badge/?version=latest)](https://readthedocs.org/projects/abqpy/)
  [![coveralls](https://coveralls.io/repos/github/haiiliin/abqpy/badge.svg?branch=2025)](https://coveralls.io/github/haiiliin/abqpy?branch=2025)
  [![python](https://img.shields.io/badge/Python-3.8%2B-brightgreen)](https://www.python.org/downloads/)
  [![abaqus](https://img.shields.io/badge/Abaqus-2016%2B-brightgreen)](https://www.3ds.com/products-services/simulia/products/abaqus/)
  [![Crowdin](https://badges.crowdin.net/abqpy-locale/localized.svg)](https://crowdin.com/project/abqpy-locale)

  Read this in other languages: [English](README.md), [简体中文](README-zh-cn.md).

  Type hints for Abaqus/Python scripting

  `abqpy` is a Python package providing type hints for Python scripting of Abaqus, you can
  use it to write your Python script of Abaqus fluently, even without doing anything in Abaqus.
  It also provides some simple APIs to execute the Abaqus commands so that you can run your
  Python script to build the model, submit the job and extract the output data in just one
  Python script, even without opening the Abaqus/CAE.

  - GitHub repository: [https://github.com/haiiliin/abqpy](https://github.com/haiiliin/abqpy)
  - PyPI: [https://pypi.org/project/abqpy](https://pypi.org/project/abqpy)
  - Documentation: [https://haiiliin.github.io/abqpy](https://haiiliin.github.io/abqpy)



  Make sure <a href="https://www.python.org/downloads/"> <img src="https://img.shields.io/badge/Python-3.8%2B-brightgreen" align=center /> </a> and
  <a href="https://www.3ds.com/products-services/simulia/products/abaqus/"> <img src="https://img.shields.io/badge/Abaqus-2016%2B-brightgreen" align=center /> </a>
  are installed on your computer,
  open `cmd` or `terminal`, type:

  ```
  pip install -U abqpy==2025.*  # change the major version to match your Abaqus version
  ```

  Then, open your Abaqus/Python script in your favorite IDE with Python language support,
  run the script with Python 3.8+ (just do it!), see the magic happens.
  For more information, please refer to the [documentation](https://haiiliin.github.io/abqpy).



  Since `abqpy` is reconstructed from the official Abaqus documentation,
  many of the docstrings are not well formatted, for example, the Raises section,
  the math equations, the attributes of the objects, due to the limitation of
  my time, those things are left behind, if anyone is willing to make any
  contributions, please feel free to create your pull requests.

  Please refer [CONTRIBUTING](https://github.com/haiiliin/abqpy/blob/main/.github/CONTRIBUTING.md) for contribution guidelines.



  ![screenshot](https://raw.githubusercontent.com/haiiliin/abqpy/main/docs/source/images/model-code.gif)

  ![screenshot](https://raw.githubusercontent.com/haiiliin/abqpy/main/docs/source/images/output-code.gif)


pkgId: f7c98c2925a21cb4662d2ee2bc5679c06e6a5c8390cfa3e552b9122c91620591
name: python-abra
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: abra: open-source eye tracking data analysis
url: https://github.com/abra-eyetracking/abra-eyetracking
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abra-1.4.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/abra-eyetracking/abra-eyetracking.svg?branch=master)](https://travis-ci.org/abra-eyetracking/abra-eyetracking)

  Abra is an open-source python eye tracking data analysis tool which provides a simple interface for managing .edf files generated by EyeLink eye trackers.


  Python 3:
  `pip install abra`

  Check out the documentation here: https://abra-eyetracking.github.io/


pkgId: 0fe5649e1b777351d412c60e9ed56efb39df63125dfba86b3424b965272740fb
name: python-abricot
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: ...
url: https://github.com/henry202-TENG/abricot
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abricot-0.0.3-1.src.rpm
checksum_type: sha256
description:
  The abricot is the first word in French vocabulary book, just like abanbon. Mean this is my first project on PyPl.


pkgId: a799d68a27bdacb960f691cbb368046ed2c04964d184b0effda01c012e649204
name: python-abritamr
arch: src
version: 1.0.19
epoch: 0
release: 1
summary: Running AMRFinderPlus for MDU
url: https://github.com/MDU-PHL/abritamr
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abritamr-1.0.19-1.src.rpm
checksum_type: sha256
description:
  <figure><img src="documentation/abriTAMR_logo.jpg"></figure>

  **_logo by Charlie Higgs (PhD candidate)_**

  [![CircleCI](https://circleci.com/gh/MDU-PHL/abritamr.svg?style=svg&circle-token=a54d59b013a30a507621695e738f0a72e47d6969)](https://circleci.com/gh/MDU-PHL/abritamr)

  [![DOI](https://zenodo.org/badge/209921768.svg)](https://zenodo.org/badge/latestdoi/209921768)

  **_Taming the AMR beast_**

  abriTAMR is an AMR gene detection pipeline that runs AMRFinderPlus on a single (or  list ) of given isolates and collates the results into a table, separating genes identified into functionally relevant groups.

  _abriTAMR is accredited by NATA for use in reporting the presence of reportable AMR genes in Victoria Australia._

  * Acquired resistance mechanims in the form of point mutations (restricted to subset of species)
  * Streamlined output.
  * Presence of virulence factors





  abritAMR is best installed with `conda` as described below (~2 minutes on laptop)


  ```
  conda create -n abritamr -c bioconda abritamr
  conda activate abritamr
  ```



  abriTAMR requires [AMRFinder Plus](https://github.com/ncbi/amr), this can be installed separately with `conda` if required.

  abriTAMR comes packaged with a version of the  AMRFinder DB consistent with current NATA accreditation. If you would like to use another DB please download it using `amrfinder -U` and use the `-d` flag to point to your database.

  Current version of AMRFinder Plus compatible with abritAMR 3.10.42 (tested on versions down to 3.10.16)





  ```
  abritamr run --help


  optional arguments:
    -h, --help            show this help message and exit
    --contigs CONTIGS, -c CONTIGS
                          Tab-delimited file with sample ID as column 1 and path to assemblies as column 2 OR path to a contig
                          file (used if only doing a single sample - should provide value for -pfx). (default: )
    --prefix PREFIX, -px PREFIX
                          If running on a single sample, please provide a prefix for output directory (default: abritamr)
    --jobs JOBS, -j JOBS  Number of AMR finder jobs to run in parallel. (default: 16)
    --identity IDENTITY, -i IDENTITY
                          Set the minimum identity of matches with amrfinder (0 - 1.0). Defaults to amrfinder preset, which is 0.9
                          unless a curated threshold is present for the gene. (default: )
    --amrfinder_db AMRFINDER_DB, -d AMRFINDER_DB
                          Path to amrfinder DB to use (default:
                          /<path_to_installation>/abritamr/abritamr/db/amrfinderplus/data/2021-09-30.1)
    --species {Neisseria,Clostridioides_difficile,Acinetobacter_baumannii,Campylobacter,Enterococcus_faecalis,Enterococcus_faecium,Escherichia,Klebsiella,Salmonella,Staphylococcus_aureus,Staphylococcus_pseudintermedius,Streptococcus_agalactiae,Streptococcus_pneumoniae,Streptococcus_pyogenes}, -sp {Neisseria,Clostridioides_difficile,Acinetobacter_baumannii,Campylobacter,Enterococcus_faecalis,Enterococcus_faecium,Escherichia,Klebsiella,Salmonella,Staphylococcus_aureus,Staphylococcus_pseudintermedius,Streptococcus_agalactiae,Streptococcus_pneumoniae,Streptococcus_pyogenes}
                          Set if you would like to use point mutations, please provide a valid species. (default: )
  ```

  You can also run abriTAMR in `report` mode, this will output a spreadsheet which is based on reportable/not-reportable requirements in Victoria. You will need to supply a quality control file (comma separated) (`-q`), with the following columns:

  * ISOLATE
  * SPECIES_EXP (the species that was expected)
  * SPECIES_OBS (the species that was observed during the quality control analysis)
  * TEST_QC (PASS or FAIL)

  `--sop` refers to the type of collation and reporting pipeline
  * general
    * standard reporting structure for aquired genes, output as reportable and non-reportable
  * plus
    * Inferred AST based on validation undertaken at MDU

  ```
  abritamr report --help

  optional arguments:
    -h, --help            show this help message and exit
    --qc QC, -q QC        Name of checked MDU QC file. (default: )
    --runid RUNID, -r RUNID
                          MDU RunID (default: Run ID)
    --matches MATCHES, -m MATCHES
                          Path to matches, concatentated output of abritamr (default: summary_matches.txt)
    --partials PARTIALS, -p PARTIALS
                          Path to partial matches, concatentated output of abritamr (default: summary_partials.txt)
    --sop {general,plus}  The MDU pipeline for reporting results. (default: general)
  ```





  Outputs 4 summary files and retains the raw AMRFinderPlus output for each sequence input.

  1. `amrfinder.out` raw output from AMRFinder plus (per sequence). For more information please see AMRFinderPlus help [here](https://github.com/ncbi/amr/wiki/Interpreting-results)

  2.  `summary_matches.txt`
    * Tab-delimited file, with a row per sequence, and columns representing functional drug classes
    * Only genes recovered from sequence which have >90% coverage of the gene reported and greater than the desired identity threshold (default 90%).

      I. Genes annotated with `*` indicate >90% coverage and > identity threshold < 100% identity.

      II. No further annotation indicates that the gene recovered exhibits 100% coverage and 100% identity to a gene in the gene catalog.

      III. Point mutations detected (if `--species` supplied) will also be present in this file in the form of `gene_AAchange`.

  3. `summary_partials.txt`
    * Tab-delimited file, with a row per sequence, and columns representing functional drug classes
    * Genes recovered from sequence which have >50% but <90% coverage of the gene reported and greater than the desired identity threshold (default 90%).

  4. `summary_virulence.txt`
    * Tab-delimited file, with a row per sequence, and columns representing AMRFinderPlus virulence gene classification
    * Genes recovered from sequence which have >50% coverage of the gene reported and greater than the desired identity threshold (default 90%).

        * Genes recovered with >50% but <90% coverage of a gene in the gene catalog will be annotated with `^`.
        * Genes annotated with `*` indicate >90% coverage and > identity threshold < 100% identity.

  4. `abritamr.txt`
    * Tab-delimited file, combining `summary_matches.txt`, `summary_partials.txt`, `summary_virulence.txt` with a row per sequence, and columns representing AMRFinderPlus virulence gene classification and/or functional drug classes.
    * Genes recovered from sequence which have >50% coverage of the gene reported and greater than the desired identity threshold (default 90%).

        * Genes recovered with >50% but <90% coverage of a gene in the gene catalog will be annotated with `^`.
        * Genes annotated with `*` indicate >90% coverage and > identity threshold < 100% identity.



  will output spreadsheets `general_runid.xlsx` (NATA accredited) or `plus_runid.xlsx` (validated - not yet accredited) depending upon the sop chosen.

  * `general_rundid.xlsx` has two tabs, one for matches and one for partials (corresponding to genes reported in the `summary_matches.txt` and `summary_partials.txt`). Each tab has 7 columns

  | Column | Interpretation |
  |:---: | :---: |
  | MDU sample ID | Sample ID |
  |Item code | suffix (MDU specific) |
  | Resistance genes (alleles) detected | genes detected that are reportable (based on species and drug classification)|
  | Resistance genes (alleles) det (non-rpt) | other genes detected that are not not reportable for the species detected.
  | Species_obs | Species observed (supplied in input file) |
  | Species_exp | Species expected (supplied in input file) |
  | db_version | Version of the AMRFinderPlus DB used |

  * `plus_runid.xlsx` output is a spreadsheet with the different drug resistance mechanims and the corresponding interpretation (based on validation of genotype and phenotype) for drug-classes relevant to reporting of anti-microbial resistance in _Salmonella enterica_ (other species will be added as validation of genotype vs phenotype is performed).

  * Ampicillin
  * Cefotaxime (ESBL)
  * Cefotaxime (AmpC)
  * Tetracycline
  * Gentamicin
  * Kanamycin
  * Streptomycin
  * Sulfathiazole
  * Trimethoprim
  * Trim-Sulpha
  * Chloramphenicol
  * Ciprofloxacin
  * Meropenem
  * Azithromycin
  * Aminoglycosides (RMT)
  * Colistin


pkgId: 780978d0131dd0bf247d664d6964fbcaa1d5c93bc113e15774d6fe300d8f485c
name: python-abroca
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: package for computing and visualizing the Absolute Between-ROC Area (ABROCA)
url: https://github.com/VaibhavKaushik3220/abroca
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abroca-0.1.3-1.src.rpm
checksum_type: sha256
description:
  "abroca" is a python package to provide basic functionality for computing and visualizing the Absolute Between-ROC Area (ABROCA).



  The source code is currently hosted on [github](https://github.com/VaibhavKaushik3220/abroca) and Python package at [PyPi](https://pypi.org/project/abroca/)

  ```sh

  pip install abroca
  ```



  You can find the .ipynb file under example folder. It is a basic example which demonstrates the use of the `abroca` package to compute the ABROCA for a simple logistic regression classifier.

  ```sh

  slice = compute_abroca(df_test, pred_col = 'pred_proba' , label_col = 'returned',
                         protected_attr_col = 'Gender', compare_type = 'binary',
                         n_grid = 10000, plot_slices = True)
  ```
  <img src="https://github.com/VaibhavKaushik3220/abroca/blob/main/example/slice_plot.png" width="100%"/>

  The plot is automatically saved to a file and is displayed on-screen. The link to download the data is given in the comments in the example file. Parameters are self explainatory through the example file. Parameter details below.

  * df - dataframe containing colnames matching pred_col, label_col and protected_attr_col
  * pred_col - name of column containing predicted probabilities (string)
  * label_col - name of column containing true labels (should be 0,1 only) (string)
  * protected_attr_col - name of column containing protected attribute (string)
  * compare_type - comparison group being 'overall', 'multiple' (compare one majority with all classes) or 'binary'
  * majority_protected_attr_val(optional) - name of 'majority' group with respect to protected attribute (string)
  * n_grid (optional) - number of grid points to use in approximation (numeric) (default of 10000 is more than adequate for most cases)
  * plot_slices (optional) - if TRUE, ROC slice plots are generated and saved to file_name (boolean)
  * lb (optional) - Lower limit of integration (use -numpy.inf for -infinity) Default is 0
  * ub (optional) - Upper limit of integration (use -numpy.inf for -infinity) Default is 1
  * limit (optional) - An upper bound on the number of subintervals used in the adaptive algorithm.Default is 1000

  Reference Paper:
  Josh Gardner, Christopher Brooks, and Ryan Baker (2019). Evaluating the
  Fairness of Predictive Student Models Through Slicing Analysis.
  Proceedings of the 9th International Conference on Learning Analytics
  and Knowledge (LAK19); March 4-8, 2019; Tempe, AZ, USA.
  <https://doi.org/10.1145/3303772.3303791>



  If you encounter a clear bug, please file a minimal reproducible example on [github](https://github.com/VaibhavKaushik3220/abroca/issues), or contact the package maintainers directly (see the package documentation).


pkgId: f3051d2418d42c4e2a5e6bd44699564af7640d30d45b95576ff413fd837c58d5
name: python-absbox
arch: src
version: 0.29.13
epoch: 0
release: 1
summary: an analytical library for cashflow modeling on ABS/MBS products
url: https://github.com/yellowbean/PyABS
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-absbox-0.29.13-1.src.rpm
checksum_type: sha256
description:
  a structured finance cashflow engine wrapper for structured credit professionals:

  * transparency -> open source for both wrapper and backend engine, great variable inspection support.
  * human readable waterfall -> no more coding/scripting, just *lists* and *maps* in Python !
  * easy interaction with Python numeric libraries as well as databases/Excel to accomodate daily work.

  [![PyPI version](https://badge.fury.io/py/absbox.svg)](https://badge.fury.io/py/absbox)
  [![PyPI download](https://img.shields.io/pypi/dm/absbox)](https://img.shields.io/pypi/dm/absbox)



      pip install absbox


  * English -> https://absbox-doc.readthedocs.io
  * Chinese(inactive) -> https://absbox.readthedocs.io


  * Structuring
    * Easy way to create different pool assets/deal capital structures and waterfalls
    * User can tell how key variables(service fee/bond WAL/bond cashflow etc) changes in different structure of transactions.
  * Investor
    * Given powerful modelling language to build cashflow model , user can price bonds of transaction with pool performance assumption


  * Provide building blocks to create cashflow models for ABS/MBS
  * Adapt to multiple asset classes
      * Residential Mortgage / AdjustRateMortgage/ IO,PO,Balloon Mortgages / Auto Loans
      * Corp Loans
      * Consumer Credit
      * Lease (For CMBS)
      * Fix Asset (Solar Panel/Hotel)
      * Receivable
      * SRT/Siginificant Risk Transfer
      * Master Trust
  * Features
    * Sensitivity Analysis on different scenarios or deal structures
      * sensitivity analysis on pool performance assumptions
      * sensitivity analysis on capital structures or any deal components
    * Bond Cashflow/Pool Cashflow Forecast, Pricing


  * Python syntax, nice to have knowledge of functional programming ,or exposure to package `toolz`/`lenses`
  * Patience & Persistence, but remember , there is a slack community and responsive support !



  Raise issues or disucssion with the prospectus or spreadsheet how asset cashflow should be projected.




  <img src="https://absbox-doc.readthedocs.io/en/latest/_images/Intergration.png" width="600" height="347"/>



  User can have option to connect to a private calculation engine in his/her own environment

  ![Screenshot_2024-08-19_15-09-10](https://github.com/user-attachments/assets/d4d7d6da-db38-46bd-96ed-524c92c1aa27)




  * [Discussion](https://github.com/yellowbean/AbsBox/discussions)
  * [Slack](https://absboxhastructure.slack.com)

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

  ```bash
  $ pip install -U absdataset
  ```

  ```python
  import absdataset
  absdataset.help()
  ```

  ```
  MIT License
  Copyright (c) 2022 AbsoluteWinter
  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: ca0da5acb9e0080c9cd3a9b2645fe9551658e7bf85a2e0003303c9529dd4f095
name: python-absense
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: Perform homolog detectability
url: https://pypi.org/project/absense/
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-absense-0.1.6-1.src.rpm
checksum_type: sha256
description:
  [![Try Now!][pyodide-badge]][pyodide-link]
  [![Actions Status][actions-badge]][actions-link]
  [![Documentation Status][rtd-badge]][rtd-link]

  [![PyPI version][pypi-version]][pypi-link]
  [![PyPI platforms][pypi-platforms]][pypi-link]

  [pyodide-badge]:            https://img.shields.io/badge/Pyodide-Try%20It!-blue.svg
  [pyodide-link]:             https://potential-waffle-8b9309b7.pages.github.io/
  [actions-badge]:            https://github.com/PrincetonUniversity/abSENSE/workflows/CI/badge.svg
  [actions-link]:             https://github.com/PrincetonUniversity/abSENSE/actions
  [pypi-link]:                https://pypi.org/project/abSENSE/
  [pypi-platforms]:           https://img.shields.io/pypi/pyversions/abSENSE
  [pypi-version]:             https://badge.fury.io/py/abSENSE.svg
  [rtd-badge]:                https://readthedocs.org/projects/abSENSE/badge/?version=latest
  [rtd-link]:                 https://abSENSE.readthedocs.io/en/latest/?badge=latest


  abSENSE is a method that calculates the probability that a homolog of a given
  gene would fail to be detected by a homology search (using BLAST or a similar
  method) in a given species, even if the homolog were present and evolving
  normally.

  The result of this calculation informs how one interprets the result of a
  homology search failing to find homologs of a gene in some species. One
  possibility to explain such a result is that the gene is _actually absent_ from
  the genome in that species: a biological, and potentially interesting (e.g. if
  due to a gene loss or the birth of a new gene), result.

  A second explanation, often ignored, is that the homolog _is_ present in the
  genome of that species, but that the homology search merely lacks statistical
  power to detect it. Here, the apparent absense of the homolog is a
  technical/statistical limitation, and does not reflect underlying biology.

  By calculating the probability that your homology search would fail to detect a
  homolog _even if one were present_ and _even if it were evolving normally_
  (e.g. no rate accelerations on a specific branch, potentially suggestive of
  biologically interesting changes), abSENSE informs the interpretation of a
  negative homology search result. If abSENSE finds that there is a high
  probability of a homolog being undetected even if present, you may not be as
  inclined to invoke a biological explanation for the result: the null model of a
  failure of the homology search is sufficient to explain what you observe.

  **The method is explained in complete detail in the paper in which it's
  introduced. This is the paper that is referred to in the rest of this README:**

  **Weisman CM, Murray AW, Eddy SR (2020) Many, but not all, lineage-specific
  genes can be explained by homology detection failure. PLoS Biol 18(11):
  e3000862. https://doi.org/10.1371/journal.pbio.3000862**

  There, it is applied to the specific case of lineage-specific genes, for which
  homologs appear absent in all species outside of a narrow lineage. The method
  itself is applicable to any case in which a homolog appears absent (e.g. a
  single species missing a homolog that one might interpret as a gene loss), and
  likewise, this code is applicable to all such cases.

  This is a rewrite of the [original repository](https://github.com/caraweisman/abSENSE/tree/c355c458e83722a0ffdf7284d4ea1f6f29ce205f)






  The main analysis script, `Run_abSENSE.py`, calculates the probabilities of
  homologs of genes from some "focal" species being undetected in a set of N
  other species. It can perform this analysis for an arbitrary number of genes in
  the taxon at one time. It requires a minimum of two input files:

  i) A file containing the bitscores of homologs of each gene to be analyzed in
  at least three of the species (including the focal species itself, so two
  others).

  ii) A file containing the N evolutionary distances, in substitutions/site,
  between the focal species and each other species. The distance between the
  focal species and itself should be 0. (If you don't already have such
  distances, a description of how to calculate them relatively painlessly can be
  found in Weisman et al 2020).

  Examples of both of these files for a subset of genes from S. cerevisiae and
  their orthologs 11 other fungal species (the same species analyzed in Weisman
  et al 2020) can be found in the folder Quickstart\_Examples: the bitscore file
  is Fungi\_Example\_Bitscores, and the distance file is Fungi\_Distances. They
  exemplify the formatting required for abSENSE to run (explained in more detail
  below).

  To run abSENSE on a given bitscore and distance file:

  ```
  python Run_abSENSE.py \
      --distfile <distance_file> \
      --scorefile <score_file>
  ```

  For example, to run abSENSE on the example fungal genes, type:

  ```
  python Run_abSENSE.py \
      --distfile Quickstart_Examples/Fungi_Distances \
      --scorefile Quickstart_Examples/Fungi_Example_Bitscores
  ```

  For each gene in the input bitscore file, the following will be computed:

  a) The probabilities of a homolog being undetected in each species (in the file
  `Detection_Failure_Probabilities`);

  b) The expected bitscores of homologs in each species (in the file
  `Predicted_bitscores`);

  c) The 99% confidence interval around this bitscore in each species (low and
  high bounds listed in separate files: `Bitscore_99PI_lowerbound_predictions`
  and `Bitscore_99PI_higherbound_predictions`)

  These results will be output to a set of tab-delimited files in a separate
  directory, by default named with the start time of the analysis. (You can
  specify the name with a command line option, see below). Additional information
  on output files is below.




  A supplemental visualization script, `Plot_abSENSE.py`, performs the same
  analysis as above, but for one gene at a time, and also produces a
  visualization of the results (see Weisman et al 2020).  It is run in the same
  way, except that it also requires specifying which single gene in the bitscore
  input file you wish to analyze.

  To run abSENSE on gene GENEID contained in a given bitscore with a given
  distance file:

  ```
  python Plot_abSENSE.py \
      --distfile <distance_file> \
      --scorefile <score_file> \
      --gene <GENEID>
  ```

  For example, to analyze the S. cerevisiae gene Uli1, listed in the bitscore
  file under its RefSeq ID (NP\_116682.3), type:

  ```
  python Plot_abSENSE.py \
      --distfile Quickstart_Examples/Fungi_Distances \
      --scorefile Quickstart_Examples/Fungi_Example_Bitscores \
      --gene NP_116682.3
  ```

  The same results as above will be computed, but now they will be output to the
  terminal, and then the visualization will be shown.




  You can specify advanced options with the additional command line options. You
  can view them all with `python Run_abSENSE.py --help`

  They are:

  `--out`: The prefix of the directory to which your results will be output.
  Default is the time at which you ran the analysis (to avoid overwriting of
  results).

  `--Eval`: The E-value threshold to be used (above this value, homologs will
  be considered undetected). Default is 0.001 (fairly permissive).

  `--genelenfile`: Allows you to specify a file containing the lengths (in aa)
  of all genes in the bitscore file to be analyzed. Default is 400 amino acids
  (~average protein size in many species) for all proteins.

  abSENSE predicts a bitscore, which is then converted to an E-value to determine
  detectability; this conversation technically requires knowledge of both the
  size of the database in which the search occurs (see below) and the length of
  the gene being searched. Because the conversion between these values and
  E-value is logarithmic, though, only fairly large changes in these values
  substantially affect results.

  Examples of such files containing the lengths of all S. cerevisiae and D.
  melanogaster genes can be found in Fungi\_Data/S\_cer\_Protein\_Lengths and
  Insect\_Data/D\_mel\_Protein\_Lengths. The format required is described more
  below.

  `--dblenfile`: Allows you to specify a file containing the sizes (in aa) of
  the database in which the homology search for each of your N species is
  performed. Default is 400 amino acids * 20,000 amino acids / gene = 8,000,000
  amino acids (~average protein and proteome size in many species) for all
  species.

  abSENSE predicts a bitscore, which is then converted to an E-value to determine
  detectability; this conversation technically requires knowledge of both the
  size of the database in which the search occurs and the length of the gene
  being searched (see above). Because the conversion between these values and
  E-value is logarithmic, though, only fairly large changes in these values
  substantially affect results.

  Examples containing the lengths of all S. cerevisiae and D. melanogaster genes
  can be found in Fungi\_Data/Fungi_Database_Lengths and
  Insect\_Data/Insect\_Database\_Lengths. The format required is described more
  below.

  `--predall`: Default is False. When True, Causes abSENSE to calculate the
  probability of homologs being undetected, the expected bitscores, and 99\%
  confidence intervals not only in species in which homologs were actually
  undetected, but also for species in which homologs have been found. This is
  obviously not the main use case, and is especially uninformative when those
  homologs and their bitscores have been used in the prediction itself (see
  below). May potentially be useful to see if a homolog in one species, although
  detected, seems to be behaving anomalously compared to those in other species
  (eg due to rate acceleration).

  `--includeonly`: Allows you to restrict the species whose bitscores are used
  in predicting bitscores in other species. Mainly useful to do control-type
  analyses, such as Figure 5 in Weisman et al 2020, to show that predictions made
  from only a subset of the data are nonetheless reliable. If not specified,
  abSENSE uses all available bitscores in the prediction. The format here should
  be a list of the species names as they are written in the distance and bitscore
  files, separated by commas and NO SPACES. For example, to include only data
  from the yeasts S. cerevisiae, S. paradoxus, and S. kudriavzevii in an analysis
  based on the files in `Fungal_Data,` you would type: `--includeonly
  S_cer,S_par,S_kud`


  For example, to run an analysis on all S. cerevisiae proteins in the selected
  fungal species in which the lengths of each S. cerevisiae protein and the sizes
  of each species' search database (their annotated proteomes as indicated in the
  supplement of Weisman et al 2020) are specified:

  ```
  python Run_abSENSE.py \
      --distfile Fungi_Data/Fungi_Distances \
      --scorefile Fungi_Data/Fungi_Bitscores \
      --genelenfile Fungi_Data/S_cer_Protein_Lengths \
      --dblenfile Fungi_Data/Fungi_Database_Lengths
  ```


  The visualization script `Plot_abSENSE.py` takes all of the same options,
  with the exception of again requiring that the gene to be analyzed is specified
  by the --gene option, and also that the --genelenfile option is instead
  --genelen, after which should be entered an integer corresponding to the length
  of the gene. (With a single gene, it's hardly worth requiring a whole file:
  just give the number.)




  `Run_abSENSE.py` outputs six output files. Examples resulting from running
  abSENSE on the provided insect and fungal data can be found in
  `Fungi_Data/Fungi_abSENSE_Results/` and `Insect_Data/Insect_abSENSE_Results/`
  respectively.



  The central output of the program. For each gene in the analysis, this contains
  the predicted probability that a homolog in each species would be undetected at
  the specified E-value by a homology search, even if the homolog were present.

  By default, this is only calculated in species in which the gene was not
  detected. Results for species in which homologs were detected are therefore
  listed as "detected". The setting --predall will calculate this value for all
  species, even those in which a homolog was in fact detected.

  If not enough data for a gene was provided to generate a bitscore prediction
  (bitscores of homologs from at least three species are needed), the results
  will read "not\_enough\_data".



  For each gene in the analysis, this contains the predicted (maximum likelihood)
  bitscore of a homolog in each species.

  By default, bitscores are only predicted in species in which the gene was not
  detected. Results for species in which homologs were detected are therefore
  listed as "detected". The setting --predall will calculates this value for all
  species, even those for which a homolog was in fact detected. Here, the known
  bitscore (often used in the prediction process; see the option --includeonly)
  will be shown alongside the prediction. If the known bitscore was used in the
  fitting process, of course, these will usually be quite similar!

  If not enough data for a gene was provided to generate a bitscore prediction
  (bitscores of homologs from at least three species are needed), the results
  will read "not\_enough\_data".



  For each gene in the analysis, this contains the upper bound of the 99\%
  confidence interval for the bitscore of a homolog in each species.

  By default, this is only calculated in species in which the gene was not
  detected. Results for species in which homologs were detected are therefore
  listed as "detected". The setting --predall will calculates this value for all
  species, even those for which a homolog was in fact detected. Here, the known
  bitscore (often used in the prediction process; see the option --includeonly)
  will be shown alongside the prediction. If the known bitscore was used in the
  fitting process, of course, these will usually be quite similar!

  If not enough data for a gene was provided to generate a bitscore prediction
  (bitscores of homologs from at least three species are needed), the results
  will read "not\_enough\_data".



  For each gene in the analysis, this contains the lower bound of the 99\%
  confidence interval for the bitscore of a homolog in each species.

  By default, this is only calculated in species in which the gene was not
  detected. Results for species in which homologs were detected are therefore
  listed as "detected". The setting --predall will calculates this value for all
  species, even those for which a homolog was in fact detected. Here, the known
  bitscore (often used in the prediction process; see the option --includeonly)
  will be shown alongside the prediction. If the known bitscore was used in the
  fitting process, of course, these will usually be quite similar!

  If not enough data for a gene was provided to generate a bitscore prediction
  (bitscores of homologs from at least three species are needed), the results
  will read "not\_enough\_data".



  For each gene in the analysis, this contains the best-fit (maximum likelihood)
  values of the a and b parameters. (See Weisman et al 2020 for full
  explanation.)

  These a and b parameters are calculated from bitscores of homologs in species
  included in the prediction process. If the command line option --includeonly is
  used, this will be only the species specified by that option. By default, all
  provided bitscores are used.

  If not enough data for a gene was provided to generate a bitscore prediction
  (bitscores of homologs from at least three species are needed), the results
  will read "not\_enough\_data".



  Contains information about the analysis, including names of input files,
  options/settings used, and the analysis time.



  Required files:



  For an analysis of M genes in N species (including the focal species), the
  bitscore file should be a tab-delimited file of N+1 columns by M+1 rows.  The
  first row should begin with a blank entry, and should be followed by N entries
  containing the names of the N species in your analysis. These names should
  match those in the distance file (below) exactly.  The remaining M rows should
  each begin with the name/identifier of the gene from the focal species to be
  analyzed, followed by the bitscore of that gene against its homolog in the
  species indicated at the top of the given column. For species in which homologs
  are undetected, this value should be __0__. For species in which a homolog is
  detected, but the orthology is unclear and so you wish to exclude it from being
  used in the fit (see Weisman et al 2020), this value should be __'N/A'__.  Two
  examples are provided: Fungi\_Data/Fungi_\Bitscores and
  Insect_\Data/Insect\_Bitscores.



  For an analysis with N species (including the focal species), the distance file
  should be a tab-delimited file of 2 columns by N rows.  Entries in the first
  column should contain the name of each species in your analysis. These names
  should match those in the bitscore file (above) exactly.  Entries in the second
  column should contain the evolutionary distance between each species in the
  indicated column and the focal species. (The distance between the focal species
  and itself should always be 0.) Two examples are provided:
  Fungi\_Data/Fungi\_Distances and Insect\_Data/Insect\_Distances.





  For an analysis of M genes, the gene length file should be a tab-delimited file
  of 2 columns by M rows.  The first column should contain the names/identifiers
  of the gene from the focal species to be analyzed. These should match exactly
  the names in the bitscore file (above).  The second column should contain the
  length in amino acids of that gene.

  If you don't already have such a file, here is a command to make one (named
  OUTPUTFILENAME), from a FASTA file (SEQFILENAME) containing all of the
  sequences: (It requires the easel package, which comes with the HMMER software,
  available at http://hmmer.org/documentation.html.)

  ```
  esl-seqstat -a (SEQFILENAME) | \
      awk '{print $2 "\t" $3}' | \
      tac | \
      sed -e '1,7d' | \
      tac > (OUTFILENAME)
  ```




  For an analysis of N species, the database length file should be a
  tab-delimited file of 2 columns by N rows.  The first column should contain the
  names of the N species. These should match exactly the names in the bitscore
  and distance files (above).  The second column should contain the sizes, in
  amino acids, of the database in which the homology search for each species is
  performed. For example, if you are searching for a gene in each of the species'
  annotated proteomes, it should be the size of that species' proteome in amino
  acids. If instead you are searching against a pan-specific database, like for
  example NR, for all species, it should be the size of that database in amino
  acids.

  If you don't already have such a file, you can make one easily if you have the
  databases themselves in eg FASTA format (again requiring the easel package,
  downloadable with HMMER as in c) above: just run the command `esl-seqstat
  (FASTA FILE)` on each database; this will report the total length in aa of
  each database file. You can then put these into a tab-delimited file manually.

  If your BLAST search is done on a nucleotide genome of the outgroup species via
  TBLASTN, the database length that you should use for each genome is 2N, where N
  is the genome length in nucleotides. (For a genome of N nucleotides, there are
  ~N/3 codons in it, which can be read in each of 6 possible reading frames, for
  a total of 6N/3 = 2N amino acids.)


pkgId: e5da17716051a2c9928d63e0195059f768222dc131e50eb924f9ad2767dc7caa
name: python-abserdes
arch: src
version: 2.8
epoch: 0
release: 1
url: https://github.com/astokely/abserdes
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abserdes-2.8-1.src.rpm
checksum_type: sha256
summary:
  A Basic Serializer and Deserializer that makes XMLserialization and deserialization in Python absurdly easy.


pkgId: d8189d7f3b3773b8f1d9d54cbb2eeae961f81b53d2aa566340b11ffb6e7d3644
name: python-abses
arch: src
version: 0.6.10
epoch: 0
release: 1
url: https://pypi.org/project/abses/
rpm_license: Apache 2.0 License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abses-0.6.10-1.src.rpm
checksum_type: sha256
summary:
  ABSESpy makes it easier to build artificial Social-ecological systems with real GeoSpatial datasets and fully incorporate human behaviour.

description:
  Language: [English Readme] | [简体中文]
  **[<kbd> <br> Install <br> </kbd>][Install]**
  **[<kbd> <br> Getting started <br> </kbd>][Getting Started]**
  **[<kbd> <br> Tutorials <br> </kbd>][Tutorials]**
  **[<kbd> <br> Contribute <br> </kbd>][Contribute]**
  </div>
  `ABSESpy` is a novel agent-based modeling (ABM) framework that facilitates socio-ecological systems (SES) research. It serves as an extension package of [Mesa], the most popular ABM framework, and further enhances agents' interactions with other components, especially grid-like spaces. With a configuration file for managing parameters and an improved data Input/Output system, `ABSESpy`'s modularity and low-coupling design enable elegant maintenance of large modeling projects. In addition, `ABSESpy` includes a schedule that aligns models' tick with the calendar time. These innovations position `ABSESpy` as a valuable tool in fostering more ABMs for real-world SES issues. Its ultimate aim is to become the go-to choice for ABM when working with a human-involved changing world.

  <img src="https://songshgeo-picgo-1302043007.cos.ap-beijing.myqcloud.com/uPic/ABSESpy%20API.jpg" alt="ABSESpy API structure" style="max-width:400px;max-height:400px;width:auto;height:auto;">
  - 🌍 Modeling social-ecological system with geo-data.
  - 🤖 Managing and manipulating agents with ease of cake.
  - 🕙 Make your model coherent with real-world time.
  - 📁 Handling complex models with a configuration file.
  - 🙋 and more...
    [Mesa]: https://github.com/projectmesa/mesa
    [Contribute]: https://absespy.github.io/ABSESpy/home/contribution/
    [Getting Started]: https://absespy.github.io/ABSESpy/home/get_started/
    [Install]: https://absespy.github.io/ABSESpy/home/Installation/
    [Tutorials]: https://absespy.github.io/ABSESpy/tutorial/tutorial/
    [简体中文]: README.zh-cn.md
    [English Readme]: README.md

  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tbody>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="http://cv.songshgeo.com"><img src="https://avatars.githubusercontent.com/u/45836839?v=4?s=100" width="100px;" alt="Shuang Song"/><br /><sub><b>Shuang Song</b></sub></a><br /><a href="https://github.com/ABSESpy/ABSESpy/commits?author=SongshGeo" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/ekmanib"><img src="https://avatars.githubusercontent.com/u/94269701?v=4?s=100" width="100px;" alt="Elías José Mantilla Ibarra"/><br /><sub><b>Elías José Mantilla Ibarra</b></sub></a><br /><a href="https://github.com/ABSESpy/ABSESpy/commits?author=ekmanib" title="Documentation">📖</a></td>
      </tr>
    </tbody>
  </table>
  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->
  <!-- ALL-CONTRIBUTORS-LIST:END -->
  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):
  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->
  <!-- ALL-CONTRIBUTORS-LIST:END -->
  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!


pkgId: 36ce9011420aaa2bb8fed35dda897473a3526f85e1d762217b48b0c1322efa83
name: python-absfuyu
arch: src
version: 3.4.0
epoch: 0
release: 1
summary: A small collection of code
url: https://github.com/AbsoluteWinter/absfuyu-public
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-absfuyu-3.4.0-1.src.rpm
checksum_type: sha256
description:
  *TL;DR: A collection of code*

  ```bash
  $ pip install -U absfuyu
  ```

  ```python
  import absfuyu
  help(absfuyu)
  ```

  > [here](https://absolutewinter.github.io/absfuyu/)

  1. Create virtual environment
  ```bash
  python -m venv env
  ```
  Note: Might need to run this in powershell (windows)
  ```powershell
  Set-ExecutionPolicy -ExecutionPolicy Unrestricted -Scope CurrentUser
  ```
  2. Install required packages
  ```bash
  python -m pip install -e .[full,dev]
  ```
  3. Getting info of dev environment
  ```bash
  hatch env show
  ```

  MIT License


pkgId: a171bbe0f58584b30890a9c5cba6c097ab63d1fa7838bd1d37d2fc204cfc38df
name: python-absl-extra
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: A wrapper to run and monitor absl app.
url: https://github.com/aaarrti/absl_extra
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-absl-extra-0.1.3-1.src.rpm
checksum_type: sha256
description:
  A collection of utils I commonly use for running my experiments.
  It will:
  - Notify on execution start, finish or failed.
    - By default, Notifier will just log those out to `stdout`.
    - I prefer receiving those in Slack, though (see example below).
  - Log parsed CLI flags from `absl.flags.FLAGS` and config values from `config_file:get_config()`
  - Select registered task to run based on --task= CLI argument.

  Minimal example

  ```python
  import os
  from absl import logging
  import tensorflow as tf

  from absl_extra import tf_utils, tasks, notifier


  @tasks.register_task(
      notifier=notifier.SlackNotifier(slack_token=os.environ["SLACK_BOT_TOKEN"], channel_id=os.environ["CHANNEL_ID"])
  )
  @tf_utils.requires_gpu
  def main() -> None:
      if tf_utils.supports_mixed_precision():
          tf.keras.mixed_precision.set_global_policy("mixed_float16")

      with tf_utils.make_gpu_strategy().scope():
          logging.info("Doing some heavy lifting...")


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


  - Common utilities used for training flax models, which I got tired of copy-pasting in every project.


pkgId: 35b3ea581f3c39e8b6ce13f1b77ddc36936cf9a50bf1b1acf5ccb117db4d0614
name: python-absolufy-imports
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: A tool to automatically replace relative imports with absolute ones.
url: https://github.com/MarcoGorelli/absolufy-imports
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-absolufy-imports-0.3.1-1.src.rpm
checksum_type: sha256
description:
  A tool and pre-commit hook to automatically convert relative imports to absolute.
  <p align="center">
      <a href="#readme">
          <img alt="demo" src="https://raw.githubusercontent.com/nbQA-dev/nbQA-demo/master/abs-imports.gif">
      </a>
  </p>

  ```console
  $ pip install absolufy-imports
  ```

  See [pre-commit](https://github.com/pre-commit/pre-commit) for instructions
  Sample `.pre-commit-config.yaml`:
  ```yaml
  -   repo: https://github.com/MarcoGorelli/absolufy-imports
      rev: v0.3.0
      hooks:
      -   id: absolufy-imports
  ```

  ```console
  $ absolufy-imports mypackage/myfile.py
  ```
  ```diff
  - from . import __version__
  + from mypackage import __version__
  ```


  If your package follows the popular `./src` layout, you can pass your application directories via `--application-directories`, e.g.
  ```console
  $ absolufy-imports src/mypackage/myfile.py --application-directories src
  ```
  ```diff
  - from . import __version__
  + from mypackage import __version__
  ```
  Multiple application directories should be colon-separated, e.g. `--application-directories .:src`. This is the same as in [reorder-python-imports](https://github.com/asottile/reorder_python_imports).

  Use the `--never` flag, e.g.
  ```console
  $ absolufy-imports mypackage/myfile.py --never
  ```
  ```diff
  - from mypackage import __version__
  + from . import __version__
  ```


pkgId: 33644c80bed89795ec82ab864d302979716929f5066345845da1e2055c4a8a9b
name: python-absorptionlib
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: A package for substance properties for absorption systems
url: https://pypi.org/project/absorptionlib/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-absorptionlib-1.0.1-1.src.rpm
checksum_type: sha256
description:
  This file contains property data for aqueous sodium hydroxide solutions.



  ```
  pip install propertiesNaOH
  ```

  ```python

  import propertiesNaOH as NaOH


  p = 100000 # [Pa]
  x = 0.4    # [%]  = [kgNaOH / kgSolution]
  t_sat = NaOH.saturation_temperature(p, x)
  print(t_sat)
  ```



  | Function                         | Parameter 1           | Parameter 2           | Parameter 3    | Return Unit   |
  |----------------------------------|-----------------------|-----------------------|----------------|---------------|
  | saturation_temperature(P, x1)    | P (Pa)                | x (kgNaOH/kgSolution) | -              | °C            |
  | saturation_pressure(x, T)        | x (kgNaOH/kgSolution) | T (°C)                | -              | Pa            |
  | saturation_concentration(x, T)   | P (Pa)                | T (°C)                | -              | kg/kg         |
  | enthalpy(x, T)                   | x (kgNaOH/kgSolution) | T (°C)                | -              | kJ/kg         |
  | specific_heat_capacity(x, T)     | x (kgNaOH/kgSolution) | T (°C)                | -              | kJ/kg·K       |
  | density(x, T)                    | x (kgNaOH/kgSolution) | T (°C)                | -              | kg/m³         |
  | dynamic_viscosity(x, T)          | x (kgNaOH/kgSolution) | T (°C)                | -              | Pa·s          |
  | thermal_conductivity(x, T, p)    | x (kgNaOH/kgSolution) | T (°C)                | p (Pa)         | W/m·K         |





  | Function                 | Description                  | Boolean Options + Defaults                              |
  |--------------------------|------------------------------|---------------------------------------------------------|
  | pTDiagram()              | shows pT-Diagram             | log=True, invT=True                                     |
  |                          |                              | editablePlot=False, show_percentages=True               |
  | crystallization_curve()  | shows crystallization curve  | return_data=False (if True, only data returned, no plot)|


pkgId: bb1d8398319456d53f63a1936dd2bab8c6fd5fb6b8b3bc5a6a61474213451eda
name: python-abspy
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: A Python tool for 3D adaptive binary space partitioning and beyond
url: https://github.com/chenzhaiyu/abspy
rpm_license: 'MIT'
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abspy-0.2.5-1.src.rpm
checksum_type: sha256
description:
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![PyPI version](https://img.shields.io/pypi/v/abspy)](https://pypi.python.org/pypi/abspy/) [![Build status](https://readthedocs.org/projects/abspy/badge/)](https://abspy.readthedocs.io/en/latest/)

  ***abspy*** is a Python tool for 3D *adaptive binary space partitioning* and beyond: an ambient 3D space is adaptively partitioned to form a linear cell complex with planar primitives, where an adjacency graph is dynamically obtained. The tool is designed primarily to support compact surface reconstruction and other applications as well.
  <div align="center" width="480">
    <img src="https://raw.githubusercontent.com/chenzhaiyu/abspy/main/docs/source/_static/images/animation.gif"><br>
  </div>

  * Manipulation of planar primitives from point cloud or reference mesh
  * Linear cell complex creation with adaptive binary space partitioning (a-BSP)
  * Dynamic BSP-tree ([NetworkX](https://networkx.org/) graph) updated locally upon primitive insertion
  * Support of polygonal surface reconstruction with graph cut
  * Compatible data structure with [Easy3D](https://github.com/LiangliangNan/Easy3D) on point cloud, primitive, mesh and cell complex
  * Robust spatial operations underpinned by the rational ring from [SageMath](https://www.sagemath.org/)'s exact kernel


  Create a conda environment with the latest *abspy* release and all its dependencies installed:
  ```bash
  git clone https://github.com/chenzhaiyu/abspy && cd abspy
  conda env create -f environment.yml && conda activate abspy
  ```

  Still easy! Create a conda environment and enter it:
  ```bash
  conda create --name abspy python=3.10 && conda activate abspy
  ```
  Install the dependencies:
  ```bash
  conda install -c conda-forge networkx numpy tqdm scikit-learn matplotlib colorlog scipy trimesh rtree pyglet sage=10.0
  ```
  Alternatively, you can use [mamba](https://github.com/mamba-org/mamba) for faster package parsing installation:
  ```bash
  conda install mamba -c conda-forge
  mamba install -c conda-forge networkx numpy tqdm scikit-learn matplotlib colorlog scipy trimesh rtree pyglet sage=10.0
  ```
  Preferably, the latest *abspy* release can be found and installed via [PyPI](https://pypi.org/project/abspy/):
  ```bash
  pip install abspy
  ```
  Otherwise, you can install the latest version locally:
  ```bash
  git clone https://github.com/chenzhaiyu/abspy && cd abspy
  pip install .
  ```


  The example loads a point cloud to `VertexGroup` (`.vg`), partitions ambient space into a cell complex, creates the adjacency graph, and extracts the object's outer surface.
  ```python
  from abspy import VertexGroup, AdjacencyGraph, CellComplex

  vertex_group = VertexGroup(filepath='points.vg')

  vertex_group.normalise_to_centroid_and_scale()

  additional_planes = [[0, 0, 1, -vertex_group.aabbs[:, 0, 2].min()]]

  cell_complex = CellComplex(vertex_group.planes, vertex_group.aabbs, vertex_group.obbs, vertex_group.points_grouped, build_graph=True, additional_planes=additional_planes)

  cell_complex.refine_planes()

  cell_complex.prioritise_planes(prioritise_verticals=True)

  cell_complex.construct()

  cell_complex.print_info()

  adjacency_graph = AdjacencyGraph(cell_complex.graph)

  adjacency_graph.assign_weights_to_n_links(cell_complex.cells, attribute='area_overlap', factor=0.001, cache_interfaces=True)
  adjacency_graph.assign_weights_to_st_links(...)

  _, _ = adjacency_graph.cut()

  adjacency_graph.save_surface_obj('surface.obj', engine='rendering')
  ```

  The example loads a mesh to `VertexGroupReference`, partitions ambient space into a cell complex, identifies cells inside reference mesh, and visualizes the cells.
  ```python
  from abspy import VertexGroupReference
  vertex_group_reference = VertexGroupReference(filepath='mesh.obj')

  cell_complex = CellComplex(vertex_group_reference.planes, vertex_group_reference.aabbs, vertex_group_reference.obbs, build_graph=True)

  cell_complex.construct()

  cells_in_mesh = cell_complex.cells_in_mesh('mesh.obj', engine='distance')

  cell_complex.save('complex.cc')

  if len(cells_in_mesh):
      cell_complex.visualise(indices_cells=cells_in_mesh)
  ```
  Please find the usage of *abspy* at [API reference](https://abspy.readthedocs.io/en/latest/api.html). For the data structure of a `.vg`/`.bvg` file, please refer to [VertexGroup](https://abspy.readthedocs.io/en/latest/vertexgroup.html).

  * **How can I install *abspy* on Windows?**
  For Windows users, you may need to build [SageMath from source](https://doc.sagemath.org/html/en/installation/source.html) or install all other dependencies into a [pre-built SageMath environment](https://doc.sagemath.org/html/en/installation/binary.html). Otherwise, virtualization with [docker](https://www.docker.com/) may come to the rescue.
  * **How can I use *abspy* for surface reconstruction?**
  As demonstrated in `Example 1`, the surface can be addressed by graph cut &mdash; in between adjacent cells where one being *inside* and the other being *outside* &mdash; exactly where the cut is performed. For more information, please refer to ***[Points2Poly](https://github.com/chenzhaiyu/points2poly)*** which wraps ***abspy*** for building surface reconstruction.
  ![adaptive](https://raw.githubusercontent.com/chenzhaiyu/abspy/main/docs/source/_static/images/surface.png)

  [MIT](https://raw.githubusercontent.com/chenzhaiyu/abspy/main/LICENSE)

  If you use *abspy* in a scientific work, please consider citing the paper:
  ```bibtex
  @article{chen2022points2poly,
    title = {Reconstructing compact building models from point clouds using deep implicit fields},
    journal = {ISPRS Journal of Photogrammetry and Remote Sensing},
    volume = {194},
    pages = {58-73},
    year = {2022},
    issn = {0924-2716},
    doi = {https://doi.org/10.1016/j.isprsjprs.2022.09.017},
    url = {https://www.sciencedirect.com/science/article/pii/S0924271622002611},
    author = {Zhaiyu Chen and Hugo Ledoux and Seyran Khademi and Liangliang Nan}
  }
  ```


pkgId: 5dd3ab496dcc4da4e440c9d44bfc911f6b96333dcd6b2dc5ff9af68d9e8f021f
name: python-absscpi
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: SCPI driver for the Bloomy Controls Advanced Battery Simulator
description: Python library for SCPI control of the Bloomy Controls ABS.
url: https://pypi.org/project/absscpi/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-absscpi-0.3.0-1.src.rpm
checksum_type: sha256
rpm_license:
  Copyright (c) 2024, Bloomy Controls, Inc. All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. 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: 45b0ff8354869c8bfc45124743ecc1a476fbbb0e3a6a6336e9191a635d2461ba
name: python-abst
arch: src
version: 2.3.58
epoch: 0
release: 1
summary: CLI Command making OCI Bastion and kubernetes usage simple and fast
url: https://github.com/jiri-otoupal/abst
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abst-2.3.58-1.src.rpm
checksum_type: sha256
description:
  Manage your bastion sessions automatically without
  pain of creating them by clicking and copy pasting commands

  [![image](https://img.shields.io/pypi/v/abst.svg)](https://pypi.org/project/abst/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/abst)](https://pypi.org/project/abst/)
  [![Downloads](https://pepy.tech/badge/abst)](https://pepy.tech/project/abst)





  No specific requirements here, whatever runs Python



  * **Oracle Cloud**





  * 3.7+



  * Add key in your Oracle cloud profile
  * Generate new key
  * Copy configuration file generated in your profile to `~/.oci/config`
  * Replace path of your `*.pem` key on line with **#TODO**





  On most MacOS machines there is `pip3` instead of `pip` **use pip3 for install**

  Install and update using [pip](https://pip.pypa.io/en/stable/quickstart/):

  ```bash
  pip install abst

  or

  pip3 install abst
  ```



  * Use `abst ctx fill {context}` to fill your credentials for usage, you can find all the
    credentials on
    cloud provider site, leave context empty if you want to fill default
  * Use `abst ctx generate {context}` to generate default config for context, leave context empty if you
    want to generate to
    default





  * `abst create forward/managed {context}` for automatic Bastion session creation once
    deleted, will keep your,
    leave context empty if you want to use default
    connection alive till you kill this script
  * `abst do forward/managed {context}` alias for `abst create`
  * `abst clean` for removal all the saved credentials
  * `abst use {context}` for using different config that you had filled, `default` is the default
    context in `creds.json`
  * Use `abst ctx locate {context}` to locate your configs, leave context empty if you want to locate
    default



  * `abst ctx list` to list contexts
  * `abst ctx upgrade <context-name>` to upgrade context you can use `--all` flag to upgrade all contexts
  * `abst ctx locate <context-name>` to get a full path of context
  * `abst ctx share <context-name>` to copy context contents into clipboard and display it, you can use `--raw` to just
    get json
  * `abst ctx paste <context-name>` to paste contents into context file provided from name



  * `abst ssh` facilitates selecting an instance to connect to. The optional `port` argument can be specified partially; a
    connection is established if only one match is found. Use `-n <context-name>` to filter a connection, where the name
    can be a partial match. `abst` employs the `in` operator for searching and proceeds with SSH if a single matching
    instance exists.



  If you are more demanding and need to have connection to your SSH Tunnels ready at all times
  you can use parallel executed Bastions that currently work for full-auto forwarded setting

  Change local port in the setting to port that is unique to other configs, and it will be running on
  all the added ports
  Until you kill the `abst` command, it will automatically remove all generated Bastion sessions by
  this program

  * `abst parallel add {context}` will add context from your `context folder` to stack that will be
    executed
  * `abst parallel remove {context}` will remove context from your `context folder` to stack that
    will be executed
  * `abst parallel run {context}` will run all the stacked contexts
  * `abst parallel display` will display current stacked contexts
  * `abst parallel list` will list all sets with contexts



  * `abst helm login` will log you in with credentials set in config.json, you set these credentials
    when running this command first time. Edit with flag --edit 1-n number is the index of credential
    in list
  * `abst helm push <chart-name>` will push to specified remote branch, if more credentials preset it
    will let you pick which one to use



  * `abst pod ssh <part of name>` will ssh into pod with similar name, if multiple found it will display select
  * `abst cp secret secret_namespace target_namespace source_namespace(optional)` this will copy
    secret to target namespace, without providing source namespace it will use current as a source

  <hr>
  Did I made your life less painful ?
  <br>
  <br>
  Support my coffee addiction ;)
  <br>
  <a href="https://www.buymeacoffee.com/jiriotoupal" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy me a Coffee" style="height: 41px !important;width: 174px !important;box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;-webkit-box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;" ></a>


pkgId: 1fb8ae90da8b02e25fa90ff67d696ced986b79724de5b0f8860baba8f37c1c01
name: python-abstcal
arch: src
version: 0.9
epoch: 0
release: 1
summary: Calculate abstinence using the timeline followback data in substance research.
url: https://github.com/ycui1-mda/abstcal
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abstcal-0.9-1.src.rpm
checksum_type: sha256
description:
  1000 | 02/03/2019 | 10
  1000 | 02/04/2019 | 8
  1000 | 02/05/2019 | 12
  1000 | 02/06/2019 | 9
  1000 | 02/07/2019 | 10
  1000 | 02/08/2019 | 8


pkgId: e1bd203764004be67f54c34d69715cad63e57f623513e5eed3729d947805fb36
name: python-abstra-notas
arch: src
version: 0.0.14
epoch: 0
release: 1
summary: Biblioteca de emissão de notas fiscais eletrônicas para empresas brasileiras.
url: https://github.com/abstra-app/abstra_notas
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abstra-notas-0.0.14-1.src.rpm
checksum_type: sha256
description:
  Biblioteca de emissão de notas fiscais eletrônicas para empresas brasileiras.


  Se você está interessado em automações financeiras com Python, dê uma olhada na [Abstra](https://abstra.io/).

  ```python
  from abstra_notas.nfse.sp.sao_paulo import Cliente


  cliente = Cliente(
      caminho_pfx="/meu/caminho/certificado.pfx",
      senha_pfx="senha"
  )

  ...

  cliente.gerar_nota(pedido) # Simples assim
  ```



  ```bash
  pip install abstra_notas
  ```



  - [NFSe](/abstra_notas/nfse/README.md): Notas de serviço via prefeituras.
  - NFe: Notas de produtos via SEFAZ (Em breve)



  MIT


pkgId: 3bf93e97a55003c9facf0afe18414b0ec1db8609f18ed9e6ab0cae47ce883a06
name: python-abstract-ai
arch: src
version: 0.2.1.90
epoch: 0
release: 1
url: https://github.com/AbstractEndeavors/abstract_ai
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abstract-ai-0.2.1.90-1.src.rpm
checksum_type: sha256
summary:
  abstract_ai is a Python module that serves as a bridge between your application and the OpenAI GPT-3 API. It provides a convenient interface for sending requests, managing responses, and controlling the behavior of the API calls. This module is highly customizable, allowing you to establish prompts, instructions, and response handling logic.

description:
  Your journey towards seamless data handling starts here! Dive into the code, and feel free to contribute or suggest improvements.
  ```

  ```python
  import os

  from abstract_ai import ModelManager
  model='gpt-4'
  model_mgr = ModelManager(input_model_name=model)
  model_mgr.selected_endpoint    #output: https://api.openai.com/v1/chat/completions
  model_mgr.selected_max_tokens  #output: 8192






  from abstract_ai import ApiManager
  api_env='OPENAI_API_KEY'
  api_mgr = ApiManager(api_env=api_env,content_type=None,header=None,api_key=None)
  api_mgr.content_type #output application/json
  api_mgr.header       #output: {'Content-Type': 'application/json', 'Authorization': 'Bearer ***private***'}
  api_mgr.api_key      #output: ***private***

  from abstract_ai import InstructionManager


  notation = True # allows the module a method of notation that it can utilize to maintain comtext and contenuity from one prompt query to the next
  suggestions = True # encourages suggestions on the users implimentation of the current query
  abort = True # allows for the module to put a full stop to the query loop if the goal is unattainable or an anamolous instance occurs
  generate_title = True # the module wil generate a title for the response file
  additional_responses = True # allows for the module to delegate the relooping of a prompt interval, generally to form a complete response if token length is insuficcient, or if context is too much or too little
  additional_instruction = "please place any iterable data inside of this key value unless otherwise specified"
  request_chunks = True # allows for the module to add an interval to the query loop to retrieve the previous prompt the previous prompt
  instruction_mgr = InstructionManager(notation=notation,
                                       suggestions=suggestions,
                                       abort=abort,
                                       generate_title=generate_title,
                                       additional_responses=additional_responses,
                                       additional_instruction=additional_instruction,
                                       request_chunks=self.request_chunks
                                       )
  instruction_mgr.instructions

  """
  your response is expected to be in JSON format with the keys as follows:
  0) api_response - place response to prompt here
  1) notation - A useful parameter that allows a module to retain context and continuity of the prompts. These notations can be used to preserve relevant information or context that should be carried over to subsequent prompts.
  2) suggestions - ': A parameter that allows the module to provide suggestions for improving efficiency in future prompt sequences. These suggestions will be reviewed by the user after the entire prompt sequence is fulfilled.
  3) additional_responses - This parameter, usually set to True when the answer cannot be fully covered within the current token limit, initiates a loop that continues to send the current chunk's prompt until the module returns a False value. This option also enables a module to have access to previous notations
  4) abort - if you cannot fullfil the request, return this value True; be sure to leave a notation detailing whythis was
  5) generate_title - A parameter used for title generation of the chat. To maintain continuity, the generated title for a given sequence is shared with subsequent queries.
  6) request_chunks - you may request that the previous chunk data be prompted again, if selected, the query itterate once more with the previous chunk included in the prompt. return this value as True to impliment this option; leave sufficient notation as to why this was neccisary for the module recieving the next prompt
  7) additional_instruction - please place any iterable data inside of this key value unless otherwise specified
  below is an example of the expected json dictionary response format, with the default inputs:
  {'api_response': '', 'notation': '', 'suggestions': '', 'additional_responses': False, 'abort': False, 'generate_title': '', 'request_chunks': False, 'additional_instruction': '...'}"""

  from abstract_ai import PromptManager

  completion_percentage = 40 #allows the user to specify the completion percentage they are seeking for this prompt(s) currently at 40% of the token allotment
  request = "thanks for using abstract_ai the description youre looking for is in the prompt_data"
  prompt_data = """The code snippet is a part of `PromptBuilder.py` from the `abstract_ai` module. This specific part shows the crucial role of chunking strategies in the functioning of `abstract_ai`.\n\nThe `chunk_data_by_type` function takes in data, a maximum token limit, and a type of chunk (with possible values like 'URL', 'SOUP', 'DOCUMENT', 'CODE', 'TEXT').Depending on the specified type, it applies different strategies to split the data into chunks. If a chunk type is not detected, the data is split based on line breaks.\n\nThe function `chunk_text_by_tokens` is specifically used when the chunk type is 'TEXT'. It chunks the input data based on the specified maximum tokens, ensuring eachchunk does not exceed this limit.\n\nWith the `chunk_source_code` function, you can chunk source code based on individual functions and classes. This is crucial to maintainthe context and readability within a code snippet.\n\n`extract_functions_and_classes` is a helper function used within `chunk_source_code`, it extracts all the functions andclasses from the given source code. The extracted functions and classes are then used to chunk source code accordingly.\n\nThese functions are called numerous times in the abstract_ai platform, emphasizing their key role in the system."""
  chunk_type="Code" #parses the chunks based on your input types, ['HTML','TEXT','CODE']
  prompt_mgr = PromptManager(instruction_mgr=instruction_mgr,
                             model_mgr=model_mgr,
                             completion_percentage=completion_percentage,
                             prompt_data=prompt_data,
                             request=request,
                             token_dist=None,
                             bot_notation=None,
                             chunk=None,
                             role=None,
                             chunk_type=chunk_type)
  prompt_mgr.token_dist = [{
      'completion':{'desired': 3276,
                    'available': 3076,
                    'used': 200},
      'prompt': {'desired': 4915,
                 'available': 4035,
                 'used': 880},
      'chunk': {'number': 0,
                'total': 1,
                'length': 260,
                'data': "\nThe code snippet is a part of `PromptBuilder.py` from the `abstract_ai` module. This specific part shows the crucial role of chunking strategies in the functioning of `abstract_ai`.\n\n\nThe `chunk_data_by_type` function takes in data, a maximum token limit, and a type of chunk (with possible values like 'URL', 'SOUP', 'DOCUMENT', 'CODE', 'TEXT').\nDepending on the specified type, it applies different strategies to split the data into chunks. If a chunk type is not detected, the data is split based on line breaks.\n\n\nThe function `chunk_text_by_tokens` is specifically used when the chunk type is 'TEXT'. It chunks the input data based on the specified maximum tokens, ensuring each\nchunk does not exceed this limit.\n\nWith the `chunk_source_code` function, you can chunk source code based on individual functions and classes. This is crucial to maintain\nthe context and readability within a code snippet.\n\n`extract_functions_and_classes` is a helper function used within `chunk_source_code`, it extracts all the functions and\nclasses from the given source code. The extracted functions and classes are then used to chunk source code accordingly.\n\n\nThese functions are called numerous times in the abstract_ai platform, emphasizing their key role in the system."}}]
  completion_percentage = 90 # completion percentage now set to 90% of the token allotment
  request = "ok now we chunk it up with abstract_ai the description youre looking for is still in the prompt_data"
  prompt_mgr = PromptManager(instruction_mgr=instruction_mgr,
                             model_mgr=model_mgr,
                             completion_percentage=completion_percentage,
                             prompt_data=prompt_data,
                             request=request)
  prompt_mgr.token_dist = [{'completion':
                            {'desired': 7372,
                             'available': 7172,
                             'used': 200},
                            'prompt':
                            {'desired': 819,
                             'available': 7,
                             'used': 812},
                            'chunk':
                            {'number': 0,
                             'total': 2,
                             'length': 192,
                             'data': "\n\nThe code snippet is a part of `PromptBuilder.py` from the `abstract_ai` module. This specific part shows the crucial role of chunking strategies in the functioning of `abstract_ai`.\n\nThe `chunk_data_by_type` function takes in data, a maximum token limit, and a type of chunk (with possible values like 'URL', 'SOUP', 'DOCUMENT', 'CODE', 'TEXT').Depending on the specified type, it applies different strategies to split the data into chunks. If a chunk type is not detected, the data is split based on line breaks.\n\nThe function `chunk_text_by_tokens` is specifically used when the chunk type is 'TEXT'. It chunks the input data based on the specified maximum tokens, ensuring eachchunk does not exceed this limit.\n\nWith the `chunk_source_code` function, you can chunk source code based on individual functions and classes. This is crucial to maintainthe context and readability within a code snippet."}},
                           {'completion':
                            {'desired': 7372,
                             'available': 7172,
                             'used': 200},
                            'prompt':
                            {'desired': 819,
                             'available': 135,
                             'used': 684},
                            'chunk':
                            {'number': 1,
                             'total': 2,
                             'length': 64,
                             'data': '`extract_functions_and_classes` is a helper function used within `chunk_source_code`, it extracts all the functions andclasses from the given source code. The extracted functions and classes are then used to chunk source code accordingly.\n\nThese functions are called numerous times in the abstract_ai platform, emphasizing their key role in the system.'}}]
  from abstract_ai import ResponseManager


  response_mgr = ResponseManager(prompt_mgr=prompt_mgr,
                  api_mgr=api_mgr,
                  title="Chunking Strategies in PromptBuilder.py",
                  directory='response_data')
  response_mgr.initial_query()
  response_mgr.output = [{'prompt': {'model': 'gpt-4', 'messages': [{'role': 'assistant', 'content': "\n-----------------------------------------------------------------------------\n#instructions#\n\nyour response is expected to be in JSON format with the keys as follows:\n\n0) api_response - place response to prompt here\n1) notation - A useful parameter that allows a module to retain context and continuity of the prompts. These notations can be used to preserve relevant information or context that should be carried over to subsequent prompts.\n2) suggestions - ': A parameter that allows the module to provide suggestions for improving efficiency in future prompt sequences. These suggestions will be reviewed by the user after the entire prompt sequence is fulfilled.\n3) additional_responses - This parameter, usually set to True when the answer cannot be fully covered within the current token limit, initiates a loop that continues to send the current chunk's prompt until the module returns a False value. This option also enables a module to have access to previous notations\n4) abort - if you cannot fullfil the request, return this value True; be sure to leave a notation detailing whythis was\n5) generate_title - A parameter used for title generation of the chat. To maintain continuity, the generated title for a given sequence is shared with subsequent queries.\n6) request_chunks - you may request that the previous chunk data be prompted again, if selected, the query itterate once more with the previous chunk included in the prompt. return this value as True to impliment this option; leave sufficient notation as to why this was neccisary for the module recieving the next prompt\n7) additional_instruction - please place any iterable data inside of this key value unless otherwise specified\n\nbelow is an example of the expected json dictionary response format, with the default inputs:\n{'api_response': '', 'notation': '', 'suggestions': '', 'additional_responses': False, 'abort': False, 'generate_title': '', 'request_chunks': False, 'additional_instruction': '...'}\n-----------------------------------------------------------------------------\n#prompt#\n\nok now we chunk it up with abstract_ai the description youre looking for is still in the prompt_data\n-----------------------------------------------------------------------------\n\n-----------------------------------------------------------------------------\n#data chunk#\n\nthis is chunk 0 of 2\n\n\n\nThe code snippet is a part of `PromptBuilder.py` from the `abstract_ai` module. This specific part shows the crucial role of chunking strategies in the functioning of `abstract_ai`.\n\nThe `chunk_data_by_type` function takes in data, a maximum token limit, and a type of chunk (with possible values like 'URL', 'SOUP', 'DOCUMENT', 'CODE', 'TEXT').Depending on the specified type, it applies different strategies to split the data into chunks. If a chunk type is not detected, the data is split based on line breaks.\n\nThe function `chunk_text_by_tokens` is specifically used when the chunk type is 'TEXT'. It chunks the input data based on the specified maximum tokens, ensuring eachchunk does not exceed this limit.\n\nWith the `chunk_source_code` function, you can chunk source code based on individual functions and classes. This is crucial to maintainthe context and readability within a code snippet.\n-----------------------------------------------------------------------------\n"}], 'max_tokens': 7172},
                                'response': {'id': '**id**', 'object': 'chat.completion', 'created': 1699054738, 'model': 'gpt-4-0613', 'choices': [{'index': 0, 'message': {'role': 'assistant', 'content': "{'api_response': 'This chunk describes a part of the `PromptBuilder.py` from the `abstract_ai` module. It underlines the significance of chunking methods in the `abstract_ai` operations. The mentioned `chunk_data_by_type` function accepts data, a maximum token limit, and a type of chunk to appropriately divide the data into chunks. The chunking process depends on the specified type, and in case the type is not identified, the data is divided based on line breaks. The `chunk_text_by_tokens` and `chunk_source_code` functions are used when the chunk type is 'TEXT' and 'CODE' respectively. The former chunks the data considering the max token limit, while the latter chunks source code as per individual classes and functions, maintaining the context and readability of a code snippet.', \n 'notation': 'The chunked data tells about the `abstract_ai` chunking mechanisms, which include `chunk_data_by_type`, `chunk_text_by_tokens` and `chunk_source_code` functions.', \n 'suggestions': 'It can be improved by providing specific examples of how each chunking function works.', \n 'additional_responses': True, \n 'abort': False, \n 'generate_title': 'Review of `abstract_ai` Chunking Mechanisms',\n 'request_chunks': False, \n 'additional_instruction': ''}"}, 'finish_reason': 'stop'}], 'usage': {'prompt_tokens': 621, 'completion_tokens': 271, 'total_tokens': 892}}, 'title': 'Chunking Strategies in PromptBuilder.py'},
                               {'prompt': {'model': 'gpt-4', 'messages': [{'role': 'assistant', 'content': "\n-----------------------------------------------------------------------------\n#instructions#\n\nyour response is expected to be in JSON format with the keys as follows:\n\n0) api_response - place response to prompt here\n1) notation - A useful parameter that allows a module to retain context and continuity of the prompts. These notations can be used to preserve relevant information or context that should be carried over to subsequent prompts.\n2) suggestions - ': A parameter that allows the module to provide suggestions for improving efficiency in future prompt sequences. These suggestions will be reviewed by the user after the entire prompt sequence is fulfilled.\n3) additional_responses - This parameter, usually set to True when the answer cannot be fully covered within the current token limit, initiates a loop that continues to send the current chunk's prompt until the module returns a False value. This option also enables a module to have access to previous notations\n4) abort - if you cannot fullfil the request, return this value True; be sure to leave a notation detailing whythis was\n5) generate_title - A parameter used for title generation of the chat. To maintain continuity, the generated title for a given sequence is shared with subsequent queries.\n6) request_chunks - you may request that the previous chunk data be prompted again, if selected, the query itterate once more with the previous chunk included in the prompt. return this value as True to impliment this option; leave sufficient notation as to why this was neccisary for the module recieving the next prompt\n7) additional_instruction - please place any iterable data inside of this key value unless otherwise specified\n\nbelow is an example of the expected json dictionary response format, with the default inputs:\n{'api_response': '', 'notation': '', 'suggestions': '', 'additional_responses': False, 'abort': False, 'generate_title': '', 'request_chunks': False, 'additional_instruction': '...'}\n-----------------------------------------------------------------------------\n#prompt#\n\nok now we chunk it up with abstract_ai the description youre looking for is still in the prompt_data\n-----------------------------------------------------------------------------\n\n-----------------------------------------------------------------------------\n#data chunk#\n\nthis is chunk 1 of 2\n\n`extract_functions_and_classes` is a helper function used within `chunk_source_code`, it extracts all the functions andclasses from the given source code. The extracted functions and classes are then used to chunk source code accordingly.\n\nThese functions are called numerous times in the abstract_ai platform, emphasizing their key role in the system.\n-----------------------------------------------------------------------------\n"}], 'max_tokens': 7172},
                                'response': {'id': '**id**', 'object': 'chat.completion', 'created': 1699054759, 'model': 'gpt-4-0613', 'choices': [{'index': 0, 'message': {'role': 'assistant', 'content': "{'api_response': '`extract_functions_and_classes` is a helper function used within `chunk_source_code`. It extracts all the functions and classes from the given source code. These extracted elements are then used to chunk source code accordingly.', 'notation': 'Explanation about `extract_functions_and_classes` and `chunk_source_code` functions.', 'suggestions': '', 'additional_responses': True, 'abort': False, 'generate_title': '', 'request_chunks': False, 'additional_instruction': ''}"}, 'finish_reason': 'stop'}], 'usage': {'prompt_tokens': 494, 'completion_tokens': 99, 'total_tokens': 593}}, 'title': 'Chunking Strategies in PromptBuilder.py_0'
                                }]

  current_file_full_data = read_from_file(os.path.abspath(__file__))
  completion_percentage = 60 # completion percentage now set to 90% of the token allotment
  request = "here is the entire example use case, please review the code and thank you for your time with abstract_ai"
  prompt_data=current_file_full_data
  title="Chunking Example Review.py"
  response_mgr = ResponseManager(prompt_mgr=PromptManager(prompt_data=prompt_data,
                                                          request=request,
                                                          completion_percentage=completion_percentage,
                                                          model_mgr=model_mgr,
                                                          instruction_mgr=instruction_mgr),
                                 api_mgr=api_mgr,
                                 title=title,
                                 directory='response_data')
  response_mgr.initial_query()
  output = response_mgr.initial_query()
  from abstract_ai import collate_response_que
  colate_responses = collate_response_que(output)

  """The provided code is a walkthrough of how the `abstract_ai` module can be used for text processing tasks. It first demonstrates how to initialize the `ModelManager`, `ApiManager`, and `InstructionManager` classes. These classes are responsible for managing model-related configurations, API interactions, and instruction-related configurations, respectively.
  The `PromptManager` class is initialized to manage prompt-related operations. This class handles the calculation of token distribution for various component parts of the prompt (i.e., the prompt itself, the completion, and the data chunk). In the example, the completion percentage is adjusted from 40% to 90%, demonstrating the flexibility of the `abstract_ai` module in shaping the AI's response. Additionally, the module supports different types of chunks, such as code, text, URL, etc., which adds further flexibility to the text processing.
  The `ResponseManager` class interacts with AI models to handle the sending of queries and storing of responses. This class ensures responses are processed correctly and saved in a structured way for easy retrieval and analysis.
  Overall, this use case provides a comprehensive view of how `abstract_ai` can be used for sophisticated and efficient management of AI-based text processing tasks."
  All of those functions enable `abstract_ai` to manage large volumes of data effectively, ensuring legibility and context preservation in the chunks produced by recognizing their critical role within the platform.
  Your request to review the provided example was processed successfully. The entire operation was completed in a single iteration, consuming about 60% of the allotted tokens."""

  "Please provide more context or specific requirements if necessary. Additional details about the specific use case or problem being solved could also be helpful for a more nuanced and tailored review."

  "Review and Analysis of Chunking Strategies in the `abstract_ai` Framework"

  "The provided example included the usage of `PromptBuilder.py` from the `abstract_ai` module and the necessary chunking functions."

  "false"

  "false"
  ```

  ![URL Grabber Component](https://raw.githubusercontent.com/AbstractEndeavors/abstract-ai/main/src/abstract_ai/documentation/images/web_scraping_utility.png)
  *URL grabber component: Allows users to add URL source code or specific portions of the URL source code to the prompt data, this feature is imported from the `UrlGrabber` component of the `Abstract_webtools` module.*
  ![Settings Tab](https://raw.githubusercontent.com/AbstractEndeavors/abstract-ai/main/src/abstract_ai/documentation/images/query_and_response.png)
  *Prompt Data: The left pane showcases the prompt data. All PromptData are derived from the `PromptManager` class.*
  *Response: The right pane contains the response intake. All Responses are derived from the `ResponseManager` class.*
  ![Instructions Display](https://raw.githubusercontent.com/AbstractEndeavors/abstract-ai/main/src/abstract_ai/documentation/images/instruction_implimentation.png)
  *Instructions Display: Showcases all default instructions, which are customizable in the same pane. All instructions are derived from the `InstructionManager` class.*
  *Settings Tab: Contains all selectable settings, including available, desired, and used prompt and completion tokens, most of which is derived from the `PromptManmager` class.*
  ![File Content Chunks](https://raw.githubusercontent.com/AbstractEndeavors/abstract-ai/main/src/abstract_ai/documentation/images/prompt_data_chunking.png)
  *File Browser Component: Enables users to add the contents of files or specific portions of file content to the prompt data, this feature is imported from the `AbstractBrowser` component of the `Abstract_gui` module.*

  The `GptManager.py` module provides an extensive class management to interact with the GPT-3 model conveniently. This module combines various functionalities into a unified and structured framework. Some of the significant classes it encapsulates are as follows:
  - GptManager: This is the central class that administers the interactions and data flow amongst distinct components.
  - ApiManager: This manages the OpenAI API keys and headers.
  - ModelManager: This takes care of model selection and querying.
  - PromptManager: This takes care of the generation and management of prompts.
  - InstructionManager: This encapsulates the instructions for the GPT model.
  - ResponseManager: This administers the responses received from the model.
  These classes work collectively to simplify the task of sending queries, interpreting responses, and managing the interactions with the GPT-3 model. The module heavily depends on packages like `abstract_webtools`, `abstract_gui`, `abstract_utilities`, and `abstract_ai_gui_layout`.

  - **abstract_webtools**: Provides web-centric tools.
  - **abstract_gui**: Houses GUI-related tools and components.
  - **abstract_utilities**: Contains general-purpose utility functions and classes.
  - **abstract_ai_gui_layout**: Lays out the AI GUI.


  To use the `abstract_ai_gui_backend.py`, first, initialize the GptManager class. Following this step, use the update methods to set or change configurations. Finally, use the `get_query()` method to query the GPT model and retrieve a response.
  This chunk of code contains several methods for the abstract_ai_gui_backend module of the Abstract AI system:

  1. `update_response_mgr`: This method updates the ResponseManager instance used by the module, linking it with the existing instances of PromptManager and ApiManager. The ResponseManager generates AI response to prompts that are sent.
  2. `get_query`: The method is used for making respective calls to get responses. If a response is already computed, it stops the existing request (using `ThreadManager`) and starts a new thread for response retrieval.
  3. `update_all`: This method is used to update all the managers used by the module, to keep their data in sync.
  4. `get_new_api_call_name`: This method generates a new unique name for API call and appends it in the API call list.
  5. `get_remainder`: It returns what's left when 100 is subtracted from the value from a specific key.
  6. `check_test_bool`: This method checks if a test run is initiated. According to the result, it sets different statuses and updates the GUI accordingly.
  7. `get_new_line`: The method simply returns a newline character(s).
  8. `update_feedback`: This method fetches a value from the last response, based on the given key, and updates the GUI accordingly.
  9. `update_text_with_responses`: This method loads the last response and if it contains API response, it updates the GUI with the Title, Request text, and Response. For other feedback, it appends the information to the output.
  10. `get_bool_and_text_keys`: This method simply returns a list of keys formed by the given key_list and sections_list.
  11. `text_to_key`: The static method uses the function from utilities to generate a key name from text.
  12. `get_dots`: This method is used for decorating progress status.
  13. `update_progress_chunks`: This method provides a visual representation of the overall progress with respect to total chunks.
  14. `check_response_mgr_status`: This method checks whether the response manager's query process is finished by checking the `query_done` attribute.
  15. `submit_query`: This method controls the sending and receiving of queries and updating the GUI with the AI response.
  16. `update_chunk_info`: This method updates information related to the chunk based on the progress.
  17. `adjust_chunk_display`: This method modifies the GUI value responsible for displaying the chunk number in GUI based on the navigation number provided.
  The above chunk contains a sequence of function definitions that manage different parts of the AI interaction process within the abstract_ai module. Here's a concise guide about each method:
  - `get_chunk_display_numbers`: Retrieves the display number for the current data chunk.
  - `determine_chunk_display`: Determines if a data chunk should be displayed based on the input event.
  - `append_output`: Appends new content to a particular key in the output.
  - `add_to_chunk`: Appends new content to the current data chunk.
  - `clear_chunks`: Resets the current chunk data.
  - `get_url`: Retrieves the URL for a script.
  - `get_url_manager`: Checks if a URL manager exists for a particular URL.
  - `test_files`: Performs tests on the AI model with a hard-coded query.
  - `update_last_response_file`: Stores the path of the most recent response file, and updates the related GUI elements.
  - `update_response_list_box`: Updates the list box displaying response files.
  - `aggregate_conversations`: Aggregates all conversations from JSON files in a specified directory.
  - `initialize_output_display`: Initializes the display for the output and sets the data to the first item of the latest output.
  This code chunk contains four methods for managing output display in the application.
  1) `get_output_display_numbers`: This functions fetches from `window_mgr` the value associated with the `-RESPONSE_TEXT_NUMBER-` key and stores it in `response_text_number_display`. Additionally, it calculates `response_text_number_actual` by subtracting 1 from `response_text_number_display`.
  2) `determine_output_display`: This function checks the current `event` and decides whether the output display needs to be adjusted and in which direction (back or forward). It checks the conditions and, if valid, calls the `adjust_output_display` method.
  3) `adjust_output_display`: This function accepts one argument `num` which is used to adjust `response_text_number_actual` and `response_text_number_display`. It updates the output display and updates the `-RESPONSE_TEXT_NUMBER-` key in the `window_mgr` with the new value of `response_text_number_display`.
  4) `update_output`: This function accepts `output_iteration` as an argument and checks if it lies within the valid range. If valid, it assigns the designated output to `self.latest_output[output_iteration]` and then calls `update_text_with_responses`.
  This code manages the logic for traversing through the returned responses. It correctly fetches the number of responses, decides whether to go back or forward based on the event, adjusts the display accordingly and updates it. It is important to update the documentation with these details to allow the users to understand the flow of control in the script.

  The ModelManager class, as part of the `abstract_ai` module, provides functionalities for selecting, querying, and managing information about the available GPT models. The class initializes a list of models and their related information like endpoint and token limits. It also has methods to get model-specific details like endpoints, names, and token limits.
  Below are the method descriptions:
  - `__init__`: Initialises the ModelManager instance with information about all available models. It also sets up the default model, endpoints, and maximum tokens.
  - `get_all_values`: Takes a key as an input parameter and returns all unique values associated with this key in the `all_models` list.
  - `_get_all_values`: An alternate private method to `get_all_values` that performs the same functionality with a reduced number of lines by using a list comprehension.
  - `_get_endpoint_by_model`: Returns the endpoint associated with the input model name.
  - `_get_models_by_endpoint`: Returns a list of models associated with a given endpoint.
  - `_get_max_tokens_by_model`: Returns the maximum tokens that can be processed by a given model.
  Note: In the `__init__` function, depending on the given inputs, the function prioritizes model_name over endpoint in setting the selected model, endpoint, and maximum tokens.

  PromptBuilder is a sophisticated module within the Abstract AI's ApiConsole, designed to handle the intricacies of token distribution, chunking of data, and prompt construction necessary for interfacing with language model APIs.

  PromptBuilder.py specializes in calculating and managing token allocations for prompt and completion outputs, considering the user's specifications and the constraints of the API's token limits. It ensures that queries are not only well-formed but also optimally structured for the language model to understand and respond effectively. The module's responsibilities extend to sizing the current query, evaluating the total prompt data, and segmenting it into processable chunks before final prompt assembly.


  - **Token Distribution:** Allocates tokens between prompts and completions based on instruction weight, verbosity, and available token quota.
  - **Data Chunking:** Separates prompt data into manageable chunks, conforming to the calculated token budget.
  - **Prompt Construction:** Assembles the full prompt incorporating user instructions, chunk data, and module notation, ready for API interaction.
  - **Integration:** Serves as a foundational tool for the system, called upon in nearly every significant interaction with Abstract AI.

  PromptBuilder.py relies on the `nltk` and `tiktoken` libraries for accurate tokenization and text encoding, ensuring precise calculations and data handling.

  To utilize the PromptBuilder.py, import the module and instantiate the required class. Utilize its methods by adjusting parameters to fit the needs of your query. Here's an example using `calculate_token_distribution`:
  ```python
  from PromptBuilder import PromptBuilder

  prompt_builder = PromptBuilder()

  token_distribution = prompt_builder.calculate_token_distribution(user_query)
  ```

  PromptBuilder.py is deeply integrated with the Abstract AI suite, often collaborating with `ApiBuilder.py`, `ModelBuilder.py`, and `abstract_ai_gui_backend.py` for a cohesive and efficient API interaction experience.

  - `get_token_calcs`: Evaluates token distribution for each chunk, ensuring balance between prompts and completions.
  - `get_token_distributions`: Distributes tokens optimally across chunks based on the prompt and completion needs.

  Among the functions in this module, the token calculation functions `get_token_calcs` and `get_token_distributions` are quite crucial. They carefully calculate the tokens used and available for prompts and completion. If, at any point, available prompt tokens fall below zero, they get added to the available completion tokens leading to a balance distribution.
  Here's an overview of two prominent methods:
  - `get_token_calcs`: Evaluates individual token calculations for prompt and completion data. On detecting a shortage in available tokens, it redistributes tokens from the completion pool.
  - `get_token_distributions`: It distributes tokens between the prompt and completion parts of the GPT-3 model query, ensuring a smooth and balanced query and keeping within the maximum token limit for the task.

  ```json
  {
    "title": "Chunking Strategies in PromptBuilder.py",
    "prompt_type": "Python Code",
    "prompt": "The code snippet is a part of `PromptBuilder.py` from the `abstract_ai` module. This specific part shows the crucial role of chunking strategies in the functioning of `abstract_ai`.\n\nThe `chunk_data_by_type` function takes in data, a maximum token limit, and a type of chunk (with possible values like 'URL', 'SOUP', 'DOCUMENT', 'CODE', 'TEXT'). Depending on the specified type, it applies different strategies to split the data into chunks. If a chunk type is not detected, the data is split based on line breaks.\n\nThe function `chunk_text_by_tokens` is specifically used when the chunk type is 'TEXT'. It chunks the input data based on the specified maximum tokens, ensuring each chunk does not exceed this limit.\n\nWith the `chunk_source_code` function, you can chunk source code based on individual functions and classes. This is crucial to maintain the context and readability within a code snippet.\n\n`extract_functions_and_classes` is a helper function used within `chunk_source_code`, it extracts all the functions and classes from the given source code. The extracted functions and classes are then used to chunk source code accordingly.\n\nThese functions are called numerous times in the abstract_ai platform, emphasizing their key role in the system.",
    "suggested_formatting": [
      {
        "code": {
          "language": "python",
          "content": [
            "def chunk_data_by_type(data, max_tokens, chunk_type=None):",
            "...",
            "def chunk_text_by_tokens(prompt_data, max_tokens):",
            "...",
            "def extract_functions_and_classes(source_code):",
            "...",
            "def chunk_source_code(source_code, max_tokens):"
          ]
        }
      }
    ]
  }
  ```


  This module is a segment of the Abstract AI system that manages the creation and modifications of instructions used by the GPT-3 model. It composes a significant component of `abstract_ai_gui_backend.py`, working closely with classes like GptManager, ApiManager, ModelManager, PromptManager, and ResponseManager to ensure efficient and structured interactions with the model.

  - Main Methods:
  1. `update_response_mgr`: Links the existing instances of PromptManager and ApiManager, updating the ResponseManager used by the module.
  2. `get_query`: Controls interrupting ongoing requests and starting a new thread for response retrieval through the `ThreadManager`.
  3. `update_all`: Keeps the model, API, and other managers up to date and synchronized.
  4. `get_new_api_call_name`: Generates unique ID for each API call and maintains them in a list.
  5. `get_remainder`: Works on value subtraction for a particular key.
  6. `get_new_line`: A simple method for returning newline characters.
  7. `update_feedback`: Fetches a key-value pair from the prior response and updates the GUI.
  8. `update_text_with_responses`: Loads the latest response, extracts necessary information, and updates the GUI accordingly.
  9. `update_chunk_info`: Manages updates relating to the chunk based on the progression of the query.
  10. `adjust_chunk_display`: Alters the GUI value responsible for showing the chunk number based on the provided navigation number.
  Each of these methods, with their signature features, enhances the usability and functionality of the Abstract_AI system, ensuring optimized interactions, easy navigation through data chunks, and adept handling of responses.

  Overview
  The ApiBuilder.py is a component of the abstract_ai GPT API console that streamlines the usage of the OpenAI API. It serves as a utility module for managing API keys and constructing request headers required for API interactions.
  Features
  API Key Retrieval: Securely fetches the OpenAI API key from environmental storage, ensuring that sensitive data is not hardcoded into the application.
  Header Construction: Automates the creation of the necessary authorization headers for making requests to the OpenAI API.
  Prerequisites
  To use ApiBuilder.py, ensure that you have an OpenAI API key stored in your environment variables under the name OPENAI_API_KEY.
  Getting Started
  To begin with ApiBuilder.py, you can create an instance of ApiManager and then use it to perform operations requiring API access. The ApiManager class encapsulates all you need to manage API keys and headers for the OpenAI GPT API requests.
  Usage
  python
  Copy code
  from ApiBuilder import ApiManager


  The Purpose of the `ResponseBuilder.py` is to handle interactions and communications with AI models primarily through API endpoints. It ensures that responses are correctly interpreted, any errors are handled gracefully, and the responses are saved in a structured manner to facilitate easy retrieval and analysis at a later stage. It’s a core part of the `abstract_ai`, module we are currently communicating through.

  The `ResponseManager` class is a single handler of all in-query events and module interactions. It leverages various utilities from the `abstract_utilities` module to process and organise the data, interacting closely with the `SaveManager` to persist responses.
  This class can be initialised with an instance of `prompt manager`' and `API manager`, optional `title` for the session or the file saved, and `directory` path where responses are to be saved.
  Below is a brief description of the methods of this class:
  - `re_initialize_query`: Resets query-related attributes to their default state for a new query cycle.
  - `post_request`: Sends a POST request with the current prompt and headers to the AI model and handles the response.
  - `get_response`: Extracts and formats the response from the API call.
  - `try_load_response`: Attempts to load the response content into a structured format.
  - `extract_response`: Processes the response and manages the creation of a save point through `SaveManager`.
  - `get_last_response`: Retrieves the last response from the save location.
  - `get_response_bools`: Checks and sets boolean flags based on the content of the latest response.
  - `send_query`: Prepares and sends a new query to the AI model, then processes the response.
  - `test_query`: Simulates sending a query for testing purposes.
  - `prepare_response`: Handles the response after a query has been sent.
  - `initial_query`: Manages the initial sequence of sending queries and processing responses.

  - The `ResponseBuilder` automatically chunks large data sets into manageable segments based on the percentage delegated for expected completion per query relative to the max tokens limit. This prevents wasting compute cycles on unnecessarily large queries and helps ensure more efficient responses.
  - It handles the communication with the AI model, sending queries and storing/interpreting responses, significantly simplifying the interaction process for the end-users.
  - It also gives the chat modules sufficient autonomy to efficiently handle the requests, preserving context and continuity in the responses. This helps avoid the need for users to stitch together the responses manually, leading to a more seamless interaction experience.

  api_manager = ApiManager()

  print(api_manager.api_key)          # Displays the loaded API key
  print(api_manager.header)           # Displays the generated headers
  Class ApiManager
  ApiManager is responsible for handling API keys and headers. It comes with a default configuration but can be customized during instantiation.
  Attributes:
  content_type (str): The MIME type of the request content. Defaults to 'application/json'.
  api_env (str): The environment variable name where the API key is stored. Defaults to 'OPENAI_API_KEY'.
  api_key (str): The actual API key used for authentication with the OpenAI API.
  header (dict): The authorization headers used in API requests.
  Methods:
  get_openai_key(): Retrieves the API key from the environment variable.
  load_openai_key(): Loads the API key into the OpenAI library for authenticating requests.
  get_header(): Constructs the headers required for making API requests.
  Security
  The ApiManager leverages environment variables to manage the API key, which is a secure practice. Ensure not to expose your API key in the codebase or any version control systems.

  - **Author**: putkoff
  - **Date**: 10/29/2023
  - **Version**: 1.0.0

  For issues, suggestions, or contributions, open a new issue on our [Github repository](https://github.com/AbstractEndeavors/abstract-ai/).

  `abstract_ai` is distributed under the [MIT License](https://opensource.org/licenses/MIT).


pkgId: 30e732413948869e45542e3d4ce658a6b6aa6fe3a31df3831bc8ca211cb71cd8
name: python-abstract-apis
arch: src
version: 0.0.0.49
epoch: 0
release: 1
url: https://github.com/AbstractEndeavors/abstract_apis
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abstract-apis-0.0.0.49-1.src.rpm
checksum_type: sha256
summary:
  The `abstract_apis` module is designed to facilitate HTTP requests in Python applications, particularly those that require handling JSON data, dealing with custom API endpoints, and parsing complex nested JSON responses. The module simplifies request handling by abstracting away common tasks such as header management, URL construction, and response parsing.

description:
  The `abstract_apis` module is designed to facilitate HTTP requests in Python applications, particularly those that require handling JSON data, dealing with custom API endpoints, and parsing complex nested JSON responses. The module simplifies request handling by abstracting away common tasks such as header management, URL construction, and response parsing.

  - **Header Management**: Automatically prepares headers suitable for JSON requests.
  - **URL Construction**: Helps in constructing URLs by cleanly appending endpoints to base URLs.
  - **Nested JSON Parsing**: Capable of parsing deeply nested JSON responses automatically to facilitate easy data extraction.
  - **Flexible Response Handling**: Offers functions to handle both raw and parsed JSON responses based on user preference.
  - **Error Handling**: Provides robust error reporting to aid in troubleshooting issues during HTTP requests.

  This module is not yet available on PyPI. To install, you can clone the repository and install it manually:
  ```bash
  git clone https://github.com/AbstractEndeavors/abstract_apis.git
  cd abstract_apis
  python setup.py install
  ```


  ```python
  from abstract_apis import getGetRequest
  url = 'https://api.example.com'
  endpoint = 'data'
  params = {'key': 'value'}
  response = getGetRequest(url, data=params, endpoint=endpoint)
  print(response)
  ```

  ```python
  from abstract_apis import getPostRequest
  url = 'https://api.example.com'
  endpoint = 'submit'
  data = {'key': 'value'}
  response = getPostRequest(url, data=data, endpoint=endpoint)
  print(response)
  ```

  The module automatically parses nested JSON responses if enabled:
  ```python
  response = getGetRequest(url, data=params, endpoint=endpoint, load_nested_json=True)
  print(response)
  ```

  - Python 3.6 or higher
  - `requests` library
  Make sure you have the `requests` library installed:
  ```bash
  pip install requests
  ```

  Contributions are welcome. Please fork the repository, make your changes, and submit a pull request on GitHub.

  For any questions or to discuss potential partnerships, please email [partners@abstractendeavors.com](mailto:partners@abstractendeavors.com).

  Contributions are welcome! Please fork the [repository on GitHub](https://github.com/AbstractEndeavors/abstract_apis) and submit a pull request with your changes.


pkgId: 71112e94a5e96f5536b7361c39d057605dcf56afe6e4ca57a36023608d45dbab
name: python-abstract-blockchain
arch: src
version: 0.0.2.32
epoch: 0
release: 1
url: https://github.com/AbstractEndeavors/abstract_blockchain
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abstract-blockchain-0.0.2.32-1.src.rpm
checksum_type: sha256
summary:
  The Abstract Blockchain package provides a collection of modules designed to simplify interaction with blockchain networks, smart contracts, and related components. It offers tools for managing RPC parameters, working with smart contract ABIs, and facilitating user-friendly interactions through graphical user interfaces (GUIs).

description:
  Remember to study the functional activities of this module and understand its relevance in the larger abstract-blockchain module. Join us in the next section where we detail another integral part of the module, the abstract-api-gui.py script.

  The `abstract_contract_console.py` module within the `abstract-blockchain` package offers a Graphical User Interface(GUI). This GUI is ideal for users interested in engaging interactively with the Smart Contracts on the Ethereum Blockchain. At its core, it is designed to provide a user-friendly console for interacting with Ethereum Smart Contract functions.
  The module imports required dependencies and presents helper functions to perform data conversions and error checks. This setup lays the foundation for an interface that allows users to input a contract address on the Ethereum Blockchain. Once the address is provided, the interface makes a connection with a network node that will process the desired transactions and fetch available contract functions.
  All available functions are displayed in the GUI, which features input fields and buttons to facilitate interaction. The GUI shows the return value for functions having 'read' or 'pure' mutability; for transaction-triggering functions, the transaction hash is displayed.
  Notably, this module also permits users to manually input their account details, vital for signing transactions when calling non-read-only functions. Determining the Endpoint URL to connect to an Ethereum node is made simple with the `get_account_layout` and `determine_correct_rpc` functions.
  Operating within a GUI Event Loop, the interface maintains responsiveness and interactive capabilities. When a button associated with a contract function is clicked, input values are collected, the function is executed, and the output is displayed.
  In summary, `abstract_contract_console.py` emulates a local Ethereum interaction console, simplifying users' interactions with the Ethereum Blockchain and providing an all-in-one abstraction service.
  Furthermore, the module features an `abstract_contract_console_main()`. This function leverages various classes from the package for smart contract interaction and accepts an optional 'rpc_list' argument. If no argument is provided, it defaults to the RPC list from the RPCBridge class. To launch a new window titled 'New Blockchain Console,' it retrieves the RPC layout and values, constructs a final layout consisting of the account, ABI, and RPC layouts. The new_window_mgr object's `while_basic()` method responsibly handles the main application loop, managing events and rendering.

  The `abstract_contracts.py` script is a part of the `abstract_blockchain` module which is designed to facilitate the interaction of users with the Ethereum network. The script is built around a suite of utility functions which assist users in communicating with smart contracts on the blockchain, providing an easy and effective way to perform a variety of tasks from simple data conversions to transaction generation.

  1. **Versatile Utility Functions:** The script offers utility functions which handle a wide range of features including estimation of average gas price for transactions, verification and handling of different input types (e.g., boolean, integers, and addresses), and user interaction management through GUIs.
  2. **Data Type Conversion:** It supports conversion of different data types (e.g., addresses, integers, bytes, boolean values, and strings) to their required format for interaction with the Ethereum blockchain.
  3. **User-friendly Interaction:** The script provides a comfortable user interface, allowing for inputs confirmation for a smart contract function or generation of a new transaction.
  4. **Error Handling and Validation:** It manages various situations and edge cases, such as checking the validity of a potential Ethereum address and dealing with batch inputs. It provides intuitive feedback and correction options throughout the code execution.

  The `abstract_contracts.py` script within the abstract_blockchain module is designed to enhance user interaction with blockchain contracts associated with the Ethereum network. This script extensively uses the web3 module to enable these interactions while also leveraging PySimpleGUI to deliver a simple yet effective graphical user interface.
  The script initiates with the importation of needed modules and subsequently defines several utility functions. These functions specialize in aiding users in contract communication and boosting their utilization of smart contracts within the Ethereum network.
  Several features are encompassed by these functions such as average gas price estimation for transactions, verification and management of multiple input types including boolean, integers, and addresses, user interaction facilitation via GUIs, and tasks like check-summing for Ethereum addresses. Further, they empower users to interact directly with the blockchain, such as confirming inputs for a smart contract function or even producing a new transaction.
  The script introduces functions to convert a diverse range of data types to a format that is suitable for the interaction with the Ethereum blockchain. Data types like addresses, integers, bytes, boolean values, and strings are all catered to. They also support list processing of these data types, allowing for batch operations.
  The functions are coded to handle a broad array of situations and edge cases such as validating potential Ethereum addresses and managing batch inputs. The code regularly provides intuitive feedback and correction options. Overall, this script serves as a comprehensive suite of tools for users interested in interacting with smart contract careers on the Ethereum network.

  The abstract_rpcs.py script is part of the Abstract Blockchain package and it offers the RPCBridge class that is designed to manage RPC parameters for different blockchain networks. RPC parameters are necessary for remote procedure calls (RPC), a protocol that one program can use to request a service from a program located in another computer on a network without having to understand the network's details. In the context of blockchain, RPC parameters are used to interact with the blockchain network.
  The RPCBridge class in abstract_rpcs.py provides several key functionalities. It allows users to filter and select RPC parameters through a graphical user interface (GUI), streamlining the process of defining these parameters. This makes it user-friendly even for those without deep knowledge of RPC parameters.
  The RPCBridge class also categorizes and organizes RPC parameters, so that they can easily be used in blockchain interactions. Information is thus made more accessible, and the usage of blockchain technology is simplified as a result.
  Overall, the abstract_rpcs.py script plays a crucial role in the Abstract Blockchain package by providing efficient and streamlined ways to manage RPC parameters, one of the essential parts of interacting with blockchain networks.
  In conclusion, `abstract_blockchain` is a powerful tool that allows developers to interact with Ethereum networks and contracts. While the package is easy to install and use, we always recommend carefully reading the documentation and understanding how blockchain technologies work before getting started. Happy coding!
  For more info regarding license, please visit [here](https://github.com/AbstractEndeavors/abstract_blockchain/blob/main/LICENSE).


pkgId: 64aacd44812d268ac3858210a7762c7d7fa61635c9016a5fb91b9b9f60bc42b3
name: python-abstract-bots
arch: src
version: 0.0.0.95
epoch: 0
release: 1
url: https://github.com/AbstractEndeavors/abstract_ai
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abstract-bots-0.0.0.95-1.src.rpm
checksum_type: sha256
summary:
  This suite of modules not only simplifies the complexities associated with blockchain application development but also ensures high levels of performance and security. By providing tools for detailed data handling, transaction analysis, and secure blockchain interactions, these modules form a comprehensive solution ideal for developers looking to build or maintain advanced Solana-based applications.

description:
  The `abstract_rpcs.py` module contains a comprehensive collection of functions for handling remote procedure calls (RPCs), particularly focusing on blockchain technologies like Solana. It manages directories for storing API calls, fetches and caches responses, and processes asynchronous requests efficiently using threading.

  1. **Singleton Pattern Implementation**:
     - `SingletonMeta`: A metaclass that ensures only one instance of a class is created, making it ideal for managing resources such as API connections or configurations.
     - `directoryStart`: Initializes directories for various data categories such as RPC calls, pool info, and blockchain data.
  2. **RPC Call Management**:
     - `rpcCallManager`: Manages RPC calls, utilizing custom or client RPC endpoints. It handles JSON responses, formats requests, and retries failed requests with exponential backoff.
  3. **Asynchronous and Concurrent Requests**:
     - Utilizes threading to handle concurrent API requests efficiently, reducing wait times and managing rate limits.
  4. **Directory and File Management**:
     - Manages directories for different types of data, ensuring that responses and logs are organized and easily accessible.
  5. **Error Handling and Logging**:
     - Robust error handling mechanisms to gracefully manage and log exceptions, ensuring the stability of the system.
  6. **Utility Functions**:
     - Functions such as `get_all_signatures`, `get_account_info`, and `get_token_supply` to interact with the blockchain and fetch data as needed.

  Here's an example of how you might use the `rpcCallManager` to fetch transaction information for a specific blockchain signature:
  ```python
  from abstract_rpcs import rpcCallManager

  rpc_manager = rpcCallManager()

  signature = "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpHGjqyt2k5zkj"
  transaction_data = rpc_manager.get_transaction(signature)

  print(transaction_data)
  ```

  For handling high-throughput environments, such as trading platforms or data analysis tools, you can leverage the asynchronous features:
  ```python
  from abstract_rpcs import assetRequestManager

  asset_manager = assetRequestManager()

  url = "https://api.dexscreener.com/latest/dex/tokens/solana"

  token_data = asset_manager.dexscreener_api_call(url)

  print(token_data)
  ```


pkgId: 630e797988f04a35b57dea8056049642549337f6ccfd22f1141a97585029631b
name: python-abstract-ip-geolocation-api
arch: src
version: 1.5.2
epoch: 0
release: 1
summary: IP Geolocation API from Abstract to geolocate any IP
url: https://pypi.org/project/abstract-ip-geolocation-api/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abstract-ip-geolocation-api-1.5.2-1.src.rpm
checksum_type: sha256
description:
  Python library for Abstract free IP Geolocation API.

  Full documentation can be found on Abstract [IP Geolocation API](https://www.abstractapi.com/ip-geolocation-api) page.



  Getting started with Abstract IP Geolocation API is very simple, you just need to install the library into your project as follow:

  ```python
  pip install abstract-ip-geolocation-api
  ```

  From there you can then call the geolocationapi as follow:

  ```python

  import importlib
  abstract_ip_geolocation_api = importlib.import_module("abstract-ip-geolocation-api")


  geolocation_api = abstract_ip_geolocation_api.v1('YOUR_API_KEY')



  location_data = geolocation_api.geolocate(ip_address="ANY_IP_ADDRESS")


  if 'ip_address' in location_data:
      
      country = location_data['country']
      city = location_data['city']
      print(country)
  elif 'error' in location_data:
      
      error = location_data['error']
      print(error)
  else:
      
      print('No location data available for this IP')
  ```


pkgId: 28f2e2734fa391e6551b4d1202970f0cb73c9a7fef9a893ba21ed6093252b48d
name: python-abstract-math
arch: src
version: 0.0.0.4
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/abstract-math/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abstract-math-0.0.0.4-1.src.rpm
checksum_type: sha256
description:
  Safe math for delicate Processes, paralell in use case to SafeMath For SmartContracts in that it is designed to circumvent fatal errors for low level MDAS.


pkgId: a90ffbbcbea6c1a3a4e6e6b60bfaf548bd24689814803838921b1ed23e6e929e
name: python-abstract-security
arch: src
version: 0.55
epoch: 0
release: 1
url: https://github.com/AbstractEndeavors/abstract_security
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abstract-security-0.55-1.src.rpm
checksum_type: sha256
summary:
  The `abstract_security` module is a Python utility that provides functionality for managing environment variables and securely loading sensitive information from `.env` files. It is designed to simplify the process of accessing and managing environment variables within your Python applications.

description:
  For more information and usage examples, please refer to the [GitHub repository](https://github.com/AbstractEndeavors/abstract_security) and [PyPI package](https://pypi.org/project/abstract-security/).
  If you encounter any issues or have questions, feel free to open an issue on GitHub or contact the author, putkoff, for assistance.

  **Author**: putkoff
  **Email**: partners@abstractendeavors.com
  **Project Link**: [https://github.com/AbstractEndeavors/abstract_security](https://github.com/AbstractEndeavors/abstract_security)


pkgId: 809442445bf20aec3967f7acab30c75b8d82ae0fb64779b9476dc01af52d5051
name: python-abstract-solcatcher
arch: src
version: 0.0.3.31
epoch: 0
release: 1
url: https://github.com/AbstractEndeavors/abstract_solcatcher
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abstract-solcatcher-0.0.3.31-1.src.rpm
checksum_type: sha256
summary:
  `abstract_solcatcher` provides a comprehensive solution for making HTTP requests specifically tailored for interacting with Solcatcher.io's APIs. It simplifies complex tasks such as data fetching, data manipulation, and interacting with the Flask backend of Solcatcher.io. This module abstracts API calls and Flask requests, providing utility functions that make it easier to perform these operations.

description:
  The `abstract_solcatcher` package provides a comprehensive solution for making HTTP requests specifically tailored for interacting with Solcatcher.io's APIs. It simplifies complex tasks such as data fetching, data manipulation, and interacting with the Flask backend of Solcatcher.io. This module abstracts API calls and Flask requests, providing utility functions that make it easier to perform these operations.

  - **API Calls**: Facilitates making custom API requests to Solcatcher.io with specific endpoints.
  - **Flask Backend Interaction**: Manages interactions with a Flask backend, including viewing and listing database tables and columns.
  - **Data Handling**: Provides functions to handle and manipulate data before sending it in requests.

  - **Abstract Call**: Handles direct API interactions with functions that tailor requests for specific Solcatcher.io endpoints.
  - **Abstract Flask**: Manages requests to the Flask backend, providing functions to view and list database tables, as well as retrieve specific table columns.
  - **Utilities**: Contains helper functions that return standard URLs and endpoints, and help in updating data payloads.

  To install the `abstract_solcatcher` package, use the following pip command:
  ```bash
  pip install abstract_solcatcher
  ```


  To make a custom API call to retrieve metadata:
  ```python
  from abstract_solcatcher import getCallRequest
  response = getCallRequest('getMetaData', signature='your_signature_here')
  print(response)
  ```

  To view a specific table in the database:
  ```python
  from abstract_solcatcher import view_table
  response = view_table('your_table_name')
  print(response)
  ```

  To list all tables in the database:
  ```python
  from abstract_solcatcher import list_tables
  tables = list_tables()
  print(tables)
  ```

  - Python 3.6+
  - `requests` library
  - `abstract_apis`
  - `abstract_utilities`

  Contributions to enhance the functionalities of `abstract_solcatcher` are welcome. Please fork the [GitHub repository](https://github.com/AbstractEndeavors/abstract_solcatcher), make your changes, and submit a pull request.

  This project is licensed under the MIT License - see the LICENSE file for details.


pkgId: 7ed13b2c7641fe32c8fa474eb055c6554f7c71422697f9f05bc82e9feb1a2e6c
name: python-abstract-solcatcher
arch: src
version: 0.0.3.66
epoch: 0
release: 1
url: https://github.com/AbstractEndeavors/abstract_solcatcher
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abstract-solcatcher-0.0.3.66-1.src.rpm
checksum_type: sha256
summary:
  `abstract_solcatcher` provides a comprehensive solution for making HTTP requests specifically tailored for interacting with Solcatcher.io's APIs. It simplifies complex tasks such as data fetching, data manipulation, and interacting with the Flask backend of Solcatcher.io.

description:
  The `abstract_solcatcher` package provides a comprehensive solution for making HTTP requests specifically tailored for interacting with Solcatcher.io's APIs. It simplifies complex tasks such as data fetching, data manipulation, and interacting with the Flask backend of Solcatcher.io. This module abstracts API calls and Flask requests, providing utility functions that make it easier to perform these operations.

  - **API Calls**: Facilitates making custom API requests to Solcatcher.io with specific endpoints.
  - **Flask Backend Interaction**: Manages interactions with a Flask backend, including viewing and listing database tables and columns.
  - **Data Handling**: Provides functions to handle and manipulate data before sending it in requests.

  - **Abstract Call**: Handles direct API interactions with functions that tailor requests for specific Solcatcher.io endpoints.
  - **Abstract Flask**: Manages requests to the Flask backend, providing functions to view and list database tables, as well as retrieve specific table columns.
  - **Utilities**: Contains helper functions that return standard URLs and endpoints, and help in updating data payloads.

  To install the `abstract_solcatcher` package, use the following pip command:
  ```bash
  pip install abstract_solcatcher
  ```


  To make a custom API call to retrieve metadata:
  ```python
  from abstract_solcatcher import getCallRequest
  response = getCallRequest('getMetaData', signature='your_signature_here')
  print(response)
  ```

  To view a specific table in the database:
  ```python
  from abstract_solcatcher import view_table
  response = view_table('your_table_name')
  print(response)
  ```

  To list all tables in the database:
  ```python
  from abstract_solcatcher import list_tables
  tables = list_tables()
  print(tables)
  ```

  - Python 3.6+
  - `requests` library
  - `abstract_apis`
  - `abstract_utilities`

  Contributions to enhance the functionalities of `abstract_solcatcher` are welcome. Please fork the [GitHub repository](https://github.com/AbstractEndeavors/abstract_solcatcher), make your changes, and submit a pull request.

  This project is licensed under the MIT License - see the LICENSE file for details.


pkgId: 47aed9608b937fa6db45a278b76d0a297a62c67ec359af749ab4188f9a8e1003
name: python-abstract-test-package
arch: src
version: 0.0.4
epoch: 0
release: 1
url: https://github.com/AbstractEndeavors/abstract_test_package
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abstract-test-package-0.0.4-1.src.rpm
checksum_type: sha256
summary:
  abstract_test_package is a Python package that facilitates testing with abstract scenarios. Utilizing PyTest, it offers extra utilities to streamline the creation and execution of abstract tests.

description:
  This is a Python package that facilitates testing with abstract scenarios. Utilizing PyTest, it offers extra utilities to streamline the creation and execution of abstract tests.

  You can locate this package in the `abstract_essentials` project at `github.io/abstract_endeavors/abstract_essentials/abstract_test_package/`.



  You can install the `abstract_test_package` module via pip:

  ```sh
  pip install abstract_test_package
  ```

  Or directly from the source:

  ```sh
  git clone https://github.io/abstract_endeavors/abstract_essentials/abstract_test_package/
  cd abstract_test_package
  python setup.py install
  ```



  Below is a usage example of the `abstract_test_package`:

  ```python
  from abstract_test_package import create_test, execute_test

  test = create_test(name="Test 1", scenario=[...])
  execute_test(test)
  ```

  This example creates an abstract test and then executes it.



  The `abstract_test_package` module provides the following classes and functions:



  Generates an abstract test scenario with the provided name and details.



  Executes the given abstract test scenario.



  Verifies if the given object is a valid test scenario.



  Calculates the results of a given abstract test scenario.



  Compares two test scenarios and returns True if their results are equivalent, False otherwise.

  ... and many more!

  Please refer to the source code for the complete list of classes and functions provided by the module, as well as their detailed documentation.



  Contributions are welcome! Please fork this repository and open a pull request to add snippets, make grammar tweaks, etc.



  If you have any questions, feel free to reach out to us at partners@abstractendeavors.com.



  This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.



  * putkoff - main developer

  This README file was last updated on May 29, 2023.


pkgId: d38829ecd42270471179278f097a2fbd8d5f0eb4184205557f233c0242c2c554
name: python-abstract-utilities
arch: src
version: 0.2.2.81
epoch: 0
release: 1
url: https://github.com/AbstractEndeavors/abstract_essentials/tree/main/abstract_utilities
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abstract-utilities-0.2.2.81-1.src.rpm
checksum_type: sha256
summary:
  abstract_utilities is a collection of utility modules providing a variety of functions to aid in tasks such as data comparison, list manipulation, JSON handling, string manipulation, mathematical computations, and time operations.

description:
   

    Abstract Utilities is a comprehensive collection of utility modules assembled to assist a multitude of common tasks. The aim of this collection is to eliminate the need to perpetually rewrite trivial but essential functions that are frequently used across projects. With minimal dependencies, this suite is an amalgam of bare essential functions, ranging from data comparison, string manipulation, mathematical operations, time tracking to JSON handling and others.

    The module's ease of use and detailed implementation allow for practical and efficient usage across different programs.


    - [Introduction](#abstract-utilities)
    - [Modules](#modules)
    - [Installation](#installation)
    - [License](#license)



    The package can be installed via pip by entering the following command:

    ```
    pip install abstract_utilities
    ~~or~~
    pip3 install abstract_utilities
    ```
    Ensure that you're using Python 3.11 or later, and the following dependencies are installed: 'pathlib>=1.0.1', 'abstract_security>=0.0.1', 'yt_dlp>=2023.10.13', 'pexpect>=4.8.0'.

    After you've installed the module, you can import any utility into your scripts using:
    ```
    from abstract_utilities import module_name
    ```



    The repository contains several utility files, each dealing with a specific theme or operation. For example, `compare_utils.py` handles string and object comparison, `list_utils.py` helps with list manipulation, `json_utils.py` deals with JSON handling, and so on.

    In-depth analysis and explanation of each utility will be provided in the upcoming sections. On a high level, utilities covered are:
    - Class utilities
    - Command line utilities
    - Collator utilities
    - Comparison utilities
    - Global utilities
    - History utilities
    - JSON utilities
    - List utilities
    - Math utilities
    - Path utilities
    - Read-Write utilities
    - String utilities
    - Thread utilities
    - Time utilities
    - Type utilities



  Abstract Utilities is licensed under the MIT License.




  This module includes helper methods tailored for manipulating and handling classes, objects, and modules. Some of the operations accomplished in the class utilities module include:

  - Fetching and verifying object types.
  - Manipulating global variables.
  - Checking an object's membership status in a module.
  - Inspecting function signatures and their arguments within a module.
  - Executing functions with supplied arguments.
  - Converting layout definitions into components.
  - Accessing attributes and methods of a module.



  1. **get_type_list:** This function helps to procure a list of common Python types.
  2. **remove_key:** This function is used to remove a specific key from a provided dictionary.
  3. **get_module_obj:** This function facilitates the retrieval of an object from a specified module.
  4. **spec_type_mod:** This function checks whether an object matches a specific type.
  5. **get_type_mod:** This function retrieves the type of a given object.
  6. **is_module_obj:** This function checks if a provided object is part of a module.
  7. **inspect_signature:** This function fetches the signature of a specified function within a module.
  8. **get_parameter_defaults:** This method helps in fetching the default parameter values for a provided function in a module.
  9. **convert_layout_to_components:** This utility converts a layout definition to its component representation.
  10. **get_dir:** This function aids in listing all attributes and methods of a specified module.
  11. **get_proper_args:** This function calls a function using either positional or keyword arguments based on the args type.
  12. **get_fun:** This method parses a dictionary to retrieve a function and call it.
  13. **if_none_change:** This function replaces a None object with a default value.
  14. **call_functions:** Executes a specified function or method using provided arguments.
  15. **process_args:** Evaluates and processes nested function calls in arguments.
  16. **has_attribute:** Checks if a function exists in a module.
  17. **get_all_functions_for_instance:** Retrieves all callable methods/functions of an object instance.



  This utility module depends on two other Python modules: 'inspect' and 'json'. Each utility method in the module has its own docstring, offering a more in-depth explanation of its purpose, expected inputs, and outputs.


  The `command_utils.py` houses a collection of utilities for executing commands with various functionalities, including handling of sudo, logging outputs, and interacting with commands that expect input.



  1. **get_all_params(instance, function_name)**: This function retrieves information about the parameters of a callable method/function of an instance.

  2. **mk_fun(module,function)**: This function checks if a function exists in a given module and prints a statement indicating whether the function exists or not.

  3. **get_output_text(parent_dir)**: Provides the path to an 'output.txt' file in a given directory.

  4. **get_env_value(key, env_path)**: Fetches the environment value associated with a provided key from a specific .env file path.

  5. **print_cmd(input, output)**:Prints the executed command alongside its corresponding output.

  6. **get_sudo_password(key)**: Retrieves the sudo password stored in an environment file.

  7. **cmd_run_sudo(cmd, password, key, output_text)**: Executes a command with sudo privileges, either using a given password or retrieving it from an environment file.

  8. **cmd_run(cmd, output_text)**: Executes a command and captures its output in a specified file.

  9. **pexpect_cmd_with_args(command, child_runs, output_text)**: Interacts with a command's expected input using the pexpect library and logs the command's output.

  10. **get_output(p)**: This function retrieves the output generated by a subprocess command execution.

  11. **get_cmd_out(st)**: This function executes a shell command and retrieves the output generated by the command's execution.


  - os
  - time
  - pexpect
  - subprocess
  - abstract_security.envy_it: find_and_read_env_file, get_env_value
  - abstract_utilities.time_utils: get_sleep


  - Ensure the necessary dependencies are installed.
  - Make sure you have appropriate permissions to execute commands, especially sudo-based ones.
  - Always keep environment files secure and away from public access to ensure sensitive information like passwords remains confidential.


  CommandLine utilities provide functions to interface with command line and appropriately handle its output and prompts. The utility includes methods for executing shell commands (including sudo commands), handling command prompts, and retrieving environment values.

  Below are descriptions for some of the key functions available in the command line utilities section:

  - `cmd_input(st: str) -> subprocess.Popen`
      - This function executes a shell command using subprocess module. It takes a command string as an argument and returns a subprocess.Popen object for communication.

  - `get_output_text(parent_dir: str = os.getcwd()) -> str`
      - This function fetches the path to the 'output.txt' file in the provided directory. If no directory is provided it takes the current working directory.

  - `get_env_value(key: str = None, env_path: str = None) -> str`
     - This function retrieves an environment value based on a key from a specified .env file.

  - `print_cmd(input: str, output: str) -> None`
      - This function prints the input command along with its corresponding output.

  - `cmd_run_sudo(cmd: str, password: str = None, key: str = None, output_text: str = None) -> None`
      - This function executes a command with sudo privileges.

  - `cmd_run(cmd: str, output_text: str = None) -> None`
      - This function executes a command and logs its output in a specified file.

  - `pexpect_cmd_with_args(command: str, child_runs: list, output_text: str = os.getcwd()) -> int`
      - This function executes a command using pexpect and handles its prompts with specified responses.



  Collator utilities offer functions related to operations with alphabets and numbers. It includes generating lists of alphabetic characters and numbers, finding an index of a character in a list, and more.

  Key functions available in the collator utilities section are:

  - `get_alpha_list() -> list`
      - This function generates a list containing all lowercase alphabets.

  - `get_num_list() -> list`
      - This function generates a list of numbers in string format.

  - `find_it_alph(ls: list, y: any) -> int`
     - This function finds the index of an element in a list.

  - `get_alpha(k: Union[int,float]) -> str`
      - This function retrieves the alphabetic character corresponding to the given index.



  Compare Utilities offer functions for comparing strings and objects. These include methods for calculating string similarity and comparing the lengths of objects.


  This section provides information about different functions present in the `compare_utils.py` module. These functions aid in various string comparison operations, counting specific characters in a string, safely getting length of the string etc.

  Functions include:

  - `get_comp(string:str, string_2:str)` : This function calculates the similarity between two strings based on overlapping sequences of characters.

  - `get_lower(obj, obj2)` : This function compares the lengths of two objects or their string representations and returns the one with shorter length.

  - `is_in_list(obj: any, ls: list = [])` : This function checks whether a given object is present in the list or not.

  - `safe_len(obj: str = '')` : This function gets the length of the string representation of a given object in a manner that avoids exceptions.

  - `line_contains(string: str = None, compare: str = None, start: int = 0, length: int = None)` : This function checks whether a substring is present in another string starting from a specific index.

  - `count_slashes(url: str) -> int` : This function counts the number of slashes in a given URL.

  - `get_letters() -> list` : This function returns a list of lowercase letters from 'a' to 'z'.

  - `get_numbers() -> list` : This function returns a list of numeric digits from 0 to 9.

  - `percent_integer_of_string(obj: str, object_compare: str = 'numbers') -> float` : This function calculates the percentage of characters in a string that are either letters or numbers.

  - `return_obj_excluded(list_obj:str, exclude:str, substitute='*')` : This function replaces all occurrences of a specified substring with a substitute string in a given list_obj.

  - `determine_closest(string_comp:str, list_obj:str)` : This function finds the closest consecutive substrings from comp in list_obj.

  - `longest_consecutive(list_cons:list)` : This function calculates the length of the longest consecutive non-empty elements in a list of strings.

  - `combined_list_len(list_cons:list)` : This function calculates the total length of a list of strings by summing their individual lengths.

  - `percent_obj(list_cons:list, list_obj:str)` : This function calculates the percentage of the combined length of a list of strings relative to the length of a target string.

  - `get_closest_match_from_list(comp_str:str, total_list:list, case_sensative:bool=True)` : This function finds the closest match from a list of strings based on various criteria such as longest consecutive substring, combined length of consecutive substrings, and percentage of combined length relative to the length of the target string.

  - `untuple(obj)` : This function returns the first element of a tuple if the provided input is a tuple.


  The `compare_utils.py` module provides functions that help compare and identify patterns or similarities between strings or group of strings.

  `get_closest_match_from_list(comp_str:str, total_list:list,case_sensative:bool=True)`

  This function finds the closest match from a list of strings to a target string based on various criteria such as longest consecutive substring, combined length of consecutive substrings, and percentage of combined length relative to the length of the target string. It returns the string from the list that best matches the target, or None if no match is found.

  `make_list(obj)`

  Converts an object into a list. Valid for set and tuple types.

  `create_new_name(name=None, names_list=None, default=True, match_true=False, num=0)`

  Creates a new name that does not exist in provided list of names. It can be used to avoid name collision when generating file names, variable names, etc. The function generates a unique name by appending an incrementing number at the end. The base name and the list of existing names can be provided as arguments. If not provided, it uses 'Default_name' as the base name.

  `get_last_comp_list(string, compare_list)`

  Finds and returns the last string in the 'compare_list' that contains the target 'string'. Returns None if no match is found.





  In `global_utils.py`, it provides functions to manage and manipulate global variables.

  `global_registry(name:str,glob:dict)`

  It records the name and the dictionary of a global variable to a global registry. If the name is not in the registry, it adds it and the provided dictionary. It returns the index of the name in the registry.

  `get_registry_number(name:str)`

  It returns the index of a name in the registry.

  `update_registry(var:str, val:any, name:str)`

  It updates a global variable with a new value.

  `get_global_from_registry(name:str)`

  It gets a dictionary of a global variable recorded in the registry using the name as reference.

  `return_globals() -> dict`

  It returns the global variables dictionary.

  `change_glob(var: str, val: any, glob: dict = return_globals()) -> any`

  It changes the value of a global variable and returns the new value.

  `get_globes(string:str='', glob:dict=return_globals())`

  It gets a specified global variable.

  `if_none_default(string:str, default:any, glob:dict=return_globals())`

  It checks if a global variable is `None`, if it is, it assigns it a default value and updates the global variable.





  The `history_utils.py` module comprises the `HistoryManager` class which allows to handle the history of objects, states or actions for undo/redo features.

  `HistoryManager()`

  This is the constructor for the `HistoryManager` class. It initializes a 'history_names' dictionary to store the history of different objects.

  `add_history_name(self, name, initial_data='')`

  This method adds a new object to the history with an initial state.

  `transfer_state(self, primary_data, secondary_data)`

  This method transfers the latest state from primary_data to secondary_data and returns the modified primary and secondary data.

  `add_to_history(self, name, data)`

  This method adds a new state to the history of an object.

  `redo(self, name)`

  This method reverts the object to the next state in the redo history. If no redo history exists, the object remains unchanged.


  'json_utils' is a utility module that allows you to work with JSON data. Its functionalities include:
  1. Converting JSON strings to dictionaries and vice versa.
  2. Merging, adding to, updating, and removing keys from dictionaries.
  3. Retrieving keys, values, specific items, and key-value pairs from dictionaries.
  4. Recursively displaying values of nested JSON data structures with indentation.
  5. Loading from and saving dictionaries to JSON files.
  6. Validating and cleaning up JSON strings.
  7. Searching and modifying nested JSON structures based on specific keys, values, or paths.
  8. Inverting JSON data structures.
  9. Creating and reading from JSON files.

  The module contains functions like 'json_key_or_default', 'all_try_json_loads', 'safe_dump_to_file', etc. Each function comes with elaborate Python docstrings that provide detailed usage instructions.

  The utility, for instance, provides a function named 'create_and_read_json' that allows you to create a JSON file if it does not exist, and then read from it. It also offers functions like 'is_valid_json' which checks whether a given string is a valid JSON string.

  Take this function 'safe_write_to_json', it safely writes data to a JSON file. If an error occurs during writing, the data is written to a temporary file first, and then the temporary file is replaced with the original one.

  Other functions like 'safe_read_from_json', 'find_keys', 'all_try', 'safe_json_loads', 'try_json_loads', and 'unified_json_loader' provide ways to work with JSON data and make handling JSON in Python easier and more efficient.
  []


  This module contains utility functions for processing file paths, directories, and files. This includes operations such as getting the home directory, checking if a path is a file, updating global variables, listing directory contents, and working with file sizes and directory sizes. The implemented functions are:

  - `get_home_folder()`: This function returns the path to the home directory of the current user.

  - `is_file(path: str) -> bool`: This function checks if the provided path is a file.

  - `update_global_variable(name: str, value) -> None`: This function updates the global variable with the provided name and value.

  - `list_directory_contents(path: str) -> list`: This function returns a list of directory contents or a list with a single file, if the path is a file.

  - `trunc(a: float, x: int) -> float`: This function truncates a float number to a specific number of decimal places.

  - `mkGb(k) -> float`: This function converts a value to Gigabytes (GB).

  - `mkGbTrunk(k) -> float`: This function converts a value to GB and truncates the result to five decimal places.

  - `mkGbTrunFroPathTot(k) -> float`: This function fetches the file size from a path, converts it to GB, and truncates the result to five decimal places.

  - `get_abs_name_of_this() -> Path`: This function returns the absolute name of the current module.

  - `createFolds(ls: list) -> None`: This function creates multiple directories from a list of paths.

  - `mkdirs(path: str) -> str`: This function creates a directory and any necessary intermediate directories.

  - `file_exists(file_path: str) -> bool`: This function checks if a file exists at the specified path.

  - `dir_exists(path: str) -> bool`: This function checks if a directory exists at the specified path.

  - `file_size(path:str)`: This function returns the size of a file in bytes, if the path is a file, else it returns 0.

  - `get_size(path: str) -> int`: This function calculates the size of a file or a directory in bytes.

  - `get_total_size(folder_path: str) -> int`: This function calculates the total size of a directory and its subdirectories in bytes.

  - `get_files(directory)`: This function returns a list of all files in a directory including the ones in its subdirectories.


  For detailed information about each function, please refer to their respective documentation in the module.


  The `read_write_utils.py` module contains a variety of utility functions to assist with file I/O operations. If you need to perform read or write operations to files in your software, this utility can ease the process and shorten your codebase. Notably, it enables you to quickly write contents to a file, read contents from a file, or check if a string includes a file extension.

  Here are the primary functions:

  1. **Write content to a file**
  ```python
  read_write_utils.write_to_file(file_path: str, contents: any)
  ```
  This function writes the provided contents to a file at the specified path. If the file doesn't exist, it will be created.

  2. **Read content from a file**
  ```python
  read_write_utils.read_from_file(file_path: str)
  ```
  This function reads and returns the contents of a file at the specified file path.

  3. **Check if a string has a file extension**
  ```python
  read_write_utils.is_file_extension(obj: str)
  ```
  This function checks whether a provided string includes a file extension and returns a boolean value accordingly.

  4. **Read from or write to a file depending on the number of arguments**
  ```python
  read_write_utils.determine_path_and_content(*args,**kwargs)
  ```
  This function determines the file path and the contents based on the provided arguments. It can be used when you want to infer the operation (read/write) based on the kind and count of arguments.

  5. **Create a file if it does not exist, then read from it**
  ```python
  read_write_utils.create_and_read_file(file_path: str, contents: str)
  ```
  This function attempts to open a file from its path. If the file doesn't exist, it creates the file, writes the provided contents to it, and then reads the file content back.

  All the utility functions are designed to be easily incorporated into your code and have detailed docstrings explaining their usage.

  **Note**: All file paths need to be absolute paths, and the file operations are conducted with 'UTF-8' encoding. If a function is called with incorrect arguments, it will alert the user with an 'Too many arguments' or 'Missing file path or contents.' message.

  Please refer to the `read_write_utils.py` source code for more details and to understand the inner workings of these utilities for optimal usage.
  []


  - **all_alive**: This method returns a dictionary indicating whether each thread is alive or not. The keys are the thread names, and the values are boolean.
  - **all_thread_names**: This method returns the keys (names) of all threads in the dictionary.
  - **get_last_result**: In the absence of a specific thread name, this method returns the result of the last thread in `thread_name_list`. If a thread name is specified, it first checks the validity of the name using `check_name` and then returns the result.
  - **check_name**: This method checks if the provided thread name is present in existing threads.


  - **get_time_stamp**: Returns the current timestamp in seconds.
  - **get_milisecond_time_stamp**: Returns the current timestamp in milliseconds.
  - **get_day**: Returns the current day of the week.
  - **get_date**: Returns the current date in YYYY-MM-DD format.
  - **save_last_time**: Saves the last timestamp to a file named 'last.txt'.
  - **get_day_seconds**: Returns the number of seconds in a day.
  - **get_week_seconds**: Returns the number of seconds in a week.
  - **get_hour_seconds**: Returns the number of seconds in an hour.
  - **get_minute_seconds**: Returns the number of seconds in a minute.
  - **get_24_hr_start**: Returns the timestamp for the start of the current day.
  - **create_timestamp**: Accepts a date string and military time string to create a timestamp.


  `time_utils` is a module in `abstract_utilities` that provides functions to work with time stamps, get the current date and time, and manage chronological operations.

  Here is an example of a function provided in this module:

  - `get_second()`: This function returns the value of one second as a float.

  Additional functions in time utilities include:
  - `get_time_stamp()`
  - `get_milisecond_time_stamp()`
  - `get_day()`
  - `get_time()`
  - `get_date()`
  - `save_last_time()`
  - `get_day_seconds()`
  - `get_week_seconds()`
  - `get_hour_seconds()`
  - `get_minute_seconds()`
  - `get_24_hr_start()`

  Each function in the `time_utils` module provides a unique operation relating to time management in your programs.



  `type_utils` is another utility module that provides type checking and conversion functionality. This module incorporates features such as determining the type of an object, checking if an object is of a certain type, and facilitating type conversion. This simplifies data handling across different data types and ensures consistent behavior.

  Some mainstay functions within this module include:
  - `is_iterable(obj: any) -> bool`
  - `is_number(obj: any) -> bool`
  - `is_str(obj: any) -> bool`
  - `is_int(obj: any) -> bool`
  - `is_float(obj: any) -> bool`
  - `is_bool(obj: any) -> bool`
  - `is_list(obj: any) -> bool`
  - `is_tuple(obj: any) -> bool`
  - `is_set(obj: any) -> bool`
  - `is_dict(obj: any) -> bool`
  - `is_frozenset(obj: any) -> bool`
  - `is_bytearray(obj: any) -> bool`
  - `is_bytes(obj: any) -> bool`
  - `is_memoryview(obj: any) -> bool`
  - `is_range(obj: any) -> bool`
  - `is_enumerate(obj: any) -> bool`
  - `is_zip(obj: any) -> bool`
  - `is_filter(obj: any) -> bool`
  - `is_map(obj: any) -> bool`
  - `is_property(obj: any) -> bool`
  - `is_slice(obj: any) -> bool`
  - `is_super(obj: any) -> bool`
  - `is_type(obj: any) -> bool`
  - `is_Exception(obj: any) -> bool`
  - `is_none(obj: any) -> bool`
  - `is_str_convertible_dict(obj: any) -> bool`
  - `is_dict_or_convertable(obj: any) -> bool`
  - `dict_check_conversion(obj: any) -> Union[dict, any]`

  These functions and more form the `type_utils` module, playing an integral part in ensuring type compatibility and facilitating data conversion.




  The `type_utils.py` module encompasses numerous functions that help in identifying the type of data structures, converting strings to their appropriate data types, and checking if the data can be represented in a specific format. Here is a description of the functions available in this module.


  Determines whether the given object is iterable or not.


  Determines the type of the given object and updates it accordingly.


  Checks whether the given object can be represented as a number.


  Checks whether the given object is of type 'object'.


  Checks whether the given object is of type 'str'.


  Checks whether the given object is of type 'int'.


  Checks whether the given object is of type 'float'.


  Checks whether the given object is of type 'bool'.

  The following functions check if the object is of respective data types (list, tuple, dictionary, frozenset, bytearray etc.)
  - is_list(obj)
  - is_tuple(obj)
  - is_set(obj)
  - is_dict(obj)
  - is_frozenset(obj)
  - is_bytearray(obj)
  - is_bytes(obj)
  - is_memoryview(obj)
  - is_range(obj)
  - is_enumerate(obj)
  - is_zip(obj)
  - is_filter(obj)
  - is_map(obj)
  - is_property(obj)
  - is_slice(obj)
  - is_super(obj)
  - is_type(obj)
  - is_Exception(obj)
  - is_none(obj)


  Converts the given object to a dictionary if possible, otherwise returns the original object.


  Converts the given object to a list if it's not already a list.


  Converts all string elements in a list to lowercase.

  Please note to replace `obj` and `ls` with the object and list you want to analyze or manipulate, respectively.


pkgId: 35ba9990917bde9e7c646f4e63e4fd57885d52a0f03ae37951ce00f40bc7858d
name: python-abstract-webtools
arch: src
version: 0.1.5.81
epoch: 0
release: 1
url: https://github.com/AbstractEndeavors/abstract_essentials/tree/main/abstract_webtools
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abstract-webtools-0.1.5.81-1.src.rpm
checksum_type: sha256
summary:
  Abstract Web Tools is a Python package that provides various utility functions for web scraping tasks. It is built on top of popular libraries such as `requests`, `BeautifulSoup`, and `urllib3` to simplify the process of fetching and parsing web content.

description:
  Abstract Web Tools is a Python package that provides various utility functions for web scraping tasks. It is built on top of popular libraries such as `requests`, `BeautifulSoup`, and `urllib3` to simplify the process of fetching and parsing web content.


pkgId: 12d1c6929076cd287831ee8717b0fcd8290d6fc3858e4f49abcf3777aa54099c
name: python-abstractTrade-simpleTrade
arch: src
version: 0.1.11
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/abstractTrade-simpleTrade/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abstractTrade-simpleTrade-0.1.11-1.src.rpm
checksum_type: sha256
description:
  This project is responsible to hold the abstraction for the flowing class and ensure they will
  work and have the same structure on other projects.

  - Initialization
  - Rates
  - Tick
  - Timeframe
  - Trade


pkgId: 464fd1ae05866082c89459404e58da07eb891fa856b66022d1126b1dbfa2c4f2
name: python-abstractcp
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Create abstract class variables
url: https://github.com/reinhrst/abstractcp
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abstractcp-1.0.0-1.src.rpm
checksum_type: sha256
description:
  ![Tox tests](https://github.com/reinhrst/abstractcp/workflows/Tox%20tests/badge.svg)


  This package allows one to create classes with abstract class properties.
  The initial code was inspired by [this question][1] (and accepted answer) -- in
  addition to me struggling many time with the same issue in the past.
  I first wanted to just post this as separate answer, however since it includes quite
  some python magic, and I would like to include quite some tests (and possibly update
  the code in the future), I made it into a package (even though I'm not a big fan of
  small packages that hardly do anything).

  The package is python3.8 and higher (version 0.9.9 runs on 3.6-3.11).


  Note: the examples use [PEP-526 type hints][3]; this is obviously optional.

  All examples assume the following imports:
  ```python
  import tying as t
  import abstractcp as acp
  ```
  Note that all typing (including the `import typing as t` is optional.
  In addition, for python < 3.8, the `Literal` type hint can be found in
  `typing_extensions`.

  ```python
  class Parser(acp.Abstract):
      PATTERN: str = acp.abstract_class_property(str)

      @classmethod
      def parse(cls, s):
          m = re.fullmatch(cls.PATTERN, s)
          if not m:
              raise ValueError(s)
          return cls(**m.groupdict())

  class FooBarParser(Parser):
      PATTERN = r"foo\s+bar"

      def __init__(...): ...

  class SpamParser(Parser):
      PATTERN = r"(spam)+eggs"

      def __init__(...): ...
  ```

  Example with (more) type hints:
  ```python
  class Array(acp.Abstract):
      payload: np.ndarray
      DIMENSIONS: int = acp.abstract_class_property(int)

      def __init__(self, payload):
          assert len(payload) == type(self).DIMENSIONS

  class Vector(Array):
      DIMENSIONS: t.Literal[1] = 1

  class Matrix(Array):
      DIMENSIONS: t.Literal[2] = 2
  ```
  Note that in the previous example, we actually fix the value for `DIMENSIONS` using `t.Literal`.
  This is allowed in mypy (however it may actually be a bug that it's allowed).
  It would possibly feel more natural to use a `t.Final` here, however mypy doesn't allow this.

  Note that if we forget to assign a value for DIMENSIONS, an error will occur:
  ```python
  class OtherArray(Array):
      pass

  > TypeError: Class OtherArray must define abstract class property DIMENSIONS, or have Abstract as direct parent
  ```
  In some cases, however, we might indeed intend for the `OtherArray` class to be abstract as well (because we will subclass this later). If so, make OtherArray inherit from Abstract directly to fix this:
  ```python
  class OtherArray(Array, acp.Abstract):
     ...

  class OtherVector(OtherArray):
      DIMENSIONS = 1
  ```


  I quite often find myself in a situation where I want to store some configuration in a class-variable, so that I can get different behaviour in different subclasses.
  Quite often this starts with a top-level base class that has the methods, but without a reasonable value to use in the configuration.
  In addition, I want to make sure that I don't accidentally forget to set this configuration for some child class -- exactly the behaviour that one would expect from abstract classes.
  However Python doesn't have a standard way to define abstract class variables (or class constants).
  The search for a solution initially led me to [this question][1] -- the accepted answer works well, as long as you accept that each subclass of the parent must be non-abstract.
  In addition, it would not play nice at all with type-hinting and tools like `mypy`.

  So I decided to write something myself -- it started as a small StackOverflow answer, however since I felt lots of tests and docs would be required, better make it a proper module.


  I had some clear requirements in mind when writing this package:
  * Pythonic syntax
  * Works well with [PEP-526 style type hints][3] and static type checkers (if possible without any `# type: ignore` in either this code, and the code using this module).
  * No runtime slowdowns (i.e.: all the work gets done at setup-time)
  * Useful error messages -- stuff needs to be explicit, no silent failures.
  * No need to define all abstract class properties directly in the first child -- so an abstract class can have abstract children.


  The package is a 100% python package. Installation is as simple as
  ```bash
  pip install abstractcp
  ```


  The system consists of 2 elements: The `Abstract` base class.
  Each class that is abstract (i.e. that has abstract class properties -- this is completely independent of the ways to make a class abstract in `abc`) must inherit _directly_ from `Abstract`, meaning that `Abstract` should be a direct parent. This is done so that it's explicit which classes are abstract (and hence, we can throw an error if a class is abstract and does not inherit _directly_ from `Abstract`).

  The second part of the system is the `_AbstractClassProperty` class.
  Every abstract class property gets assigned an `_AbstractClassProperty()` instance, through the `acp.abstract_class_property(...)` method. Note that this method has typehints to  return the exact class that you provide, so from a type checker point of view, `acp.abstract_class_property(int)` is identical to `3` (or `4`, or any other `int` instance). This means that we can be more flexible here, for instance doing `acp.abstract_class_property(t.Dict[str, int])`, however note that `acp.abstract_class_property(t.Mapping[str, int])` does not work, since mypy wants a concrete type there.

  Note that `abstract_class_property()` can only be assigned in classes that have `Abstract` as direct parent.


  See the Examples section above for exact use.


  Note that since 0.9.1 the syntax has changed a bit.
  Rather than writing:
  ```python
  class A(acp.Abstract):
     i = acp.AbstractInt()
  ```

  you now use

  ```python
  class A(acp.Abstract):
     i = acp.abstract_class_property(int)
  ```

  It results in cleaner code, and also means that we don't have to make our own classes for new types.






  This happens when you try to feed something that is not actually a type to abstract_class_property, for instance `x = acp.abstract_class_property(t.Union[str, int])` (or even, more correctly, `t.Type[t.Union[str, int]]` or `t.Union[t.Type[str], t.Type[int]]`. Also `x = acp.abstract_class_property(t.Type[Employee])`  will not work (since `t.Type` does not actually make something a type; in this case use `type(Employee)` instead (which would give you an abstract property that could receive some subclass of Employee).

  Note that the argument to `abstract_class_property` is only for readability and used in the `__repr__` of the `_AbstractClassProperty` class -- and for static typing. So as long as you satisfy static typing, all will be fine:

  ```
  T = t.TypeVar("T", int, str)

  class A(t.Generic[T], acp.Abstract):
      VALUE_TYPE: t.Type[T] = acp.abstract_class_property(t.cast(t.Type[t.Type[T]], "union of int and str"))
      def to_value(self) -> T:
          ...
  ```
  Note the double `t.Type`, since acp.abstract_class_property will remove 1 t.Type.



  You will get a Python warning if you run the following code:

  ```
  class A(acp.Abstract):
     i = 3
  ```

  You are defining class `A` to be abstract, however it has no fields with `abstract_class_property`.
  In almost all cases this means that either you should add an abstract class property, or remove the `acp.Abstract` inherritance.

  Defining a class like this used to result in a `TypeError` in versions <= 0.9.8, but is a warning from version 0.9.9 forward.

  You can safely ignore the warning (if you understand what you're doing; for instance if you just commented out the abstract class property during development for a moment), or if you really want to silence the warning forever in production code, add the following code to your program:

  ```
  import warnings
  warnings.filterwarnings("ignore", category=acp.AbstractClassWithoutAbstractPropertiesWarning)
  ```

  If you do this, I would appreciate if you drop me a line, since it probably means you've found a novel use for the package that I'd be happy to learn about (and possibly document).


  [1]: https://stackoverflow.com/questions/45248243/most-pythonic-way-to-declare-an-abstract-class-property
  [2]: https://github.com/reinhrst/abstractcp/issues/
  [3]: https://www.python.org/dev/peps/pep-0526/


pkgId: 93834d345b3105ff94606204cf2f5eeb8b6a9ebc2850f5b0c49e765b607f04c1
name: python-abstracttree
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Abstract base classes for tree data structures
url: https://github.com/lverweijen/abstracttree
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-abstracttree-0.1.1-1.src.rpm
checksum_type: sha256
description:
  This Python package contains a few abstract base classes for tree data structures.
  Trees are very common data structure that represents a hierarchy of common nodes.
  There are many different ways to represent them.
  This package tries to provide a uniform interface, mixin methods and some utility functions without settling on a concrete tree implementation.



  ```python
  from abstracttree import DownTree, to_mermaid

  to_mermaid(DownTree)
  ```

  ```mermaid
  graph TD;
  Tree[Tree];
  MutableTree[MutableTree];
  DownTree[DownTree];
  Tree[Tree];
  MutableTree[MutableTree];
  MutableDownTree[MutableDownTree];
  MutableTree[MutableTree];
  BinaryDownTree[BinaryDownTree];
  BinaryTree[BinaryTree];
  Tree-->MutableTree;
  DownTree-->Tree;
  DownTree-->MutableDownTree;
  MutableDownTree-->MutableTree;
  DownTree-->BinaryDownTree;
  BinaryDownTree-->BinaryTree;
  Tree-->BinaryTree;
  ```

  A `Downtree` needs to have links to its direct children, but doesn't require a link to its parent.
  A `Tree` needs to have links to both its `children` and its `parent`.

  | ABC               | Inherits from             | Abstract Methods                | Mixin Methods                                                                                                                                                           |
  |-------------------|---------------------------|---------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | `DownTree`        |                           | `children`                      | `nodes`, `nodes.preorder()`, `nodes.postorder()`, `nodes.levelorder()`, `descendants`, `leaves`, `levels`, `levels.zigzag()`, `is_leaf`, `transform()`,  `nid`, `eqv()` |
  | `Tree`            | `DownTree`                | `parent`                        | `root`, `is_root`, `ancestors`, `path`, `siblings`                                                                                                                      |
  | `MutableDownTree` | `DownTree`                | `add_child()`, `remove_child()` | `add_children()`                                                                                                                                                        |
  | `MutableTree`     | `Tree`, `MutableDownTree` |                                 | `detach()`                                                                                                                                                              |
  | `BinaryDownTree`  | `DownTree`                | `left_child`, `right_child`     | `children`, `nodes.inorder()`, `descendants.inorder()`                                                                                                                  |
  | `BinaryTree`      | `BinaryDownTree`, `Tree`  |                                 |                                                                                                                                                                         |

  In your own code, you can inherit from these trees.
  For example, if your tree only has links to children:

  ```python
  import abstracttree
  from abstracttree import print_tree

  class MyTree(abstracttree.DownTree):
      def __init__(self, value, children=()):
          self.value = value
          self._children = children

      def __str__(self):
          return "MyTree " + str(self.value)

      @property
      def children(self):
          return self._children

  tree = MyTree(1, children=[MyTree(2), MyTree(3)])
  print_tree(tree)





  ```



  In practice, not all existing tree data structures implement one of these abstract classes.
  As a bridge, you can use `AbstractTree.convert` to convert these trees to a `Tree` instance.
  However, whenever possible, it's recommended to inherit from `Tree` directly for minimal overhead.

  Examples:

  ```python

  tree = Tree.convert(int)
  tree = Tree.convert(ast.parse("1 + 1 == 2"))
  tree = Tree.convert(pathlib.Path("abstracttree"))


  tree = Tree.convert(anytree.Node('name'))


  tree = Tree.convert([[1, 2, 3], [4, 5, 6]])
  ```

  Or use `astree` if you need a custom function for `parent` or `children`:

  ```python

  data = {"name": "a",
          "children": [
              {"name": "b", "children": []},
              {"name": "c", "children": []}
  ]}
  astree(data, children=operator.itemgetter["children"])


  astree(widget, children=lambda w: w.children(), parent = lambda w: w.parent())


  astree(tree.root, children=lambda nid: tree.children(nid), parent=lambda nid: tree.parent(nid))


  astree(tree, children=iter, parent=lambda t: t.parent)


  inf_binary = astree(0, children=lambda n: (2*n + 1, 2*n + 2))
  ```



  Pretty printing
  ```python
  tree = astree(seq, children=lambda x: [x[:-2], x[1:]] if x else [])
  print_tree(tree)
  print(to_string(tree))








  ```

  Plotting with matplotlib
  ```python
  import matplotlib.pyplot as plt

  expr = ast.parse("y = x*x + 1")
  plot_tree(expr)
  plt.show()
  ```
  ![images/tree_calc_plot.png](images/tree_calc_plot.png)

  Export to various formats
  ```python
  to_dot(tree)
  to_mermaid(tree)
  to_latex(tree)
  to_reportlab(tree)

  to_image(Path('.'), "filetree.png", how="dot")
  to_image(AbstractTree, "class_hierarchy.svg", how="mermaid")
  to_pillow(tree).show()
  ```



  ```python
  import heapq

  from abstracttree import HeapTree, Route

  tree = HeapTree([5, 4, 3, 2, 1])
  heapq.heapify(tree.heap)
  route = Route(tree.left_child, tree.right_child)

  print(f"{route.lca = }")  # => HeapTree([1, 2, 3, 5, 4], 0)
  print(f"{route.nodes.count() = }")  # => 3
  print(f"{route.edges.count() = }")  # => 2
  ```



  - [anytree](https://github.com/c0fec0de/anytree)
  - [treelib](https://github.com/caesar0301/treelib)
  - [bigtree](https://github.com/kayjan/bigtree)
  - [itertree](https://github.com/BR1py/itertree)
  - [dendropy](https://github.com/jeetsukumaran/DendroPy)
  - [ete](https://github.com/etetoolkit/ete)
  - [littletree](https://github.com/lverweijen/littletree) - also by me



  - [PrettyPrintTree](https://github.com/AharonSambol/PrettyPrintTree) - colored terminal output


