# packages

pkgId: 149d31494183600a5520e46edfeb88fb7ec9bd38d586a2eecc731659076e5b49
name: python-autopandas
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: Process, visualize and use data easily.
url: https://github.com/didayolo/autopandas
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autopandas-0.5.1-1.src.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/autopandas/badge/?version=latest)](https://autopandas.readthedocs.io/en/latest/?badge=latest)

  ![logo](https://raw.githubusercontent.com/Didayolo/autopandas/master/logo_autopandas.png)




  * `pip install autopandas`
  * [Notebook with examples](https://nbviewer.jupyter.org/github/Didayolo/autopandas/blob/master/AutoPandas_workspace.ipynb)
  * [Documentation](https://autopandas.readthedocs.io/en/latest/)


  Forked from [medi-chal project](https://github.com/Didayolo/medi-chal).


pkgId: 85ac65413588c457d3c18ca583d6359924c82de91889869f8d58fe54d2553658
name: python-autopaths
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: autopaths is a python package for dealing with file paths and automation.
url: http://github.com/xapple/autopaths/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autopaths-1.6.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/autopaths.svg)](https://badge.fury.io/py/autopaths)



  `autopaths` is a python package for dealing with file paths and automation.

  It has many convenience methods that apply to directory paths and/or file paths and contains several submodules that are useful when building pipelines. See below for examples and documentation.



  Since `autopaths` is written in python, it is compatible with all operating systems: Linux, macOS and Windows. The only prerequisite is `python3` (which is often installed by default) along with the `pip3` package manager.

  To check if you have `python3` installed, type the following on your terminal:

      $ python3 -V

  If you do not have `python3` installed, please refer to the section [obtaining python3](docs/installing_tips.md#obtaining-python3).

  To check you have `pip3` installed, type the following on your terminal:

      $ pip3 -V

  If you do not have `pip3` installed, please refer to the section [obtaining pip3](docs/installing_tips.md#obtaining-pip3).



  To install the `autopaths` package, simply type the following commands on your terminal:

      $ pip3 install --user autopaths

  Alternatively, if you want to install it for all users of the system:

      $ sudo pip3 install autopaths



  Bellow are some examples to illustrate the various ways there are to use this package.




  Here are a few example usages of this object:

      from autopaths.file_path import FilePath
      f = FilePath("input/raw/reads_56.fastq")
      print(f.exists)
      print(f.extension)
      print(f.size)
      print(f.contains_binary)
      f.prepend('# This file was backed-up\n')
      f.gzip_to('backup/old_reads/reads_56.fastq.gz')
      f.move_to(f.parent)

  As you can see, once you have created a FilePath, many useful methods are available. No more need for long `os.path` or `shutil` commands of which you can never remember the syntax.

  To see the complete list of utility methods and properties, look at the source code. You can find lots of the common things you would need to do with file paths such as `f.make_executable()` etc. right at your fingertips.



  Similar to a file path object. Here is an example usage of this object:

      from autopaths.dir_path import DirectoryPath
      d = DirectoryPath("cleaned/reads/")
      print(d.mod_time)
      d.create_if_not_exists()
      f = d + 'new.fastq'



  You can use this class like this when making pipelines to quickly refer to a predefined file path with a simple attribute lookup. This example explains it:

      class Sample(object):
          all_paths = """
                      /raw/raw.sff
                      /raw/raw.fastq
                      /clean/trim.fastq
                      /clean/clean.fastq
                      """

          def __init__(self, base_dir):
              from autopaths.auto_paths import AutoPaths
              self.p = AutoPaths(base_dir, self.all_paths)

          def clean(self):
              shutil.move(self.p.raw_sff, self.p.clean_fastq)



  More documentation is available at:

  <http://xapple.github.io/autopaths/autopaths>

  This documentation is simply generated with:

      $ pdoc --html --output-dir docs --force autopaths


pkgId: 2d43d9543bc5711af56cc67938e5846892bcfc9bf14ce653445ea9a4fe98f824
name: python-autopilot-tools
arch: src
version: 0.4.7
epoch: 0
release: 1
summary: PX4/ArduPilot autopilot tools
url: https://github.com/PonomarevDA/autopilot_tools
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autopilot-tools-0.4.7-1.src.rpm
checksum_type: sha256
description:
  [autopilot_tools](https://pypi.org/project/autopilot-tools/) is a python package intended to be used as part of automated work with PX4 and ArduPilot autopilots. It allows you to:

  - [x] 1. Upload firmware to PX4/ArduPilot targets
  - [x] 2. Easily write set of parameters,
  - [x] 3. Run flight mission and wait for result,
  - [x] 4. Download flight logs,
  - [x] 5. Upload flight logs to [review.px4.io](https://review.px4.io/),
  - [ ] 6. Parse flight logs,
  - [ ] 7. Provide a flight log stats and overall stats of multiple log files.



  The package is distrubuted via [pypi.org/project/autopilot-tools/](https://pypi.org/project/autopilot-tools/).

  ```bash
  pip install autopilot_tools
  ```

  Alternatively, you can install the package from sources in [Development Mode (a.k.a. “Editable Installs”)](https://setuptools.pypa.io/en/latest/userguide/development_mode.html). Clone the repository, install the package in development mode and use it in virtual environment:

  ```bash
  git clone https://github.com/PonomarevDA/autopilot_tools.git
  python3 -m venv venv
  ./venv/bin/activate
  pip install -e .
  ```



  After the installation the package is accessible as a few executables.



  `autopilot-configurator` uploads the given firmware to the autopilot, reset parameters to default, upload the required parameters and perform force sensor calibration.

  <img src="https://github.com/PonomarevDA/autopilot_tools/blob/docs/assets/autopilot_configurator.gif?raw=true" width="768">



  `test-scenario` uploads the given mission to the autopilot, run it and wait until it is finished, then download the log from the vehicle and upload it to [review.px4.io](https://review.px4.io/). It returns a user the result of the flight and link to the flight report.

  <img src="https://github.com/PonomarevDA/autopilot_tools/blob/docs/assets/test_scenario.gif?raw=true" width="768">




  The package can be imported as a module. This allows you to implement more customized behaviour and use extended features if you need.

  An example is shown below:

  ```python
  from autopilot_tools.vehicle import Vehicle
  from autopilot_tools.analyzer import Analyzer

  vehicle = Vehicle()
  vehicle.connect(device="serial")
  vehicle.upload_firmware(firmware_path_or_url)
  vehicle.configure(params_path)
  vehicle.load_mission(mission_path)

  res = vehicle.run_mission(mission_path)
  print(res)

  log_file = vehicle.load_latest_log(mission_path)

  analzyer = Analyzer()
  res = analzyer.analyse_log(log_file, analyze_requests=("airspeed", "ice", "esc_status"))
  print(res)
  ```



  The package is primarily based on [ArduPilot/pymavlink](https://github.com/ArduPilot/pymavlink).

  <!-- The project structure should be like:

  ```
  src/autopilot-tools/
  ├── autopilot_tools/
  │   ├── firmware.py
  │   ├── parameters.py
  │   ├── mission.py
  │   ├── logs.py
  │   ├── stats.py
  │   └── cli/
  │       ├── __init__.py
  │       ├── upload_firmware.py
  │       ├── set_parameters.py
  │       ├── run_mission.py
  │       ├── download_logs.py
  │       ├── upload_logs.py
  │       ├── parse_logs.py
  │       ├── log_stats.py
  │       └── overall_stats.py
  ├── scripts/
  │   ├── deploy.sh
  │   ├── install.sh
  |   └── code_style.py
  ├── tests/
  │   ├── test_firmware.py
  │   ├── test_parameters.py
  │   ├── test_mission.py
  │   ├── test_logs.py
  │   └── test_stats.py
  ├── LICENSE
  ├── README.md
  ├── requirements.txt
  └── pyproject.toml
  ``` -->



  A developer should follow the [CONTRIBUTING.md](CONTRIBUTING.md) guide.

  **Deployment**.
  Please, deploy initially on [test.pypi.org](https://test.pypi.org/project/autopilot-tools/). Only if everything is fine, then deploy on [pypi.org](https://pypi.org/project/autopilot-tools/). Try the script below to get details:

  ```bash
  ./deploy.sh --help
  ```



  The package inherits [ArduPilot/pymavlink](https://github.com/ArduPilot/pymavlink) license and is distributed under GPLv3 license.


pkgId: ed747acf7ba58db5cd4fb2d3c288a600e9529a6b0064c810dc42b2e96c21ef20
name: python-autopilot-tools
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: PX4/ArduPilot autopilot tools
url: https://github.com/PonomarevDA/autopilot_tools
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autopilot-tools-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![](https://badge.fury.io/py/autopilot-tools.svg)](https://pypi.org/project/autopilot-tools/) ![](https://github.com/PonomarevDA/autopilot_tools/actions/workflows/build_package.yml/badge.svg) ![](https://github.com/PonomarevDA/autopilot_tools/actions/workflows/pylint.yml/badge.svg) ![](https://github.com/PonomarevDA/autopilot_tools/actions/workflows/tests.yml/badge.svg)



  [autopilot_tools](https://pypi.org/project/autopilot-tools/) is a python package intended to be used as part of automated work with PX4 and ArduPilot autopilots.



  The package is distrubuted via [pypi.org/project/autopilot-tools/](https://pypi.org/project/autopilot-tools/).

  ```bash
  pip install autopilot_tools
  ```

  Alternatively, you can install the package from sources in [Development Mode (a.k.a. “Editable Installs”)](https://setuptools.pypa.io/en/latest/userguide/development_mode.html). Clone the repository, install the package in development mode and use it in virtual environment:

  ```bash
  git clone https://github.com/PonomarevDA/autopilot_tools.git
  python3 -m venv venv
  ./venv/bin/activate
  pip install -e .
  ```



  After the installation the package is accessible as a few executables.



  Let's say you have an autopilot, but you’re unsure about its current firmware version or configuration. All you want is to upload the exact firmware you need and configure it according to your specifications. This is where `autopilot-configurator` can be extremely helpful. This script:
  - uploads the specified PX4 or ArduPilot firmware to the autopilot,
  - resets all parameters to default and then applyed the required parameters in the given order,
  - performs a force sensor calibration, which is especially useful for HITL simulators.

  <img src="https://github.com/PonomarevDA/autopilot_tools/blob/docs/assets/autopilot_configurator.gif?raw=true" width="768">

  There are a few ways how to use this feature.

  **First way**. Using `--firmware` and `--params` options you can configure the autopilot with desired firmware and/or parameters:

  ```
  autopilot-configurator -v --firmware https://github.com/ZilantRobotics/PX4-Autopilot/releases/download/v1.15.0-0.4.3-beta1/px4_fmu-v6c_cyphal.px4 --params examples/px4_sys_autostart_13000.yaml
  ```

  **Second way**. Using `--force` or `--load` option you can either configure (upload firmware + load parameters) or only load parameters to the target using a singel yaml file:

  ```bash
  cd ~/zilant/uav_hitl_sim # or your path to the simulator
  autopilot-configurator -v --force configs/vehicles/px4_v1_15_0_cyphal_quadplane_vtol.yaml
  ```

  **Third way**. You can import the module and perform the configuration manually from your custom python script:

  ```python
  from autopilot_tools.configurator import AutopilotConfigurator

  AutopilotConfigurator.configure_with_yaml_file(config_path="path_to_config_file.yaml",
                                                 need_upload_firmware=True,
                                                 need_load_parameters=True)
  ```



  `test-scenario` uploads the given mission to the autopilot,
  run it and wait until it is finished,
  then download the log from the vehicle and upload it to [review.px4.io](https://review.px4.io/).
  It returns a user the result of the flight and link to the flight report.

  <img src="https://github.com/PonomarevDA/autopilot_tools/blob/docs/assets/test_scenario.gif?raw=true" width="768">

  You can run this utility as follows:

  ```bash
  test-scenario examples/plan_without_fence.plan --output flight.ulg
  ```

  This will run mission from the `examples` folder.



  The package can be imported as a module. This allows you to implement more customized behaviour and use extended features if you need.

  An example is shown below:

  ```python
  from autopilot_tools.vehicle import Vehicle
  from autopilot_tools.analyzer import Analyzer

  vehicle = Vehicle()
  vehicle.connect(device="serial")
  vehicle.upload_firmware(firmware_path_or_url)
  vehicle.configure(params_path)
  vehicle.load_mission(mission_path)

  res = vehicle.run_mission()
  print(res)

  log_file = vehicle.load_latest_log(mission_path)

  analzyer = Analyzer()
  res = analzyer.analyse_log(log_file, analyze_requests=("airspeed", "ice", "esc_status"))
  print(res)
  ```



  The package is primarily based on [ArduPilot/pymavlink](https://github.com/ArduPilot/pymavlink).

  <!-- The project structure should be like:

  ```
  src/autopilot-tools/
  ├── autopilot_tools/
  │   ├── firmware.py
  │   ├── parameters.py
  │   ├── mission.py
  │   ├── logs.py
  │   ├── stats.py
  │   └── cli/
  │       ├── __init__.py
  │       ├── upload_firmware.py
  │       ├── set_parameters.py
  │       ├── run_mission.py
  │       ├── download_logs.py
  │       ├── upload_logs.py
  │       ├── parse_logs.py
  │       ├── log_stats.py
  │       └── overall_stats.py
  ├── scripts/
  │   ├── deploy.sh
  │   ├── install.sh
  |   └── code_style.py
  ├── tests/
  │   ├── test_firmware.py
  │   ├── test_parameters.py
  │   ├── test_mission.py
  │   ├── test_logs.py
  │   └── test_stats.py
  ├── LICENSE
  ├── README.md
  ├── requirements.txt
  └── pyproject.toml
  ``` -->



  A developer should follow the [CONTRIBUTING.md](CONTRIBUTING.md) guide.

  **Deployment**.
  Please, deploy initially on [test.pypi.org](https://test.pypi.org/project/autopilot-tools/). Only if everything is fine, then deploy on [pypi.org](https://pypi.org/project/autopilot-tools/). Try the script below to get details:

  ```bash
  ./deploy.sh --help
  ```



  The package inherits [ArduPilot/pymavlink](https://github.com/ArduPilot/pymavlink) license and is distributed under GPLv3 license.


pkgId: 349b06f2ce4eb9b6726275f0ce15d09b66b32cee1bd0bc87f055a131bf901046
name: python-autopilotml
arch: src
version: 1.0.14
epoch: 0
release: 1
summary: A package for automating machine learning tasks
url: https://github.com/shyam1326
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autopilotml-1.0.14-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <p>
      <a align="center" href="" target="_blank">
        <img
          width="1280"
          src="https://raw.githubusercontent.com/shyam1326/autopilotml/main/images/autopilotml.png"
      </a>
    </p>


  [![version](https://badge.fury.io/py/autopilotml.svg)](https://badge.fury.io/py/autopilotml)
  <a href="https://pepy.tech/project/autopilotml"><img src="https://pepy.tech/badge/autopilotml" alt="total autopilotml downloads"></a>
  [![license](https://img.shields.io/pypi/l/autopilotml)](LICENSE)
  [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/shyam1326/autopilotml/blob/main/autopilotml/research/autopilotml_examples.ipynb)


  </div>



  > Automated machine learning library for analytics



  - `pip install autopilotml`





  ```python
  from autopilotml import load_data, load_database


  df = load_data(path = "dataset/titanic_train.csv", csv=True, **kwargs)


  df = load_data(path = "dataset/titanic_train.xlsx", excel=True, **kwargs)




  df = load_database(database_type='sqlite', sqlite_db_path = 'database.db', query='select * from employee_table')
  ```



  ```python
  from autopilotml import preprocessing



  df = preprocessing(dataframe=df, label_column='Survived',
                                  missing={
                                      'type':'impute',
                                      'drop_columns': False,
                                      'threshold': 0.25,
                                      'strategy_numerical': 'knn',
                                      'strategy_categorical': 'most_frequent',
                                      'fill_value': None},
                                  outlier={
                                      'method': 'None',
                                      'zscore_threshold': 3,
                                      'iqr_threshold': 1.5,
                                      'Lc': 0.05,
                                      'Uc': 0.95,
                                      'cap': False})
  ```



  ```python
  from autopilotml import transformation



  df, encoder = transformation(dataframe=df,
                                  label_column='Survived',
                                  type = 'ordinal',
                                  target_transform = False,
                                  cardinality = True,
                                  Cardinality_threshold = 0.3)
  ```



  ```python


  from autopilotml import scaling

  df, scaler = scaling(df, label_column= 'Survived', type = 'standard', target_scaling = False)
  ```



  ```python
  from autopilotml import feature_selection

  df, selector = feature_selection(dataframe=df, label_column='Survived',
                                  estimator='RandomForestClassifier',
                                  type='rfe', max_features=10,
                                  min_features=2, scoring= 'accuracy',
                                  cv=5)
  ```



  ```python
  from autopilotml import training

  model = training(dataframe=df, label_column='Survived', model_name='SVC', problem_type='Classification',
                  target_scaler=None, test_split =0.15, hypertune=True, n_epochs=100)
  ```



  ```python
  !mlflow ui
  ```


pkgId: 6b1e33b4195e8f695dce3b1e11a401fa3476bb61d530833961d66e6e89393153
name: python-autopip
arch: src
version: 1.7.9
epoch: 0
release: 1
summary: Easily install apps from PyPI and automatically keep them updated
url: https://github.com/maxzheng/autopip
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autopip-1.7.9-1.src.rpm
checksum_type: sha256
description:
  Easily install apps from PyPI and automatically keep them updated.
  `autopip` automates the creation of a virtual environment using `venv <https://docs.python.org/3/library/venv.html>`_,
  installs any Python package with scripts (i.e. app) from PyPI using `pip <https://pypi.org/project/pip/>`_, and
  atomically creates symlinks for installed scripts in `/usr/local/bin` so you can easily use them. Each app version is
  installed cleanly into its own virtual environment. Optionally, it can set up crontab entries to update apps
  automatically (may require admin permission on macOS).
  Before starting, make sure your Python installation meets all the requirements -- while `autopip` can install Python
  apps that run on any Python version, it requires Python 3.6+ to run::
      curl -s https://raw.githubusercontent.com/maxzheng/autopip/master/etc/check-python.py | python3
  To install `autopip` to `/usr/local/bin`::
      sudo pip3 install autopip
  No need to worry about tainting system Python install as `autopip` has no install dependencies and never will.
  Alternatively, you can install it in a virtual environment -- the last one that you will ever create manually for
  installing Python apps::
      python3 -m venv ~/.virtualenvs/autopip
      source ~/.virtualenvs/autopip/bin/activate
      pip3 install autopip
  Optionally, create installation directories and chown to your user so that ``autopip`` can create symlinks in
  `/usr/local/bin`::
      sudo mkdir /usr/local/opt /usr/local/var
      sudo chown -R $(whoami) /usr/local/*
  Now, you can easily install any apps from PyPI:
      $ autopip install workspace-tools
      Installing workspace-tools to /usr/local/opt/apps/workspace-tools/3.2.2
      Updating symlinks in /usr/local/bin
      + wst
  Optionally use the ``--update`` option to update it daily via cron (may require admin permission on macOS):
      $ autopip install workspace-tools --update daily
      workspace-tools is up-to-date
      Adding to crontab (may require admin permission)
      Daily auto-update enabled via cron service
      Scripts are in /usr/local/bin: wst
  Install paths are selected based on your user's permission to write to `/opt` or `/usr/local/opt`. If you do not have
  permission for either, then ``autopip`` will install apps to your user home at `~/.apps` with script symlinks in `~/bin`
  therefore you will need to add `~/bin` to your PATH env var to easily run scripts from installed apps.  To install
  script symlinks to `/usr/local/bin`, either chown/chmod dirs in `/usr/local/*` to be writeable by your user as suggested
  above or run ``autopip`` using ``sudo`` (i.e. as root). To see why a particular path is selected, append ``--debug``
  after ``autopip`` when running it.
  To save typing a few letters, you can also use the ``app`` alias -- short for **a**\ uto\ **p**\ i\ **p**.
      $ app install ansible-hostmanager
      Installing ansible-hostmanager to /usr/local/opt/apps/ansible-hostmanager/0.2.3
      Updating script symlinks in /usr/local/bin
      + ah
  To install an app for a specific Python version, use the ``--python`` option:
      $ app install ducktape --python 3.7
      Installing ducktape to /usr/local/opt/apps/ducktape/0.7.3
      Updating script symlinks in /usr/local/bin
      + ducktape
  To show currently installed apps and their scripts:
      $ app list --scripts
      ansible-hostmanager  0.2.3   /usr/local/opt/apps/ansible-hostmanager/0.2.3
                                   /usr/local/bin/ah
      ducktape             0.7.3   /usr/local/opt/apps/ducktape/0.7.3
                                   /usr/local/bin/ducktape
      workspace-tools      3.2.2   /usr/local/opt/apps/workspace-tools/3.2.2      [updates daily]
                                   /usr/local/bin/wst
  To manually update all apps:
      $ app update
      ansible-hostmanager is up-to-date
      ducktape is up-to-date
      workspace-tools is up-to-date
  To uninstall::
      app uninstall ducktape
  If you need to use a private PyPI index, just configure `index-url` in `pip.conf
  <https://pip.pypa.io/en/stable/user_guide/#configuration>`_ as `autopip` uses `pip` to install apps.
  To control versioning and uniform installations across multiple hosts/users, you can also define an `autopip`
  installation group using entry points. See example in `developer-tools <https://pypi.org/project/developer-tools/>`_
  package.


pkgId: aaa941bfdfe87acdd5c02e699addd992368e150dc604a813a9896ca8c60768cb
name: python-autoplex
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: Automated machine-learned Potential Landscape explorer
url: https://pypi.org/project/autoplex/
rpm_license: GPL-3.0 license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoplex-0.0.7-1.src.rpm
checksum_type: sha256
description:
  [![Testing Linux](https://github.com/JaGeo/autoplex/actions/workflows/python-package.yml/badge.svg)](https://github.com/JaGeo/autoplex/actions/workflows/python-package.yml) [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/autoatml/autoplex/main.svg)](https://results.pre-commit.ci/latest/github/autoatml/autoplex/main) [![DOI](https://zenodo.org/badge/671124251.svg)](https://doi.org/10.5281/zenodo.14105049) ![supported python versions](https://img.shields.io/pypi/pyversions/autoplex) [![PyPI version](https://badge.fury.io/py/autoplex.svg)](https://badge.fury.io/py/autoplex)

  <img src="docs/_static/autoplex_logo.png" width="66%">

  <div style="border: 1px solid #2e3191; padding: 5px; position: relative;">
      <div style="background-color: #2e3191; color: #ffffff; padding: 0px; position: absolute; top: 0; left: 0; right: 0; text-align: center;">
          <strong>Disclaimer</strong>
      </div>
  <br>

  `autoplex` is still under very active development and is only suitable for expert users as not all of the documentation is in place. This will change until end of November 2024.
  </div>

  <br>

  `autoplex` is a software for generating and benchmarking machine learning (ML)-based interatomic potentials. The aim of `autoplex` is to provide a fully automated solution for creating high-quality ML potentials. The software is interfaced to multiple different ML potential fitting frameworks and to the atomate2 and ase environments for efficient high-throughput computations. The vision of this project is to allow a wide community of researchers to create accurate and reliable ML potentials for materials simulations.

  `autoplex` is developed jointly by two research groups at BAM Berlin and the University of Oxford.

  `autoplex` is an evolving project and **contributions are very welcome**! To ensure that the code remains of high quality, please raise a pull request for any contributions, which will be reviewed before integration into the main branch of the code. Initially, [@JaGeo](https://github.com/JaGeo) will handle the reviews.



  You can find the `autoplex` documentation [here](https://autoatml.github.io/autoplex/index.html)!
  The documentation also contains tutorials that teach you how to use `autoplex` for different use cases.



  We expect the general user of `autoplex` to be familiar with the [Materials Project](https://github.com/materialsproject) framework software tools and related
  packages for (high-throughput) workflow submission and management.
  This involves the following software packages:
  - [pymatgen](https://github.com/materialsproject/pymatgen) for input and output handling of computational materials science software
  - [atomate2](https://github.com/materialsproject/atomate2) for providing a library of pre-defined computational materials science workflows
  - [jobflow](https://github.com/materialsproject/jobflow) for processes, job and workflow handling
  - [jobflow-remote](https://github.com/Matgenix/jobflow-remote) or [FireWorks](https://github.com/materialsproject/fireworks) for workflow and database (MongoDB) management
  - [MongoDB](https://www.mongodb.com/) as the database (we recommend installing the MongoDB community version)

  All of these software tools provide documentation and tutorials. Please take your time and check everything out!



  To set up the mandatory prerequisites for using `autoplex,` please follow the [installation guide of atomate2](https://materialsproject.github.io/atomate2/user/install.html).

  After setting up `atomate2`, make sure to add `VASP_INCAR_UPDATES: {"NPAR": number}` in your `~/atomate2/config/atomate2.yaml` file.
  Set a number that is a divisor of the number of tasks you use for the VASP calculations.





  Before the installation, please make sure that you are using one of the supported Python versions (see [pyproject.toml](https://github.com/autoatml/autoplex/blob/main/pyproject.toml))



  Please install `autoplex` using ``pip install git+https://github.com/autoatml/autoplex.git``. This will install all the Python packages and dependencies needed for MLIP fits. We will release a version of `autoplex` to PyPI in the next few weeks.

  Additionally, to fit and validate `ACEpotentials`, one also needs to install Julia, as Autoplex relies on [ACEpotentials](https://acesuit.github.io/ACEpotentials.jl/dev/gettingstarted/installation/), which supports fitting of linear ACE. Currently, no Python package exists for the same.
  Please run the following commands to enable the `ACEpotentials` fitting options and further functionality.

  Install Julia v1.9.2

  ```bash
  curl -fsSL https://install.julialang.org | sh -s -- default-channel 1.9.2
  ```

  Once installed in the terminal, run the following commands to get Julia ACEpotentials dependencies.

  ```bash
  julia -e 'using Pkg; Pkg.Registry.add("General"); Pkg.Registry.add(Pkg.Registry.RegistrySpec(url="https://github.com/ACEsuit/ACEregistry")); Pkg.add(Pkg.PackageSpec(;name="ACEpotentials", version="0.6.7")); Pkg.add("DataFrames"); Pkg.add("CSV")'
  ```



  Additionally, `buildcell` as a part of `AIRSS` needs to be installed if one wants to use the RSS functionality:

  ```bash
  curl -O https://www.mtg.msm.cam.ac.uk/files/airss-0.9.3.tgz; tar -xf airss-0.9.3.tgz; rm airss-0.9.3.tgz; cd airss; make ; make install ; make neat; cd ..
  ```



  A short guide to contributing to autoplex can be found [here](https://autoatml.github.io/autoplex/dev/contributing.html). Additional information for developers can be found [here](https://autoatml.github.io/autoplex/dev/dev_install.html).



  We currently have two different types of automation workflows available:

  * Workflow to use random-structure searches for the systematic construction of interatomic potentials. The implementation automates ideas from the following articles: [*Phys. Rev. Lett.* **120**, 156001 (2018)](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.120.156001) and [*npj Comput. Mater.* **5**, 99 (2019)](https://www.nature.com/articles/s41524-019-0236-6).
  * Workflow to train accurate interatomic potentials for harmonic phonon properties. The implementation automates the ideas from the following article: [*J. Chem. Phys.* **153**, 044104 (2020)](https://pubs.aip.org/aip/jcp/article/153/4/044104/1056348/Combining-phonon-accuracy-with-high).


pkgId: c8b22bd1a0d32198fac9ef511ee2d180b1c5ccdf6c313b3455db501989de5759
name: python-autoplex
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: Automated machine-learned Potential Landscape explorer
url: https://pypi.org/project/autoplex/
rpm_license: GPL-3.0 license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoplex-0.0.8-1.src.rpm
checksum_type: sha256
description:
  [![Testing Linux](https://github.com/JaGeo/autoplex/actions/workflows/python-package.yml/badge.svg)](https://github.com/JaGeo/autoplex/actions/workflows/python-package.yml) [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/autoatml/autoplex/main.svg)](https://results.pre-commit.ci/latest/github/autoatml/autoplex/main) [![DOI](https://zenodo.org/badge/671124251.svg)](https://doi.org/10.5281/zenodo.14105049) ![supported python versions](https://img.shields.io/pypi/pyversions/autoplex) [![PyPI version](https://badge.fury.io/py/autoplex.svg)](https://badge.fury.io/py/autoplex)

  <img src="docs/_static/autoplex_logo.png" width="66%">

  <div style="border: 1px solid #2e3191; padding: 5px; position: relative;">
      <div style="background-color: #2e3191; color: #ffffff; padding: 0px; position: absolute; top: 0; left: 0; right: 0; text-align: center;">
          <strong>Disclaimer</strong>
      </div>
  <br>

  `autoplex` is still under very active development and is only suitable for expert users as not all of the documentation is in place. This will change until end of November 2024.
  </div>

  <br>

  `autoplex` is a software for generating and benchmarking machine learning (ML)-based interatomic potentials. The aim of `autoplex` is to provide a fully automated solution for creating high-quality ML potentials. The software is interfaced to multiple different ML potential fitting frameworks and to the atomate2 and ase environments for efficient high-throughput computations. The vision of this project is to allow a wide community of researchers to create accurate and reliable ML potentials for materials simulations.

  `autoplex` is developed jointly by two research groups at BAM Berlin and the University of Oxford.

  `autoplex` is an evolving project and **contributions are very welcome**! To ensure that the code remains of high quality, please raise a pull request for any contributions, which will be reviewed before integration into the main branch of the code. Initially, [@JaGeo](https://github.com/JaGeo) will handle the reviews.



  You can find the `autoplex` documentation [here](https://autoatml.github.io/autoplex/index.html)!
  The documentation also contains tutorials that teach you how to use `autoplex` for different use cases for the RSS and phonon workflows and individual modules therein.



  We expect the general user of `autoplex` to be familiar with the [Materials Project](https://github.com/materialsproject) framework software tools and related
  packages for (high-throughput) workflow submission and management.
  This involves the following software packages:
  - [pymatgen](https://github.com/materialsproject/pymatgen) for input and output handling of computational materials science software,
  - [atomate2](https://github.com/materialsproject/atomate2) for providing a library of pre-defined computational materials science workflows,
  - [jobflow](https://github.com/materialsproject/jobflow) for processes, job and workflow handling,
  - [jobflow-remote](https://github.com/Matgenix/jobflow-remote) or [FireWorks](https://github.com/materialsproject/fireworks) for workflow and database (MongoDB) management,
  - [MongoDB](https://www.mongodb.com/) as the database (we recommend installing the MongoDB community edition). More help regarding the MongoDB installation can be found [here](https://materialsproject.github.io/fireworks/installation.html#install-mongodb).

  All of these software tools provide documentation and tutorials. Please take your time and check everything out!



  To set up the mandatory prerequisites for using `autoplex,` please follow the [installation guide of atomate2](https://materialsproject.github.io/atomate2/user/install.html).

  After setting up `atomate2`, make sure to add `VASP_INCAR_UPDATES: {"NPAR": number}` in your `~/atomate2/config/atomate2.yaml` file.
  Set a number that is a divisor of the number of tasks you use for the VASP calculations.





  Before the installation, please make sure that you are using one of the supported Python versions (see [pyproject.toml](https://github.com/autoatml/autoplex/blob/main/pyproject.toml))



  Please install `autoplex` using
  ```
  pip install autoplex[strict]
  ```
  This will install all the Python packages and dependencies needed for MLIP fits.

  Additionally, to fit and validate `ACEpotentials`, one also needs to install Julia, as `autoplex` relies on [ACEpotentials](https://acesuit.github.io/ACEpotentials.jl/dev/gettingstarted/installation/), which supports fitting of linear ACE. Currently, no Python package exists for the same.
  Please run the following commands to enable the `ACEpotentials` fitting options and further functionality.

  Install Julia v1.9.2

  ```bash
  curl -fsSL https://install.julialang.org | sh -s -- default-channel 1.9.2
  ```

  Once installed in the terminal, run the following commands to get Julia ACEpotentials dependencies.

  ```bash
  julia -e 'using Pkg; Pkg.Registry.add("General"); Pkg.Registry.add(Pkg.Registry.RegistrySpec(url="https://github.com/ACEsuit/ACEregistry")); Pkg.add(Pkg.PackageSpec(;name="ACEpotentials", version="0.6.7")); Pkg.add("DataFrames"); Pkg.add("CSV")'
  ```



  Additionally, `buildcell` as a part of `AIRSS` needs to be installed if one wants to use the RSS functionality:

  ```bash
  curl -O https://www.mtg.msm.cam.ac.uk/files/airss-0.9.3.tgz; tar -xf airss-0.9.3.tgz; rm airss-0.9.3.tgz; cd airss; make ; make install ; make neat; cd ..
  ```



  You only need to install LAMMPS, if you want to use J-ACE as your MLIP.
  Recipe for compiling lammps-ace including the download of the `libpace.tar.gz` file:

  ```
  git clone -b release https://github.com/lammps/lammps
  cd lammps
  mkdir build
  cd build
  wget -O libpace.tar.gz https://github.com/wcwitt/lammps-user-pace/archive/main.tar.gz

  cmake  -C ../cmake/presets/clang.cmake -D BUILD_SHARED_LIBS=on -D BUILD_MPI=yes \
  -DMLIAP_ENABLE_PYTHON=yes -D PKG_PYTHON=on -D PKG_KOKKOS=yes -D Kokkos_ARCH_ZEN3=yes \
  -D PKG_PHONON=yes -D PKG_MOLECULE=yes -D PKG_MANYBODY=yes \
  -D Kokkos_ENABLE_OPENMP=yes -D BUILD_OMP=yes -D LAMMPS_EXCEPTIONS=yes \
  -D PKG_ML-PACE=yes -D PACELIB_MD5=$(md5sum libpace.tar.gz | awk '{print $1}') \
  -D CMAKE_INSTALL_PREFIX=$LAMMPS_INSTALL -D CMAKE_EXE_LINKER_FLAGS:STRING="-lgfortran" \
  ../cmake

  make -j 16
  make install-python
  ```

  $LAMMPS_INSTALL is the conda environment for installing the lammps-python interface.
  Use `BUILD_MPI=yes` to enable MPI for parallelization.

  After the installation is completed, enter the following commands in the Python environment.
  If you get the same output, it means the installation was successful.

  ```
  from lammps import lammps; lmp = lammps()
  LAMMPS (27 Jun 2024)
  OMP_NUM_THREADS environment is not set. Defaulting to 1 thread. (src/comm.cpp:98)
    using 1 OpenMP thread(s) per MPI task
  Total wall time: 0:02:22
  ```
  It is very important to have it compiled with Python (`-D PKG_PYTHON=on`) and
  LIB PACE flags (`-D PACELIB_MD5=$(md5sum libpace.tar.gz | awk '{print $1}')`).



  A short guide to contributing to autoplex can be found [here](https://autoatml.github.io/autoplex/dev/contributing.html). Additional information for developers can be found [here](https://autoatml.github.io/autoplex/dev/dev_install.html).



  We currently have two different types of automation workflows available:

  * Workflow to use random-structure searches for the systematic construction of interatomic potentials. The implementation automates ideas from the following articles: [*Phys. Rev. Lett.* **120**, 156001 (2018)](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.120.156001) and [*npj Comput. Mater.* **5**, 99 (2019)](https://www.nature.com/articles/s41524-019-0236-6).
  * Workflow to train accurate interatomic potentials for harmonic phonon properties. The implementation automates the ideas from the following article: [*J. Chem. Phys.* **153**, 044104 (2020)](https://pubs.aip.org/aip/jcp/article/153/4/044104/1056348/Combining-phonon-accuracy-with-high).


pkgId: 752fe81c43944ddee0d7c21ac488bc6e7ee131c3313dc0336061d7169c4c9032
name: python-autoplot
arch: src
version: 0.9.2
epoch: 0
release: 1
summary: Interface to Autoplot Java library
url: https://github.com/autoplot/python/
rpm_license: LICENSE.txt
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoplot-0.9.2-1.src.rpm
checksum_type: sha256
description:
  Install using `pip install autoplot`
    import autoplot as ap
    
    ap.init()
    
    apds = ap.APDataSet()
    
    apds.setDataSetURI('http://autoplot.org/data/swe-np.xls?column=data&depend0=dep0')
    
    apds.doGetDataSet()
    print(apds.toString())
    
    
    
    
    vv = ap.to_ndarray(apds, 'data')
    tt = ap.to_ndarray(apds, 'dep0')
    from matplotlib import pyplot as plt
    plt.plot(tt,vv)
    plt.show()


pkgId: d87d45ea797632c1d40b20d7a4f6104ebf11bee5bd655aabf32990d3ed068aae
name: python-autopop
arch: src
version: 2.7
epoch: 0
release: 1
summary: Auto Populate GDoc tables using LLMs.
url: https://github.com/yourusername/yourrepository
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autopop-2.7-1.src.rpm
checksum_type: sha256
description:
  AutoPop is a Python package designed to automatically populate tables in Google Docs using Large Language Models (LLMs). The package leverages the power of LLMs to generate content for various aspects of a Google Doc, making it easier to create comprehensive and informative tables without manual effort.


  Auto-populate tables in Google Docs with data generated by LLMs.
  Supports various types of LLMs including GPT-4, Claude, etc.
  Easy to use with a simple Python API.
  Highly customizable to suit different use-cases.


  To install the package, run:

  pip install autopop


  requests
  selenium
  openai


  TBD


  Contributions are welcome! Please read the contributing guidelines to get started.


  This project is licensed under the MIT License. See LICENSE.md for details.


  For questions and support, please contact david.schwartz@devfactory.com.


pkgId: 023ece8589dbc8ec18d189b8a81805fd88aad3548b807cbda60b86ebc1a09836
name: python-autopost
arch: src
version: 0.0.9
epoch: 0
release: 1
summary: Auto-posts social media updates
url: https://pypi.org/project/autopost/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autopost-0.0.9-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/woodruffw/autopost/actions/workflows/ci.yml/badge.svg)](https://github.com/woodruffw/autopost/actions/workflows/ci.yml)
  [![PyPI version](https://badge.fury.io/py/autopost.svg)](https://pypi.org/project/autopost)
  A social media auto-poster for a blog.
  Supported sites:
  * Twitter (currently untested)
  * Mastodon (any instance)
  * Reddit (any subreddit)
  * Bluesky

  `autopost` requires Python 3.11 or newer, and is available on PyPI:
  ```bash
  python -m pip install autopost
  ```

  ```console
  usage: autopost [-h] [-V] [-v] [--dry-run] [--config-file CONFIG_FILE] {manual,atom} ...
  auto-posts social media updates
  positional arguments:
    {manual,atom}
      manual              auto-post manually
      atom                auto-post from an Atom RSS feed
  options:
    -h, --help            show this help message and exit
    -V, --version         show program's version number and exit
    -v, --verbose         be more verbose while running (default: False)
    --dry-run             perform a dry-run (default: False)
    --config-file CONFIG_FILE
                          the file to load for configuration (default: ./autopost.toml)
  ```

  To do anything meaningful with `autopost`, you'll need to configure
  it. See [autopost.example.toml](./autopost.example.toml) for an example configuration file.
  Once configured, you can use `autopost` to make a post manually:
  ```console
  $ autopost manual "test" --url "https://example.com" --tags foo bar
  🎉 reddit:/r/enosuchblog: https://reddit.com/r/enosuchblog/comments/zldk8y/test/
  🎉 mastodon:@yossarian@infosec.exchange: https://infosec.exchange/@yossarian/109509443715725349
  ```
  Alternatively, you can use `autopost atom` to retrieve a post from an Atom-style
  RSS feed:
  ```bash
  autopost atom https://example.com/feed.xml
  ```
  In both cases, you can pass `--dry-run` to see what `autopost` *would* post
  instead of actually doing it:
  ```console
  $ autopost --dry-run atom https://blog.yossarian.net/feed.xml
  dry run: would have posted Modernizing my 1980s sound system with URL:
  https://blog.yossarian.net/2022/11/07/Modernizing-my-1980s-sound-system and tags: ['howto', 'workflow', 'music']
  ```

rpm_license:
  The MIT License (MIT)  Copyright (c) 2022 William Woodruff <william @ yossarian.net>  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: affeef70aca4566ef3aeae18c9f3d305911195737c4d60cfe851cee6715232ff
name: python-autopwlf
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: Automated piecewise linear fitting
url: https://github.com/nweerasuriya/auto_pwlf
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autopwlf-0.9.0-1.src.rpm
checksum_type: sha256
description:
  Piecewise Linear Fit with ability to automatically find the optimal number of line segments.

  Full Documentation can be found here: [Documentation](https://autopwlf.readthedocs.io/en/latest/#)


  Installation available through pip: https://pypi.org/project/autopwlf/
  ```
  pip install autopwlf
  ```

  ![image](https://github.com/user-attachments/assets/aac67188-37ad-4e89-8eca-160d67e6c7d9)


  The piecewise fitting uses the [pwlf module](https://github.com/cjekel/piecewise_linear_fit_py) with full credit to all contributors to this package.


  The currently available Piecewise Linear Fit models in Python do not have a method to determine the optimal number of break points to use. To do so this package performs the following steps:

  1. Smooth the data using a rolling median function
  2. Fit a linear interpolation function on the smoothened data
  3. Use scipy find_peaks function to find the number of extrema points
  4. Filter by primenence to return an estimate on the number of break points


pkgId: 0794e3c10dfe7fc6f76227bbaea6f5d28a95f566aca19590e354b3bc28740fe0
name: python-autopwn-suite
arch: src
version: 2.1.5
epoch: 0
release: 1
summary: AutoPWN Suite is a project for scanning vulnerabilities and exploiting systems automatically.
url: https://auto.pwnspot.com
rpm_license: EULA
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autopwn-suite-2.1.5-1.src.rpm
checksum_type: sha256
description:
  AutoPWN Suite is a project for scanning vulnerabilities and exploiting systems automatically.

  ![GitHub top language](https://img.shields.io/github/languages/top/GamehunterKaan/AutoPWN-Suite)
  ![Lines of code](https://img.shields.io/tokei/lines/github/GamehunterKaan/AutoPWN-Suite?label=total%20lines%20of%20code)
  ![Repo Size](https://img.shields.io/github/repo-size/GamehunterKaan/AutoPWN-Suite)
  [![Tests](https://github.com/GamehunterKaan/AutoPWN-Suite/actions/workflows/tests.yml/badge.svg)](https://github.com/GamehunterKaan/AutoPWN-Suite/actions/workflows/tests.yml)
  ![GitHub issues](https://img.shields.io/github/issues-raw/GamehunterKaan/AutoPWN-Suite)
  ![GitHub closed issues](https://img.shields.io/github/issues-closed-raw/GamehunterKaan/AutoPWN-Suite)
  ![GitHub Repo stars](https://img.shields.io/github/stars/GamehunterKaan/AutoPWN-Suite?style=social)
  ![Banner](https://raw.githubusercontent.com/GamehunterKaan/AutoPWN-Suite/main/images/banner.png)



  - Fully [automatic!](#usage)
  - Detect network IP range without any user input.
  - Vulnerability detection based on version.
  - Web app vulnerability testing. (LFI, XSS, SQLI)
  - Web app dirbusting.
  - Get information about the vulnerability right from your terminal.
  - Automatically download exploit related with vulnerability.
  - Noise mode for creating a noise on the network.
  - Evasion mode for being sneaky.
  - Automatically decide which scan types to use based on privilege.
  - Easy to read output.
  - Specify your arguments using a config file.
  - Send scan results via webhook or email.
  - Works on Windows, MacOS and Linux.
  - Use as a [module!](#module-usage)




  AutoPWN Suite uses nmap TCP-SYN scan to enumerate the host and detect the version of softwares running on it. After gathering enough information about the host, AutoPWN Suite automatically generates a list of "keywords" to search [NIST vulnerability database.](https://www.nist.gov/)

  [Visit "PWN Spot!" for more information.](https://pwnspot.com/posts/AutoPWN/)




  AutoPWN Suite has a very user friendly easy to read output.

  [![asciicast](https://asciinema.org/a/509345.svg)](https://asciinema.org/a/509345)




  You can install it using pip. (sudo recommended)

  ```
  sudo pip install autopwn-suite
  ```

  OR

  You can clone the repo.

  ```
  git clone https://github.com/GamehunterKaan/AutoPWN-Suite.git
  cd AutoPWN-Suite
  sudo pip install -r requirements.txt
  ```

  OR

  You can download debian (deb) package from [releases.](https://github.com/GamehunterKaan/AutoPWN-Suite/releases)

  ```
  sudo pip install requests rich python-nmap bs4 distro
  sudo apt-get install ./autopwn-suite_2.1.5.deb
  ```

  OR

  If you are on Arch Linux based system you can install `python-autopwn-suite` package using AUR helper of your choice.

  OR

  You can use Google Cloud Shell.

  [![Open in Cloud Shell](https://gstatic.com/cloudssh/images/open-btn.svg)](https://shell.cloud.google.com/cloudshell/editor?cloudshell_git_repo=https://github.com/GamehunterKaan/AutoPWN-Suite.git)




  Running with root privileges (sudo) is always recommended.

  Automatic mode

  ```console
  autopwn-suite -y
  ```


  Help Menu

  ```console
  $ autopwn-suite -h

  usage: autopwn.py [-h] [-v] [-y] [-c CONFIG] [-nc] [-t TARGET] [-hf HOST_FILE] [-sd] [-st {arp,ping}] [-nf NMAP_FLAGS] [-s {0,1,2,3,4,5}] [-ht HOST_TIMEOUT] [-a API] [-m {evade,noise,normal}] [-nt TIMEOUT]
                    [-o OUTPUT] [-ot {html,txt,svg}] [-rp {email,webhook}] [-rpe EMAIL] [-rpep PASSWORD] [-rpet EMAIL] [-rpef EMAIL] [-rpes SERVER] [-rpesp PORT] [-rpw WEBHOOK]

  AutoPWN Suite | A project for scanning vulnerabilities and exploiting systems automatically.

  options:
    -h, --help            show this help message and exit
    -v, --version         Print version and exit.
    -y, --yes-please      Don't ask for anything. (Full automatic mode)
    -c CONFIG, --config CONFIG
                          Specify a config file to use. (Default : None)
    -nc, --no-color       Disable colors.

  Scanning:
    Options for scanning

    -t TARGET, --target TARGET
                          Target range to scan. This argument overwrites the hostfile argument. (192.168.0.1 or 192.168.0.0/24)
    -hf HOST_FILE, --host-file HOST_FILE
                          File containing a list of hosts to scan.
    -sd, --skip-discovery
                          Skips the host discovery phase.
    -st {arp,ping}, --scan-type {arp,ping}
                          Scan type.
    -nf NMAP_FLAGS, --nmap-flags NMAP_FLAGS
                          Custom nmap flags to use for portscan. (Has to be specified like : -nf="-O")
    -s {0,1,2,3,4,5}, --speed {0,1,2,3,4,5}
                          Scan speed. (Default : 3)
    -ht HOST_TIMEOUT, --host-timeout HOST_TIMEOUT
                          Timeout for every host. (Default :240)
    -a API, --api API     Specify API key for vulnerability detection for faster scanning. (Default : None)
    -m {evade,noise,normal}, --mode {evade,noise,normal}
                          Scan mode.
    -nt TIMEOUT, --noise-timeout TIMEOUT
                          Noise mode timeout.

  Reporting:
    Options for reporting

    -o OUTPUT, --output OUTPUT
                          Output file name. (Default : autopwn.log)
    -ot {html,txt,svg}, --output-type {html,txt,svg}
                          Output file type. (Default : html)
    -rp {email,webhook}, --report {email,webhook}
                          Report sending method.
    -rpe EMAIL, --report-email EMAIL
                          Email address to use for sending report.
    -rpep PASSWORD, --report-email-password PASSWORD
                          Password of the email report is going to be sent from.
    -rpet EMAIL, --report-email-to EMAIL
                          Email address to send report to.
    -rpef EMAIL, --report-email-from EMAIL
                          Email to send from.
    -rpes SERVER, --report-email-server SERVER
                          Email server to use for sending report.
    -rpesp PORT, --report-email-server-port PORT
                          Port of the email server.
    -rpw WEBHOOK, --report-webhook WEBHOOK
                          Webhook to use for sending report.
  ```




  ```python
  from autopwn_suite.api import AutoScanner

  scanner = AutoScanner()
  json_results = scanner.scan("192.168.0.1")
  scanner.save_to_file("autopwn.json")
  ```




  Do you have a cool feature idea? [Create a feature request!](https://github.com/GamehunterKaan/AutoPWN-Suite/issues/new?assignees=&labels=&template=feature_request.md&title=)

  - [x] 23 Completed.
  - [ ] Function to brute force common services like `ssh`, `vnc`, `ftp`.
  - [ ] GUI interface.
  - [ ] Daemon mode.




  I would be glad if you are willing to contribute this project. I am looking forward to merge your pull request unless its something that is not needed or just a personal preference. Also minor changes and bug fixes will not be merged. Please create an issue for those and I will do it myself. [Click here for more info!](https://github.com/GamehunterKaan/AutoPWN-Suite/blob/main/.github/CONTRIBUTING.md)




  You may not rent or lease, distribute, modify, sell or transfer the software to a third party. AutoPWN Suite is free for distribution, and modification with the condition that credit is provided to the creator and not used for commercial use. You may not use software for illegal or nefarious purposes. No liability for consequential damages to the maximum extent permitted by all applicable laws.




  Having trouble using this tool? You can reach me out on [discord](https://search.discordprofile.info/374953845438021635), [create an issue](https://github.com/GamehunterKaan/AutoPWN-Suite/issues/new/choose) or [create a discussion!](https://github.com/GamehunterKaan/AutoPWN-Suite/discussions)




  If you want to support my work and also get your job done you can hire me on [Fiverr](https://www.fiverr.com/kaangultekin)! I do various things such as website pentesting, python programming, cleaning malware, PC optimization, file recovery and mentoring.


pkgId: 95505170787559dd159b64e9a0f465a8e439e57b46041aec8c80b476fb905ea9
name: python-autopxd2
arch: src
version: 2.4.0
epoch: 0
release: 1
summary: Automatically generate Cython pxd files from C headers
url: https://github.com/elijahr/python-autopxd2
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autopxd2-2.4.0-1.src.rpm
checksum_type: sha256
description:
  A friendly fork of autopxd https://github.com/tarruda/python-autopxd

  It generates `.pxd` files automatically from `.h` files.



  - Python 3.9
  - Python 3.10
  - Python 3.11
  - Python 3.12

  [![Test](https://github.com/elijahr/python-autopxd2/actions/workflows/test.yml/badge.svg)](https://github.com/elijahr/python-autopxd2/actions/workflows/test.yml)
  [![Lint](https://github.com/elijahr/python-autopxd2/actions/workflows/lint.yml/badge.svg)](https://github.com/elijahr/python-autopxd2/actions/workflows/lint.yml)



  ```shell
  pip install autopxd2
  ```



  ```shell
  Usage: autopxd [OPTIONS] [INFILE] [OUTFILE]

    Generate a Cython pxd file from a C header file.

  Options:
    -v, --version                   Print program version and exit.
    -I, --include-dir <dir>         Allow the C preprocessor to search for files
                                    in <dir>.

    -D, --compiler-directive <directive>
                                    Additional directives for the C compiler.
    --debug / --no-debug            Dump preprocessor output to stderr.
    -h, --help                      Show this message and exit.
  ```





  - Add: Support for Python 3.12 from Michael Milton [#45](https://github.com/elijahr/python-autopxd2/pull/45)
  - Add: Support for char and binary expression in enum from Poiuzy & Emmanuel Leblond [#47](https://github.com/elijahr/python-autopxd2/pull/47)
  - Release now also provide a Wheel on Pypi from Emmanuel Leblond #[#46](https://github.com/elijahr/python-autopxd2/pull/46)



  - Add: Support for const & volatile qualifiers from Emmanuel Leblond [#42](https://github.com/elijahr/python-autopxd2/pull/42)



  - Move to https://github.com/elijahr/python-autopxd2



  - Add: Microsoft Visual C++ support from Steve Dower [#40](https://github.com/elijahr/python-autopxd2/pull/40)



  - Add: `--regex` for arbitrary conversions
  - Fix: Various other fixes and improvements from Mads Ynddal in [#38](https://github.com/elijahr/python-autopxd2/pull/38)



  - Fix: Windows CRLF issue ([#24](https://github.com/elijahr/python-autopxd2/pull/24))



  - Fix: remove unnecessary `importlib_resources` from `install_requires`



  - Migrate to [`setup.cfg`](https://docs.python.org/3/distutils/configfile.html)



  - Add: `--compiler-directive` option to pass along to the compiler
  - Add: some type annotations (`nodes.py`)
  - Deprecation: Drop support for Python 2
  - Add: linting, format with black
  - Add: Migrate from Travis CI to Github Actions



  - Add: Support for macOS



  - Refactoring of the code **DONE**
  - Adding tests for PEP8 **DONE**
  - Uploading to PyPi **DONE**
  - Check that the generated code is correct by comparing it to the libc in Cython
  - More tests
  - Merge it into Cython so that the `.pxd` files aren't necessary anymore? Maybe.



  It's difficult to catch all the corner cases.


pkgId: dbc9300dac8977108715a3737d00b6538c5bbaa4aa9a39b86787b31686cc0bfb
name: python-autora
arch: src
version: 4.1.0
epoch: 0
release: 1
url: https://pypi.org/project/autora/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autora-4.1.0-1.src.rpm
checksum_type: sha256
summary:
  Autonomous Research Assistant (AutoRA) is a framework for automating steps of the empirical research process.

description:
  ![PyPI](https://img.shields.io/pypi/v/autora)
  ![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/autoresearch/autora/test-pytest.yml)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/autora)
  ![Link to docs](https://img.shields.io/badge/Docs-autoresearch.github.io-purple)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  ![GitHub Discussions](https://img.shields.io/github/discussions/autoresearch/autora)
  [![DOI](https://zenodo.org/badge/261852986.svg)](https://zenodo.org/doi/10.5281/zenodo.10277414)
  [![status](https://joss.theoj.org/papers/be6d470033fbe5bd705a49858eb4e21e/status.svg)](https://joss.theoj.org/papers/be6d470033fbe5bd705a49858eb4e21e)

  <a href="https://ccbs.carney.brown.edu/brainstorm"><img src="docs/img/brainstorm.png" alt="BRAINSTORM Program" height="60"></img></a>&nbsp;&nbsp;&nbsp;&nbsp;
  <a href="https://schmidtsciencefellows.org/"><img src="docs/img/ssf.png" alt="Schmidt Science Fellows" height="60"></img></a>

  <b>[AutoRA](https://pypi.org/project/autora/)</b> (<b>Auto</b>mated <b>R</b>esearch <b>A</b>ssistant) is an open-source framework for
  automating multiple stages of the empirical research process, including model discovery, experimental design, data collection, and documentation for open science.

  AutoRA was initially intended for accelerating research in the behavioral and brain sciences. However, AutoRA is designed as a general framework that enables automation of the research processes in other empirical sciences, such as material science or physics.

  ![Autonomous Empirical Research Paradigm](https://github.com/AutoResearch/autora/raw/main/docs/img/overview.png)




  We recommend using a `Python` environment manager like `virtualenv`. You may refer to the Development Guide on how to [set up a virtual environment](https://autoresearch.github.io/autora/contribute/setup/#create-a-virtual-environment).

  Before installing the PyPI ``autora`` package, you may [activate your environment](https://autoresearch.github.io/autora/contribute/setup/#activating-and-using-the-environment). To install the PyPI `autora` package, run the following command:

  ```shell
  pip install "autora"
  ```



  Check out tutorials and documentation at
  [https://autoresearch.github.io/autora](https://autoresearch.github.io/autora). If you run into any issues or questions regarding the use of AutoRA, please reach out to us at the [AutoRA forum](https://github.com/orgs/AutoResearch/discussions/categories/using-autora).



  The following example demonstrates how to use AutoRA to automate the process of model discovery, experimental design, and data collection.

  The discovery problem is defined by a single independent variable $x \in [0, 2 \pi]$ and dependent variable $y$.
  The experiment amounts to a simple sine wave, $y = \sin(x)$, which is the model we are trying to discover.

  Th discovery cycle iterates between the experimentalist, experiment runner, and theorist. Here, we us a "random" experimentalist, which samples novel experimental conditions for $x$ every cycle.
  The experiment runner then collects data for the corresponding $y$ values. Finally, the theorist uses a [Bayesian Machine Scientist](https://autoresearch.github.io/autora/user-guide/theorists/bms/) (BMS; Guimerà et al., in Science Advances) to identify a scientific model that explains the data.

  The workflow relies on the ``StandardState`` object, which stores the current state of the discovery process, such as ``conditions``, ``experiment_data``, or ``models``. The state is passed between the experimentalist, experiment runner, and theorist.


  ```python




  import pandas as pd
  import numpy as np
  import sympy as sp

  from autora.variable import Variable, ValueType, VariableCollection

  from autora.experimentalist.random import random_pool
  from autora.experiment_runner.synthetic.abstract.equation import equation_experiment
  from autora.theorist.bms import BMSRegressor

  from autora.state import StandardState, on_state, estimator_on_state






  iv = Variable(name="x", value_range=(0, 2 * np.pi), allowed_values=np.linspace(0, 2 * np.pi, 30))
  dv = Variable(name="y", type=ValueType.REAL)
  variables = VariableCollection(independent_variables=[iv],dependent_variables=[dv])


  conditions = random_pool(variables, num_samples=10, random_state=0)





  experimentalist = on_state(random_pool, output=["conditions"])





  sin_experiment = equation_experiment(sp.simplify('sin(x)'), variables.independent_variables, variables.dependent_variables[0])
  sin_runner = sin_experiment.experiment_runner

  experiment_runner = on_state(sin_runner, output=["experiment_data"])





  theorist = estimator_on_state(BMSRegressor(epochs=100))





  s = StandardState(
      variables = variables,
      conditions = conditions,
      experiment_data = pd.DataFrame(columns=["x","y"])
  )





  print('Pre-Defined State:')
  print(f"Number of datapoints collected: {len(s['experiment_data'])}")
  print(f"Derived models: {s['models']}")
  print('\n')

  for i in range(5):
      s = experimentalist(s, num_samples=10, random_state=42)
      s = experiment_runner(s, added_noise=1.0, random_state=42)
      s = theorist(s)
      print(f"\nCycle {i+1} Results:")
      print(f"Number of datapoints collected: {len(s['experiment_data'])}")
      print(f"Derived models: {s['models']}")
      print('\n')
  ```




  We welcome contributions to the AutoRA project. Please refer to the [contributor guide](https://autoresearch.github.io/autora/contribute/) for more information. Also, feel free to ask any questions or provide any feedback regarding core contributions on the [AutoRA forum](https://github.com/orgs/AutoResearch/discussions/).



  This project is in active development by
  the [Autonomous Empirical Research Group](http://empiricalresearch.ai),
  in collaboration with the [Center for Computation and Visualization at Brown University](https://ccv.brown.edu).

  The development of this package is supported by Schmidt Science Fellows, in partnership with the Rhodes Trust, as well as the Carney BRAINSTORM program at Brown University.




  - [Package Documentation](https://autoresearch.github.io/autora/)
  - [AutoRA Pip Package](https://pypi.org/project/autora/)
  - [Autonomous Empirical Research Group](http://www.empiricalresearch.ai)

rpm_license:
  MIT License  Copyright (c) 2023 Autonomous Empirical Research Initiative  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: 413d1c214b30c85bf0f916c39fdee97e43165d213e4b61528c0f3576be654799
name: python-autora
arch: src
version: 4.2.0
epoch: 0
release: 1
url: https://pypi.org/project/autora/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autora-4.2.0-1.src.rpm
checksum_type: sha256
summary:
  Autonomous Research Assistant (AutoRA) is a framework for automating steps of the empirical research process.

description:
  ![PyPI](https://img.shields.io/pypi/v/autora)
  ![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/autoresearch/autora/test-pytest.yml)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/autora)
  ![Link to docs](https://img.shields.io/badge/Docs-autoresearch.github.io-purple)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  ![GitHub Discussions](https://img.shields.io/github/discussions/autoresearch/autora)
  [![DOI](https://zenodo.org/badge/261852986.svg)](https://zenodo.org/doi/10.5281/zenodo.10277414)
  [![status](https://joss.theoj.org/papers/be6d470033fbe5bd705a49858eb4e21e/status.svg)](https://joss.theoj.org/papers/be6d470033fbe5bd705a49858eb4e21e)

  <a href="https://ccbs.carney.brown.edu/brainstorm"><img src="docs/img/brainstorm.png" alt="BRAINSTORM Program" height="60"></img></a>&nbsp;&nbsp;&nbsp;&nbsp;
  <a href="https://schmidtsciencefellows.org/"><img src="docs/img/ssf.png" alt="Schmidt Science Fellows" height="60"></img></a>

  <b>[AutoRA](https://pypi.org/project/autora/)</b> (<b>Auto</b>mated <b>R</b>esearch <b>A</b>ssistant) is an open-source framework for
  automating multiple stages of the empirical research process, including model discovery, experimental design, data collection, and documentation for open science.

  AutoRA was initially intended for accelerating research in the behavioral and brain sciences. However, AutoRA is designed as a general framework that enables automation of the research processes in other empirical sciences, such as material science or physics.

  ![Autonomous Empirical Research Paradigm](https://github.com/AutoResearch/autora/raw/main/docs/img/overview.png)




  We recommend using a `Python` environment manager like `virtualenv`. You may refer to the Development Guide on how to [set up a virtual environment](https://autoresearch.github.io/autora/contribute/setup/#create-a-virtual-environment).

  Before installing the PyPI ``autora`` package, you may [activate your environment](https://autoresearch.github.io/autora/contribute/setup/#activating-and-using-the-environment). To install the PyPI `autora` package, run the following command:

  ```shell
  pip install "autora"
  ```



  Check out tutorials and documentation at
  [https://autoresearch.github.io/autora](https://autoresearch.github.io/autora). If you run into any issues or questions regarding the use of AutoRA, please reach out to us at the [AutoRA forum](https://github.com/orgs/AutoResearch/discussions/categories/using-autora).



  The following basic example demonstrates how to use AutoRA to automate the process of model discovery, experimental design, and data collection.

  The discovery problem is defined by a single independent variable $x \in [0, 2 \pi]$ and dependent variable $y$.
  The experiment amounts to a simple sine wave, $y = \sin(x)$, which is the model we are trying to discover.

  Th discovery cycle iterates between the experimentalist, experiment runner, and theorist. Here, we us a "random" experimentalist, which samples novel experimental conditions for $x$ every cycle.
  The experiment runner then collects data for the corresponding $y$ values. Finally, the theorist uses a [Bayesian Machine Scientist](https://autoresearch.github.io/autora/user-guide/theorists/bms/) (BMS; Guimerà et al., in Science Advances) to identify a scientific model that explains the data.

  The workflow relies on the ``StandardState`` object, which stores the current state of the discovery process, such as ``conditions``, ``experiment_data``, or ``models``. The state is passed between the experimentalist, experiment runner, and theorist.


  ```python




  import pandas as pd
  import numpy as np
  import sympy as sp

  from autora.variable import Variable, ValueType, VariableCollection

  from autora.experimentalist.random import random_pool
  from autora.experiment_runner.synthetic.abstract.equation import equation_experiment
  from autora.theorist.bms import BMSRegressor

  from autora.state import StandardState, on_state, estimator_on_state






  iv = Variable(name="x", value_range=(0, 2 * np.pi), allowed_values=np.linspace(0, 2 * np.pi, 30))
  dv = Variable(name="y", type=ValueType.REAL)
  variables = VariableCollection(independent_variables=[iv],dependent_variables=[dv])


  conditions = random_pool(variables, num_samples=10, random_state=0)





  experimentalist = on_state(random_pool, output=["conditions"])





  sin_experiment = equation_experiment(sp.simplify('sin(x)'), variables.independent_variables, variables.dependent_variables[0])
  sin_runner = sin_experiment.experiment_runner

  experiment_runner = on_state(sin_runner, output=["experiment_data"])





  theorist = estimator_on_state(BMSRegressor(epochs=100))





  s = StandardState(
      variables = variables,
      conditions = conditions,
      experiment_data = pd.DataFrame(columns=["x","y"])
  )





  print('Pre-Defined State:')
  print(f"Number of datapoints collected: {len(s['experiment_data'])}")
  print(f"Derived models: {s['models']}")
  print('\n')

  for i in range(5):
      s = experimentalist(s, num_samples=10, random_state=42)
      s = experiment_runner(s, added_noise=1.0, random_state=42)
      s = theorist(s)
      print(f"\nCycle {i+1} Results:")
      print(f"Number of datapoints collected: {len(s['experiment_data'])}")
      print(f"Derived models: {s['models']}")
      print('\n')
  ```

  If you are curious about how to apply AutoRA to real-world discovery problems, you can find use case examples of AutoRA in the [Use Case Tutorials](https://autoresearch.github.io/autora/examples/) section of the documentation.



  We welcome contributions to the AutoRA project. Please refer to the [contributor guide](https://autoresearch.github.io/autora/contribute/) for more information. Also, feel free to ask any questions or provide any feedback regarding core contributions on the [AutoRA forum](https://github.com/orgs/AutoResearch/discussions/).



  This project is in active development by the [Autonomous Empirical Research Group](https://musslick.github.io/AER_website/Research.html).

  The development of this package was supported by [Schmidt Science Fellows](https://schmidtsciencefellows.org/), in partnership with the Rhodes Trust, as well as the [Carney BRAINSTORM program](https://ccbs.carney.brown.edu/brainstorm) at Brown University. The development of auxiliary packages for AutoRA, such as `autodoc`, is supported by [Schmidt Sciences, LLC. and the Virtual Institute for Scientific Software (VISS)](https://www.schmidtsciences.org/viss/). The AutoRA package was developed using computational resources and services at the [Center for Computation and Visualization at Brown University](https://ccv.brown.edu).




  - [Package Documentation](https://autoresearch.github.io/autora/)
  - [AutoRA Pip Package](https://pypi.org/project/autora/)
  - [Autonomous Empirical Research Group](http://www.empiricalresearch.ai)

rpm_license:
  MIT License  Copyright (c) 2023 Autonomous Empirical Research Initiative  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: 722887bf4fa451fcea2c071b95a56f8be320809a5a3692fabe5a984164276ee9
name: python-autora-experiment-runner-experimentation-manager-firebase
arch: src
version: 1.1.4
epoch: 0
release: 1
url: https://pypi.org/project/autora-experiment-runner-experimentation-manager-firebase/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autora-experiment-runner-experimentation-manager-firebase-1.1.4-1.src.rpm
checksum_type: sha256
summary:
  AutoRA Experimentation Manager Firebase provides functionality to manage communication of conditions and observations between AutoRA and an experiment on Firebase.

description:
  Firebase Experimentation Manager provides functionality to manage communication of conditions and observation between AutoRA and an experiment on Firebase.



  You will need:
  `python` >=3.8,<4: [https://www.python.org/downloads/](https://www.python.org/downloads/)

  !!! It is recommended to use a python environment manger like virtualenv

  Install the package via pip:

  ```shell
  pip install "aurora[experiment-runner-experimentation-manager-firebase]"
  ```


  ```shell
  python -c "from autora.experiment_runner.experimentation_manager.firebase import send_conditions"
  ```




  autora-core, firebase_admin

rpm_license:
  MIT License  Copyright (c) 2023 Autonomous Empirical Research Initiative  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: 03da57b6d2902da5a76481a755047b25be05b9d25808840e1fcef41069d54de2
name: python-autora-experiment-runner-recruitment-manager-prolific
arch: src
version: 1.0.1
epoch: 0
release: 1
url: https://pypi.org/project/autora-experiment-runner-recruitment-manager-prolific/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autora-experiment-runner-recruitment-manager-prolific-1.0.1-1.src.rpm
checksum_type: sha256
summary:
  AutoRA Prolific Recruitment Manager provides functionality to recruit participants via Prolific to set up an experiment runner for AutoRA

description:
  Prolific Recruitment Manager provides functionality to recruit participants via Prolific to set up an experiment runner for AutoRA.



  You will need:
  `python` >=3.8,<4: [https://www.python.org/downloads/](https://www.python.org/downloads/)

  !!! It is recommended to use a python environment manger like virtualenv

  Install the package via pip:

  ```shell
  pip install "aurora[experiment-runner-recruitment-manager-prolific]"
  ```


  ```shell
  python -c "from autora.experiment_runner.recruitment_manager.prolific import setup_study"
  ```




  autora-core

rpm_license:
[cell repeats an earlier one in this file: 1096 characters]


pkgId: e19a64f0a6b545d7b21d98a9c8537568aca5b422ffcb2a7c97ba78ea29c0b5c6
name: python-autora-experimentalist-falsification
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: AutoRA Falsification Experimentalist
url: https://pypi.org/project/autora-experimentalist-falsification/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autora-experimentalist-falsification-2.2.0-1.src.rpm
checksum_type: sha256
description:
  The falsification pooler and sampler identify novel experimental conditions $X'$ under
  which the loss $\hat{\mathcal{L}}(M,X,Y,X')$ of the best
  candidate model is predicted to be the highest. This loss is
  approximated with a multi-layer perceptron, which is trained to
  predict the loss of a candidate model, $M$, given experiment
  conditions $X$  and dependent measures $Y$ that have already been probed:

  $$
  \underset{X'}{argmax}~\hat{\mathcal{L}}(M,X,Y,X').
  $$



  You will need:

  - `python` 3.8 or greater: [https://www.python.org/downloads/](https://www.python.org/downloads/)

  *Falsification Experimentalist* is a part of the `autora` package:

  ```shell
  pip install -U autora["experimentalist-falsification"]
  ```


  Check your installation by running:
  ```shell
  python -c "from autora.experimentalist.falsification import falsification_pool"
  ```

rpm_license:
[cell repeats an earlier one in this file: 1096 characters]


pkgId: 77fb4f5400cd6c7271c581ba708e3db360f4740d7225887f4c476e5ccb9a4d00
name: python-autora-synthetic
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: AutoRA Synthetic Experiments
url: https://pypi.org/project/autora-synthetic/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autora-synthetic-2.2.0-1.src.rpm
checksum_type: sha256
description:
  Synthetic experiment data for testing AutoRA theorists and experimentalists.



  You will need:

  - `python` 3.8 or greater: [https://www.python.org/downloads/](https://www.python.org/downloads/)

  Install the synthetic data package (as part of `autora`):

  ```shell
  pip install -U "autora"
  ```

  > 💡We recommend using a `python` environment manager like `virtualenv`.

  Print a description of the prospect theory model by Kahneman and Tversky by running:
  ```shell
  python -c "
  from autora.experiment_runner.synthetic.economics.prospect_theory import prospect_theory
  study = prospect_theory()
  print(study.description)
  "
  ```

  For more information, see the
  [documentation](https://autoresearch.github.io/autora/user-guide/experiment-runners/synthetic/).

rpm_license:
[cell repeats an earlier one in this file: 1096 characters]


pkgId: 7090dd195003cccfdee2ec27d93a93642d274a087200402164043f3bcbf97e24
name: python-autora-theorist-bms
arch: src
version: 1.0.6
epoch: 0
release: 1
summary: Bayesian Machine Scientist theorist for AutoRA
url: https://pypi.org/project/autora-theorist-bms/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autora-theorist-bms-1.0.6-1.src.rpm
checksum_type: sha256
description:
  `autora-theorist-bms` is a Python module built on AutoRA that can be used to discover equations that fit data.

  Website: [https://autoresearch.github.io/autora/](https://autoresearch.github.io/autora/)



  You will need:

  - `python` 3.8 or greater: [https://www.python.org/downloads/](https://www.python.org/downloads/)

  Install BMS as part of the `autora` package:

  ```shell
  pip install -U "autora[theorist-bms]" --pre
  ```

  > It is recommended to use a `python` environment manager like `virtualenv`.

  Check your installation by running:
  ```shell
  python -c "from autora.theorist.bms import BMSRegressor; BMSRegressor()"
  ```

rpm_license:
[cell repeats an earlier one in this file: 1096 characters]


pkgId: bbdbcd057ef081307546e1f9ea48e2faaca5e1058b0a35ea5d43a80ed814db7a
name: python-autora-workflow
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Workflow tools for the Autonomous Research Assistant (AutoRA) package.
url: https://pypi.org/project/autora-workflow/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autora-workflow-0.6.0-1.src.rpm
checksum_type: sha256
description:
  Workflow management tools for AutoRA.



  You will need:

  - `python` 3.8 or greater: [https://www.python.org/downloads/](https://www.python.org/downloads/)

  Workflow is a part of the `autora` package:

  ```shell
  pip install -U "autora"
  ```

  !!! success
      It is recommended to use a `python` environment manager like `virtualenv`.

  Check your installation by running:
  ```shell
  python -m autora.workflow --help
  ```

rpm_license:
[cell repeats an earlier one in this file: 1096 characters]


pkgId: fdbfcd0848de27e14a79848b2b8887cc6954c4d6b4f5d5d2b5e53e5baf76cf3a
name: python-autorad
arch: src
version: 0.2.6
epoch: 0
release: 1
summary: Radiomics-related modules for extraction and experimenting
url: https://github.com/pwoznicki/AutoRadiomics
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autorad-0.2.6-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
  <br>
    <img src="docs/images/logo.png" alt="AutoRadiomics">
  </p>

  [![License](https://img.shields.io/badge/license-Apache%202.0-green.svg)](https://opensource.org/licenses/Apache-2.0)
  [![docs](https://readthedocs.org/projects/autoradiomics/badge/?version=latest)](https://autoradiomics.readthedocs.io)
  [![CI Build](https://github.com/pwoznicki/AutoRadiomics/actions/workflows/testing.yml/badge.svg)](https://github.com/pwoznicki/AutoRadiomics/commits/main)
  [![codecov](https://codecov.io/gh/pwoznicki/AutoRadiomics/branch/main/graph/badge.svg)](https://codecov.io/gh/pwoznicki/AutoRadiomics)



  | <p align="center"><a href="https://pwoznicki-autoradiomics-autoradwebappapp-streamlit-demo-w7ej7a.streamlit.app"> Streamlit Share | <p align="center"><a href="https://hub.docker.com/repository/docker/pwoznicki/autorad"> Docker                | <p align="center"><a href="https://pypi.org/project/autorad/"> Python                                          |
  | --------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
  | <p align="center"><img src="https://github.com/pwoznicki/AutoRadiomics/raw/main/docs/images/streamlit.png" /></p>                 | <p align="center"><img src="https://github.com/pwoznicki/AutoRadiomics/raw/main/docs/images/docker.png"/></p> | <p align="center"><img src="https://github.com/pwoznicki/AutoRadiomics/raw/main/docs/images/python.png" /></p> |
  | <p align="center"><a href="https://pwoznicki-autoradiomics-autoradwebappapp-streamlit-demo-w7ej7a.streamlit.app"> **Demo**        | `docker run -p 8501:8501 -v <your_data_dir>:/data -it pwoznicki/autorad:latest`                               | `pip install -U autorad`                                                                                       |

  &nbsp;



  | <p align="center"><a href="https://drive.google.com/uc?export=download&id=1fZyBeMvFUZXn7ND_FgeQRV3W68Dn6zZb"> Windows 10 | <p align="center"><a href="https://drive.google.com/uc?export=download&id=1N3JLv2h00Pp8XfwWXbBWvr7OnQ2h9pNu"> MacOS 11 (x64) | <p align="center"><a href="https://drive.google.com/uc?export=download&id=1SDG7J5ucwd4Nkq-5fAeArLKvHTcD045M"> Ubuntu 20.04 |
  | ------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
  | <p align="center"><img src="https://github.com/pwoznicki/AutoRadiomics/raw/main/docs/images/windows.png" /></p>          | <p align="center"><img src="https://github.com/pwoznicki/AutoRadiomics/raw/main/docs/images/macos.png"/></p>                 | <p align="center"><img src="https://github.com/pwoznicki/AutoRadiomics/raw/main/docs/images/ubuntu.png" /></p>             |



  ```bash
  git clone https://github.com/pwoznicki/AutoRadiomics.git
  cd AutoRadiomics
  pip install -e .
  ```



  Tutorials can be found in the [examples](./examples/) directory:

  - [Binary classification](./examples/example_WORC.ipynb)

  Documentation is available at [autoradiomics.readthedocs.io](https://autoradiomics.readthedocs.io/en/latest/).



  To use the application, make sure you have its dependencies installed:

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

  The application can be started from the root directory with:

  ```bash
  streamlit run autorad/webapp/app.py
  ```

  By default it willl run at http://localhost:8501/.
  <br/><br/>

  For more information about AutoRadiomics, please read [our paper](https://www.frontiersin.org/articles/10.3389/fradi.2022.919133/full):

  ```
    AutoRadiomics: A Framework for Reproducible Radiomics Research;
    P Woznicki, F Laqua, T Bley, B Baeßler;
    Frontiers in Radiology, 22
  ```

  Please cite it if you're using the framework for your research.


pkgId: f74ac714d08c7c6b2c25db3f01867842935a643e2f71cac5b54f45eab9d905a2
name: python-autorandr
arch: src
version: 1.15.post1
epoch: 0
release: 1
summary: Automatically select a display configuration based on connected devices
url: https://github.com/phillipberndt/autorandr
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autorandr-1.15.post1-1.src.rpm
checksum_type: sha256
description:
  Automatically select a display configuration based on connected devices



  This is a compatible Python rewrite of
  [wertarbyte/autorandr](https://github.com/wertarbyte/autorandr). Contributions
  for bash-completion, fd.o/XDG autostart, Nitrogen, pm-utils, and systemd can be
  found under [contrib](contrib/).

  The original [wertarbyte/autorandr](https://github.com/wertarbyte/autorandr)
  tree is unmaintained, with lots of open pull requests and issues. I forked it
  and merged what I thought were the most important changes. If you are searching
  for that version, see the [`legacy` branch](https://github.com/phillipberndt/autorandr/tree/legacy).
  Note that the Python version is better suited for non-standard configurations,
  like if you use `--transform` or `--reflect`. If you use `auto-disper`, you
  have to use the bash version, as there is no disper support in the Python
  version (yet). Both versions use a compatible configuration file format, so
  you can, to some extent, switch between them.  I will maintain the `legacy`
  branch until @wertarbyte finds the time to maintain his branch again.

  If you are interested in why there are two versions around, see
  [#7](https://github.com/phillipberndt/autorandr/issues/7),
  [#8](https://github.com/phillipberndt/autorandr/issues/8) and
  especially
  [#12](https://github.com/phillipberndt/autorandr/issues/12)
  if you are unhappy with this version and would like to contribute to the bash
  version.



  autorandr is available under the terms of the GNU General Public License
  (version 3).

  Contributors to this version of autorandr are:

  * Adrián López
  * andersonjacob
  * Alexander Lochmann
  * Alexander Wirt
  * Brice Waegeneire
  * Chris Dunder
  * Christoph Gysin
  * Christophe-Marie Duquesne
  * Daniel Hahler
  * Maciej Sitarz
  * Mathias Svensson
  * Matthew R Johnson
  * Nazar Mokrynskyi
  * Phillip Berndt
  * Rasmus Wriedt Larsen
  * Sam Coulter
  * Simon Wydooghe
  * Stefan Tomanek
  * stormc
  * tachylatus
  * Timo Bingmann
  * Timo Kaufmann
  * Tomasz Bogdal
  * Victor Häggqvist
  * Jan-Oliver Kaiser
  * Alexandre Viau



  You can use the `autorandr.py` script as a stand-alone binary. If you'd like to
  install it as a system-wide application, there is a Makefile included that also
  places some configuration files in appropriate directories such that autorandr
  is invoked automatically when a monitor is connected or removed, the system
  wakes up from suspend, or a user logs into an X11 session. Run `make install`
  as root to install it.

  If you prefer to have a system wide install managed by your package manager,
  you can

  * Use the [official Arch package](https://archlinux.org/packages/extra/any/autorandr/).
  * Use the [official Debian package](https://packages.debian.org/sid/x11/autorandr) on sid
  * Use the [FreeBSD Ports Collection](https://www.freshports.org/x11/autorandr/) on FreeBSD.
  * Use the [official Gentoo package](https://packages.gentoo.org/packages/x11-misc/autorandr).
  * Use the
    [nix package](https://github.com/NixOS/nixpkgs/blob/master/nixos/modules/services/misc/autorandr.nix)
    on NixOS.
  * Use the
    [guix package](https://git.savannah.gnu.org/cgit/guix.git/log/gnu/packages/xdisorg.scm?qt=grep&q=autorandr)
    on Guix.
  * Use the [SlackBuild](https://slackbuilds.org/repository/14.2/desktop/autorandr/) on Slackware.
  * Use the automated nightlies generated by the
    [openSUSE build service](https://build.opensuse.org/package/show/home:phillipberndt/autorandr)
    for various distributions (RPM and DEB based).
  * Use the [X binary package system](https://wiki.voidlinux.eu/XBPS)' on Void Linux
  * Build a .deb-file from the source tree using `make deb`.
  * Build a .rpm-file from the source tree using `make rpm`.

  We appreciate packaging scripts for other distributions, please file a pull
  request if you write one.

  If you prefer `pip` over your package manager, you can install autorandr with:

      sudo pip install "git+http://github.com/phillipberndt/autorandr#egg=autorandr"

  or simply

      sudo pip install autorandr

  if you prefer to use a stable version.



  Save your current display configuration and setup with:

      autorandr --save mobile

  Connect an additional display, configure your setup and save it:

      autorandr --save docked

  Now autorandr can detect which hardware setup is active:

      $ autorandr
        mobile
        docked (detected)

  To automatically reload your setup:

      $ autorandr --change

  To manually load a profile:

      $ autorandr --load <profile>

  or simply:

      $ autorandr <profile>

  autorandr tries to avoid reloading an identical configuration. To force the
  (re)configuration:

      $ autorandr --load <profile> --force

  To prevent a profile from being loaded, place a script call _block_ in its
  directory. The script is evaluated before the screen setup is inspected, and
  in case of it returning a value of 0 the profile is skipped. This can be used
  to query the status of a docking station you are about to leave.

  If no suitable profile can be identified, the current configuration is kept.
  To change this behaviour and switch to a fallback configuration, specify
  `--default <profile>`. The system-wide installation of autorandr by default
  calls autorandr with a parameter `--default default`. There are three special,
  virtual configurations called `horizontal`, `vertical` and `common`. They
  automatically generate a configuration that incorporates all screens
  connected to the computer. You can symlink `default` to one of these
  names in your configuration directory to have autorandr use any of them
  as the default configuration without you having to change the system-wide
  configuration.

  You can store default values for any option in an INI-file located at
  `~/.config/autorandr/settings.ini`. In a `config` section, you may place any
  default values in the form `option-name=option-argument`.

  A common and effective use of this is to specify default `skip-options`, for
  instance skipping the `gamma` setting if using
  [`redshift`](https://github.com/jonls/redshift) as a daemon.  To implement
  the equivalent of `--skip-options gamma`, your `settings.ini` file should look
  like this:

  ```
  [config]
  skip-options=gamma
  ```





  Three more scripts can be placed in the configuration directory
  (as defined by the [XDG spec](https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html),
  usually `~/.config/autorandr` or `~/.autorandr` if you have an old installation
  for user configuration and `/etc/xdg/autorandr` for system wide configuration):

  - `postswitch` is executed *after* a mode switch has taken place. This can be
    used to notify window managers or other applications about the switch.
  - `preswitch` is executed *before* a mode switch takes place.
  - `postsave` is executed after a profile was stored or altered.
  - `predetect` is executed before autorandr attempts to run xrandr.

  These scripts must be executable and can be placed directly in the configuration
  directory, where they will always be executed, or in the profile subdirectories,
  where they will only be executed on changes regarding that specific profile.

  Instead (or in addition) to these scripts, you can also place as many executable
  files as you like in subdirectories called `script_name.d` (e.g. `postswitch.d`).
  The order of execution of scripts in these directories is by file name, you can
  force a certain ordering by naming them `10-wallpaper`, `20-restart-wm`, etc.

  If a script with the same name occurs multiple times, user configuration
  takes precedence over system configuration (as specified by the
  [XDG spec](https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html))
  and profile configuration over general configuration.

  As a concrete example, suppose you have the files

  - `/etc/xdg/autorandr/postswitch`
  - `~/.config/autorandr/postswitch`
  - `~/.config/autorandr/postswitch.d/notify-herbstluftwm`
  - `~/.config/autorandr/docked/postswitch`

  and switch from `mobile` to `docked`. Then
  `~/.config/autorandr/docked/postswitch` is executed, since the profile specific
  configuration takes precedence, and
  `~/.config/autorandr/postswitch.d/notify-herbstluftwm` is executed, since
  it has a unique name.

  If you switch back from `docked` to `mobile`, `~/.config/autorandr/postswitch`
  is executed instead of the `docked` specific `postswitch`.

  If you experience issues with xrandr being executed too early after connecting
  a new monitor, then you can use a `predetect` script to delay the execution.
  Write e.g. `sleep 1` into that file to make autorandr wait a second before
  running `xrandr`.



  Some of autorandr's state is exposed as environment variables
  prefixed with `AUTORANDR_`, such as:
  - `AUTORANDR_CURRENT_PROFILE`
  - `AUTORANDR_CURRENT_PROFILES`
  - `AUTORANDR_PROFILE_FOLDER`
  - `AUTORANDR_MONITORS`

  with the intention that they can be used within the hook scripts.

  For instance, you might display which profile has just been activated by
  including the following in a `postswitch` script:
  ```sh
  notify-send -i display "Display profile" "$AUTORANDR_CURRENT_PROFILE"
  ```

  The one kink is that during `preswitch`, `AUTORANDR_CURRENT_PROFILE` is
  reporting the *upcoming* profile rather than the *current* one.



  The EDID strings in the `~/.config/autorandr/*/setup` files may contain an
  asterisk to enable wildcard matching: Such EDIDs are matched against connected
  monitors using the usual file name globbing rules. This can be used to create
  profiles matching multiple (or any) monitors.



  In order for `udev` to detect `drm` events from the native NVidia driver, the
  kernel parameter `nvidia-drm.modeset` must be set to 1. For example, add a file
  `/etc/modprobe.d/nvidia-drm-modeset.conf`:

  ```
  options nvidia_drm modeset=1
  ```



  Before running autorandr will check the environment for the `WAYLAND_DISPLAY`
  variable to check if the program is running in a Wayland session. This is to
  avoid issues between usage of xrandr in Wayland environments.

  If you need to run autorandr in a Wayland environment, one workaround is to
  unset the `WAYLAND_DISPLAY` variable before running the program, such as:

  ```
  WAYLAND_DISPLAY= autorandr
  ```



  **autorandr 1.15**
  * *2023-11-27* Several regex literal bug fixes
  * *2023-12-27* Fix #375: Listen to correct events in launcher
  * *2024-03-03* Fix #367: Skip profiles without outputs


  **autorandr 1.14**
  * *2023-06-22* Direct --match-edid renaming of output messages to stderr
  * *2023-06-22* Add Wayland awareness
  * *2023-06-22* Various minor auxiliary tooling bug fixes, see git-log

  **autorandr 1.13.3**
  * *2023-01-24* Revert udev rule to rely on "change" event (see #324)

  **autorandr 1.13.2**
  * *2023-01-23* Fix autostart in KDE (see #320)
  * *2023-01-23* Match add/remove rather than change in udev rule (see #321)
  * *2023-01-23* Fix wildcard use in EDIDs (see #322)
  * *2023-01-23* Do a final xrandr call to set the frame buffer size (see #319)

  **autorandr 1.13.1**
  * *2023-01-16* Fix bug with Version comparison

  **autorandr 1.13**
  * *2023-01-15* Add reversed horizontal/vertical profiles
  * *2023-01-15* Fix distutils deprecation warning
  * *2023-01-15* Print error when user script fails
  * *2022-12-01* Support `--skip-options set` to skip setting properties

  **autorandr 1.12.1**
  * *2021-12-22* Fix `--match-edid` (see #273)

  **autorandr 1.12**
  * *2021-12-16* Switch default interpreter to Python 3
  * *2021-12-16* Add `--list` to list all profiles
  * *2021-12-16* Add `--cycle` to cycle all detected profiles
  * *2021-12-16* Store display properties (see #204)

  **autorandr 1.11**
  * *2020-05-23* Handle empty sys.executable
  * *2020-06-08* Fix Python 2 compatibility
  * *2020-10-06* Set group membership of users in batch mode

  **autorandr 1.10.1**
  * *2020-05-04* Revert making the launcher the default (fixes #195)

  **autorandr 1.10**
  * *2020-04-23* Fix hook script execution order to match description from readme
  * *2020-04-11* Handle negative gamma values (fixes #188)
  * *2020-04-11* Sort approximate matches in detected profiles by quality of match
  * *2020-01-31* Handle non-ASCII environment variables (fixes #180)
  * *2019-12-31* Fix output positioning if the top-left output is not the first
  * *2019-12-31* Accept negative gamma values (and interpret them as 0)
  * *2019-12-31* Prefer the X11 launcher over systemd/udev configuration

  **autorandr 1.9**

  * *2019-11-10* Count closed lids as disconnected outputs
  * *2019-10-05* Do not overwrite existing configurations without `--force`
  * *2019-08-16* Accept modes that don't match the WWWxHHH pattern
  * *2019-03-22* Improve bash autocompletion
  * *2019-03-21* Store CRTC values in configurations
  * *2019-03-24* Fix handling of recently disconnected outputs (See #128 and #143)

  **autorandr 1.8.1**

  * *2019-03-18* Removed mandb call from Makefile

  **autorandr 1.8**

  * *2019-02-17* Add an X11 daemon that runs autorandr when a display connects (by @rliou92, #127)
  * *2019-02-17* Replace width=0 check with disconnected to detect disconnected monitors (by @joseph-jones, #139)
  * *2019-02-17* Fix handling of empty padding (by @jschwab, #138)
  * *2019-02-17* Add a man page (by @somers-all-the-time, #133)

  **autorandr 1.7**

  * *2018-09-25* Fix FB size computation with rotated screens (by @Janno, #117)

  **autorandr 1.6**

  * *2018-04-19* Bugfix: Do not load default profile unless --change is set
  * *2018-04-30* Added a `AUTORANDR_MONITORS` variable to hooks (by @bricewge, #106)
  * *2018-06-29* Fix detection of current configuration if extra monitors are active
  * *2018-07-11* Bugfix in the latest change: Correctly handle "off" minitors when comparing
  * *2018-07-19* Do not kill spawned user processes from systemd unit
  * *2018-07-20* Correctly handle "off" monitors when comparing -- fixup for another bug.

  **autorandr 1.5**

  * *2018-01-03* Add --version
  * *2018-01-04* Fixed vertical/horizontal/clone-largest virtual profiles
  * *2018-03-07* Output all non-error messages to stdout instead of stderr
  * *2018-03-25* Add --detected and --current to filter the profile list output
  * *2018-03-25* Allow wildcard matching in EDIDs

  **autorandr 1.4**

  * *2017-12-22* Fixed broken virtual profile support
  * *2017-12-14* Added support for a settings file
  * *2017-12-14* Added a virtual profile `off`, which disables all screens

  **autorandr 1.3**

  * *2017-11-13* Add a short form for `--load`
  * *2017-11-21* Fix environment stealing in `--batch` mode (See #87)

  **autorandr 1.2**

  * *2017-07-16* Skip `--panning` unless it is required (See #72)
  * *2017-10-13* Add `clone-largest` virtual profile

  **autorandr 1.1**

  * *2017-06-07* Call systemctl with `--no-block` from udev rule (See #61)
  * *2017-01-20* New script hook, `predetect`
  * *2017-01-18* Accept comments (lines starting with `#`) in config/setup files

  **autorandr 1.0**

  * *2016-12-07* Tag the current code as version 1.0.0; see github issue #54
  * *2016-10-03* Install a desktop file to `/etc/xdg/autostart` by default


pkgId: 697f82b6235532dcf4283d150ba74ae156dd5ff9cd40e0a8e49c18be11fc5a05
name: python-autorank
arch: src
version: 1.2.1
epoch: 0
release: 1
url: https://github.com/sherbold/autorank
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autorank-1.2.1-1.src.rpm
checksum_type: sha256
summary:
  Automated ranking of populations in a repeated measures experiment, e.g., to rank different machine learning approaches tested on the same data.

description:
  [![Actions Status](https://github.com/sherbold/autorank/workflows/Build/badge.svg)](https://github.com/sherbold/autorank/actions)
  [![codecov](https://codecov.io/gh/sherbold/autorank/branch/master/graph/badge.svg)](https://codecov.io/gh/sherbold/autorank)
  [![DOI](https://joss.theoj.org/papers/10.21105/joss.02173/status.svg)](https://doi.org/10.21105/joss.02173)
  [![PyPI version](https://badge.fury.io/py/autorank.svg)](https://badge.fury.io/py/autorank)



  Autorank is a simple Python package with one task: simplify the comparison between (multiple) paired populations. This
  is, for example, required if the performance of different machine learning algorithms or simulations should be compared
  on multiple data sets. The performance measures on each data set are then the paired samples, the difference in the
  central tendency (e.g., the mean or median) can be used to rank the different algorithms. This problem is not new and
  how such tests could be done was already described in 2006  in the well-known article _Janez Demšar. 2006. Statistical
  Comparisons of Classifiers over Multiple Data Sets. J. Mach. Learn. Res. 7 (December 2006), 1–30_.

  Regardless, the correct use of Demšar guidelines is hard for non-experts in statistics. Correct use of the guidelines
  requires the decision of whether a paired t-test, a Wilcoxon's rank sum test, repeated measures ANOVA with Tukey's HSD
  as post-hoc test, or Friedman's tests and Nemenyi's post-hoc test to determine an answer to the question if there are
  differences. For this, the distribution of the populations must be analyzed with the Shapiro-Wilk test for normality
  and, depending on the normality with Levene's test or Bartlett's tests for homogeneity of the data. All this is already
  quite complex. This does not yet account for the adjustment of the significance level in case of repeated tests to
  achieve the desired family-wise significance. Additionally, not only the tests should be conducted, but good reporting
  of the results also include confidence intervals, effect sizes, and the decision of whether it is appropriate to report
  the mean value and standard deviation, or whether the median value and the median absolute deviation is more
  appropriate.

  Moreover, Bayesian statistics have become more popular in recent years. There is even a follow up article co-authored
  by Janez Demšar that suggest to use Bayesian statistics: _Alessio Benavoli, Giorgio Corani, Janez Demšar, Marco
  Zaffalon. 2017. Time for a Change: a Tutorial for Comparing Multiple Classifiers Through Bayesian Analysis. J. Mach.
  Learn. Res. 18(77), 1-36_. There are two main advantages of the Bayesian approach. 1) Instead of an indirect assessment
  of the hypothesis that something is equal or different through a p-value, Bayesian statistics directly computes the
  probability that the central tendency of a population is smaller, equal, or larger than that of other populations. 2)
  The definition of a Region of Practical Equivalence (ROPE) allows the definition of differences are too small to be
  practically relevant, which enables the Bayesian approach to determine equality of populations.

  The goal of Autorank is to simplify the statistical analysis for non-experts. Autorank takes care of all of the above
  with a single function call, both for the traditional *frequentist* approach (Guidelines from 2006), as well as for the
  *Bayesian* approach (Guidelines from 2017). Additional functions allow the generation of appropriate plots, result
  tables, and even of a complete latex document. All that is required is the data about the populations is in a
  [Pandas](https://pandas.pydata.org/) dataframe.




  ```
  @article{Herbold2020,
    doi = {10.21105/joss.02173},
    url = {https://doi.org/10.21105/joss.02173},
    year = {2020},
    publisher = {The Open Journal},
    volume = {5},
    number = {48},
    pages = {2173},
    author = {Steffen Herbold},
    title = {Autorank: A Python package for automated ranking of classifiers},
    journal = {Journal of Open Source Software}
  }
  ```



  Autorank is available on PyPi and can be installed using pip.

  ```
  pip install autorank
  ```

  You can also clone this repository and install the latest development version (requires git and setuptools).
  ```
  git clone https://github.com/sherbold/autorank
  cd autorank
  python setup.py install
  ```



  You can find the API documentation of the current master of autorank
  [online](https://sherbold.github.io/autorank/autorank/).



  The following flow chart summarizes the decisions made by autorank.

  ![CD Diagram](flowchart.png)

  The user has to decide if the frequentist approach based on the guidelines from 2006 or the Bayesian approach based on
  the guidelines from 2017 is used. Afterwards, autorank does the rest on its own.



  Autorank determines if all populations are normal to select appropriate statistical markers for reporting.
  - First all populations are checked with the Shapiro-Wilk test for normality. We use Bonferoni correction for these
    tests, i.e., alpha/#populations.
  - Based on the normality and the homogeneity, we select appropriate tests, effect sizes, and methods for determining
    the confidence intervals of the central tendency.

  If all columns are normal, we calculate:
  - The mean value as central tendency.
  - The empirical standard deviation as measure for the variance.
  - The confidence interval for the mean value.
  - The effect size in comparison to the highest mean value using Cohen's d.

  If at least one column is not normal, we calculate:
  - The median as central tendency.
  - The median absolute deviation from the median as measure for the variance.
  - The confidence interval for the median.
  - The effect size in comparison to the highest ranking approach using
  [Akinshin's gamma](https://aakinshin.net/posts/nonparametric-effect-size/).



  The appropriate statistical test for the frequentist approach is determined based on the normality of the data, the
  homogeneity of the populations (equal variances), and the number of populations. The best test for homogeneity depends
  on the normality of the data.
  - If all columns are normal, we use Bartlett's test for homogeneity, otherwise we use Levene's test.

  We then have four variants for statistical testing.
  - If there are two populations and both populations are normal, we use the paired t-test.
  - If there are two populations and at least one populations is not normal, we use Wilcoxon's signed rank test.
  - If there are more than two populations and all populations are normal and homoscedastic, we use repeated measures
    ANOVA with Tukey's HSD as post-hoc test.
  - If there are more than two populations and at least one populations is not normal or the populations are
    heteroscedastic, we use Friedman's test with the Nemenyi post-hoc test.



  For the Bayesian approach, we can use the Bayesian Signed Rank test, which makes no assumptions on the data. The
  critical aspect of this test is the Region Of Practical Equivalence (ROPE) that defines when differences are practically
  irrelevant. If not configured otherwise, autorank determines the ROPE as follows.
  - For normal data, the ROPE is defined as 0.1*STD, where STD is the standard deviation. This means the ROPE is the area
    with an effect size of less than d=0.1 (Cohen's d).
  - For non-normal data, the ROPE is defined as 0.1*MAD, where MAD is the mean absolute deviation of the median. This means
    the ROPE is the area with an effect size of less than gamma=0.1 (Akinshin's gamma)

  This follows [Kruschke and Liddell, 2018](https://doi.org/10.3758/s13423-016-1221-4), who suggest to determine the ROPE
  as half the size of a small effect. Since a small
  effect with Cohen's d is 0.2, this means that a ROPE of 0.1*d translates to a considering all differences that are not
  even half of a small effect as practically equivalent. The same concept is applied with Akinshin's gamma, which is a
  direct translation of the concept of Cohen's d to robust statistics based on the median absolute deviation instead
  of the standard deviation.

  Users of autorank can define their own ROPE either with a different ratio of the effect size or using a fixed range for
  the ROPE.




  We use the paired t-test, the Wilcoxon signed rank test, and the Friedman test from [scipy](https://www.scipy.org/). The
  repeated measures ANOVA and Tukey's HSD test (including the calculation of the confidence intervals) are used from
  [statsmodels](statsmodels). We use the Bayesian signed rank test from the [baycomp](https://github.com/janezd/baycomp)
  package. We use own implementations for the calculation of critical distance of the Nemenyi test, the calculation of the
  effect sizes, and the calculation of the confidence intervals (with the exception of Tukey's HSD).




  The following example shows the usage of `autorank`. First, we import the functions from autorank and create some data.
  ```python
  import numpy as np
  import pandas as pd
  import matplotlib.pyplot as plt
  from autorank import autorank, plot_stats, create_report, latex_table

  np.random.seed(42)
  pd.set_option('display.max_columns', 7)
  std = 0.3
  means = [0.2, 0.3, 0.5, 0.8, 0.85, 0.9]
  sample_size = 50
  data = pd.DataFrame()
  for i, mean in enumerate(means):
      data['pop_%i' % i] = np.random.normal(mean, std, sample_size).clip(0, 1)
  ```

  The statistical analysis of the data only requires a single command. As a result, you get a named tuple with all
  relevant information from the statistical analysis conducted.
  ```python
  result = autorank(data, alpha=0.05, verbose=False)
  print(result)
  ```
  Output:
  ```
  RankResult(rankdf=
         meanrank    median       mad  ci_lower  ci_upper  effect_size    mangitude
  pop_5      2.18  0.912005  0.130461  0.692127         1  2.66454e-17   negligible
  pop_4      2.29  0.910437  0.132786  0.654001         1       -0.024   negligible
  pop_3      2.47  0.858091  0.210394  0.573879         1       0.1364   negligible
  pop_2      3.95  0.505057  0.333594  0.227184   0.72558       0.6424        large
  pop_1      4.71  0.313824  0.247339  0.149473  0.546571       0.8516        large
  pop_0      5.40  0.129756  0.192377         0  0.349014       0.9192        large
  pvalue=2.3412212612346733e-28
  cd=1.0662484349869374
  omnibus='friedman'
  posthoc='nemenyi'
  all_normal=False
  pvals_shapiro=[1.646607051952742e-05, 0.0605173334479332, 0.13884511590003967, 0.00010030837438534945,
                 2.066387423838023e-06, 1.5319776593969436e-06]
  homoscedastic=True
  pval_homogeneity=0.2663177301695518
  homogeneity_test='levene'
  alpha=0.05
  alpha_normality=0.008333333333333333
  num_samples=50
  posterior_matrix=
  None
  decision_matrix=
  None
  rope=None
  rope_mode=None
  effect_size=akinshin_gamma)
  ```

  By default, autorank performs a frequentist analysis. If you want to conduct a Bayesian analysis, you simple have to
  define this in the call of the `autorank` function. Please not that the Bayesian analysis is computationally expensive,
  so do not worry if this requires a couple of seconds (or in case of many populations, even minutes).

  ```python
  result_bayesian = autorank(data, alpha=0.05, verbose=False, approach='bayesian')
  ```
  Output:
  ```
  RankResult(rankdf=
           median       mad  ci_lower  ci_upper effect_size   magnitude  p_equal  p_smaller      decision
  pop_5  0.912005  0.130461  0.605547         1           0  negligible      NaN        NaN            NA
  pop_4  0.910437  0.132786   0.63089         1   0.0119148  negligible      0.0    0.66490  inconclusive
  pop_3  0.858091  0.210394  0.545962         1    0.307991       small      0.0    0.81552  inconclusive
  pop_2  0.505057  0.333594  0.181309  0.744055     1.60669       large      0.0    1.00000       smaller
  pop_1  0.313824  0.247339  0.106464  0.590593     3.02519       large      0.0    1.00000       smaller
  pop_0  0.129756  0.192377         0   0.42154     4.75934       large      0.0    1.00000       smaller
  pvalue=None
  cd=None
  omnibus=bayes
  posthoc=bayes
  all_normal=False
  pvals_shapiro=[1.646607051952742e-05, 0.0605173334479332, 0.13884511590003967, 0.00010030837438534945, 2.066387423838023e-06, 1.5319776593969436e-06]
  homoscedastic=None
  pval_homogeneity=None
  homogeneity_test=None
  alpha=0.05
  alpha_normality=0.008333333333333333
  num_samples=50
  posterior_matrix=
        pop_5                  pop_4                    pop_3            pop_2                    pop_1                    pop_0
  pop_5   NaN  (0.6649, 0.0, 0.3351)  (0.81552, 0.0, 0.18448)  (1.0, 0.0, 0.0)          (1.0, 0.0, 0.0)          (1.0, 0.0, 0.0)
  pop_4   NaN                    NaN  (0.80308, 0.0, 0.19692)  (1.0, 0.0, 0.0)          (1.0, 0.0, 0.0)          (1.0, 0.0, 0.0)
  pop_3   NaN                    NaN                      NaN  (1.0, 0.0, 0.0)          (1.0, 0.0, 0.0)          (1.0, 0.0, 0.0)
  pop_2   NaN                    NaN                      NaN              NaN  (0.99538, 0.0, 0.00462)          (1.0, 0.0, 0.0)
  pop_1   NaN                    NaN                      NaN              NaN                      NaN  (0.99938, 0.0, 0.00062)
  pop_0   NaN                    NaN                      NaN              NaN                      NaN                      NaN
  decision_matrix=
                pop_5         pop_4         pop_3    pop_2    pop_1    pop_0
  pop_5           NaN  inconclusive  inconclusive  smaller  smaller  smaller
  pop_4  inconclusive           NaN  inconclusive  smaller  smaller  smaller
  pop_3  inconclusive  inconclusive           NaN  smaller  smaller  smaller
  pop_2        larger        larger        larger      NaN  smaller  smaller
  pop_1        larger        larger        larger   larger      NaN  smaller
  pop_0        larger        larger        larger   larger   larger      NaN
  rope=0.1
  rope_mode=effsize
  effect_size=akinshin_gamma)
  ```

  You can go ahead and use this tuple to create your own report about the statistical analysis. Alternatively, you can use
  autorank for this task.
  ```python
  create_report(result)
  ```
  Output:
  ```
  The statistical analysis was conducted for 6 populations with 50 paired samples.
  The family-wise significance level of the tests is alpha=0.050.
  We rejected the null hypothesis that the population is normal for the populations pop_5 (p=0.000), pop_2 (p=0.000),
  pop_1 (p=0.000), and pop_0 (p=0.000). Therefore, we assume that not all populations are normal.
  Because we have more than two populations and the populations and some of them are not normal, we use the
  non-parametric Friedman test as omnibus test to determine if there are any significant differences between the
  median values of the populations. We use the post-hoc Nemenyi test to infer which differences are significant. We report
  the median (MD), the median absolute deviation (MAD) and the mean rank (MR) among all populations over the samples.
  Differences between populations are significant, if the difference of the mean rank is greater than the critical
  distance CD=1.066 of the Nemenyi test.
  We reject the null hypothesis (p=0.000) of the Friedman test that there is no difference in the central tendency of
  the populations pop_5 (MD=0.912+-0.154, MAD=0.130, MR=2.180), pop_4 (MD=0.910+-0.173, MAD=0.133, MR=2.290), pop_3
  (MD=0.858+-0.213, MAD=0.210, MR=2.470), pop_2 (MD=0.505+-0.249, MAD=0.334, MR=3.950), pop_1 (MD=0.314+-0.199,
  MAD=0.247, MR=4.710), and pop_0 (MD=0.130+-0.175, MAD=0.192, MR=5.400). Therefore, we assume that there is a
  statistically significant difference between the median values of the populations.
  Based on the post-hoc Nemenyi test, we assume that there are no significant differences within the following groups:
  pop_5, pop_4, and pop_3; pop_2 and pop_1; pop_1 and pop_0. All other differences are significant.
  ```

  Or you could use Autorank to generate a plot that visualizes the statistical analysis. Autorank creates plots of the
  confidence interval in case of the paired t-test and repeated measures ANOVA and a critical distance diagram for the
  post-hoc Nemenyi test.

  ```python
  plot_stats(result)
  plt.show()
  ```

  For the above example, the following plot is created:

  ![CD Diagram](examples/cd_diagram.png)

  To further support reporting in scholarly article, Autorank can also generate a latex table with the relevant results.
  ```python
  latex_table(result)
  ```
  Output:
  ```
  \begin{table}[h]
  \centering
  \begin{tabular}{lrrllll}
  \toprule
  {} &    MR &   MED &   MAD &              CI & $\gamma$ &   Magnitude \\
  \midrule
  pop\_5 & 2.180 & 0.912 & 0.130 &  [0.692, 1.000] &     0.000 &  negligible \\
  pop\_4 & 2.290 & 0.910 & 0.133 &  [0.654, 1.000] &     0.012 &  negligible \\
  pop\_3 & 2.470 & 0.858 & 0.210 &  [0.574, 1.000] &     0.308 &       small \\
  pop\_2 & 3.950 & 0.505 & 0.334 &  [0.227, 0.726] &     1.607 &       large \\
  pop\_1 & 4.710 & 0.314 & 0.247 &  [0.149, 0.547] &     3.025 &       large \\
  pop\_0 & 5.400 & 0.130 & 0.192 &  [0.000, 0.349] &     4.759 &       large \\
  \bottomrule
  \end{tabular}
  \caption{Summary of populations}
  \label{tbl:stat_results}
  \end{table}
  ```

  The rendered table looks like this (may change depending on the class of the document).

  ![Table](examples/table.png)



  If you want to modify the code of autorank, we recommend that you setup a local development environment with a
  virtual environment as follows.

  ```
  git clone https://github.com/sherbold/autorank
  cd autorank
  python3 -m venv .
  source bin/activate
  pip install .
  ```

  You can run the tests to check if everything works.

  ```
  python -m unittest
  ```



  Contributions to Autorank are welcome.

  - Just file an [Issue](https://github.com/sherbold/autorank/issues) to ask questions, report bugs, or request new
  features.
  - Pull requests via GitHub are also welcome.

  Potential contributions include more detailed report generation or the extension of Autorank to more types of data,
  e.g., independent populations, or paired populations with unequal sample sizes.




  Autorank is published under the Apache 2.0 Licence.


pkgId: 84f85b69b4662562d0aef6e06e3eb56f71b045b41dd683701a2c9111d5ad9540
name: python-autoray
arch: src
version: 0.6.12
epoch: 0
release: 1
summary: Abstract your array operations.
url: http://github.com/jcmgray/autoray
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoray-0.6.12-1.src.rpm
checksum_type: sha256
description:
  ![autoray-header](https://github.com/jcmgray/autoray/assets/8982598/c5cb89bf-cc16-4345-8796-e0bd98dc2a15)

  [![tests](https://github.com/jcmgray/autoray/actions/workflows/tests.yml/badge.svg)](https://github.com/jcmgray/autoray/actions/workflows/tests.yml)
  [![codecov](https://codecov.io/gh/jcmgray/autoray/branch/main/graph/badge.svg?token=Q5evNiuT9S)](https://codecov.io/gh/jcmgray/autoray)
  [![Codacy Badge](https://app.codacy.com/project/badge/Grade/ba896d74c4954dd58da01df30c7bf326)](https://app.codacy.com/gh/jcmgray/autoray/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
  [![Docs](https://readthedocs.org/projects/autoray/badge/?version=latest)](https://autoray.readthedocs.io)
  [![PyPI](https://img.shields.io/pypi/v/autoray?color=teal)](https://pypi.org/project/autoray/)
  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/autoray/badges/version.svg)](https://anaconda.org/conda-forge/autoray)

  [`autoray`](https://autoray.readthedocs.io/en/latest) is a lightweight python AUTOmatic-arRAY library for
  abstracting your tensor operations. Primarily it provides an
  [*automatic* dispatch mechanism](https://autoray.readthedocs.io/en/latest/automatic_dispatch.html#)
  that means you can write backend agnostic code that works for:

  * [numpy](https://github.com/numpy/numpy)
  * [pytorch](https://pytorch.org/)
  * [jax](https://github.com/google/jax)
  * [cupy](https://github.com/cupy/cupy)
  * [dask](https://github.com/dask/dask)
  * [autograd](https://github.com/HIPS/autograd)
  * [tensorflow](https://github.com/tensorflow/tensorflow)
  * [sparse](https://sparse.pydata.org/)
  * [mars](https://github.com/mars-project/mars)
  * ... and indeed **any** library that provides a numpy-*ish* api, even if it
    knows nothing about `autoray`.

  Beyond that, abstracting the array interface allows you to:

  * *swap [custom versions of functions](https://autoray.readthedocs.io/en/latest/automatic_dispatch.html#functions)
    for specific backends*
  * *trace through computations [lazily](https://autoray.readthedocs.io/en/latest/lazy_computation.html) without actually
    running them*
  * *automatically [share intermediates and fold constants](https://autoray.readthedocs.io/en/latest/lazy_computation.html#sharing-intermediates)
    in computations*
  * *compile functions with a [unified interface](https://autoray.readthedocs.io/en/latest/compilation.html) for different
    backends*




  The main function of `autoray` is
  [`do`](https://autoray.readthedocs.io/en/latest/autoapi/autoray/autoray/index.html#autoray.autoray.do),
  which takes a function
  name followed by `*args` and `**kwargs`, and automatically looks up (and
  caches) the correct function to match the equivalent numpy call:

  ```python
  from autoray as ar

  def noised_svd(x):
      
      U, s, VH = ar.do('linalg.svd', x)

      
      sn = s + 0.1 * ar.do('random.normal', size=ar.shape(s), like=s)

      
      return ar.do('einsum', 'ij,j,jk->ik', U, sn, VH)


  x = ar.do('random.uniform', size=(100, 100), like="torch")


  y = noised_svd(x)


  ar.infer_backend(y)

  ```

  If you don't like the explicit `do` syntax, or simply want a
  drop-in replacement for existing code, you can also import the `autoray.numpy`
  module:

  ```python
  from autoray import numpy as np


  with ar.backend_like('cupy'):
      z = np.ones((3, 4), dtype='float32')

  np.exp(z)



  ```

  Custom backends and functions can be dynamically registered with:

  * [`register_backend`](https://autoray.readthedocs.io/en/latest/autoapi/autoray/autoray/index.html#autoray.autoray.register_backend)
  * [`register_function`](https://autoray.readthedocs.io/en/latest/autoapi/autoray/autoray/index.html#autoray.autoray.register_function)

  The main documentation is available at [autoray.readthedocs.io](https://autoray.readthedocs.io/en/latest/).


pkgId: 21c0f6ddf7315b6102975a5e3829a5f7131f247da48fe239e627874c86966027
name: python-autoreadme
arch: src
version: 0.2302.3
epoch: 0
release: 1
summary: Generate READMEs with collapsable* code and corresponding output from Python
url: https://github.com/davips/autoreadme
rpm_license: GPL3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoreadme-0.2302.3-1.src.rpm
checksum_type: sha256
description:
  ![test](https://github.com/davips/autoreadme/workflows/test/badge.svg)
  [![codecov](https://codecov.io/gh/davips/autoreadme/branch/main/graph/badge.svg)](https://codecov.io/gh/davips/autoreadme)



  Generate READMEs with collapsable* code and corresponding output from Python.





  ```bash

  python3 -m venv venv
  source venv/bin/activate


  pip install autoreadme
  ```



  ```bash
  git clone https://github.com/davips/autoreadme
  cd autoreadme
  ```



  A typical *README-edit.md* file would be:

  ```markdown

  We can cook using the following Python code:
  <<cook>>

  However, we can also clean:
  <<clean>>
  ```

  The example file (given in this repo as *examples/README-edit.md*) depends on two scripts. Each script should have
  a `# ...` line where the output until that moment is expected to appear:

  *examples/cook.py*:

  ```python3

  x = 2 * 8
  print("This script prints something:", x)

  ```

  *examples/clean.py*:

  ```python3

  y = 34 % 5
  print("this script prints another thing.", y)

  ```

  Running...

  ```bash
  autoreadme -i examples/README-edit.md -s examples/ -o examples/README.md examples/README-edit.md
  ```

  ...will result in the following markdown:


  <blockquote>


  We can cook using the following Python code:

  **Cooking**
  <details>
  <p>

  ```python3
  x = 2 * 8
  print("This script prints something:", x)
  ```

  ```
  This script prints something: 16
  ```

  </p>
  </details>

  However, we can also clean:

  **Cleaning**
  <details>
  <p>

  ```python3
  y = 34 % 5
  print("this script prints another thing.", y)
  ```

  ```
  this script prints another thing. 4
  ```

  </p>
  </details>
  </blockquote>


pkgId: 07ab7f1b3141af9e9ea75a3c897b27d165f07964d66f023fb3dc0e21b0f55400
name: python-autoreduce-db
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: ISIS Autoreduce
url: https://github.com/ISISScientificComputing/autoreduce-db/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoreduce-db-0.1.4-1.src.rpm
checksum_type: sha256
description:
  This package contains the database models that are shared across the backend and the frontend of Autoreduce.


pkgId: ee2669b90bfc63729b7b13f8af31c04dc11ce1f4cb8cc84969ca09a8ce6cf8f1
name: python-autoreduce-rest-api
arch: src
version: 22.0.0.dev23
epoch: 0
release: 1
summary: ISIS Autoreduction Runs REST API
url: https://pypi.org/project/autoreduce-rest-api/
rpm_license: GNU General Public License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoreduce-rest-api-22.0.0.dev23-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/autoreduction/autoreduce/workflows/Tests/badge.svg?branch=master)](https://github.com/autoreduction/autoreduce/actions?query=workflow%3ATests+branch%3Amaster)
  [![codecov](https://codecov.io/gh/autoreduction/autoreduce/branch/master/graph/badge.svg?token=ZJ1C5VE5WN)](https://codecov.io/gh/autoreduction/autoreduce)



  A service for automated batch processing of jobs specifically design for use at [ISIS Neutron and Muon Facility](https://www.isis.stfc.ac.uk). For further documentation see also [Wiki](https://github.com/autoreduction/autoreduce/wiki).

  In one (not complete) picture the Autoreduction service is:

  ![Example Table](documentation/assets/main_components/Autoreduction_main_components.png)

  The code for monitors of experiments, i.e. that send messages to the Messenging server when experiments are ready to be reduced (processed) is in monitors folder. The code for processors which consume/subscribe to Messenging queues and run jobs on the compute nodes are in the QueueProcessors folder. Finally, the code for the WebApp, which is used to monitor the system by both users and those who support the service is located in the WebApp folder.

  This service discovers raw data automatically, reduces it (performs some processing on them) and stores the result. The results are rendered by the web application which allows the user and support staff to monitor the system and rerun jobs manually as needed.


pkgId: bc81716071d6b81271fe92948dac9969669bc491b70e870dbd1865a7f6b7f10c
name: python-autoreduce-scripts
arch: src
version: 22.0.0.dev44
epoch: 0
release: 1
summary: ISIS Autoreduce helper scripts
url: https://pypi.org/project/autoreduce-scripts/
rpm_license: GNU General Public License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoreduce-scripts-22.0.0.dev44-1.src.rpm
checksum_type: sha256
description:
  This repository contains scripts for using the Autoreduce service from command line, or health/sanity checks.


pkgId: f0105b8d2904927dc9e9ae59326cee856c353a925a642675c796d322a3a67992
name: python-autoregistry
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: Automatic registry design-pattern for mapping names to functionality.
url: https://github.com/BrianPugh/autoregistry
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoregistry-1.1.2-1.src.rpm
checksum_type: sha256
description:
  Invoking functions and class-constructors from a string is a common design pattern
  that AutoRegistry aims to solve.
  For example, a user might specify a backend of type ``"sqlite"`` in a yaml configuration
  file, for which our program needs to construct the ``SQLite`` subclass of our ``Database`` class.
  Classically, you would need to manually create a lookup, mapping the string ``"sqlite"`` to
  the ``SQLite`` constructor.
  With AutoRegistry, the lookup is automatically created for you.
  AutoRegistry has a single  powerful class ``Registry`` that can do the following:
  * Be inherited to automatically register subclasses by their name.
  * Be directly invoked ``my_registry = Registry()`` to create a decorator
    for registering callables like functions.
  * Traverse and automatically create registries for other python libraries.
  AutoRegistry is also highly configurable, with features like name-schema-enforcement and name-conversion-rules.
  `Checkout the docs for more information <https://autoregistry.readthedocs.io/en/latest/?badge=latest/>`_.
  `Watch AutoRegistry in action! <https://youtu.be/4No_NE7bUOM>`_


pkgId: 0e4517dbb16137dbba9c8f67eeb0285a4e9fba2abeb5e91717e238ec132bcc6b
name: python-autoregressive-diffusion-pytorch
arch: src
version: 0.2.8
epoch: 0
release: 1
summary: Autoregressive Diffusion - Pytorch
url: https://pypi.org/project/autoregressive-diffusion-pytorch/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoregressive-diffusion-pytorch-0.2.8-1.src.rpm
checksum_type: sha256
description:
  <img src="./ar-diffusion.png" width="400px"></img>



  Implementation of the architecture behind <a href="https://arxiv.org/abs/2406.11838">Autoregressive Image Generation without Vector Quantization</a> in Pytorch

  Official repository has been released <a href="https://github.com/LTH14/mar">here</a>

  <a href="https://github.com/lucidrains/transfusion-pytorch">Alternative route</a>

  <img src="./images/results.96600.png" width="400px"></img>

  *oxford flowers at 96k steps*



  ```bash
  $ pip install autoregressive-diffusion-pytorch
  ```



  ```python
  import torch
  from autoregressive_diffusion_pytorch import AutoregressiveDiffusion

  model = AutoregressiveDiffusion(
      dim_input = 512,
      dim = 1024,
      max_seq_len = 32,
      depth = 8,
      mlp_depth = 3,
      mlp_width = 1024
  )

  seq = torch.randn(3, 32, 512)

  loss = model(seq)
  loss.backward()

  sampled = model.sample(batch_size = 3)

  assert sampled.shape == seq.shape

  ```

  For images treated as a sequence of tokens (as in paper)

  ```python
  import torch
  from autoregressive_diffusion_pytorch import ImageAutoregressiveDiffusion

  model = ImageAutoregressiveDiffusion(
      model = dict(
          dim = 1024,
          depth = 12,
          heads = 12,
      ),
      image_size = 64,
      patch_size = 8
  )

  images = torch.randn(3, 3, 64, 64)

  loss = model(images)
  loss.backward()

  sampled = model.sample(batch_size = 3)

  assert sampled.shape == images.shape

  ```

  An images trainer

  ```python
  import torch

  from autoregressive_diffusion_pytorch import (
      ImageDataset,
      ImageAutoregressiveDiffusion,
      ImageTrainer
  )

  dataset = ImageDataset(
      '/path/to/your/images',
      image_size = 128
  )

  model = ImageAutoregressiveDiffusion(
      model = dict(
          dim = 512
      ),
      image_size = 128,
      patch_size = 16
  )

  trainer = ImageTrainer(
      model = model,
      dataset = dataset
  )

  trainer()
  ```

  For an improvised version using flow matching, just import `ImageAutoregressiveFlow` and `AutoregressiveFlow` instead

  The rest is the same

  ex.

  ```python
  import torch

  from autoregressive_diffusion_pytorch import (
      ImageDataset,
      ImageTrainer,
      ImageAutoregressiveFlow,
  )

  dataset = ImageDataset(
      '/path/to/your/images',
      image_size = 128
  )

  model = ImageAutoregressiveFlow(
      model = dict(
          dim = 512
      ),
      image_size = 128,
      patch_size = 16
  )

  trainer = ImageTrainer(
      model = model,
      dataset = dataset
  )

  trainer()
  ```



  ```bibtex
  @article{Li2024AutoregressiveIG,
      title   = {Autoregressive Image Generation without Vector Quantization},
      author  = {Tianhong Li and Yonglong Tian and He Li and Mingyang Deng and Kaiming He},
      journal = {ArXiv},
      year    = {2024},
      volume  = {abs/2406.11838},
      url     = {https://api.semanticscholar.org/CorpusID:270560593}
  }
  ```

  ```bibtex
  @article{Wu2023ARDiffusionAD,
      title     = {AR-Diffusion: Auto-Regressive Diffusion Model for Text Generation},
      author    = {Tong Wu and Zhihao Fan and Xiao Liu and Yeyun Gong and Yelong Shen and Jian Jiao and Haitao Zheng and Juntao Li and Zhongyu Wei and Jian Guo and Nan Duan and Weizhu Chen},
      journal   = {ArXiv},
      year      = {2023},
      volume    = {abs/2305.09515},
      url       = {https://api.semanticscholar.org/CorpusID:258714669}
  }
  ```

  ```bibtex
  @article{Karras2022ElucidatingTD,
      title   = {Elucidating the Design Space of Diffusion-Based Generative Models},
      author  = {Tero Karras and Miika Aittala and Timo Aila and Samuli Laine},
      journal = {ArXiv},
      year    = {2022},
      volume  = {abs/2206.00364},
      url     = {https://api.semanticscholar.org/CorpusID:249240415}
  }
  ```

  ```bibtex
  @article{Liu2022FlowSA,
      title   = {Flow Straight and Fast: Learning to Generate and Transfer Data with Rectified Flow},
      author  = {Xingchao Liu and Chengyue Gong and Qiang Liu},
      journal = {ArXiv},
      year    = {2022},
      volume  = {abs/2209.03003},
      url     = {https://api.semanticscholar.org/CorpusID:252111177}
  }
  ```

  ```bibtex
  @article{Esser2024ScalingRF,
      title   = {Scaling Rectified Flow Transformers for High-Resolution Image Synthesis},
      author  = {Patrick Esser and Sumith Kulal and A. Blattmann and Rahim Entezari and Jonas Muller and Harry Saini and Yam Levi and Dominik Lorenz and Axel Sauer and Frederic Boesel and Dustin Podell and Tim Dockhorn and Zion English and Kyle Lacey and Alex Goodwin and Yannik Marek and Robin Rombach},
      journal = {ArXiv},
      year    = {2024},
      volume  = {abs/2403.03206},
      url     = {https://api.semanticscholar.org/CorpusID:268247980}
  }
  ```

rpm_license:
[cell repeats an earlier one in this file: 1065 characters]


pkgId: 46042381ffb181df8ca2ffeaed0f2474e5e49cdd0f9b8c167b72763f86ab95a2
name: python-autoreject
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: Automated rejection and repair of epochs in M/EEG.
url: http://autoreject.github.io/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoreject-0.4.3-1.src.rpm
checksum_type: sha256
description:
  |CircleCI|_ |GitHub Actions|_ |Codecov|_ |PyPI|_ |Conda-Forge|_
  This is a library to automatically reject bad trials and repair bad sensors in magneto-/electroencephalography (M/EEG) data.
  The documentation can be found under the following links:
  - for the `stable release <https://autoreject.github.io/stable/index.html>`_
  - for the `latest (development) version <https://autoreject.github.io/dev/index.html>`_


pkgId: 97e57b93fcdb8983684afb679264595ba32c5ab17f0a901d5a486c65bf180ea1
name: python-autoremove-torrents-hnr
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: Automatically remove torrents according to your strategies with H&R check support.
url: https://github.com/tjupt/autoremove-torrents
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoremove-torrents-hnr-1.6.0-1.src.rpm
checksum_type: sha256
description:
  这是一个支持 H&R 检查的自动删种程序，基于 [autoremove-torrents](https://github.com/jerrymakesjelly/autoremove-torrents) 修改，在此感谢原作者jerrymakesjelly。



  - 支持通过 API 检查种子的 H&R 状态
  - 可以根据 H&R 达标情况决定是否删除种子



  ```bash
  pip install autoremove-torrents-hnr
  ```



  ```yaml
  my_task:
    client: qbittorrent
    host: http://127.0.0.1:7474
    username: admin
    password: password

    strategies:
      remove_completed_hnr:
        categories:
          - TJUPT
        hnr:
          host: https://pt.example.org/api/v1/hnr.php
          api_token: your_api_token
          require_complete: true  # true表示只删除已达标的种子
  ```

  其他条件配置请参考原项目 [autoremove-torrents](https://github.com/jerrymakesjelly/autoremove-torrents) 的文档。



  H&R API 接口文档：[hnr_api.md](https://github.com/tjupt/autoremove-torrents/blob/master/hnr_api.md)

  在策略配置中添加 `hnr` 部分：

  - `host`: H&R API 地址
  - `api_token`: API 访问令牌
  - `require_complete`:
    - `true`: 只删除 H&R 已达标的种子
    - `false`: 只删除 H&R 未达标的种子



  ```bash

  autoremove-torrents --view --conf=config.yml


  autoremove-torrents --conf=config.yml
  ```



  ```bash
  autoremove-torrents --conf=config.yml --log=logs/autoremove.log
  ```



  - hnr_api.py: H&R API 客户端，用于查询种子的 H&R 状态
  - 其他客户端适配器（如 qBittorrent, Transmission 等）

  - base.py: 条件基类，定义了条件的基本接口
  - hnr.py: H&R 条件检查实现
  - 其他条件实现（如分享率、做种时间等）

  - strategy.py: 策略执行器，负责：
  - 应用各种条件
  - 管理种子的保留和删除列表
  - 执行删除操作

  - conditionparser.py: 条件解析器，负责：
  - 解析配置文件中的条件
  - 创建对应的条件实例
  - 处理条件组合



  - 读取 config.yml
  - 解析任务和策略配置

  - 根据配置创建对应的客户端实例
  - 建立连接并验证

  - 获取种子列表
  - 应用分类过滤
  - 执行条件检查
  - 确定删除列表

  - 执行种子删除
  - 记录操作日志



  MIT License


pkgId: e5172f54cbd899245904e4396ec81bf1d3205df4266ad8742764e8f04fc2b18a
name: python-autoremove-torrents-hnr
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Automatically remove torrents according to your strategies with H&R check support.
url: https://github.com/tjupt/autoremove-torrents
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoremove-torrents-hnr-2.0.0-1.src.rpm
checksum_type: sha256
description:
  这是一个支持 H&R 检查的自动删种程序，基于 [autoremove-torrents](https://github.com/jerrymakesjelly/autoremove-torrents) 修改，在此感谢原作者jerrymakesjelly。



  v2.0.0
  - 整体重构，可以根据 H&R 状态码灵活配置删除条件
  - 支持多个策略组合使用
  - 支持检查种子的做种时间、上传速度等条件
  - 增加种子状态本地缓存，减少 API 请求次数

  v1.6.1
  - 支持通过 API 检查种子的 H&R 状态来删除种子



  ```bash
  pip install autoremove-torrents-hnr
  ```



  ```bash
  pip install autoremove-torrents-hnr --upgrade
  或者
  pip install autoremove-torrents-hnr==具体版本号
  ```



  ```bash
  pip uninstall autoremove-torrents-hnr
  ```



  ```yaml
  my_task:
    client: qbittorrent
    host: http://127.0.0.1:7474
    username: admin
    password: password

    strategies:
      
      remove_untriggered_hnr:
        categories:  # 种子分类（可选）
          - TJUPT
        hnr:
          host: https://tjupt.org/api/v1/hnr.php
          api_token: your_api_token
          target_codes: 0  # 未触发考核的种子
          min_seed_time: 86400  # 做种时间大于1天将被删除
          min_upload_speed: 51200  # 上传速度小于50KB/s将被删除

      
      remove_completed_hnr:
        categories:
          - TJUPT
        hnr:
          host: https://tjupt.org/api/v1/hnr.php
          api_token: your_api_token
          target_codes: [20, 21]  # 已通过考核的种子
          last_activity: 172800  # 2天没有活动的种子将被删除
          min_upload_speed: 10240  # 上传速度小于10KB/s将被删除
          min_ratio: 1.0  # 分享率大于1.0将被删除

      
      remove_cancelled_hnr:
        categories:
          - TJUPT
        hnr:
          host: https://tjupt.org/api/v1/hnr.php
          api_token: your_api_token
          target_codes: [40, 41, 42]  # 考核被取消的种子

    delete_data: true  # 是否在删除种子的同时也删除数据
  ```

  其他条件配置请参考原项目 [autoremove-torrents](https://autoremove-torrents.readthedocs.io/zh-cn/latest/) 的文档。



  H&R API 接口文档：[hnr_api.md](https://github.com/tjupt/autoremove-torrents/blob/master/hnr_api.md)

  在策略配置中添加 `hnr` 部分：


  - `host`: H&R API 地址
  - `api_token`: API 访问令牌
  - `target_codes`: 目标状态码，可以是单个状态码或状态码列表，具体见H&R API 接口文档：[hnr_api.md](https://github.com/tjupt/autoremove-torrents/blob/master/hnr_api.md)


  - `last_activity`: 种子不活跃时间限制，单位为秒
  - `min_seed_time`: 最小做种时间，单位为秒
  - `min_upload_speed`: 最小上传速度，单位为字节/秒
  - `min_ratio`: 最小分享率


  1. 首先检查种子的 HNR 状态码是否匹配 `target_codes`
  2. 如果状态码匹配，则继续检查其他配置的条件（如 `last_activity`、`min_seed_time` 等）
  3. 只有当所有配置的条件都满足时，种子才会被删除
  4. 未配置的条件会被跳过，不参与判断


  参考原项目 [autoremove-torrents](https://autoremove-torrents.readthedocs.io/zh-cn/latest/inst.html#run) 的运行说明
  ```bash

  autoremove-torrents --view --conf=config.yml


  autoremove-torrents --conf=config.yml
  ```



  ```bash
  autoremove-torrents --conf=config.yml --log=logs/autoremove.log --debug
  ```



  - hnr_api.py: H&R API 客户端，用于查询种子的 H&R 状态
  - 其他客户端适配器（如 qBittorrent, Transmission 等）

  - base.py: 条件基类，定义了条件的基本接口
  - hnr.py: H&R 条件检查实现
  - 其他条件实现（如分享率、做种时间等）

  - strategy.py: 策略执行器，负责：
  - 应用各种条件
  - 管理种子的保留和删除列表
  - 执行删除操作

  - conditionparser.py: 条件解析器，负责：
  - 解析配置文件中的条件
  - 创建对应的条件实例
  - 处理条件组合



  - 读取 config.yml
  - 解析任务和策略配置

  - 根据配置创建对应的客户端实例
  - 建立连接并验证

  - 获取种子列表
  - 应用分类过滤
  - 执行条件检查
  - 确定删除列表

  - 执行种子删除
  - 记录操作日志



  MIT License


pkgId: 82a32b68c3e090aa4334a89c3c6776e34b101fb6d52649e70289144e35aff0b7
name: python-autoresevaluator
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/autoresevaluator/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoresevaluator-0.1.11-1.src.rpm
checksum_type: sha256
description:
  ※ 追加で実装して欲しい機能や質問などがあれば以下のissuesから投稿をお願いします

  https://github.com/auto-res/autores-evaluator/issues/new



  - Prediction by logistic regression on the Titanic dataset
  <a href="https://colab.research.google.com/github/fuyu-quant/autores-evaluator/blob/main/examples/logistic_regression.ipynb" target="_blank" rel="noopener noreferrer"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>

  - Prediction by CNN on CIFAR10
  <a href="https://colab.research.google.com/github/fuyu-quant/autores-evaluator/blob/main/examples/cnn.ipynb" target="_blank" rel="noopener noreferrer"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>




  ![ロゴ1](images/image.png)



  - Install
      - https://pypi.org/project/autoresevaluator/

  ```Python
  pip install autoresevaluator

  from autoresevaluator import AutoResEvaluator
  ```

  - Setting
  ```python


  params = {
      'lambda_l1': {'type': 'log_float', 'args': [1e-8, 10.0]},
      'lambda_l2': {'type': 'log_float', 'args': [1e-8, 10.0]},
      'num_leaves': {'type': 'int', 'args': [2, 256]},
      'feature_fraction': {'type': 'float', 'args': [0.4, 1.0]},
      'bagging_fraction': {'type': 'float', 'args': [0.4, 1.0]},
      'verbosity': -1
  }

  are = AutoResEvaluator(
      
      dataset_name='titanic',
      
      model_path='/content/example.py',
      
      params=params,
      
      valuation_index='roc_auc',
      
      datasave_path=None
      )
  ```

  - Execution
  ```python
  are.exec()
  ```


  - result.log
      - File to output the results

  - model_error.log
      - File to write errors in model files


pkgId: 9188883a6886871c744c37b127168f42a4161dd37645d7da086d64e3c09b2f17
name: python-autorunpy
arch: src
version: 8.1.13
epoch: 0
release: 1
summary: Tools for auto running python scripts
description: Tools for auto running Python scripts.
url: https://pypi.org/project/autorunpy/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autorunpy-8.1.13-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2022 Mahdi  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: 646a3ad31b7e78c87d98b7d70c5c35963ad5c8cc74cfff2806a2bef361d7260e
name: python-autosar
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: A set of Python modules for working with AUTOSAR XML files
url: http://github.com/cogu/autosar
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autosar-0.4.2-1.src.rpm
checksum_type: sha256
description:
  A set of Python modules for working with [AUTOSAR](https://www.autosar.org/) XML files.

  The primary use case is to enable Python to generate ARXML files for further importing into other (commercial) AUTOSAR toolchains.
  It has some support for parsing ARXML files.

  This is the maintenance branch for v0.4. Latest release is [v0.4.2](https://github.com/cogu/autosar/releases/tag/v0.4.2).



  [Documentation for v0.4](https://autosar.readthedocs.io/en/latest/).



  * AUTOSAR 3.0
  * AUTOSAR 4.2

  Classic AUTOSAR only.



  * Python 3.4+
  * cfile v0.2.0



  ```bash
  pip install "autosar<0.5"
  ```

  For now it works to install without the version part, it's there for future proofing the instruction after newer versions are released to PyPI.


pkgId: 0616fe6ff4be05bffa58e91a550004afb466f81e5a9156f8b83ae10efd5b9d40
name: python-autosbatch
arch: src
version: 0.2.7
epoch: 0
release: 1
summary: submit hundreds of jobs to slurm automatically.
url: https://github.com/Jianhua-Wang/autosbatch
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autosbatch-0.2.7-1.src.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/autosbatch.svg)](https://pypi.org/project/autosbatch/)
  [![python](https://img.shields.io/pypi/pyversions/autosbatch.svg)](https://pypi.org/project/autosbatch/)
  [![Build Status](https://github.com/Jianhua-Wang/autosbatch/actions/workflows/dev.yml/badge.svg)](https://github.com/Jianhua-Wang/autosbatch/actions/workflows/dev.yml)
  [![codecov](https://codecov.io/gh/Jianhua-Wang/autosbatch/branch/main/graphs/badge.svg)](https://codecov.io/github/Jianhua-Wang/autosbatch)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![PyPI download month](https://img.shields.io/pypi/dm/autosbatch.svg)](https://pypi.org/project/autosbatch/)


  submit hundreds of jobs to slurm automatically


  * Documentation: <https://Jianhua-Wang.github.io/autosbatch>
  * GitHub: <https://github.com/Jianhua-Wang/autosbatch>
  * PyPI: <https://pypi.org/project/autosbatch/>
  * Free software: MIT




  Sometimes, it's quite inconvenient when we submit hundreds of jobs to slurm. For example, one needs to align RNA-seq data from one hundred samples. He may start with a bash script that takes the fastq of one sample and write sbatch scripts which execute `bash align.sh sample.fq` multiple times. If he wants to run 50 samples at the same time, he should write 50 sbatch scripts and each script contains two align commands. Manually managing these sbatch scripts is inconvenient. autosbatch is very helpful for submitting slurm jobs automatically and it's just like the `multiprocessing.Pool`.

  * Automatically submit hundreds of jobs to Slurm with a few code.
  * The same usage as `multiprocessing.Pool`.
  * Provide command line tool for people who are not familiar with Python.



  * Support gpu allocation
  * Support MPI jobs



  This package was created with [Cookiecutter](https://github.com/audreyr/cookiecutter) and the [waynerv/cookiecutter-pypackage](https://github.com/waynerv/cookiecutter-pypackage) project template.


pkgId: c225a928a13fe6577d926b2444b8f44b4156e1f2f79753972d240110a862c4c2
name: python-autoscrape
arch: src
version: 1.6.14
epoch: 0
release: 1
summary: An automated, programming-free web scraper for interactive sites
url: https://github.com/brandonrobertz/autoscrape-py
rpm_license: AGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoscrape-1.6.14-1.src.rpm
checksum_type: sha256
description:
  A project of `Artificial Informer Labs <https://artificialinformer.com>`__.
  AutoScrape is an automated scraper of structured data from interactive
  web pages. You point this scraper at a site, give it a little information
  and structured data can then be extracted. No brittle, site-specific
  programming necessary.
  This is an implementation of the web scraping framework described in the
  paper, `Robust Web Scraping in the Public Interest with AutoScrape <https://bxroberts.org/files/autoscrape.pdf>`__ and presented at
  `Computation + Journalism Symposium 2019 <http://cplusj.org/>`__.
  Currently there are two methods of running AutoScrape:
  - as a local CLI python script
  - a full Web interface for scraping (see bottom of page)
  Installation and running instructions are provided for both below.


pkgId: 8bd577e1e739622e13de9bde837c2f041c1ad4c48fa6eae23ce7f30fb437d869
name: python-autoscraper
arch: src
version: 1.1.14
epoch: 0
release: 1
summary: A Smart, Automatic, Fast and Lightweight Web Scraper for Python
url: https://github.com/alirezamika/autoscraper
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoscraper-1.1.14-1.src.rpm
checksum_type: sha256
description:
  ![img](https://user-images.githubusercontent.com/17881612/91968083-5ee92080-ed29-11ea-82ec-d99ec85367a5.png)

  This project is made for automatic web scraping to make scraping easy.
  It gets a url or the html content of a web page and a list of sample data which we want to scrape from that page. **This data can be text, url or any html tag value of that page.** It learns the scraping rules and returns the similar elements. Then you can use this learned object with new urls to get similar content or the exact same element of those new pages.




  It's compatible with python 3.

  - Install latest version from git repository using pip:
  ```bash
  $ pip install git+https://github.com/alirezamika/autoscraper.git
  ```

  - Install from PyPI:
  ```bash
  $ pip install autoscraper
  ```

  - Install from source:
  ```bash
  $ python setup.py install
  ```





  Say we want to fetch all related post titles in a stackoverflow page:

  ```python
  from autoscraper import AutoScraper

  url = 'https://stackoverflow.com/questions/2081586/web-scraping-with-python'



  wanted_list = ["What are metaclasses in Python?"]

  scraper = AutoScraper()
  result = scraper.build(url, wanted_list)
  print(result)
  ```

  Here's the output:
  ```python
  [
      'How do I merge two dictionaries in a single expression in Python (taking union of dictionaries)?',
      'How to call an external command?',
      'What are metaclasses in Python?',
      'Does Python have a ternary conditional operator?',
      'How do you remove duplicates from a list whilst preserving order?',
      'Convert bytes to a string',
      'How to get line count of a large file cheaply in Python?',
      "Does Python have a string 'contains' substring method?",
      'Why is “1000000000000000 in range(1000000000000001)” so fast in Python 3?'
  ]
  ```
  Now you can use the `scraper` object to get related topics of any stackoverflow page:
  ```python
  scraper.get_result_similar('https://stackoverflow.com/questions/606191/convert-bytes-to-a-string')
  ```



  Say we want to scrape live stock prices from yahoo finance:

  ```python
  from autoscraper import AutoScraper

  url = 'https://finance.yahoo.com/quote/AAPL/'

  wanted_list = ["124.81"]

  scraper = AutoScraper()


  result = scraper.build(url, wanted_list)
  print(result)
  ```
  Note that you should update the `wanted_list` if you want to copy this code, as the content of the page dynamically changes.

  You can also pass any custom `requests` module parameter. for example you may want to use proxies or custom headers:

  ```python
  proxies = {
      "http": 'http://127.0.0.1:8001',
      "https": 'https://127.0.0.1:8001',
  }

  result = scraper.build(url, wanted_list, request_args=dict(proxies=proxies))
  ```

  Now we can get the price of any symbol:

  ```python
  scraper.get_result_exact('https://finance.yahoo.com/quote/MSFT/')
  ```

  **You may want to get other info as well.** For example if you want to get market cap too, you can just append it to the wanted list. By using the `get_result_exact` method, it will retrieve the data as the same exact order in the wanted list.

  **Another example:** Say we want to scrape the about text, number of stars and the link to issues of Github repo pages:

  ```python
  from autoscraper import AutoScraper

  url = 'https://github.com/alirezamika/autoscraper'

  wanted_list = ['A Smart, Automatic, Fast and Lightweight Web Scraper for Python', '2.5k', 'https://github.com/alirezamika/autoscraper/issues']

  scraper = AutoScraper()
  scraper.build(url, wanted_list)
  ```

  Simple, right?




  We can now save the built model to use it later. To save:

  ```python

  scraper.save('yahoo-finance')
  ```

  And to load:

  ```python
  scraper.load('yahoo-finance')
  ```



  - See [this gist](https://gist.github.com/alirezamika/72083221891eecd991bbc0a2a2467673) for more advanced usages.
  - [AutoScraper and Flask: Create an API From Any Website in Less Than 5 Minutes](https://medium.com/better-programming/autoscraper-and-flask-create-an-api-from-any-website-in-less-than-5-minutes-3f0f176fc4a3)


  Feel free to open an issue if you have any problem using the module.




  <a href="https://www.buymeacoffee.com/alirezam" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-black.png" alt="Buy Me A Coffee" height="45" width="163" ></a>


pkgId: 81b9db9d3fc94127a7257b6d7272bbd20419f6afc57117f09e54398e938a4fd5
name: python-autoscrub
arch: src
version: 0.7.5
epoch: 0
release: 1
summary: Hastens silent intervals of videos using FFmpeg
url: https://github.com/philipstarkey/autoscrub
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoscrub-0.7.5-1.src.rpm
checksum_type: sha256
description:
  autoscrub is a command line tool that automates the production of educational videos by increasing the playback speed during silent segments.


  Documentation, along with installation instructions, are available at [http://autoscrub.readthedocs.io/](http://autoscrub.readthedocs.io/)


  autoscrub is licensed under the GPLv3 licence.


  Please see [contributing.md](https://github.org/philipstarkey/autoscrub/src/tip/contributing.md)


pkgId: 31e20641506a78950caeb8e4ae79b072599be079c31a9601d4408f8e1054f540
name: python-autosentiment
arch: src
version: 1.2.6
epoch: 0
release: 1
summary: An automatic sentiment analysis pakage
url: https://github.com/CodeFighter03/autosentiment
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autosentiment-1.2.6-1.src.rpm
checksum_type: sha256
description:
  * Email : <sazinsamin50@gmail.com>






  For analysis the seintiment type in positive,negetive or neutral



  ```
  pip install autosentiment
  ```



  ```
  !pip install autosentiment
  ```



  ```
  import autosentiment as at
  ```



  ```
  Have to get dataframe('text columns') and give to command.
  Like df['text]
  ```






  ```
  at.pie()
  ```


  Get the sentiment type(postive,negetive,neutral numbers)
  ```
  at.number()
  ```



  Get the percentage of sentiment type
  ```
  at.percentage()

  ```



  Get the type of all text, here -1:negetive, 0:neutral, 1:positive

  ```
  at.ternary_analysis()
  ```




  ```

  >>import autosentiment as at

  >>import pandas as pd

  >>df=pd.read_csv("/home/samin/anaconda3/dataset_2.csv")

  >>percent=at.percentage(df['text'])

  >>print(percent)
  >>Positve : 33.31 %, Negetive 20.96 %, Neutral : 45.72 %

  >>number=at.number(df['text'])

  >>print(number)
  >>{'positive  ': 1087, 'negetive': 684, 'neutral': 1492}

  >>ana=at.analysis_ternary(df['text'])

  >>print(ana)
  >>[-1, 1, 0.0, 0.0, 0.0, 0.0,.......,1]

  >>at.pie(df['text'])


  ```
  ![pie chart](image_12.png)




  * For any bug, please notify in my email : <sazinsamin50@gmail.com>


pkgId: 3545dffe4f5ff032eb626726e5ef4474747e0f0b72769f295f22b0b2cacc954b
name: python-autosolveclient
arch: src
version: 2.0.9
epoch: 0
release: 1
summary: Client for connecting to AYCD AutoSolve network
url: https://pypi.org/project/autosolveclient/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autosolveclient-2.0.9-1.src.rpm
checksum_type: sha256
description:
  Client for connecting to the AYCD AutoSolve network



  https://docs.aycd.io/docs/getting-started/




  This project is licensed under the MIT License


pkgId: a2755e24f524e113dc213d6914ce08007c726d4092e2f944b92afb76e763ae98
name: python-autostack
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: Automatically detect python errors and search Stack Overflow.
url: https://github.com/elijahsawyers/autostack
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autostack-1.2.1-1.src.rpm
checksum_type: sha256
description:
  ![Logo](https://raw.githubusercontent.com/autostack-team/autostack/develop/Logo.png)

  <p align="center">
      <a href="https://travis-ci.com/autostack-team/autostack/">
          <img src="https://travis-ci.com/autostack-team/autostack.svg?branch=master"
              alt="Build status"/>
      </a>
      <a href="https://codeclimate.com/github/autostack-team/autostack/test_coverage">
          <img src="https://api.codeclimate.com/v1/badges/4dc7775be0fef62e5492/test_coverage"
              alt="Code coverage"/>
      </a>
      <a href="https://codeclimate.com/github/autostack-team/autostack/maintainability">
          <img src="https://api.codeclimate.com/v1/badges/4dc7775be0fef62e5492/maintainability"
              alt="Maintainability"/>
      </a>
      <a href="https://github.com/autostack-team/autostack">
          <img src="https://img.shields.io/github/commit-activity/m/autostack-team/autostack"
              alt="GitHub commit activity"/>
      </a>
      <a href="https://pypi.org/project/autostack/">
          <img src="https://img.shields.io/pypi/dm/autostack"
               alt="PyPI - Downloads"/>
      </a>
      <a href="https://pypi.org/project/autostack/">
          <img src="https://img.shields.io/pypi/v/autostack"
               alt="PyPI"/>
      </a>
      <a href="https://opensource.org/licenses/MIT">
          <img src="https://img.shields.io/badge/License-MIT-orange.svg"
               alt="License"/>
      </a>
      <a href="https://gitter.im/autostack-team/community?utm_source=share-link&utm_medium=link&utm_campaign=share-link">
          <img src="https://badges.gitter.im/autostack-team/community.svg"
               alt="Chat"/>
      </a>
      <a href="https://twitter.com/intent/follow?screen_name=autostackteam">
          <img src="https://img.shields.io/twitter/follow/autostackteam.svg?style=social&logo=twitter"
               alt="Follow on Twitter"/>
      </a>
      <a href="https://www.patreon.com/autostack">
          <img src="https://img.shields.io/badge/Support-Patreon-red?logo=patreon"
               alt="Support on Patreon"/>
      </a>
      <a href="https://instagram.com/retractablebearfist?igshid=7qlm4fol0o50">
          <img src="https://img.shields.io/badge/logo%20by-RBF-purple?logo=instagram"
               alt="Logo designer's instagram"/>
      </a>
  </p>

  autostack is a command-line debugging tool for Python projects that automatically displays Stack Overflow answers for thrown errors.

  What is the first thing you do when a confusing error message is displayed in your terminal window? You search for an answer on Stack Overflow, of course! With autostack, you no longer have to search for answers on Stack Overflow, they are found for you. Gone are the days of scouring the internet for hours to find an answer to your development questions! autostack is here to automate the debugging process and in turn, expedite Python project development.



  * [Installation](#Installation)
  * [Usage](#Usage)
  * [Demo](#Demo)
  * [Contributing](#Contributing)
  * [License](#License)
  * [Show&nbsp;your&nbsp;support](#Show-your-support)
  * [Authors](#Authors)



  **1. Clone the repo and use the install script.**

  Clone the repo.

  ```sh
  git clone https://github.com/autostack-team/autostack.git
  ```

  Navigate to the project directory, and run the install bash script.

  ```sh
  cd /path/to/project/
  chmod +x install.sh
  ./install.sh
  ```

  **2. Or just use pip to install.**

  ```sh
  pip3 install autostack
  ```



  In one terminal window, execute "autostack capture" which will capture all errors in the terminal. You can run this command in as many terminal windows as you'd like.

  ```sh
  autostack capture
  ```

  In another terminal window, execute "autostack display" to display Stack Overflow posts for all captured errors.

  ```sh
  autostack display
  ```

  To stop running autostack, use the exit command in the terminals that executed "autostack capture". This automatically stops the terminal window displaying Stack Overflow posts for captured errors.

  ```sh
  exit
  ```



  Checkout the demo below!

  <p align="center">
      <img src="https://raw.githubusercontent.com/autostack-team/autostack/master/Demo.gif"
          alt="Demo"/>
  </p>



  For information on how to get started contributing to autostack, see the [contributing guidlines](https://github.com/autostack-team/autostack/blob/master/CONTRIBUTING.md).



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



  Give a ⭐️ if autostack has helped you!

  <a href="https://www.patreon.com/autostack">
    <img src="https://c5.patreon.com/external/logo/become_a_patron_button@2x.png" width="160">
  </a>


  * [Elijah Sawyers](https://github.com/elijahsawyers)
  * [Benjamin Sanders](https://github.com/BenOSanders)
  * [Caleb Werth](https://github.com/cwerth1)


pkgId: 94691c2d7ab4efd3cb8bad15b5ccd14f4613ccbfc660d52411eb93a7da45d8e4
name: python-autostr
arch: src
version: 1.4
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/number3141/autostr
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autostr-1.4-1.src.rpm
checksum_type: sha256
description:
  Небольшой модуль, который добавляет класс `AutostrMixin`
  Вы можете наследоваться от данного класса и тогда вам не придётся писать `__str__ `

  Пример:

  ```
  class A(AutostrMixin):
  	b = 0
  	def __init__(self):
  		self.a = 1


  t = A()
  print(t)
  ```

  Вывод:

  ```
  Экземпляр класса: A

  Атрибуты класса:
  ·b: 0

  Атрибуты экземпляра:
  ·a: 1
  ```


pkgId: 7c358526f5dfc753db956956571cf7dc9cbfcba46b5b60e161126a8c9cf37027
name: python-autosubmit-api
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: An extension to the Autosubmit package that serves its information as an API
url: https://earth.bsc.es/gitlab/es/autosubmit_api
rpm_license: GNU GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autosubmit-api-4.0.0-1.src.rpm
checksum_type: sha256
description:
  1. [Overview](#overview)
  2. [Installation](#installation)
  3. [Configuration options](#configuration-options)
  4. [How to run tests](#how-to-run-tests)



  Autosubmit API is a package that consumes the information generated by Autosubmit and serves it as an API.

  Distribution: https://pypi.org/project/autosubmit-api/

  See the `openapi.json` specification and the repository wiki for more information.



  Autosubmit API can be easily installed via pip

  ```sh
  pip install autosubmit-api # >=4.0 (recommended)


  autosubmit_api start -h
  ```

  Start the server:

  ```sh
  autosubmit_api start
  ```



  The Autosubmit API have some configuration options that can be modified by setting their specific environment variable before starting the server:

  - **`PROTECTION_LEVEL`**: Default `ALL`. Possible values `ALL`, `WRITEONLY`, `NONE`.
    - If set to `ALL`, all the endpoints will be protected by needing a valid token inside the `Authorization` header of the request.
    - If set to `WRITEONLY`, only a subset of the endpoints will be protected.
    - If set to `NONE`, none of the endpoints will be protected.
  - **`SECRET_KEY`**: The secret key to encode the JWT tokens from the Authorization Module. **Important to be set up on production.**
  - **`CAS_SERVER_URL`**: CAS Protocol server base URL to request a ticket and verify it. Used for `/v4` endpoints. `CAS_LOGIN_URL` and `CAS_VERIFY_URL` can be empty if this variable is set (the API will append the protocol URL subpaths).
  - **`CAS_LOGIN_URL`**: CAS Protocol URL to request a ticket. Used for `/v3` endpoints.
  - **`CAS_VERIFY_URL`**: CAS Protocol URL to verify a given ticket. Used for `/v3` endpoints.
  - **`GITHUB_OAUTH_CLIENT_ID`**: Client ID of the Github Oauth app.
  - **`GITHUB_OAUTH_CLIENT_SECRET`**: Secret key of the Github Oauth app.
  - **`GITHUB_OAUTH_WHITELIST_ORGANIZATION`**: Used to use authorization based on the membership of a Github organization.
  - **`GITHUB_OAUTH_WHITELIST_TEAM`**: Used to use authorization based on the membership of a Github team in an organization. `GITHUB_OAUTH_WHITELIST_ORGANIZATION` is required





  ```bash
  pip install -e .[test]
  ```



  ```bash
  pytest
  ```



  ```bash
  pytest --cov=autosubmit_api --cov-config=.coveragerc --cov-report=html tests/
  ```

  You will find the report in `htmlcov/index.html`


pkgId: 39d48fa1340d7a24b014f45a1d3bce3b07c610175041247199d41ed4ac7d4bfd
name: python-autosubmitconfigparser
arch: src
version: 1.0.72
epoch: 0
release: 1
summary: An utility library that allows to read an Autosubmit 4 experiment configuration.
url: https://earth.bsc.es/gitlab/ces/autosubmit4-config-parser.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autosubmitconfigparser-1.0.72-1.src.rpm
checksum_type: sha256
description:
  Simple library that allows to read the data of an Autosubmit experiment.



  ```python

  from autosubmitconfigparser.config.configcommon import AutosubmitConfig
  import os

  expid = "a01y"
  as_conf = AutosubmitConfig("a01y")

  as_conf.reload(True)


  as_conf.experiment_data

  as_conf.jobs_data

  as_conf.platforms_data

  parameters = as_conf.deep_parameters_export(as_conf.experiment_data)


  with open("as_sample.txt", "w") as f:
      f.write("This is a sample text with a placeholder %DEFAULT.EXPID%")


  with open("as_sample_parsed.txt", "w") as f:
      f.write(as_conf.parse_placeholders(open("as_sample.txt","r").read(), parameters))



  with open("as_sample.txt", "r") as f:
      print(f.read())

  with open("as_sample_parsed.txt", "r") as f:
      print(f.read())






  os.remove("as_sample.txt")
  os.remove("as_sample_parsed.txt")
  ```


pkgId: 988253005e20227d38f55ac1c223810bbedf9c8269a7641e8169968f13a2fa59
name: python-autosynthesis
arch: src
version: 0.0.18
epoch: 0
release: 1
url: https://github.com/sarangbhagwat/autosynthesis
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autosynthesis-0.0.18-1.src.rpm
checksum_type: sha256
summary:
  A toolkit for automated synthesis of biorefinery processes including pretreatment, conversion, separation, and upgrading.


pkgId: b832a5b85839312b0f171dcb1692d57b1f7ecc095a25af09ade0d4c189d0113d
name: python-autotask
arch: src
version: 0.5.4
epoch: 0
release: 1
summary: A django-application for handling asynchronous tasks.
url: https://bitbucket.org/kbr/autotask
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autotask-0.5.4-1.src.rpm
checksum_type: sha256
description:
  autotask is a django-application for handling asynchronous tasks without the need to install, configure and supervise additional processes like `celery <http://www.celeryproject.org/>`_, `redis <http://redis.io/>`_ or `rabbitmq <https://www.rabbitmq.com/>`_ . autotask is aimed for applications where asynchronous tasks happen occasionally and the installation, configuration and monitoring of an additionally technology stack seems to be to much overhead.
  The Code is available on `bitbucket <https://bitbucket.org/kbr/autotask>`_ and can also installed with ::
      pip install autotask
  Requirements: ::
      - Python >= 3.3, 2.7
      - Django >= 1.8
      - Databases: PostgreSQL, SQLite3
                  (MySQL and Oracle should work, but untested)


pkgId: a2ec5081ac64cf5bfbf59cf6656ec61fe3698883cc39cdc582065dc88fc6b365
name: python-autotiktokenizer
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: 🧰 The AutoTokenizer that TikToken always needed -- Load any tokenizer with TikToken now! ✨
url: https://github.com/bhavnicksm/autotiktokenizer
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autotiktokenizer-0.2.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">

  ![AutoTikTokenizer Logo](./assets/AutoTikTokenizer%20Logo.png)



  [![PyPI version](https://img.shields.io/pypi/v/autotiktokenizer.svg)](https://pypi.org/project/autotiktokenizer/)
  [![Downloads](https://static.pepy.tech/badge/autotiktokenizer)](https://pepy.tech/project/autotiktokenizer)
  ![Package size](https://img.shields.io/badge/size-9.7MB-blue)
  [![License](https://img.shields.io/github/license/bhavnicksm/autotiktokenizer)](https://github.com/bhavnicksm/autotiktokenizer/blob/main/LICENSE)
  [![Documentation](https://img.shields.io/badge/docs-available-brightgreen.svg)](https://github.com/bhavnicksm/autotiktokenizer#readme)
  [![Last Commit](https://img.shields.io/github/last-commit/bhavnicksm/autotiktokenizer)](https://github.com/bhavnicksm/autotiktokenizer/commits/main)
  [![GitHub Stars](https://img.shields.io/github/stars/bhavnicksm/autotiktokenizer?style=social)](https://github.com/bhavnicksm/autotiktokenizer/stargazers)

  🚀 Accelerate your HuggingFace tokenizers by converting them to TikToken format with AutoTikTokenizer - get TikToken's speed while keeping HuggingFace's flexibility.

  [Features](#key-features) •
  [Installation](#installation) •
  [Examples](#examples) •
  [Supported Models](#supported-models) •
  [Benchmarks](#benchmarks) •
  [Citation](#citation)

  </div>



  - 🚀 **High Performance** - Built on TikToken's efficient tokenization engine
  - 🔄 **HuggingFace Compatible** - Seamless integration with the HuggingFace ecosystem
  - 📦 **Lightweight** - Minimal dependencies, just TikToken and Huggingface-hub
  - 🎯 **Easy to Use** - Simple, intuitive API that works out of the box
  - 💻 **Well Tested** - Comprehensive test suite across supported models



  Install `autotiktokenizer` from PyPI via the following command:

  ```bash
  pip install autotiktokenizer
  ```

  You can also install it from _source_, by the following command:

  ```bash
  pip install git+https://github.com/bhavnicksm/autotiktokenizer
  ```



  This section provides a basic usage example of the project. Follow these simple steps to get started quickly.

  ```python

  from autotiktokenizer import AutoTikTokenizer


  tokenizer = AutoTikTokenizer.from_pretrained("meta-llama/Llama-3.2-3B-Instruct")


  text = "Wow! I never thought I'd be able to use Llama on TikToken"
  encodings = tokenizer.encode(text)


  text = tokenizer.decode(encodings)
  ```



  AutoTikTokenizer current supports the following models (and their variants) out of the box, with support for other models to be tested and added soon!

  - [x] GPT2
  - [x] GPT-J Family
  - [x] SmolLM Family: Smollm2-135M, Smollm2-350M, Smollm2-1.5B etc.
  - [x] LLaMa 3 Family: LLama-3.2-1B-Instruct, LLama-3.2-3B-Instruct, LLama-3.1-8B-Instruct etc.
  - [x] Deepseek Family: Deepseek-v2.5 etc
  - [x] Gemma2 Family: Gemma2-2b-It, Gemma2-9b-it etc
  - [x] Mistral Family: Mistral-7B-Instruct-v0.3 etc
  - [ ] BERT Family: BERT, RoBERTa, MiniLM, TinyBERT, DeBERTa etc.

  **NOTE:** Some models use the _unigram_ tokenizers, which are not supported with TikToken and hence, 🧰 AutoTikTokenizer cannot convert the tokenizers for such models. Some models that use _unigram_ tokenizers include T5, ALBERT, Marian and XLNet.



  Benchmarking results for tokenizing **1 billion tokens** from fineweb-edu dataset using **Llama 3.2 tokenizer** on CPU (Google colab)

  | Configuration | Processing Type | AutoTikTokenizer | HuggingFace | Speed Ratio |
  |--------------|-----------------|------------------|--------------|-------------|
  | Single Thread | Sequential | **14:58** (898s) | 40:43 (2443s) | 2.72x faster |
  | Batch x1 | Batched | 15:58 (958s) | **10:30** (630s) | 0.66x slower |
  | Batch x4 | Batched | **8:00** (480s) | 10:30 (630s) | 1.31x faster |
  | Batch x8 | Batched | **6:32** (392s) | 10:30 (630s) | 1.62x faster |
  | 4 Processes | Parallel | **2:34** (154s) | 8:59 (539s) | 3.50x faster |

  The above table shows that AutoTikTokenizer's tokenizer (TikToken) is actually way faster than HuggingFace's Tokenizer by 1.6-3.5 times under fair comparison! While, it's not making the most optimal use of TikToken (yet), its still way faster than the stock solutions you might be getting otherwise.



  Special thanks to HuggingFace and OpenAI for making their respective open-source libraries that make this work possible. I hope that they would continue to support the developer ecosystem for LLMs in the future!

  **If you found this repository useful, give it a ⭐️! Thank You :)**



  If you use `autotiktokenizer` in your research, please cite it as follows:

  ```bibtex
  @misc{autotiktokenizer,
      author = {Bhavnick Minhas},
      title = {AutoTikTokenizer},
      year = {2024},
      publisher = {GitHub},
      journal = {GitHub repository},
      howpublished = {\url{https://github.com/bhavnicksm/autotiktokenizer}},
  }
  ```

rpm_license:
  MIT License  Copyright (c) 2024 Bhavnick Minhas  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: 1d78bc97278b6ce67a050ede6e33eab7200ae706dde8f35c28f6e7477c2921a4
name: python-autotm
arch: src
version: 0.2.3.4
epoch: 0
release: 1
summary: Automatic hyperparameters tuning for topic models (ARTM approach) using evolutionary algorithms
url: https://autotm.readthedocs.io/en/latest/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autotm-0.2.3.4-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
  <img src="docs/img/MyLogo.png" alt="Library scheme" height="200"/>
  </p>

  <h2 align="center">
  AutoTM
  </h2>

  <p align="center">
      <a href="https://www.repostatus.org/#active">
      <img alt="Project Status: Active – The project has reached a stable, usable state and is being actively developed." src="https://www.repostatus.org/badges/latest/active.svg">
      </a>
      <img alt="build" src="https://github.com/ngc436/AutoTM/actions/workflows/build.yaml/badge.svg">
      <a href="https://opensource.org/licenses/BSD-3-Clause">
      <img alt="License" src="https://img.shields.io/badge/License-BSD%203--Clause-blue.svg">
      </a>
      <a href="https://badge.fury.io/py/autotm">
      <img alt="PyPI version" src="https://badge.fury.io/py/autotm.svg">
      </a>
      <a href="https://autotm.readthedocs.io/en/latest/?badge=latest">
      <img alt="Documentation Status" src="https://readthedocs.org/projects/autotm/badge/?version=latest">
      </a>
      <a href="https://pepy.tech/project/autotm">
      <img alt="Downloads" src="https://static.pepy.tech/personalized-badge/autotm?period=total&units=international_system&left_color=grey&right_color=orange&left_text=Downloads">
      </a>
  </p>

  :sparkles:**News**:sparkles: We have fully updated our framework to AutoTM 2.0 version enriched with new functionality! Stay tuned!

  Automatic parameters selection for topic models (ARTM approach) using evolutionary and bayesian algorithms.
  AutoTM provides necessary tools to preprocess english and russian text datasets and tune additively regularized topic models.


  Topic modeling is one of the basic methods for a whole range of tasks:

  * Exploratory data analysis of unlabelled text data
  * Extracting interpretable features (topics and their combinations) from text data
  * Searching for hidden insights in the data

  While ARTM (additive regularization for topic models) approach provides the significant flexibility and quality comparative or better that neural
  approaches it is hard to tune such models due to amount of hyperparameters and their combinations. That is why we provide optimization pipelines to efortlessly process custom datasets.

  To overcome the tuning problems AutoTM presents an easy way to represent a learning strategy to train specific models for input corporas. We implement two strategy variants:

  * fixed-size variant, that provides a learning strategy that follow the best practices collected from the manual tuning history

  <img src="docs/img/strategy.png" alt="Learning strategy representation (fixed-size)" height=""/>

  * graph-based variant with more flexibility and unfixed ordering and amount of stages (**New in AutoTM 2.0**). Example of pipeline is provided below:

  <p align="center">
  <img src="docs/img/pipeling.png" alt="Learning strategy representation (graph-based)" width="500"/>
  </p>

  Optimization procedure is done by genetic algorithm (GA) which operators are specifically tuned for the each of the strategy creation variants (GA for graph-based is **New in AutoTM 2.0**). Bayesian Optimization is available only for fixed-size strategy.

  To speed up the procedure AutoTM also contain surrogate modeling implementation for fixed-size and graph-based (**New in AutoTM 2.0**) learning strategies that, for some iterations,
  approximate fitness function to reduce computation costs on training topic models.

  <p align="center">
      <img src="docs/img/autotm_arch_v3 (1).png" alt="Library scheme" height="700"/>
  </p>

  AutoTM also propose a range of metrics that can be used as fitness function, like classical ones as coherence to LLM-based (**New in AutoTM 2.0**).



  ! Note: The functionality of topic models training is available only for linux distributions.

  **Via pip:**

  ```pip install autotm```

  ```python -m spacy download en_core_web_sm```

  **From source:**

  ```poetry install```

  ```python -m spacy download en_core_web_sm```

  [//]: # (## Dataset and )



  Start with the notebook:

  - [Easy topic modeling with AutoTM](https://github.com/aimclub/AutoTM/blob/main/examples/examples_autotm_fit_predict.py)



  To fit a model:
  ```autotmctl --verbose fit --config conf/config.yaml --in data/sample_corpora/sample_dataset_lenta.csv```

  To predict with a fitted model:
  ```autotmctl predict --in data/sample_corpora/sample_dataset_lenta.csv --model model.artm```




  ```bibtex
  @article{10.1093/jigpal/jzac019,
      author = {Khodorchenko, Maria and Butakov, Nikolay and Sokhin, Timur and Teryoshkin, Sergey},
      title = "{ Surrogate-based optimization of learning strategies for additively regularized topic models}",
      journal = {Logic Journal of the IGPL},
      year = {2022},
      month = {02},
      issn = {1367-0751},
      doi = {10.1093/jigpal/jzac019},
      url = {https://doi.org/10.1093/jigpal/jzac019},}

  ```


pkgId: e0ac2ab6c26831599e682d1eefe0fe69fc6ac144ff13f02b8e4c819011f1dcca
name: python-autotorrent
arch: src
version: 1.7.1
epoch: 0
release: 1
summary: AutoTorrent allows easy cross-seeding
url: https://github.com/JohnDoee/autotorrent
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autotorrent-1.7.1-1.src.rpm
checksum_type: sha256
description:
  Given an input torrent, it will scan your collection for the files in
  the torrent. If all (or most) the files are found, a folder with links to all the
  files will be created and the torrent added to the torrent client.
  All you need to do is download the torrents and AutoTorrent plays mix and match
  to make it possible to seed as much as possible across trackers.


pkgId: d01ad8ec60af96fd695058cfab67e069fd45720e5c5bef9b4d1dedfce95acd5f
name: python-autotrader
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: A Python-based platform for developing, optimising and deploying automated trading systems.
url: https://kieran-mackle.github.io/AutoTrader/
rpm_license: gpl-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autotrader-1.1.2-1.src.rpm
checksum_type: sha256
description:
  <a name="readme-top"></a>

  <p align="center">
    <a href="https://kieran-mackle.github.io/AutoTrader/">
      <img src="https://user-images.githubusercontent.com/60687606/132320916-23445f43-dfdc-4949-9881-e18f622605d2.png" alt="AutoTrader Logo" width="15%" >
    </a>
  </p>

  <h1 align="center">AutoTrader</h1>

  <p align="center">
    <a href="https://pypi.org/project/autotrader">
      <img src="https://img.shields.io/pypi/v/autotrader.svg?color=blue&style=plastic" alt="Latest version" width=95 height=20>
    </a>

    <a href="https://pepy.tech/project/autotrader">
      <img src="https://pepy.tech/badge/autotrader" alt="Total downloads" >
    </a>

    <a href="https://pepy.tech/project/autotrader">
      <img src="https://pepy.tech/badge/autotrader/month" alt="Monthly downloads" >
    </a>

    <a href='https://autotrader.readthedocs.io/en/latest/?badge=latest'>
      <img src='https://readthedocs.org/projects/autotrader/badge/?version=latest' alt='Documentation Status' />
    </a>

    <a href="https://github.com/psf/black">
      <img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg">
    </a>

  </p>


  AutoTrader is Python-based platform intended to help in the development, optimisation and deployment of automated trading systems.
  A basic level of experience with Python is recommended for using AutoTrader, but the [docs](https://autotrader.readthedocs.io/en/latest/)
  aim to make using it as easy as possible with detailed tutorials and documentation.


  - [CryptoBots](https://github.com/kieran-mackle/cryptobots) has been released along with version `1.0.0`, offering ready-to-trade crypto strategies from the command line
  - Version 0.7 has been released, adding integrations with [CCXT](https://github.com/ccxt/ccxt) crypto exchanges. Many more powerful upgrades too.
  - AutoTrader has been featured in GitClone's recent article, [*Top Crypto Trader Open-Source Projects on Github*](https://gitclone.dev/top-crypto-trader-open-source-projects-on-github/).


  - A feature-rich trading simulator, supporting [backtesting](https://autotrader.readthedocs.io/en/latest/features/backtesting.html) and
  papertrading. The 'virtual broker' allows you to test your strategies in a risk-free, simulated environment before going live. Capable
  of simulating multiple order types, stop-losses and take-profits, cross-exchange arbitrage and portfolio strategies, AutoTrader has
  more than enough to build a profitable trading system.
  - [Integrated data feeds](https://kieran-mackle.github.io/AutoTrader/tutorials/price-data), making OHLC data retrieval as easy as possible.
  - [Automated interactive visualisation](https://autotrader.readthedocs.io/en/latest/features/visualisation.html) using [Bokeh](https://bokeh.org/)
  - [Library of custom indicators](https://autotrader.readthedocs.io/en/latest/indicators.html).
  - [Live trading](https://autotrader.readthedocs.io/en/latest/features/live-trading.html) supported for multiple venues.
  - [Detailed documenation and tutorials](https://autotrader.readthedocs.io/en/latest/index.html)
  - [Repository](https://github.com/kieran-mackle/autotrader-demo) of example strategies

  <p align="right">[<a href="#readme-top">back to top</a>]</p>




  | Broker | Asset classes | Integration status |
  | -------- | ------------- | ------------------ |
  | [Oanda](https://www.oanda.com/)    | Forex CFDs    | Complete |
  | [Interactive Brokers](https://www.interactivebrokers.com/en/home.php) | Many | In progress |
  | [CCXT](https://github.com/ccxt/ccxt) | Cryptocurrencies | In progress |

  <p align="right">[<a href="#readme-top">back to top</a>]</p>


  AutoTrader can be installed using pip:
  ```
  pip install autotrader
  ```

  AutoTrader can be updated by appending the `--upgrade` flag to the install command:
  ```
  pip install autotrader --upgrade
  ```

  <p align="right">[<a href="#readme-top">back to top</a>]</p>


  AutoTrader is very well documented in-code and on [Read the Docs](https://autotrader.readthedocs.io/en/latest/). There is also a [detailed walthrough](https://autotrader.readthedocs.io/en/latest/tutorials/walkthrough.html), covering everything from strategy concept to livetrading.


  Example strategies can be found in the [demo repository](https://github.com/kieran-mackle/autotrader-demo).

  <p align="right">[<a href="#readme-top">back to top</a>]</p>


  The chart below is produced by a backtest of the MACD trend strategy documented in the
  [tutorials](https://autotrader.readthedocs.io/en/latest/tutorials/building-strategy.html) (and available in the
  [demo repository](https://github.com/kieran-mackle/autotrader-demo)). Entry signals are defined by MACD crossovers, with exit targets defined
  by a 1.5 risk-to-reward ratio. Stop-losses are automatically placed using the custom
  [swing detection](https://autotrader.readthedocs.io/en/latest/indicators.html#swing-detection) indicator, and position sizes are dynamically calculated based
  on risk percentages defined in the strategy configuration.

  Running this strategy with AutoTrader in backtest mode will produce the following interactive chart.

  [![MACD-backtest-demo](https://user-images.githubusercontent.com/60687606/128127659-bf81fdd2-c246-4cd1-b86d-ef624cac50a7.png)](https://autotrader.readthedocs.io/en/latest/tutorials/backtesting.html#interactive-chart)

  Note that stop loss and take profit levels are shown for each trade taken. This allows you to see how effective your exit strategy is - are you being stopped out too
  early by placing your stop losses too tight? Are you missing out on otherwise profitable trades becuase your take profits are too far away? AutoTrader helps you
  visualise your strategy and answer these questions.

  <p align="right">[<a href="#readme-top">back to top</a>]</p>



  To contribute to `autotrader`, please read the instructions below,
  and stick to the styling of the code.



  1. Create a new Python virtual environment to isolate the package. You
  can do so using [`venv`](https://docs.python.org/3/library/venv.html) or
  [anaconda](https://www.anaconda.com/).

  2. Install the code in editable mode using the command below (run from
  inside the `autotrader` root directory). Also install all dependencies
  using the `[all]` command, which includes the developer dependencies.

  ```
  pip install -e .[all]
  ```

  3. Install the [pre-commit](https://pre-commit.com/) hooks.

  ```
  pre-commit install
  ```

  4. Start developing! After following the steps above, you are ready
  to start developing the code. Make sure to follow the guidelines
  below.




  - Fork the repository and clone to your local machine for development.

  - Run [black](https://black.readthedocs.io/en/stable/index.html) on any
  code you modify. This formats it according to
  [PEP8](https://peps.python.org/pep-0008/) standards.

  - Document as you go: use
  [numpy style](https://numpydoc.readthedocs.io/en/latest/format.html)
  docstrings, and add to the docs where relevant.

  - Write unit tests for the code you add, and include them in `tests/`.
  This project uses [pytest](https://docs.pytest.org/en/7.2.x/).

  - Commit code regularly to avoid large commits with many changes.

  - Write meaningful commit messages, following the
  [Conventional Commits standard](https://www.conventionalcommits.org/en/v1.0.0/).
  The python package [commitizen](https://commitizen-tools.github.io/commitizen/)
  is a great tool to help with this, and is already configured for this
  repo. Simply stage changed code, then use the `cz c` command to make a
  commit.

  - Open a [Pull Request](https://github.com/kieran-mackle/autoTrader/pulls)
  when your code is complete and ready to be merged.




  To build the documentation, run the commands below.

  ```
  cd docs/
  make html
  xdg-open build/html/index.html
  ```

  If you are actively developing the docs, consider using
  [sphinx-autobuild](https://pypi.org/project/sphinx-autobuild/).
  This will continuosly update the docs for you to see any changes
  live, rather than re-building repeatadly. From the `docs/`
  directory, run the following command:

  ```
  sphinx-autobuild source/ build/html --open-browser
  ```

  <p align="right">[<a href="#readme-top">back to top</a>]</p>




  AutoTrader is licensed under the [GNU General Public License v3.0](https://www.gnu.org/licenses/gpl-3.0.en.html).


  Never risk money you cannot afford to lose. Always test your strategies on a paper trading account before taking it live.

  <p align="right">[<a href="#readme-top">back to top</a>]</p>


pkgId: a897aac7286d7ad0e83b9d043162b10bb883e19b7ebf358c8b6575f4bc861f16
name: python-autotraders
arch: src
version: 2.3.5
epoch: 0
release: 1
summary: A powerful spacetraders API
url: https://comsictraders.github.io/autotraders/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autotraders-2.3.5-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](https://static.pepy.tech/badge/autotraders)](https://pepy.tech/project/autotraders)
  [![Python package](https://github.com/cosmictraders/autotraders/actions/workflows/python-package.yml/badge.svg)](https://github.com/cosmictraders/autotraders/actions/workflows/python-package.yml)

  A spacetraders API focused on automation and ease of use

  First you need a client, which can be generated
  ```python
  from autotraders import session
  s = session.get_session("YOUR_TOKEN_HERE")
  ```
  And now you're all set to use they actual API.



  ```python
  from autotraders.ship import Ship
  from autotraders.session import get_session


  session = get_session("YOUR TOKEN HERE")
  ship = Ship("SYMBOL-Here", session)  # This makes an API request
  ships = Ship.all(session)  # This also only makes one API request
  ship.dock()
  ship.refuel()
  ship.orbit()  # All these functions make API calls (one each), but the line below doesn't make any
  print(ship.fuel.current + "/" + ship.fuel.total)
  ```

  ```python
  from autotraders.faction.contract import Contract
  from autotraders.session import get_session


  session = get_session("YOUR TOKEN HERE")
  contract = Contract("id-here", session)
  contracts = Contract.all(session)
  contract.accept()
  print(contract.accepted) # True
  contract.deliver("SHIP_SYMBOL", "ALUMINUM_ORE", 30)
  contract.fulfill()
  print(contract.fulfilled) # True
  ```


pkgId: 5311e89ce6e41024da72a4d3e39f324199c68cfe95deae701524b726d4a77451
name: python-autotranscribe
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: An auto transcription service for youtube and normal videos.
url: https://github.com/DeveshParagiri/auto-transcribe
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autotranscribe-0.1.5-1.src.rpm
checksum_type: sha256
description:
  Autotranscribe is a simple library to convert video/audio to text. The library currently supports transcription of youtube files as well as implementing multiprocessing for faster transcription. It is built around the OpenAI whisper model.



  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install autotranscribe.

  ```bash
  pip install autotranscribe
  ```



  ```python
  import autotranscribe


  autotranscribe.transcribe_from_youtube(url,'transcripts/transcript.txt', multiproc = True)
  ```



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

  Please make sure to update tests as appropriate.



  [MIT](https://choosealicense.com/licenses/mit/)


pkgId: 15f2c6b731ae87b47559c549ee38e150f1f8c55c86b0ee161d1ec4dda9909260
name: python-autotransformers
arch: src
version: 0.0.12
epoch: 0
release: 1
summary: a Python package for automatic training and benchmarking of Language Models.
url: https://lenguajenatural.ai
rpm_license: CC BY-NC-SA 4.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autotransformers-0.0.12-1.src.rpm
checksum_type: sha256
description:
  ![autotransformers logo](./imgs/portada.png)

  `autotransformers` is useful for training multiple transformer-like models for a bunch of datasets in one go, without writing much code or using too much time (the machine does the effort, not you). It is highly integrated with HuggingFace libraries: Transformers, PEFT, TRL, Datasets and Evaluate.

  Please check the [online documentation](https://lenguajenatural-ai.github.io/autotransformers/autotransformers.html) for a more complete overview of the library.

  The main functionality of `autotransformers` is depicted in the following figure, where the dashed lines represent fully customizable modules:

  ![Diagram autotrainer](./imgs/autotransformers_diagram.png "Diagram for AutoTrainer, the main class in autotransformers!")


  The main class in `autotransformers` is `AutoTrainer`, which is configured with a list of `DatasetConfig`s and a list of `ModelConfig`s. Then, `AutoTrainer` will loop through each dataset configuration, performing hyperparameter tuning for each of the models configurations. For that, it uses `HFDatasetsManager` to load the dataset, depending on the configuration of `DatasetConfig`. It will also tokenize the dataset accordingly. As the dashed lines show, the user can use the default `tokenization_function` for the desired task, or can define their own in `DatasetConfig`. Then, `HFTransformersManager` will load all necessary Transformer objects (model, data collator, training arguments, trainer...). After that, hyperparameter tuning is performed with Optuna. A `CkptCleaner` (checkpoint cleaner) class removes bad performing checkpoints every 10 minutes, also saving the best performing checkpoint in the experiment in a separate directory. After hyperparameter tuning, results on the test split (if available, otherwise the validation split) are obtained via `ResultsGetter`, which is customizable (by passing a custom ResultsGetter class overriding the current methods), and uses a `compute_metrics_function` which is also customizable, by passing a `custom_eval_func` to `DatasetConfig`. These results are stored in json or, if json saving fails, in txt format (results in txt can be also easily loaded with `ast.literal_eval`). `ResultsPlotter` is a helper class that enables the user to easily get a plot of the models' performance on each dataset, and their average performance.



  The main advantages you will find when using autotransformers are the following:

  * |:high_brightness:| You can easily train multiple models on multiple datasets, sequentially, with hyperparameter tuning. This eases the task of finding the best model for each task, by comparing multiple models with different parameter configurations. Optuna is used for hyperparameter search.

  * |:hourglass:| Once you get used to the library and how scripts are configured, writing a new script for any task belonging to QA, NER, Classification (in any of its forms), or Seq2Seq, will take minutes.

  * |:floppy_disk:| To avoid disk overloading, AutoTrainer, the main class in autotransformers, comes with a checkpoint cleaner, which removes every 10 minutes all checkpoints but the four best (excluding the current optuna run to avoid errors). Additionally, a directory with the best checkpoint found (using validation metrics) is saved each time checkpoints are cleaned. This saves not only disk usage, but effort, easing the task of finding the best checkpoint and removing all unnecessary checkpoints. This is also useful if you want to run many models for many trials on many datasets while you go to a music festival |:sunglasses:| (tested). In that situation you don't want to worry about whether your disk is full before your experiments finish.

  * |:tokyo_tower:| autotransformers comes with a tool to easily integrate NLP data augmentation methods from [nlpaug](https://github.com/makcedward/nlpaug/) library. Keep reading to learn how.

  * |:bar_chart:| Metrics on test after hyperparameter tuning are saved in a directory defined when initializing AutoTrainer. Additionally, with ResultsPlotter you can easily generate a beautiful graph depicting the comparison of the different models you have trained for a dataset. This is handy for presenting a models' comparison in a visual way.

  * |:palm_tree:| autotransformers is flexible, so when you get a deep understanding of the tool, you will be able to train ensembles of transformers or other monsters of nature. Simpler architectures like pre-trained Transformers models plus LSTMs or other type of layers before the task layers are also possible. This speeds up the research process, as the user only needs to create a custom class inheriting from transformers.PretrainedModel and configure ModelConfig and DatasetConfig accordingly; the rest is done by AutoTrainer. The same applies to artificial Encoder-Decoder models (that is encoder-decoder models created from pre-trained encoder-only or decoder-only models) - check [this](https://huggingface.co/docs/transformers/model_doc/encoder-decoder) for more information. EncoderDecoderModel architecture can be configured for seq2seq tasks by setting the correct ModelConfig's parameters. This is useful for seq2seq tasks on languages for which there is no Encoder-Decoder model available.



  To install `autotransformers` from pypi, you can simply run:

  ```
  pip install autotransformers
  ```

  Alternatively, to install the most recent version from source, you can directly install it from GitHub:

  ```
  pip install git+https://github.com/lenguajenatural-ai/autotransformers.git
  ```

  If you prefer to have a local copy of the library, in case you want to customize any part of it or for whatever reason, you can install it from the local repository in editable mode, like this:

  ```
  git clone https://github.com/lenguajenatural-ai/autotransformers.git
  cd autotransformers
  pip install -e .
  ```

  Be aware that pytorch must be built on a cuda version that is compatible with the machine's installed cuda version. In case pytorch's default cuda version is not compatible visit https://pytorch.org/get-started/locally/ and install a compatible pytorch version.

  You can run tests after installing the library with `pytest`. It is already installed when installing `autotransformers`. Inside the main `autotransformers` repository directory (where README is), run:

  ```
  pytest .
  ```



  Here is a list of the tasks supported by `autotransformers`.



  Now you can train chatbots and instructional models with `autotransformers`, by using `task=chatbot` in `DatasetConfig`.



  Binary or multi-class classification is supported under the task name `classification`. So, for training models for this task, you just need to set in your DatasetConfig `task="classification"`.



  Multi-label classification is also under the task name `classification`. However, the user must add `is_multilabel=True` and `config_num_labels=<num_labels_multilabel>` to DatasetConfig. For multi-label classification, `AutoTrainer`, the main class in `autotransformers`, expects a dataset with a text field and the rest of the fields must be labels. If your dataset does not come in this format initially, you can either process your dataset outside of `AutoTrainer` and then pass a DatasetConfig with the processed dataset in the correct format, or you can define a `pre_func` to pass to `DatasetCOnfig` that will do that preprocessing. You can find an example of how to do this under the `notebooks/classification` folder, in the script called `train_multilabel.py`.

  For multi-label tasks, we can define a probability threshold for labels to be positive, as each label is independent of the rest. However, defining this threshold can be tricky, and is not straightforward. For that reason, when computing the metrics for multilabel, we iterate over thresholds from 0.1 to 0.9, with 0.1 step size. Then, we return the metrics belonging to the threshold which scored highest, together with that threshold. This way, the user already knows which probability threshold to use when using the returned model in production.



  The task name for NER is `ner`, so inside DatasetConfig, the user must pass `task="ner"`. AutoTrainer expects two fields: a list of tokens (`token_list`) and a list of labels (`label_list`) for each data instance. If your dataset is not already in that format, which is the most common case, you can easily process your dataset with a `pre_func`, using `autotransformers.utils.dict_to_list` function. You can check an example of how to do this in the script `notebooks/NER/train_spanish_ner.py`. In that script, `ehealth_kd` dataset does not have that format by default, so `pre_func=dict_to_list` is added to `DatasetConfig` to preprocess data before tokenizing it.



  The task name for QA is `qa`, so the correct configuration is `DatasetConfig(..., task="qa")`. The default format for this task is the SQUAD format (check [squad dataset in Huggingface's Datasets](https://huggingface.co/datasets/squad)). If your QA dataset is not in that format, you can either preprocess it before using `AutoTrainer` with it, or use a `pre_func` in `DatasetConfig` to achieve the same.



  Seq2Seq involves many different subtasks, such as translation, summarization, generative question answering... `AutoTrainer` is suited to perform any of these, as they all are based on generating a target text from a source text. The task name in `autotransformers` is `seq2seq`, so the configuration would be `DatasetConfig(..., task="seq2seq")`. You can find an example on how to train models on a seq2seq task in `notebooks/seq2seq/train_summarization_mlsum.py` script.




  Here is a list of public projects that have used `autotransformers` as its main tool for training models:

  1. `BioMedIA`: The winning project of [SomosNLP Hackaton](https://huggingface.co/hackathon-pln-es). It was also presented at NAACL2022, obtaining the Best Poster Presentation Award. You can check the paper [here](https://research.latinxinai.org/papers/naacl/2022/pdf/paper_06.pdf).

  2. `Detecting and Classifying Sexism by Ensembling Transformers Models`. This work was presented as part of IberLEF2022@Sepln2022 Conference. In the [results page of the workshop](http://nlp.uned.es/exist2022/#results) you can check that the systems produced by this paper achieved highest on both tasks of the workshop. Link to the paper [here](https://ceur-ws.org/Vol-3202/exist-paper3.pdf).

  3. `Named Entity Recognition For Humans and Species With Domain-Specific and Domain-Adapted Transformer Models`. This work was presented as part of IberLEF2022@Sepln2022 Conference. Link to the paper [here](https://ceur-ws.org/Vol-3202/livingner-paper9.pdf).

  4. Adversarial Question Answering in Spanish with Transformer Models. This work was presented as part of IberLEF2022@Sepln2022 Conference. Link to the paper [here](https://ceur-ws.org/Vol-3202/quales-paper3.pdf).

  5. Extractive and Abstractive Summarization Methods for Financial Narrative Summarization in English, Spanish and Greek. . This work was presented as part of FNP@LREC2022 Conference. Link to the paper [here](https://aclanthology.org/2022.fnp-1.8.pdf).



  The library is composed mainly of 3 important objects: the ModelConfig, DatasetConfig, and AutoTrainer. The two first are useful for configuring the experiments in a user-friendly way; both of them are dataclasses. AutoTrainer, on the other hand, serves for optimizing the models with the configurations passed to it. It uses Optuna in the background to optimize the models' parameters, which are passed in the ModelConfig.



  The ModelConfig class allows to configure each of the models' configurations. For a full list and description of all arguments of ModelConfig, please check the documentation.

  There are some examples in the following lines on how to instantiate a class of this type for different kind of models.

  - Example 1: instantiate a roberta large with a given hyperparameter space to save it under the name bsc@roberta-large, in a directory "/prueba/". We are going to run 20 trials, the first 8 of them will be random.

  ```python
  from autotransformers import ModelConfig

  def hp_space(trial):
      return {
          "learning_rate": trial.suggest_float(
              "learning_rate", 1e-5, 5e-5, log=True
          ),
          "num_train_epochs": trial.suggest_categorical(
              "num_train_epochs", [5, 10, 15, 20]
          ),
          "per_device_train_batch_size": trial.suggest_categorical(
              "per_device_train_batch_size", [8]),
          "per_device_eval_batch_size": trial.suggest_categorical(
              "per_device_eval_batch_size", [16]),
          "gradient_accumulation_steps": trial.suggest_categorical(
              "gradient_accumulation_steps", [2, 4, 8, 16]),
          "warmup_ratio": trial.suggest_float(
              "warmup_ratio", 0.1, 0.10, log=True
          ),
          "weight_decay": trial.suggest_float(
              "weight_decay", 1e-2, 0.1, log=True
          ),
          "adam_epsilon": trial.suggest_float(
              "adam_epsilon", 1e-10, 1e-6, log=True
          ),
      }

  bsc_large_config = ModelConfig(
          name="PlanTL-GOB-ES/roberta-large-bne",
          save_name="bsc@roberta-large",
          hp_space=hp_space,
          save_dir="./test_trial/",
          n_trials=20, # number of optuna trials to run for optimizing hyperparameters.
          random_init_trials=8, # number of optuna random init trials (before the optimization algorithm drives the search)
          dropout_vals=[0.0], # dropout values for last layer to use.
          only_test=False, # whether to only test on test dataset (no prev train)
      )
  ```

  Example 2: if the model we are configuring is aimed at doing a seq2seq task, we could configure it like this:

  ```python
  from transformers import Seq2SeqTrainer, MT5ForConditionalGeneration

  def tokenize_dataset(examples, tokenizer, dataset_config):
      inputs = ["question: {} context: {}".format(q, c) for q, c in zip(examples["question"], examples["context"])]
      targets = examples[dataset_config.label_col]
      model_inputs = tokenizer(inputs, max_length=1024 if tokenizer.model_max_length != 512 else 512, truncation=True)

      
      with tokenizer.as_target_tokenizer():
          labels = tokenizer(targets, max_length=dataset_config.max_length_summary, padding=True, truncation=True)

      labels["input_ids"] = [
          [(l if l != tokenizer.pad_token_id else -100) for l in label] for label in labels["input_ids"]
      ]

      model_inputs["labels"] = labels["input_ids"]
      return model_inputs

  mt5_config = ModelConfig(
           name="google/mt5-base",
           save_name="mt5-base",
           hp_space=hp_space,
           num_beams=4,
           trainer_cls_summarization=Seq2SeqTrainer,
           model_cls_summarization=MT5ForConditionalGeneration,
           custom_tok_func=tokenize_dataset,
           only_test=False,
           **{
              "min_length_summary": 64,
              "max_length_summary": 360,
              "random_init_trials": 3,
              "n_trials": 1,
              "save_dir": "./example_seq2seq/"
           }
  )
  ```



  Next we have the DatasetConfig class, aimed at configuring all the specifications of a dataset: the fields where data is located, how to process it, what kind of task it is, etc. For a full list of the parameters, please check the online documentation.


  Here we will see different examples of how to create a DatasetConfig for different tasks. There are certain objects that are used in all the examples:

  ```python
  fixed_train_args = {
          "evaluation_strategy": "steps",
          "num_train_epochs": 10,
          "do_train": True,
          "do_eval": True,
          "logging_strategy": "steps",
          "eval_steps": 1,
          "save_steps": 1,
          "logging_steps": 1,
          "save_strategy": "steps",
          "save_total_limit": 2,
          "seed": 69,
          "fp16": False,
          "no_cuda": True,
          "dataloader_num_workers": 2,
          "load_best_model_at_end": True,
          "per_device_eval_batch_size": 16,
          "adam_epsilon": 1e-6,
          "adam_beta1": 0.9,
          "adam_beta2": 0.999,
          "max_steps": 1
      }

  ```

  * Example 1: Create a config for Conll2002 dataset, loading it from the Hub:

  ```python
  from transformers import EarlyStoppingCallback
  from autotransformers import DatasetConfig


  conll2002_config = {
      "seed": 44,
      "direction_optimize": "maximize", # whether to maximize or minimize the metric_optimize.
      "metric_optimize": "eval_f1-score", # metric to optimize; must be returned by compute_metrics_func
      "callbacks": [EarlyStoppingCallback(1, 0.00001)], # callbacks
      "fixed_training_args": fixed_train_args, # fixed train args defined before
      "dataset_name": "conll2002", # the name for the dataset
      "alias": "conll2002", # the alias for our dataset
      "task": "ner", # the type of tasl
      "hf_load_kwargs": {"path": "conll2002", "name": "es"}, # this are the arguments we should pass to datasets.load_dataset
      "label_col": "ner_tags", # in this column we have the tags in list of labels format.
  }

  conll2002_config = DatasetConfig(**conll2002_config) # Now we have it ready for training with AutoTrainer !

  ```

  * Example 2: Create a config for MLSUM dataset (for summarization)

  ```python
  from transformers import EarlyStoppingCallback
  from autotransformers import DatasetConfig

  mlsum_config = {
          "seed": 44,
          "direction_optimize": "maximize",
          "metric_optimize": "eval_rouge2",
          "callbacks": [EarlyStoppingCallback(1, 0.00001)],
          "fixed_training_args": fixed_train_args,
          "dataset_name": "mlsum",
          "alias": "mlsum",
          "retrain_at_end": False,
          "task": "summarization",
          "hf_load_kwargs": {"path": "mlsum", "name": "es"},
          "label_col": "summary",
          "num_proc": 16
      }

  mlsum_config = DatasetConfig(**mlsum_config)
  ```

  * Example 3: Create a config for a NER task which is in json format.

  ```python
  from transformers import EarlyStoppingCallback
  from autotransformers import DatasetConfig, joinpaths

  data_dir = "/home/loquesea/livingnerdata/"

  livingner1_config = {
      "seed": 44,
      "direction_optimize": "maximize",
      "metric_optimize": "eval_f1-score",
      "callbacks": [EarlyStoppingCallback(1, 0.00001)],
      "fixed_training_args": fixed_train_args,
      "dataset_name": "task1-complete@livingner",
      "alias": "task1-complete@livingner",
      "task": "ner",
      "split": False,
      "label_col": "ner_tags", # in this field of each json dict labels are located.
      "text_field": "token_list", # in this field of each json dict the tokens are located
      "files": {"train": joinpaths(data_dir, "task1_train_complete.json"),
              "validation": joinpaths(data_dir, "task1_val_complete.json"),
              "test": joinpaths(data_dir, "task1_val_complete.json")
      }
  }







  livingner1_config = DatasetConfig(**livingner1_config)
  ```

  You can refer to the examples folder to see more ways of using DatasetConfig, as well as to understand the functionalities of it that are specific to a certain task.



  AutoTrainer is the main class in `autotransformers`, but is almost purely configured via lists of `DatasetConfig` and `ModelConfig`. The full configuration of AutoTrainer, given that you already have a `DatasetConfig` and a `ModelConfig`, would be the following:

  ```python
  from autotransformers import AutoTrainer

  autotrainer = AutoTrainer(
      dataset_configs=[dataset_config],
      model_configs=[model_config],
      metrics_dir="experiments_metrics",
      hp_search_mode="optuna",
      clean=True,
      metrics_cleaner="tmp_metrics_cleaner",
      use_auth_token=True,
  )
  all_results = autotrainer()
  ```





  This is a pipeline for data augmentation. With this, you can easily integrate [nlpaug](https://github.com/makcedward/nlpaug/) into your datasets from Huggingface, in an easy way. Below there is an example of how to build a pipeline that will be applied over the dataset with different data augmentation methods.
  In the below example, 10% of the examples are augmented with contextual word embeddings in inserting mode (that is, a word from the language model is inserted somewhere in the text); 15% are augmented with the same type of augmenter but substituting the words instead of inserting them. Moreover, we also use a backtranslation augmenter over 20% of the examples, translating them to german and then back to english.
  If you want more information on how to use and configure each of these augmenters, just check [this notebook](https://github.com/makcedward/nlpaug/blob/master/example/textual_augmenter.ipynb).

  ```python
  from datasets import load_dataset
  from autotransformers.augmentation import NLPAugPipeline, NLPAugConfig

  dataset = load_dataset("ade_corpus_v2", "Ade_corpus_v2_classification")

  dataset = dataset["train"].select(range(100))

  steps = [
      NLPAugConfig(name="contextual_w_e", proportion=0.1, aug_kwargs={"model_path": "bert-base-cased", "action": "insert", "device":"cuda"}),
      NLPAugConfig(name="contextual_w_e", proportion=0.15, aug_kwargs={"model_path": "bert-base-cased", "action": "substitute", "device": "cuda"}),
      NLPAugConfig(
          name="backtranslation", proportion=0.2, aug_kwargs={"from_model_name": "facebook/wmt19-en-de", "to_model_name": "facebook/wmt19-de-en"}
      ),
  ]
  aug_pipeline = NLPAugPipeline(steps=steps)
  augmented_dataset = dataset.map(aug_pipeline.augment, batched=True)
  ```

  It is already integrated with AutoTrainer via the DatasetConfig, as shown below.

  ```python
  from autotransformers import DatasetConfig, ModelConfig, AutoTrainer
  from autotransformers.augmentation import NLPAugConfig
  from autotransformers.default_param_spaces import hp_space_base

  augment_steps = [
      NLPAugConfig(name="contextual_w_e", proportion=0.3, aug_kwargs={"model_path": "bert-base-cased", "action": "insert", "device":"cuda"}),
      NLPAugConfig(name="contextual_w_e", proportion=0.3, aug_kwargs={"model_path": "bert-base-cased", "action": "substitute", "device": "cuda"}),
      NLPAugConfig(
          name="backtranslation", proportion=0.3, aug_kwargs={"from_model_name": "Helsinki-NLP/opus-mt-es-en", "to_model_name": "Helsinki-NLP/opus-mt-en-es", "device": "cuda"}
      ),
  ]

  data_config = DatasetConfig(
      **{
          "hf_load_kwargs": {"path": "ade_corpus_v2", "name": "Ade_corpus_v2_classification"},
          "task": "classification",
          
          "augment_data": True,
          "data_augmentation_steps": augment_steps
      }
  )



  model_config = ModelConfig(
      name="bert-base-uncased",
      save_name="bert_prueba",
      hp_space = hp_space_base, # we would have to define this object before.
      n_trials=10,
      random_init_trials=5
  )

  autotrainer = AutoTrainer(
      model_configs = [model_config],
      dataset_configs = [data_config]
  )

  autotrainer()
  ```

  In this way, we are using the pipeline to internally augment data before training, therefore we will increment the amount of training data, without modifying the validation and test subsets.



  ```
  @misc{vaca2024autotransformers,
      author = {Alejandro Vaca Serrano},
      title = {AutoTransformers: A Library for Automatic Training and Benchmarking of Transformer Models},
      year = {2024},
      howpublished = {\url{https://github.com/lenguajenatural-ai/autotransformers}},
  }
  ```


pkgId: 87912c1153b56a147a8e5fa7a2189a631bac5cca88536c31495fa2cc1d9c9157
name: python-autots
arch: src
version: 0.6.15
epoch: 0
release: 1
summary: Automated Time Series Forecasting
url: https://github.com/winedarksea/AutoTS
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autots-0.6.15-1.src.rpm
checksum_type: sha256
description:
  <img src="/img/autots_1280.png" width="400" height="184" title="AutoTS Logo">

  AutoTS is a time series package for Python designed for rapidly deploying high-accuracy forecasts at scale.

  In 2023, AutoTS won in the M6 forecasting competition, delivering the highest performance investment decisions across 12 months of stock market forecasting.

  There are dozens of forecasting models usable in the `sklearn` style of `.fit()` and `.predict()`.
  These includes naive, statistical, machine learning, and deep learning models.
  Additionally, there are over 30 time series specific transforms usable in the `sklearn` style of `.fit()`, `.transform()` and `.inverse_transform()`.
  All of these function directly on Pandas Dataframes, without the need for conversion to proprietary objects.

  All models support forecasting multivariate (multiple time series) outputs and also support probabilistic (upper/lower bound) forecasts.
  Most models can readily scale to tens and even hundreds of thousands of input series.
  Many models also support passing in user-defined exogenous regressors.

  These models are all designed for integration in an AutoML feature search which automatically finds the best models, preprocessing, and ensembling for a given dataset through genetic algorithms.

  Horizontal and mosaic style ensembles are the flagship ensembling types, allowing each series to receive the most accurate possible models while still maintaining scalability.

  A combination of metrics and cross-validation options, the ability to apply subsets and weighting, regressor generation tools, simulation forecasting mode, event risk forecasting, live datasets, template import and export, plotting, and a collection of data shaping parameters round out the available feature set.


  * [Installation](https://github.com/winedarksea/AutoTS#installation)
  * [Basic Use](https://github.com/winedarksea/AutoTS#basic-use)
  * [Tips for Speed and Large Data](https://github.com/winedarksea/AutoTS#tips-for-speed-and-large-data)
  * Extended Tutorial [GitHub](https://github.com/winedarksea/AutoTS/blob/master/extended_tutorial.md) or [Docs](https://winedarksea.github.io/AutoTS/build/html/source/tutorial.html)
  * [Production Example](https://github.com/winedarksea/AutoTS/blob/master/production_example.py)


  ```
  pip install autots
  ```
  This includes dependencies for basic models, but [additonal packages](https://github.com/winedarksea/AutoTS/blob/master/extended_tutorial.md#installation-and-dependency-versioning) are required for some models and methods.

  Be advised there are several other projects that have chosen similar names, so make sure you are on the right AutoTS code, papers, and documentation.



  Input data for AutoTS is expected to come in either a *long* or a *wide* format:

  - The *wide* format is a `pandas.DataFrame` with a `pandas.DatetimeIndex` and each column a distinct series.
  - The *long* format has three columns:
    - Date (ideally already in pandas-recognized `datetime` format)
    - Series ID. For a single time series, series_id can be `= None`.
    - Value
  - For *long* data, the column name for each of these is passed to `.fit()` as `date_col`, `id_col`, and `value_col`. No parameters are needed for *wide* data.

  Lower-level functions are only designed for `wide` style data.

  ```python

  from autots import AutoTS, load_daily


  long = False
  df = load_daily(long=long)

  model = AutoTS(
      forecast_length=21,
      frequency='infer',
      prediction_interval=0.9,
      ensemble='auto',
      model_list="fast",  # "superfast", "default", "fast_parallel"
      transformer_list="fast",  # "superfast",
      drop_most_recent=1,
      max_generations=4,
      num_validations=2,
      validation_method="backwards"
  )
  model = model.fit(
      df,
      date_col='datetime' if long else None,
      value_col='value' if long else None,
      id_col='series_id' if long else None,
  )

  prediction = model.predict()

  prediction.plot(model.df_wide_numeric,
                  series=model.df_wide_numeric.columns[0],
                  start_date="2019-01-01")

  print(model)


  forecasts_df = prediction.forecast

  forecasts_up, forecasts_low = prediction.upper_forecast, prediction.lower_forecast


  model_results = model.results()

  validation_results = model.results("validation")
  ```

  The lower-level API, in particular the large section of time series transformers in the scikit-learn style, can also be utilized independently from the AutoML framework.

  Check out [extended_tutorial.md](https://winedarksea.github.io/AutoTS/build/html/source/tutorial.html) for a more detailed guide to features.

  Also take a look at the [production_example.py](https://github.com/winedarksea/AutoTS/blob/master/production_example.py)


  * Use appropriate model lists, especially the predefined lists:
  	* `superfast` (simple naive models) and `fast` (more complex but still faster models, optimized for many series)
  	* `fast_parallel` (a combination of `fast` and `parallel`) or `parallel`, given many CPU cores are available
  		* `n_jobs` usually gets pretty close with `='auto'` but adjust as necessary for the environment
  	* 'scalable' is the best list to avoid crashing when many series are present. There is also a transformer_list = 'scalable'
  	* see a dict of predefined lists (some defined for internal use) with `from autots.models.model_list import model_lists`
  * Use the `subset` parameter when there are many similar series, `subset=100` will often generalize well for tens of thousands of similar series.
  	* if using `subset`, passing `weights` for series will weight subset selection towards higher priority series.
  	* if limited by RAM, it can be distributed by running multiple instances of AutoTS on different batches of data, having first imported a template pretrained as a starting point for all.
  * Set `model_interrupt=True` which passes over the current model when a `KeyboardInterrupt` ie `crtl+c` is pressed (although if the interrupt falls between generations it will stop the entire training).
  * Use the `result_file` method of `.fit()` which will save progress after each generation - helpful to save progress if a long training is being done. Use `import_results` to recover.
  * While Transformations are pretty fast, setting `transformer_max_depth` to a lower number (say, 2) will increase speed. Also utilize `transformer_list` == 'fast' or 'superfast'.
  * Check out [this example](https://github.com/winedarksea/AutoTS/discussions/76) of using AutoTS with pandas UDF.
  * Ensembles are obviously slower to predict because they run many models, 'distance' models 2x slower, and 'simple' models 3x-5x slower.
  	* `ensemble='horizontal-max'` with `model_list='no_shared_fast'` can scale relatively well given many cpu cores because each model is only run on the series it is needed for.
  * Reducing `num_validations` and `models_to_validate` will decrease runtime but may lead to poorer model selections.
  * For datasets with many records, upsampling (for example, from daily to monthly frequency forecasts) can reduce training time if appropriate.
  	* this can be done by adjusting `frequency` and `aggfunc` but is probably best done before passing data into AutoTS.
  * It will be faster if NaN's are already filled. If a search for optimal NaN fill method is not required, then fill any NaN with a satisfactory method before passing to class.
  * Set `runtime_weighting` in `metric_weighting` to a higher value. This will guide the search towards faster models, although it may come at the expense of accuracy.
  * Memory shortage is the most common cause of random process/kernel crashes. Try testing a data subset and using a different model list if issues occur. Please also report crashes if found to be linked to a specific set of model parameters (not AutoTS parameters but the underlying forecasting model params). Also crashes vary significantly by setup such as underlying linpack/blas so seeing crash differences between environments can be expected.


  * Give feedback on where you find the documentation confusing
  * Use AutoTS and...
  	* Report errors and request features by adding Issues on GitHub
  	* Posting the top model templates for your data (to help improve the starting templates)
  	* Feel free to recommend different search grid parameters for your favorite models
  * And, of course, contributing to the codebase directly on GitHub.


  *Also known as Project CATS (Catlin's Automated Time Series) hence the logo.*


pkgId: b47461b9dd3c8626789809490d3d8491bb91207bc25735c5916faea4a89bb287
name: python-autots
arch: src
version: 0.6.16
epoch: 0
release: 1
summary: Automated Time Series Forecasting
url: https://github.com/winedarksea/AutoTS
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autots-0.6.16-1.src.rpm
checksum_type: sha256
description:
  <img src="/img/autots_1280.png" width="400" height="184" title="AutoTS Logo">

  AutoTS is a time series package for Python designed for rapidly deploying high-accuracy forecasts at scale.

  In 2023, AutoTS won in the M6 forecasting competition, delivering the highest performance investment decisions across 12 months of stock market forecasting.

  There are dozens of forecasting models usable in the `sklearn` style of `.fit()` and `.predict()`.
  These includes naive, statistical, machine learning, and deep learning models.
  Additionally, there are over 30 time series specific transforms usable in the `sklearn` style of `.fit()`, `.transform()` and `.inverse_transform()`.
  All of these function directly on Pandas Dataframes, without the need for conversion to proprietary objects.

  All models support forecasting multivariate (multiple time series) outputs and also support probabilistic (upper/lower bound) forecasts.
  Most models can readily scale to tens and even hundreds of thousands of input series.
  Many models also support passing in user-defined exogenous regressors.

  These models are all designed for integration in an AutoML feature search which automatically finds the best models, preprocessing, and ensembling for a given dataset through genetic algorithms.

  Horizontal and mosaic style ensembles are the flagship ensembling types, allowing each series to receive the most accurate possible models while still maintaining scalability.

  A combination of metrics and cross-validation options, the ability to apply subsets and weighting, regressor generation tools, simulation forecasting mode, event risk forecasting, live datasets, template import and export, plotting, and a collection of data shaping parameters round out the available feature set.


  * [Installation](https://github.com/winedarksea/AutoTS#installation)
  * [Basic Use](https://github.com/winedarksea/AutoTS#basic-use)
  * [Tips for Speed and Large Data](https://github.com/winedarksea/AutoTS#tips-for-speed-and-large-data)
  * [Flowchart](https://github.com/winedarksea/AutoTS#autots-process)
  * Extended Tutorial [GitHub](https://github.com/winedarksea/AutoTS/blob/master/extended_tutorial.md) or [Docs](https://winedarksea.github.io/AutoTS/build/html/source/tutorial.html)
  * [Production Example](https://github.com/winedarksea/AutoTS/blob/master/production_example.py)


  ```
  pip install autots
  ```
  This includes dependencies for basic models, but [additonal packages](https://github.com/winedarksea/AutoTS/blob/master/extended_tutorial.md#installation-and-dependency-versioning) are required for some models and methods.

  Be advised there are several other projects that have chosen similar names, so make sure you are on the right AutoTS code, papers, and documentation.



  Input data for AutoTS is expected to come in either a *long* or a *wide* format:

  - The *wide* format is a `pandas.DataFrame` with a `pandas.DatetimeIndex` and each column a distinct series.
  - The *long* format has three columns:
    - Date (ideally already in pandas-recognized `datetime` format)
    - Series ID. For a single time series, series_id can be `= None`.
    - Value
  - For *long* data, the column name for each of these is passed to `.fit()` as `date_col`, `id_col`, and `value_col`. No parameters are needed for *wide* data.

  Lower-level functions are only designed for `wide` style data.

  ```python

  from autots import AutoTS, load_daily


  long = False
  df = load_daily(long=long)

  model = AutoTS(
      forecast_length=21,
      frequency="infer",
      prediction_interval=0.9,
      ensemble=None,
      model_list="superfast",  # "fast", "default", "fast_parallel"
      transformer_list="fast",  # "superfast",
      drop_most_recent=1,
      max_generations=4,
      num_validations=2,
      validation_method="backwards"
  )
  model = model.fit(
      df,
      date_col='datetime' if long else None,
      value_col='value' if long else None,
      id_col='series_id' if long else None,
  )

  prediction = model.predict()

  prediction.plot(model.df_wide_numeric,
                  series=model.df_wide_numeric.columns[0],
                  start_date="2019-01-01")

  print(model)


  forecasts_df = prediction.forecast

  forecasts_up, forecasts_low = prediction.upper_forecast, prediction.lower_forecast


  model_results = model.results()

  validation_results = model.results("validation")
  ```

  The lower-level API, in particular the large section of time series transformers in the scikit-learn style, can also be utilized independently from the AutoML framework.

  Check out [extended_tutorial.md](https://winedarksea.github.io/AutoTS/build/html/source/tutorial.html) for a more detailed guide to features.

  Also take a look at the [production_example.py](https://github.com/winedarksea/AutoTS/blob/master/production_example.py)


  * Use appropriate model lists, especially the predefined lists:
  	* `superfast` (simple naive models) and `fast` (more complex but still faster models, optimized for many series)
  	* `fast_parallel` (a combination of `fast` and `parallel`) or `parallel`, given many CPU cores are available
  		* `n_jobs` usually gets pretty close with `='auto'` but adjust as necessary for the environment
  	* 'scalable' is the best list to avoid crashing when many series are present. There is also a transformer_list = 'scalable'
  	* see a dict of predefined lists (some defined for internal use) with `from autots.models.model_list import model_lists`
  * Use the `subset` parameter when there are many similar series, `subset=100` will often generalize well for tens of thousands of similar series.
  	* if using `subset`, passing `weights` for series will weight subset selection towards higher priority series.
  	* if limited by RAM, it can be distributed by running multiple instances of AutoTS on different batches of data, having first imported a template pretrained as a starting point for all.
  * Set `model_interrupt=True` which passes over the current model when a `KeyboardInterrupt` ie `crtl+c` is pressed (although if the interrupt falls between generations it will stop the entire training).
  * Use the `result_file` method of `.fit()` which will save progress after each generation - helpful to save progress if a long training is being done. Use `import_results` to recover.
  * While Transformations are pretty fast, setting `transformer_max_depth` to a lower number (say, 2) will increase speed. Also utilize `transformer_list` == 'fast' or 'superfast'.
  * Check out [this example](https://github.com/winedarksea/AutoTS/discussions/76) of using AutoTS with pandas UDF.
  * Ensembles are obviously slower to predict because they run many models, 'distance' models 2x slower, and 'simple' models 3x-5x slower.
  	* `ensemble='horizontal-max'` with `model_list='no_shared_fast'` can scale relatively well given many cpu cores because each model is only run on the series it is needed for.
  * Reducing `num_validations` and `models_to_validate` will decrease runtime but may lead to poorer model selections.
  * For datasets with many records, upsampling (for example, from daily to monthly frequency forecasts) can reduce training time if appropriate.
  	* this can be done by adjusting `frequency` and `aggfunc` but is probably best done before passing data into AutoTS.
  * It will be faster if NaN's are already filled. If a search for optimal NaN fill method is not required, then fill any NaN with a satisfactory method before passing to class.
  * Set `runtime_weighting` in `metric_weighting` to a higher value. This will guide the search towards faster models, although it may come at the expense of accuracy.
  * Memory shortage is the most common cause of random process/kernel crashes. Try testing a data subset and using a different model list if issues occur. Please also report crashes if found to be linked to a specific set of model parameters (not AutoTS parameters but the underlying forecasting model params). Also crashes vary significantly by setup such as underlying linpack/blas so seeing crash differences between environments can be expected.


  * Give feedback on where you find the documentation confusing
  * Use AutoTS and...
  	* Report errors and request features by adding Issues on GitHub
  	* Posting the top model templates for your data (to help improve the starting templates)
  	* Feel free to recommend different search grid parameters for your favorite models
  * And, of course, contributing to the codebase directly on GitHub.



  ```mermaid
  flowchart TD
      A[Initiate AutoTS Model] --> B[Import Template]
      B --> C[Load Data]
      C --> D[Split Data Into Initial Train/Test Holdout]
      D --> E[Run Initial Template Models]
      E --> F[Evaluate Accuracy Metrics on Results]
      F --> G[Generate Score from Accuracy Metrics]
      G --> H{Max Generations Reached or Timeout?}

      H -->|No| I[Evaluate All Previous Templates]
      I --> J[Genetic Algorithm Combines Best Results and New Random Parameters into New Template]
      J --> K[Run New Template Models and Evaluate]
      K --> G

      H -->|Yes| L[Select Best Models by Score for Validation Template]
      L --> M[Run Validation Template on Additional Holdouts]
      M --> N[Evaluate and Score Validation Results]
      N --> O{Create Ensembles?}

      O -->|Yes| P[Generate Ensembles from Validation Results]
      P --> Q[Run Ensembles Through Validation]
      Q --> N

      O -->|No| R[Export Best Models Template]
      R --> S[Select Single Best Model]
      S --> T[Generate Future Time Forecast]
      T --> U[Visualize Results]

      R --> B[Import Best Models Template]
  ```

  *Also known as Project CATS (Catlin's Automated Time Series) hence the logo.*


pkgId: 96c0b6a2999d233ccedde4113dedebe12ddb16ecd11683e6806580aa55171447
name: python-autotui
arch: src
version: 0.4.7
epoch: 0
release: 1
url: https://github.com/seanbreckenridge/autotui
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autotui-0.4.7-1.src.rpm
checksum_type: sha256
summary:
  "quickly create UIs to interactively prompt, validate, and persist python objects to disk (JSON/YAML) and back using type hints"

description:
  [![PyPi version](https://img.shields.io/pypi/v/autotui.svg)](https://pypi.python.org/pypi/autotui) [![Python 3.8|3.9|3.10](https://img.shields.io/pypi/pyversions/autotui.svg)](https://pypi.python.org/pypi/autotui) [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)

  This uses type hints to convert [`NamedTuple`](https://docs.python.org/3.9/library/typing.html#typing.NamedTuple)'s (short struct-like classes) to JSON/YAML, and back to python objects.

  It also wraps [`prompt_toolkit`](https://python-prompt-toolkit.readthedocs.io/en/master/index.html) to prompt the user and validate the input for common types, and is extendible to whatever types you want.

  - [Supported Types](#supported-types)
  - [Install](#install)
  - [Usage](#usage)
    - [Enabling Options](#enabling-options)
    - [Partial prompts](#partial-prompts)
    - [YAML](#yaml)
    - [Picking items](#picking)
    - [Editing items](#editing)
    - [Custom types/prompting](#custom-types)
  - [Testing](#testing)



  This has built-ins to prompt, validate and serialize:

  - `int`
  - `float`
  - `bool`
  - `str`
  - `datetime`
  - `Enum`
  - `Decimal`
  - `Optional[<type>]` [(or `<type> | None`)](https://www.python.org/dev/peps/pep-0604/)
  - `List[<type>]` (or `list[<type>]`)
  - `Set[<type>]` (or `set[<type>]`)
  - other `NamedTuple`s (recursively)

  I wrote this so that I don't have to repeatedly write boilerplate-y python code to validate/serialize/deserialize data. As a more extensive example of its usage, you can see my [`ttally`](https://github.com/seanbreckenridge/ttally) repo, which I use to track things like calories/water etc...



  This requires `python3.8+`, specifically for modern [`typing`](https://docs.python.org/3/library/typing.html) support.

  To install with pip, run:

      pip install autotui



  As an example, if I want to log whenever I drink water to a file:

  ```python
  from datetime import datetime
  from typing import NamedTuple

  from autotui.shortcuts import load_prompt_and_writeback

  class Water(NamedTuple):
      at: datetime
      glass_count: float

  if __name__ == "__main__":
      load_prompt_and_writeback(Water, "~/.local/share/water.json")
  ```

  <img src="https://raw.githubusercontent.com/seanbreckenridge/autotui/master/.assets/builtin_demo.gif">

  Which, after running a few times, would create:

  `~/.local/share/water.json`

  ```json
  [
    {
      "at": 1598856786,
      "glass_count": 2.0
    },
    {
      "at": 1598856800,
      "glass_count": 1.0
    }
  ]
  ```

  _(datetimes are serialized into epoch time)_

  If I want to load the values back into python, its just:

  ```python
  from autotui.shortcuts import load_from

  class Water(NamedTuple):
      

  if __name__ == "__main__":
      print(load_from(Water, "~/.local/share/water.json"))



  ```

  A lot of my usage of this only ever uses 3 functions in the [`autotui.shortcuts`](https://github.com/seanbreckenridge/autotui/blob/master/autotui/shortcuts.py) module; `dump_to` to dump a sequence of my `NamedTuple`s to a file, `load_from` to do the opposite, and `load_prompt_and_writeback`, to load values in, prompt me, and write back to the file.



  Some options/features can be enabled using global environment variables, or by using a contextmanager to temporarily enable certain prompts/features.

  As an example, there are two versions of the `datetime` prompt

  - The one you see above using a dialog
  - A live version which displays the parsed datetime while typing. Since that can cause some lag, it can be enabled by setting the `LIVE_DATETIME` option.

  You can enable that by:

  - setting the `AUTOTUI_LIVE_DATETIME` (prefix the name of the option with `AUTOTUI_`) environment variable, e.g., add `export AUTOTUI_LIVE_DATETIME=1` to your `.bashrc`/`.zshrc`
  - using the `options` contextmanager:

  ```python
  import autotui

  with autotui.options("LIVE_DATETIME"):
      autotui.prompt_namedtuple(...)
  ```

  Options:

  - `LIVE_DATETIME`: Enables the live datetime prompt
  - `CONVERT_UNKNOWN_ENUM_TO_NONE`: If an enum value is not found on the enumeration (e.g. you remove some enum value), convert it to `None` instead of raising a `ValueError`
  - `ENUM_FZF`: Use `fzf` to prompt for enums
  - `CLICK_PROMPT` - Where possible, use [`click`](https://click.palletsprojects.com/en/8.1.x/) to prompt for values instead of [`prompt_toolkit`](https://python-prompt-toolkit.readthedocs.io/en/master/index.html)



  If you want to prompt for only a few fields, you can supply the `attr_use_values` or `type_use_values` to supply default values:

  ```python

  from datetime import datetime
  from typing import NamedTuple

  from autotui import prompt_namedtuple
  from autotui.shortcuts import load_prompt_and_writeback

  class Water(NamedTuple):
      at: datetime
      glass_count: float

  load_prompt_and_writeback(Water, "./water.json", type_use_values={datetime: datetime.now()})


  val = prompt_namedtuple(Water, attr_use_values={"at": datetime.now})
  ```

  Since you can specify a function to either of those arguments -- you're free to [write a completely custom prompt function](https://python-prompt-toolkit.readthedocs.io/en/master/pages/asking_for_input.html) to prompt/grab data for that field however you want

  For example, to prompt for strings by opening `vim` instead:

  ```python
  from datetime import datetime
  from typing import NamedTuple, List, Optional

  from autotui.shortcuts import load_prompt_and_writeback

  import click


  def edit_in_vim() -> str:
      m = click.edit(text=None, editor="vim")
      return m if m is None else m.strip()


  class JournalEntry(NamedTuple):
      creation_date: datetime
      tags: Optional[List[str]]  # one or more tags to tag this journal entry with
      content: str


  if __name__ == "__main__":
      load_prompt_and_writeback(
          JournalEntry,
          "~/Documents/journal.json",
          attr_use_values={"content": edit_in_vim},
      )
  ```

  Can also define those as a `staticmethod` on the class, so you don't have to pass around the extra state:

  ```python
  class JournalEntry(NamedTuple):
      ...

      @staticmethod
      def attr_use_values() -> Dict:
          return {"content": edit_in_vim}



  prompt_namedtuple(JournalEntry, "~/Documents/journal.json")
  ```



  Since YAML is a superset of JSON, this can also be used with YAML files. `autotui.shortcuts` will automatically decode/write to YAML files based on the file extension.

  ```python

  if __name__ == "__main__":
      load_prompt_and_writeback(Water, "~/.local/share/water.yaml")
  ```

  Results in:

  ```yaml
  - at: 1645840523
    glass_count: 1.0
  - at: 1645839340
    glass_count: 1.0
  ```

  You can also pass `format="yaml"` to the `namedtuple_sequence_dumps/namedtuple_sequence_loads` functions (shown below)



  This has a basic [`fzf`](https://github.com/junegunn/fzf) picker using [`pyfzf-iter`](https://github.com/seanbreckenridge/pyfzf), which lets you pick one item from a list/iterator:

  ```python
  from autotui import pick_namedtuple
  from autotui.shortcuts import load_from

  picked = pick_namedtuple(load_from(Water, "~/.local/share/water.json"))
  print(picked)
  ```

  To install the required dependencies, install [`fzf`](https://github.com/junegunn/fzf) and `pip install 'autotui[pick]'`



  This also provides a basic editor, which lets you edit a single field of a `NamedTuple`.

  ```
  $ python3 ./examples/edit.py
  Water(at=datetime.datetime(2023, 3, 5, 18, 55, 59, 519320), glass_count=1)
  Which field to edit:

  	1. at
  	2. glass_count

  'glass_count' (float) > 30
  Water(at=datetime.datetime(2023, 3, 5, 18, 55, 59, 519320), glass_count=30.0)
  ```

  In python:

  ```python
  from autotui.edit import edit_namedtuple

  water = edit_namedtuple(water, print_namedtuple=True)

  water = edit_namedtuple(water, print_namedtuple=True, loop=True)
  ```

  Any additional arguments to `edit_namedtuple` are passed to `prompt_namedtuple`, so you can specify `type_validators` to `attr_validators` to prompt in some custom way

  To install, `pip install 'autotui[edit]'` or `pip install click`



  If you want to support custom types, or specify a special way to serialize another NamedTuple recursively, you can specify `type_validators`, and `type_[de]serializer` to handle the validation, serialization, deserialization for that type/attribute name.

  As a more complicated example, heres a validator for [`timedelta`](https://docs.python.org/3.8/library/datetime.html#datetime.timedelta) (duration of time), being entered as MM:SS, and the corresponding serializers.

  ```python




  def _timedelta(user_input: str) -> timedelta:
      if len(user_input.strip()) == 0:
          raise ValueError("Not enough input!")
      minutes, _, seconds = user_input.partition(":")
      
      return timedelta(minutes=float(minutes), seconds=float(seconds))



  def to_seconds(t: timedelta) -> int:
      return int(t.total_seconds())



  def from_seconds(seconds: int) -> timedelta:
      return timedelta(seconds=seconds)



  class Action(NamedTuple):
      name: str
      duration: timedelta




  timedelta_handler = AutoHandler(
      func=_timedelta,  # accepts the string the user is typing as input
      catch_errors=[ValueError],
  )












  a = prompt_namedtuple(
      Action,
      type_validators={
          timedelta: timedelta_handler,
      },
  )








  a_str: str = namedtuple_sequence_dumps(
      [a],
      type_serializers={
          timedelta: to_seconds,
      },
      indent=None,
  )


  a_load = namedtuple_sequence_loads(
      a_str,
      to=Action,
      type_deserializers={
          timedelta: from_seconds,
      },
  )[0]


  a_load2 = namedtuple_sequence_loads(
      a_str,
      to=Action,
      attr_deserializers={
          "duration": from_seconds,
      },
  )[0]

  print(a)
  print(a_str)
  print(a_load)
  print(a_load2)
  ```

  Output:

  ```
  $ python3 ./examples/timedelta_serializer.py
  'name' (str) > on the bus
  'duration' (_timedelta) > 30:00
  Action(name='on the bus', duration=datetime.timedelta(seconds=1800))
  [{"name": "on the bus", "duration": 1800}]
  Action(name='on the bus', duration=datetime.timedelta(seconds=1800))
  Action(name='on the bus', duration=datetime.timedelta(seconds=1800))
  ```

  The general philosophy I've taken for serialization and deserialization is send a warning if the types aren't what the NamedTuple expects, but load the values anyways. If serialization can't serialize something, it warns, and if `json.dump` doesn't have a way to handle it, it throws an error. When deserializing, all values are loaded from their JSON primitives, and then converted into their corresponding python equivalents; If the value doesn't exist, it warns and sets it to None, if there's a deserializer supplied, it uses that. This is meant to help facilitate quick TUIs, I don't want to have to fight with it.

  (If you know what you're doing and want to ignore those warnings, you can set the `AUTOTUI_DISABLE_WARNINGS=1` environment variable)

  There are lots of examples on how this is handled/edge-cases in the [`tests`](./tests/test_autotui.py).

  You can also take a look at the [`examples`](./examples)



  ```bash
  git clone https://github.com/seanbreckenridge/autotui
  cd ./autotui
  pip install '.[testing]'
  mypy ./autotui
  pytest
  ```


pkgId: d267e8f9c4df92c55beb3d3f80ec55045df4945100e7eb1b3504db13ecac4aa9
name: python-autotuneml
arch: src
version: 0.4.6
epoch: 0
release: 1
summary: A package for automated machine learning on tabular data
url: https://github.com/jss367/autotuneml
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autotuneml-0.4.6-1.src.rpm
checksum_type: sha256
description:
  Automated machine learning for tabular data.
  * Works with HyperOpt or Optuna

  It is recommended that you use [datacleanml](https://github.com/jss367/datacleanml) before running this code.


pkgId: 9a88b730349c92ae4a3449885d8ae38c9e0ced53afb521e3ede144dbd518ee95
name: python-autotwin_gmglib
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: Graph Model Generation Library for Auto-Twin
url: https://github.com/AutotwinEU/graph-model-gen
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autotwin_gmglib-0.1.7-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - License](https://img.shields.io/pypi/l/autotwin_gmglib)](https://github.com/AutotwinEU/graph-model-gen/blob/main/LICENSE)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/autotwin_gmglib)](https://www.python.org/downloads/)
  [![PyPI - Version](https://img.shields.io/pypi/v/autotwin_gmglib)](https://pypi.org/project/autotwin_gmglib/)



  The graph model generation library provides a set of utility functions to
  import an event log from a system knowledge graph, generate a graph model from
  the event log and export the graph model to the system knowledge graph.


pkgId: a953e9daf17699c77eb5ffaad121583cce301e0730a1e2796c115498f7f1cd21
name: python-autotwin_pmswsgi
arch: src
version: 0.1.8
epoch: 0
release: 1
summary: Process Mining Service WSGI for Auto-Twin
url: https://github.com/AutotwinEU/proc-mining-serv
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autotwin_pmswsgi-0.1.8-1.src.rpm
checksum_type: sha256
description:
  <details>
      <summary>
          <code>POST</code>
          <code><b>/graph-model</b></code>
          <code>(create a graph model in the SKG)</code>
      </summary>
      <br/>
  **Parameters**
  > None
  **Body**
  > Definition
  >
  > | Name                       | Type                    | Default      | Description                                                       |
  > |----------------------------|-------------------------|--------------|-------------------------------------------------------------------|
  > | `name`                     | `string`                | `"System"`   | Name of the system to be discovered                               |
  > | `version`                  | `string`                | `""`         | Version of the system to be discovered                            |
  > | `neo4j:interval`           | `array[number\|string]` | `[0.0, 0.0]` | Interval of the event log to be used                              |
  > | `model:time_unit`          | `string`                | `"s"`        | Unified time unit of algorithm and model parameters               |
  > | `model:operation:io_ratio` | `number`                | `1.5`        | Minimum ratio of input to output for an ATTACH/COMPOSE operation  |
  > | `model:operation:co_ratio` | `number`                | `0.5`        | Minimum ratio of cross to output for an ATTACH/ORDINARY operation |
  > | `model:operation:oi_ratio` | `number`                | `1.5`        | Minimum ratio of output to input for a DETACH/DECOMPOSE operation |
  > | `model:operation:ci_ratio` | `number`                | `0.5`        | Minimum ratio of cross to input for a DETACH/ORDINARY operation   |
  > | `model:formula:ratio`      | `number`                | `0.0`        | Minimum ratio of a formula to the primary one                     |
  > | `model:delays:seize`       | `number\|string`        | `0.0`        | Maximum delay in seizing a queued part                            |
  > | `model:delays:release`     | `number\|string`        | `0.0`        | Maximum delay in releasing a blocked part                         |
  > | `model:cdf:points`         | `number`                | `100`        | Maximum number of points in a CDF                                 |
  > Example
  > ```json
  > {
  >     "name": "Pizza Line",
  >     "version": "V4",
  >     "neo4j": {
  >         "interval": [0, 500000000]
  >     },
  >     "model": {
  >         "time_unit": "ms",
  >         "operation": {
  >             "io_ratio": 1.5,
  >             "co_ratio": 0.5,
  >             "oi_ratio": 1.5,
  >             "ci_ratio": 0.5
  >         },
  >         "formula": {
  >             "ratio": 0.06
  >         },
  >         "delays": {
  >             "seize": 30000,
  >             "release": 0
  >         },
  >         "cdf": {
  >             "points": 100
  >         }
  >     }
  > }
  > ```
  **Response**
  > Code: 201
  > Definition
  >
  > | Name       | Type     | Description                     |
  > |------------|----------|---------------------------------|
  > | `model_id` | `string` | ID of the generated graph model |
  > Example
  > ```json
  > {
  >     "model_id": "4:d44864fe-b050-4f74-8157-60d999e3580b:620887"
  > }
  > ```


pkgId: ea0f08d89ca3c77bd70522edf0e10c8ac2b31eb0184249060bc8107c98fa5f62
name: python-autotwin_pnglib
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Petri Net Model Generation Library for Auto-Twin
url: https://pypi.org/project/autotwin_pnglib/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autotwin_pnglib-0.1.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - License](https://img.shields.io/pypi/l/autotwin_pnglib)](https://github.com/AutotwinEU/petri_net_model_gen/blob/master/LICENSE) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/autotwin_gmglib)](https://www.python.org/downloads/) [![PyPI - Version](https://img.shields.io/pypi/v/autotwin_pnglib)](https://pypi.org/project/autotwin_pnglib/)





  The Petri Net Model Generation Library is a Python package designed to create, manipulate, and export Petri net models to a Neo4j database.



  To facilitate installation, the PMS WSGI is released as a Python module, `autotwin_pmswsgi`, in the PyPI repository.

  `autotwin_pnglib` has implicit dependencies on `autotwin_gmglib` and the optimization solver [SCIP](https://scipopt.org/). These dependencies cannot be automatically resolved by `pip` and must be installed manually.

  1. Install `autotwin_gmglib` by following the instructions provided [here](https://github.com/AutotwinEU/proc-mining-serv/blob/main/README.md).
  2. Install SCIP by following the instructions [here](https://www.scipopt.org/doc/html/INSTALL.php). Using the precompiled binary for version 9.1.0 is sufficient.

  Once `autotwin_gmglib` and SCIP are installed, you can easily install the other required Python packages with:

  `pip install -r requirements.txt `


pkgId: f5558fd7992f0e23ea65c65b4768e7361e7fa1885ee74812169209e92348f279
name: python-autotyping
arch: src
version: 24.9.0
epoch: 0
release: 1
summary: A tool for autoadding simple type annotations.
url: https://github.com/JelleZijlstra/autotyping
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autotyping-24.9.0-1.src.rpm
checksum_type: sha256
description:
  When I refactor code I often find myself tediously adding type
  annotations that are obvious from context: functions that don't
  return anything, boolean flags, etcetera. That's where autotyping
  comes in: it automatically adds those types and inserts the right
  annotations.



  Autotyping can be called directly from the CLI, be used as a [pre-commit hook](#pre-commit-hook) or run via the [`libcst` interface](#LibCST) as a codemod.
  Here's how to use it from the CLI:

  - `pip install autotyping`
  - `python -m autotyping /path/to/my/code`

  By default it does nothing; you have to add flags to make it do
  more transformations. The following are supported:

  - Annotating return types:
    - `--none-return`: add a `-> None` return type to functions without any
      return, yield, or raise in their body
    - `--scalar-return`: add a return annotation to functions that only return
      literal bool, str, bytes, int, or float objects.
  - Annotating parameter types:
    - `--bool-param`: add a `: bool` annotation to any function
      parameter with a default of `True` or `False`
    - `--int-param`, `--float-param`, `--str-param`, `--bytes-param`: add
      an annotation to any parameter for which the default is a literal int,
      float, str, or bytes object
    - `--annotate-optional foo:bar.Baz`: for any parameter of the form
      `foo=None`, add `Baz`, imported from `bar`, as the type. For example,
      use `--annotate-optional uid:my_types.Uid` to annotate any `uid` in your
      codebase with a `None` default as `Optional[my_types.Uid]`.
    - `--annotate-named-param foo:bar.Baz`: annotate any parameter with no
      default that is named `foo` with `bar.Baz`. For example, use
      `--annotate-named-param uid:my_types.Uid` to annotate any `uid`
      parameter in your codebase with no default as `my_types.Uid`.
    - `--guess-common-names`: infer certain parameter types from their names
      based on common patterns in open-source Python code. For example, infer
      that a `verbose` parameter is of type `bool`.
  - Annotating magical methods:
    - `--annotate-magics`: add type annotation to certain magic methods.
      Currently this does the following:
      - `__str__` returns `str`
      - `__repr__` returns `str`
      - `__len__` returns `int`
      - `__length_hint__` returns `int`
      - `__init__` returns `None`
      - `__del__` returns `None`
      - `__bool__` returns `bool`
      - `__bytes__` returns `bytes`
      - `__format__` returns `str`
      - `__contains__` returns `bool`
      - `__complex__` returns `complex`
      - `__int__` returns `int`
      - `__float__` returns `float`
      - `__index__` returns `int`
      - `__exit__`: the three parameters are `Optional[Type[BaseException]]`,
        `Optional[BaseException]`, and `Optional[TracebackType]`
      - `__aexit__`: same as `__exit__`
    - `--annotate-imprecise-magics`: add imprecise type annotations for
      some additional magic methods. Currently this adds `typing.Iterator`
      return annotations to `__iter__`, `__await__`, and `__reversed__`.
      These annotations should have a generic parameter to indicate what
      you're iterating over, but that's too hard for autotyping to figure
      out.
  - External integrations
    - `--pyanalyze-report`: takes types suggested by
      [pyanalyze](https://github.com/quora/pyanalyze)'s `suggested_parameter_type`
      and `suggested_return_type` codes and applies them. You can generate these
      with a command like:
      `pyanalyze --json-output failures.json -e suggested_return_type -e suggested_parameter_type -v .`
    - `--only-without-imports`: only apply pyanalyze suggestions that do not require
      new imports. This is useful because suggestions that require imports may need
      more manual work.

  There are two shortcut flags to enable multiple transformations at once:

  - `--safe` enables changes that should always be safe. This includes
    `--none-return`, `--scalar-return`, and `--annotate-magics`.
  - `--aggressive` enables riskier changes that are more likely to produce
    new type checker errors. It includes all of `--safe` as well as `--bool-param`,
    `--int-param`, `--float-param`, `--str-param`, `--bytes-param`, and
    `--annotate-imprecise-magics`.



  Autotyping is built as a LibCST codemod; see the
  [LibCST documentation](https://libcst.readthedocs.io/en/latest/codemods_tutorial.html)
  for more information on how to use codemods.

  If you wish to run things through the `libcst.tool` interface, you can do this like so:
  - Make sure you have a `.libcst.codemod.yaml` with `'autotyping'` in the `modules` list.
    For an example, see the `.libcst.codemod.yaml` in this repo.
  - Run `python -m libcst.tool codemod autotyping.AutotypeCommand /path/to/my/code`




  Pre-commit hooks are scripts that runs automatically before a commit is made,
  which makes them really handy for checking and enforcing code-formatting
  (or in this case, typing)

  1. To add `autotyping` as a [pre-commit](https://pre-commit.com/) hook,
  you will first need to install pre-commit if you haven't already:
  ```
  pip install pre-commit
  ```

  2. After that, create or update the `.pre-commit-config.yaml` file at the root
  of your repository and add in:

  ```yaml
  - repos:
    - repo: https://github.com/JelleZijlstra/autotyping
      rev: 24.9.0
      hooks:
        - id: autotyping
          stages: [commit]
          types: [python]
          args: [--safe] # or alternatively, --aggressive, or any of the other flags mentioned above
  ```

  3. Finally, run the following command to install the pre-commit hook
  in your repository:

  ```
  pre-commit install
  ```

  Now whenever you commit changes, autotyping will automatically add
  type annotations to your code!




  Autotyping is intended to be a simple tool that uses heuristics to find
  annotations that would be tedious to add by hand. The heuristics may fail,
  and after you run autotyping you should run a type checker to verify that
  the types it added are correct.

  Known limitations:

  - autotyping does not model code flow through a function, so it may miss
    implicit `None` returns





  - Add pre-commit support. (Thanks to Akshit Tyagi and Matthew Akram.)
  - Add missing dependency. (Thanks to Stefane Fermigier.)



  - Add simpler ways to invoke autotyping. Now, it is possible to simply use
    `python3 -m autotyping` to invoke the tool. (Thanks to Shantanu Jain.)
  - Drop support for Python 3.7; add support for Python 3.12. (Thanks to Hugo
    van Kemenade.)
  - Infer return types for some more magic methods. (Thanks to Dhruv Manilawala.)



  - Fix crash on certain argument names like `iterables` (contributed by
    Marco Gorelli)



  - Add `--guess-common-names` (contributed by John Litborn)
  - Fix the `--safe` and `--aggressive` flags so they don't take
    ignored arguments
  - `--length-hint` should return `int` (contributed by Nikita Sobolev)
  - Fix bug in import adding (contributed by Shantanu)



  - Add `--safe` and `--aggressive`
  - Add `--pyanalyze-report`
  - Do not add `None` return types to methods marked with `@abstractmethod` and
    to methods in stub files
  - Improve type inference:
    - `"string" % ...` is always `str`
    - `b"bytes" % ...` is always `bytes`
    - An `and` or `or` operator where left and right sides are of the same type
      returns that type
    - `is`, `is not`, `in`, and `not in` always return `bool`



  - Initial PyPI release


pkgId: d5e24dfe93df2d693490c78510d0fe3b990f236035dc5e887c88059281a82754
name: python-autoverse-cli
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: The Autoverse CLI
description: The new implementation of the Autoverse CLI
url: https://pypi.org/project/autoverse-cli/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoverse-cli-0.8.0-1.src.rpm
checksum_type: sha256
rpm_license:
  # End-User License Agreement (EULA) of the Autonoma AutoVerse CLI  This End-User License Agreement ("EULA") is a legal agreement between you and Autonoma, Inc.  ## License Grant  Autonoma, Inc. hereby grants you a personal, non-transferable, non-exclusive licence to use the AutoVerse software in accordance with the terms of this EULA agreement.  ## Limitation of Liability The software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND, express or implied. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in action of contract, tort or otherwise, arising from, out of or in connection with the software or the use of the software.  ### You are NOT permitted to:  - Edit, alter, modify, adapt, translate or otherwise change the whole or any part of the Software nor permit the whole or any part of the Software to be combined with or become incorporated in any other software, nor decompile, disassemble or reverse engineer the Software or attempt to do any such things - Reproduce, copy, distribute, resell or otherwise use the Software for any commercial purpose - Allow any third party to use the Software on behalf of or for the benefit of any third party - Use the Software in any way which breaches any applicable local, national or international law use the Software for any purpose that Autonoma, Inc. considers is a breach of this EULA agreement Intellectual Property and Ownership  Autonoma, Inc. shall at all times retain ownership of the Software as originally downloaded by you and all subsequent downloads of the Software by you. The Software (and the copyright, and other intellectual property rights of whatever nature in the Software, including any modifications made thereto) are and shall remain the property of Autonoma, Inc.  Autonoma, Inc. reserves the right to grant licences to use the Software to third parties.  ## Termination  This EULA agreement is effective from the date you first use the Software and shall continue until terminated. You may terminate it at any time upon written notice to Autonoma, Inc.  It will also terminate immediately if you fail to comply with any term of this EULA agreement. Upon such termination, the licenses granted by this EULA agreement will immediately terminate and you agree to stop all access and use of the Software. The provisions that by their nature continue and survive will survive any termination of this EULA agreement.  ## Governing Law  This EULA agreement, and any dispute arising out of or in connection with this EULA agreement, shall be governed by and construed in accordance with the laws of the USA.


pkgId: 8ee2abd00fa1eb9cd8154ca6269d27a68effd86a427d8e81e32a9fc83a0d31db
name: python-autoviml
arch: src
version: 0.1.800
epoch: 0
release: 1
summary: Automatically Build Variant Interpretable ML models fast - now with CatBoost!
url: https://github.com/AutoViML/Auto_ViML
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoviml-0.1.800-1.src.rpm
checksum_type: sha256
description:
  ![banner](logo.png)<br>
  Automatically Build Various Interpretable ML models fast!<br>
  [![Downloads](https://pepy.tech/badge/autoviml/week)](https://pepy.tech/project/autoviml/week)
  [![Downloads](https://pepy.tech/badge/autoviml/month)](https://pepy.tech/project/autoviml/month)
  [![Downloads](https://pepy.tech/badge/autoviml)](https://pepy.tech/project/autoviml)
  [![standard-readme compliant](https://img.shields.io/badge/standard--readme-OK-green.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
  [![Python Versions](https://img.shields.io/pypi/pyversions/autoviml.svg?logo=python&logoColor=white)](https://pypi.org/project/autoviml)
  [![PyPI Version](https://img.shields.io/pypi/v/autoviml.svg?logo=pypi&logoColor=white)](https://pypi.org/project/autoviml)
  [![PyPI License](https://img.shields.io/pypi/l/autoviml.svg)](https://github.com/AutoViML/Auto_ViML/blob/master/LICENSE)

  Auto_ViML is pronounced as "auto vimal" (autovimal logo created by Sanket Ghanmare).


  <ol>
  <li><b>Auto_ViML has a new flag to speed up processing using GPU's</b>. Just set the `GPU_flag`=`True` on Colab and other environments. But don't forget to set the runtime type to be "GPU" while running on Colab. Otherwise you will get an error.</li>
  </ol>


  <ul>
  <li><b>Auto_ViML as of version 0.1.710 uses a very high performance library called `imbalanced_ensemble` for Imbalanced dataset problems.</b> It will produce a 5-10% boost in your balanced_accuracy based on my experience with  many datasets I have tried.</li>
  </ul>
  <br>
  <p>In addition, new features in this version are:<br>
  <ul>
  <li>SULOV -> Uses the SULOV algorithm for removing highly correlated features automatically.</li>
  <li>Auto_NLP -> AutoViML automatically detects Text variables and does NLP processing using Auto_NLP</li>
  <li>Date Time -> It automatically detects  date time variables and generates new features</li>
  <li>`imbalanced_ensemble` library -> Uses imbalanced_ensemble library for imbalanced data. Just set Imbalanced_Flag = True in arguments</li>
  <li>Feature Selection -> We use the same algorithm that featurewiz library uses: SULOV and Recursive XGBoost to select best features fast. See below.</li>
  </ul>


  <ul>
  <li><a href="#background">Background</a></li>
  <li><a href="#install">Install</a></li>
  <li><a href="#usage">Usage</a></li>
  <li><a href="#tips-for-using-auto_viml">Tips for using Auto_ViML</a></li>
  <li><a href="#api">API</a></li>
  <li><a href="#maintainers">Maintainers</a></li>
  <li><a href="#contributing">Contributing</a></li>
  <li><a href="#license">License</a></li>
  </ul>


  <p>Read this <a href="https://towardsdatascience.com/why-automl-is-an-essential-new-tool-for-data-scientists-2d9ab4e25e46">Medium article to learn how to use Auto_ViML effectively.</a>

  <p>Auto_ViML was designed for building High Performance Interpretable Models with the fewest variables needed.
  The "V" in Auto_ViML stands for Variant because it tries multiple models with multiple features to find you the best performing model for your dataset. The "i" in Auto_ViML stands for "interpretable" since Auto_ViML selects the least number of features necessary to build a simpler, more interpretable model. In most cases, Auto_ViML builds models with 20% fewer features than a similar performing model with all included features (this is based on my trials. Your experience may vary).<br>
  <p>
  Auto_ViML is every Data Scientist's model accelerator tool that:
  <ol>
  <li><b>Helps you with data cleaning</b>: you can send in your entire dataframe as is and Auto_ViML will suggest changes to help with missing values, formatting variables, adding variables, etc. It loves dirty data. The dirtier the better!</li>
  <li><b>Performs Feature Selection</b>: Auto_ViML selects variables automatically by default. This is very helpful when you have hundreds if not thousands of variables since it can readily identify which of those are important variables vs which are unnecessary. You can turn this off as well (see API).</li>

  ![xgboost](sulov_xgboost.png)
  <li><b>Removes highly correlated features automatically</b>. If two variables are highly correlated in your dataset, which one should you remove and which one should you keep? The decision is not as easy as it looks. Auto_ViML uses the SULOV algorithm to remove highly correlated features. You can understand SULOV from this picture more intuitively.</li>

  ![sulov](SULOV.jpg)

  <li><b>Generates performance results graphically</b>. Just set verbose = 1 (or) 2 instead of 0 (silent). You will get higher quality of insights as you increase verbosity. </li>
  <li><b>Handles text, date-time, structs (lists, dictionaries), numeric, boolean, factor and categorical</b> variables all in one model using one straight process.</li>
  </ol>
  Auto_ViML is built using scikit-learn, numpy, pandas and matplotlib. It should run on most Python 3 Anaconda installations. You won't have to import any special libraries other than "XGBoost", "Imbalanced-Learn", "CatBoost", and "featuretools" library. We use "SHAP" library for interpretability. <br>But if you don't have these libraries, Auto_ViML will install those for you automatically.



  **Prerequsites:**

  - [Anaconda](https://docs.anaconda.com/anaconda/install/)

  To clone Auto_ViML, it is better to create a new environment, and install the required dependencies:

  To install from PyPi:
  <p>
  <code>$ pip install autoviml --upgrade --ignore-installed</code><br />


  ```
  pip install git+https://github.com/AutoViML/Auto_ViML.git
  ```

  To install from source:

  ```
  cd <AutoVIML_Destination>
  git clone git@github.com:AutoViML/Auto_ViML.git

  conda create -n <your_env_name> python=3.7 anaconda
  conda activate <your_env_name> # ON WINDOWS: `source activate <your_env_name>`
  cd Auto_ViML
  pip install -r requirements.txt
  ```



  In the same directory, open a Jupyter Notebook and use this line to import the .py file:

  ```
  from autoviml.Auto_ViML import Auto_ViML
  ```

  Load a data set (any CSV or text file) into a Pandas dataframe and split it into Train and Test dataframes. If you don't have a test dataframe, you can simple assign the test variable below to '' (empty string):

  ```
  model, features, trainm, testm = Auto_ViML(
      train,
      target,
      test,
      sample_submission,
      hyper_param="GS",
      feature_reduction=True,
      scoring_parameter="weighted-f1",
      KMeans_Featurizer=False,
      Boosting_Flag=False,
      Binning_Flag=False,
      Add_Poly=False,
      Stacking_Flag=False,
      Imbalanced_Flag=False,
      verbose=0,
  )
  ```

  Finally, it writes your submission file to disk in the current directory called `mysubmission.csv`.
  This submission file is ready for you to show it clients or submit it to competitions.
  If no submission file was given, but as long as you give it a test file name, it will create a submission file for you named `mySubmission.csv`.
  Auto_ViML works on any Multi-Class, Multi-Label Data Set. So you can have many target labels.
  You don't have to tell Auto_ViML whether it is a Regression or Classification problem.


  1. `scoring_parameter`: For Classification problems and imbalanced classes, choose scoring_parameter="balanced_accuracy". It works better.
  2. `Imbalanced_Flag`: For Imbalanced Classes (<5% samples in rare class), choose "Imbalanced_Flag"=True. You can also set this flag to True for Regression problems where the target variable might have skewed distributions.
  3. `target`: For Multi-Label dataset, the target input target variable can be sent in as a list of variables.
  4. `Boosting_Flag`: It is recommended that you first set Boosting_Flag=None to get a Linear model. Once you understand that, then you can try to set Boosting_Flag=False to get a Random Forest model. Finally, try Boosting_Flag=True to get an XGBoost model. This is the order that we recommend in order to use Auto_ViML. Finally try Boosting_Flag="CatBoost" to get a complex but high performing model.
  5. `Binning_Flag`: Binning_Flag=True improves a CatBoost model since it adds to the list of categorical vars in data
  6. `KMeans_featurizer`: KMeans_featurizer=True works well in NLP and CatBoost models since it creates cluster variables
  7. `Add_Poly`: Add_Poly=3 improves certain models where there is date-time or categorical and numeric variables
  8. `feature_reduction`: feature_reduction=True is the default and works best. But when you have <10 features in data, set it to False
  9. `Stacking_Flag`: Do not set Stacking_Flag=True with Linear models since your results may not look great.
  10. `Stacking_Flag`: Use Stacking_Flag=True only for complex models and as a last step with Boosting_Flag=True or CatBoost
  11. `hyper_param`: Leave hyper_param ="RS" as input since it runs faster than GridSearchCV and gives better results unless you have a small data set and can afford to spend time on hyper tuning.
  12. `KMeans_Featurizer`: KMeans_Featurizer=True does not work well for small data sets. Use it for data sets > 10,000 rows.
  13. `Final thoughts`: Finally Auto_ViML is meant to be a baseline or challenger solution to your data set. So use it for making quick models that you can compare against or in Hackathons. It is not meant for production!



  **Arguments**

  - `train`: could be a datapath+filename or a dataframe. It will detect which is which and load it.
  - `test`: could be a datapath+filename or a dataframe. If you don't have any, just leave it as "".
  - `submission`: must be a datapath+filename. If you don't have any, just leave it as empty string.
  - `target`: name of the target variable in the data set.
  - `sep`: if you have a spearator in the file such as "," or "\t" mention it here. Default is ",".
  - `scoring_parameter`: if you want your own scoring parameter such as "f1" give it here. If not, it will assume the appropriate scoring param for the problem and it will build the model.
  - `hyper_param`: Tuning options are GridSearch ('GS') and RandomizedSearch ('RS'). Default is 'RS'.
  - `feature_reduction`: Default = 'True' but it can be set to False if you don't want automatic feature_reduction since in Image data sets like digits and MNIST, you get better results when you don't reduce features automatically. You can always try both and see.
  - `KMeans_Featurizer`
    - `True`: Adds a cluster label to features based on KMeans. Use for Linear.
    - `False (default)` For Random Forests or XGB models, leave it False since it may overfit.
  - `Boosting Flag`: you have 4 possible choices (default is False):
    - `None` This will build a Linear Model
    - `False` This will build a Random Forest or Extra Trees model (also known as Bagging)
    - `True` This will build an XGBoost model
    - `CatBoost` This will build a CatBoost model (provided you have CatBoost installed)
  - `Add_Poly`: Default is 0 which means do-nothing. But it has three interesting settings:
    - `1` Add interaction variables only such as x1*x2, x2*x3,...x9\*10 etc.
    - `2` Add Interactions and Squared variables such as x1**2, x2**2, etc.
    - `3` Adds both Interactions and Squared variables such as x1*x2, x1**2,x2*x3, x2**2, etc.
  - `Stacking_Flag`: Default is False. If set to True, it will add an additional feature which is derived from predictions of another model. This is used in some cases but may result in overfitting. So be careful turning this flag "on".
  - `Binning_Flag`: Default is False. It set to True, it will convert the top numeric variables into binned variables through a technique known as "Entropy" binning. This is very helpful for certain datasets (especially hard to build models).
  - `Imbalanced_Flag`: Default is False. Uses imbalanced_ensemble library for imbalanced data. Just set Imbalanced_Flag = True in arguments
  - `verbose`: This has 3 possible states:
    - `0` limited output. Great for running this silently and getting fast results.
    - `1` more charts. Great for knowing how results were and making changes to flags in input.
    - `2` lots of charts and output. Great for reproducing what Auto_ViML does on your own.

  **Return values**

  - `model`: It will return your trained model
  - `features`: the fewest number of features in your model to make it perform well
  - `train_modified`: this is the modified train dataframe after removing and adding features
  - `test_modified`: this is the modified test dataframe with the same transformations as train



  * [@AutoViML](https://github.com/AutoViML)
  * [@morenoh149](https://github.com/morenoh149)
  * [@hironroy](https://github.com/hironroy)



  See [the contributing file](CONTRIBUTING.md)!

  PRs accepted.



  Apache License 2.0 © 2020 Ram Seshadri


  This project is not an official Google project. It is not supported by Google and Google specifically disclaims all warranties as to its quality, merchantability, or fitness for a particular purpose.


pkgId: cbf4e407f0979c4c954c36c818827fb346ad8a9d7461d79dd708174f42a5008c
name: python-autoviz
arch: src
version: 0.1.905
epoch: 0
release: 1
summary: Automatically Visualize any dataset, any size with a single line of code
url: https://github.com/AutoViML/AutoViz.git
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoviz-0.1.905-1.src.rpm
checksum_type: sha256
description:
  ![logo](images/logo.png)

  Unlock the power of **AutoViz** to visualize any dataset, any size, with just a single line of code! Plus, now you can get a quick assessment of your dataset's quality and fix DQ issues through the FixDQ() function.

  [![Pepy Downloads](https://pepy.tech/badge/autoviz)](https://pepy.tech/project/autoviz)
  [![Pepy Downloads per week](https://pepy.tech/badge/autoviz/week)](https://pepy.tech/project/autoviz)
  [![Pepy Downloads per month](https://pepy.tech/badge/autoviz/month)](https://pepy.tech/project/autoviz)
  [![standard-readme compliant](https://img.shields.io/badge/standard--readme-OK-green.svg)](https://github.com/RichardLitt/standard-readme)
  [![Python Versions](https://img.shields.io/pypi/pyversions/autoviz.svg)](https://pypi.org/project/autoviz)
  [![PyPI Version](https://img.shields.io/pypi/v/autoviz.svg)](https://pypi.org/project/autoviz)
  [![PyPI License](https://img.shields.io/pypi/l/autoviz.svg)](https://github.com/AutoViML/AutoViz/blob/master/LICENSE)

  With AutoViz, you can easily and quickly generate insightful visualizations for your data. Whether you're a beginner or an expert in data analysis, AutoViz can help you explore your data and uncover valuable insights. Try it out and see the power of automated visualization for yourself!


  <ul>
  <li><a href="#latest">Latest Updates</a></li>
  <li><a href="#importantannouncement">Important Announcement</a></li>
  <li><a href="#citation">Citation</a></li>
  <li><a href="#motivation">Motivation for AutoViz</a></li>
  <li><a href="#usage">How to use AutoViz</a></li>
  <li><a href="#api">API for using AutoViz</a></li>
  <li><a href="#examples">Examples of using AutoViz</a></li>
  <li><a href="#maintainers">Maintainers</a></li>
  <li><a href="#contributing">Contributing</a></li>
  <li><a href="#license">License</a></li>
  <li><a href="#tips">Tips for using AutoViz</a></li>
  <li><a href="#disclaimer">Disclaimer</a></li>
  </ul>


  The latest updates about `autoviz` library can be found in <a href="https://github.com/AutoViML/AutoViz/blob/master/updates.md">Updates page</a>.



  <li>We're excited to announce we've made significant updates to our `setup.py` script to leverage the latest versions in our dependencies while maintaining  support for older Python versions (you may want to check older versions). The installation process is seamless—simply run pip install . in the AutoViz directory, and the script takes care of the rest, tailoring the installation to your environment.</li>


  Your feedback is crucial! If you encounter any issues or have suggestions, please let us know through [GitHub Issues](https://github.com/AutoViML/AutoViz/issues)

  Thank you for your continued support and happy visualizing!


  If you use AutoViz in your research project or paper, please use the following format for citations:<p>
  "Seshadri, Ram (2020). GitHub - AutoViML/AutoViz: Automatically Visualize any dataset, any size with a single line of code. source code: https://github.com/AutoViML/AutoViz"</p>
  <b>Current citations for AutoViz</b>

  [Google Scholar](https://scholar.google.com/scholar?hl=en&as_sdt=0%2C31&q=autoviz&oq=autoviz)


  The motivation behind the creation of AutoViz is to provide a more efficient, user-friendly, and automated approach to exploratory data analysis (EDA) through quick and easy data visualization plus data quality. The library is designed to help users understand patterns, trends, and relationships in the data by creating insightful visualizations with minimal effort. AutoViz is particularly useful for beginners in data analysis as it abstracts away the complexities of various plotting libraries and techniques. For experts, it provides another expert tool that they can use to provide inights into data that they may have missed.

  AutoViz is a powerful tool for generating insightful visualizations with minimal effort. Here are some of its key selling points compared to other automated EDA tools:
  <ol>
  <li><b>Ease of use</b>: AutoViz is designed to be user-friendly and accessible to beginners in data analysis, abstracting away the complexities of various plotting libraries</li>
  <li><b>Speed</b>: AutoViz is optimized for speed and can generate multiple insightful plots with just a single line of code</li>
  <li><b>Scalability</b>: AutoViz is designed to work with datasets of any size and can handle large datasets efficiently</li>
  <li><b>Automation</b>: AutoViz automates the visualization process, requiring just a single line of code to generate multiple insightful plots</li>
  <li><b>Customization</b>: AutoViz provides several options for customizing the visualizations, such as changing the chart type, color palette, etc.</li>
  <li><b>Data Quality</b>: AutoViz now provides data quality assessment by default and helps you fix DQ issues with a single line of code using the FixDQ() function</li>
  </ol>


  **Prerequisites**
  - [Anaconda](https://docs.anaconda.com/anaconda/install/)

  Create a new environment and install the required dependencies to clone AutoViz:

  **From PyPi:**
  ```sh
  cd <AutoViz_Destination>
  git clone git@github.com:AutoViML/AutoViz.git

  conda create -n <your_env_name> python=3.7 anaconda
  conda activate <your_env_name> # ON WINDOWS: `source activate <your_env_name>`
  cd AutoViz
  ```
  For Python versions below 3.10, install dependencies as follows:

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

  For Python 3.10, please use:

  ```
  pip install -r requirements-py310.txt
  ```

  For Python 3.11 and above, it's recommended to use:

  ```
  pip install -r requirements-py311.txt
  ```

  These requirement files ensure that AutoViz works seamlessly with your Python environment by installing compatible versions of libraries like HoloViews, Bokeh, and hvPlot. Please select the requirement file that corresponds to your Python version to enjoy a smooth experience with AutoViz.</li>


  Discover how to use AutoViz in this Medium article.

  In the AutoViz directory, open a Jupyter Notebook or open a command palette (terminal) and use the following code to instantiate the AutoViz_Class. You can simply run this code step by step:

  ```python
  from autoviz import AutoViz_Class
  AV = AutoViz_Class()
  dft = AV.AutoViz(filename)
  ```

  AutoViz can use any input either filename (in CSV, txt, or JSON format) or a pandas dataframe. If you have a large dataset, you can set the `max_rows_analyzed` and `max_cols_analyzed` arguments to speed up the visualization by asking autoviz to sample your dataset.

  AutoViz can also create charts in multiple  formats using the `chart_format` setting:
  - If `chart_format ='png'` or `'svg'` or `'jpg'`: Matplotlib charts are plotted inline.
      * Can be saved locally (using `verbose=2` setting) or displayed (`verbose=1`) in Jupyter Notebooks.
      * This is the default behavior for AutoViz.
  - If `chart_format='bokeh'`: Interactive Bokeh charts are plotted in Jupyter Notebooks.
  - If `chart_format='server'`, dashboards will pop up for each kind of chart on your browser.
  - If `chart_format='html'`, interactive Bokeh charts will be created and silently saved as HTML files under the `AutoViz_Plots` directory (under working folder) or any other directory that you specify using the `save_plot_dir` setting (during input).



  Arguments for `AV.AutoViz()` method:

  - `filename`: Use an empty string ("") if there's no associated filename and you want to use a dataframe. In that case, using the `dfte` argument for the dataframe. Otherwise provide a filename and leave `dfte` argument with an empty string. Only one of them can be used.
  - `sep`: File separator (comma, semi-colon, tab, or any column-separating value) if you use a filename above.
  - `depVar`: Target variable in your dataset; set it as an empty string if not applicable.
  - `dfte`: name of the pandas dataframe for plotting charts; leave it as empty string if using a filename.
  - `header`: set the row number of the header row in your file (0 for the first row). Otherwise leave it as 0.
  - `verbose`: 0 for minimal info and charts, 1 for more info and charts, or 2 for saving charts locally without display.
  - `lowess`: Use regression lines for each pair of continuous variables against the target variable in small datasets; avoid using for large datasets (>100,000 rows).
  - `chart_format`: 'svg', 'png', 'jpg', 'bokeh', 'server', or 'html' for displaying or saving charts in various formats, depending on the verbose option.
  - `max_rows_analyzed`: Limit the max number of rows to use for visualization when dealing with very large datasets (millions of rows). A statistically valid sample will be used by autoviz. Default is 150000 rows.
  - `max_cols_analyzed`: Limit the number of continuous variables to be analyzed. Defaul is 30 columns.
  - `save_plot_dir`: Directory for saving plots. Default is None, which saves plots under the current directory in a subfolder named AutoViz_Plots. If the save_plot_dir doesn't exist, it will be created.


  Here are some examples to help you get started with AutoViz. If you need full jupyter notebooks with code samples they can be found in [examples](https://github.com/AutoViML/AutoViz/tree/master/Examples) folder.



  ```python
  from autoviz import AutoViz_Class
  AV = AutoViz_Class()

  filename = "your_file.csv"
  target_variable = "your_target_variable"

  dft = AV.AutoViz(
      filename,
      sep=",",
      depVar=target_variable,
      dfte=None,
      header=0,
      verbose=1,
      lowess=False,
      chart_format="svg",
      max_rows_analyzed=150000,
      max_cols_analyzed=30,
      save_plot_dir=None
  )
  ```

  ![var_charts](images/var_charts.JPG)



  ```python
  import pandas as pd
  from autoviz import AutoViz_Class

  AV = AutoViz_Class()

  data = {'col1': [1, 2, 3, 4, 5], 'col2': [5, 4, 3, 2, 1]}
  df = pd.DataFrame(data)

  dft = AV.AutoViz(
      "",
      sep=",",
      depVar="",
      dfte=df,
      header=0,
      verbose=1,
      lowess=False,
      chart_format="server",
      max_rows_analyzed=150000,
      max_cols_analyzed=30,
      save_plot_dir=None
  )

  ```

  ![server_charts](images/server_charts.JPG)



  ```python
  from autoviz import AutoViz_Class
  AV = AutoViz_Class()

  filename = "your_file.csv"
  target_variable = "your_target_variable"
  custom_plot_dir = "your_custom_plot_directory"

  dft = AV.AutoViz(
      filename,
      sep=",",
      depVar=target_variable,
      dfte=None,
      header=0,
      verbose=2,
      lowess=False,
      chart_format="bokeh",
      max_rows_analyzed=150000,
      max_cols_analyzed=30,
      save_plot_dir=custom_plot_dir
  )
  ```

  ![bokeh_charts](images/bokeh_charts.JPG)

  These examples should give you an idea of how to use AutoViz with different scenarios and settings. By tailoring the options and settings, you can generate visualizations that best suit your needs, whether you're working with large datasets, interactive charts, or simply exploring the relationships between variables.


  AutoViz is actively maintained and improved by a team of dedicated developers. If you have any questions, suggestions, or issues, feel free to reach out to the maintainers:

  - [@AutoViML](https://github.com/AutoViML)
  - [@morenoh149](https://github.com/morenoh149)
  - [@hironroy](https://github.com/hironroy)


  We welcome contributions from the community! If you're interested in contributing to AutoViz, please follow these steps:

  - Fork the repository on GitHub.
  - Clone your fork and create a new branch for your feature or bugfix.
  - Commit your changes to the new branch, ensuring that you follow coding standards and write appropriate tests.
  - Push your changes to your fork on GitHub.
  - Submit a pull request to the main repository, detailing your changes and referencing any related issues.

  See [the contributing file](contributing.md)!


  AutoViz is released under the Apache License, Version 2.0. By using AutoViz, you agree to the terms and conditions specified in the license.


  Here are some additional tips and reminders to help you make the most of the library:

  - **Make sure to regularly upgrade AutoViz** to benefit from the latest features, bug fixes, and improvements. You can update it using pip install --upgrade autoviz.
  - **AutoViz is highly customizable, so don't hesitate to explore and experiment with various settings**, such as chart_format, verbose, and max_rows_analyzed. This will allow you to create visualizations that better suit your specific needs and preferences.
  - **Remember to delete the AutoViz_Plots directory (or any custom directory you specified) periodically** if you used the verbose=2 option, as it can accumulate a large number of saved charts over time.
  - **For further guidance or inspiration, check out the <a href="https://towardsdatascience.com/autoviz-a-new-tool-for-automated-visualization-ec9c1744a6ad">Medium article</a> on AutoViz**, as well as other online resources and tutorials.
  <ul>
    <li>AutoViz will visualize any sized file using a statistically valid sample.</li>
    <li>COMMA is the default separator in the file, but you can change it.</li>
    <li>Assumes the first row as the header in the file, but this can be changed.</li>
  </ul>

  - **By leveraging AutoViz's powerful and flexible features**, you can streamline your data visualization process and gain valuable insights more efficiently. Happy visualizing!


  This project is not an official Google project. It is not supported by Google, and Google specifically disclaims all warranties as to its quality, merchantability, or fitness for a particular purpose.


pkgId: 79370176b8572843840d11e4b3f37efb90930d648bf0cea2c65ba9810d34737e
name: python-autowoe
arch: src
version: 1.3.2
epoch: 0
release: 1
summary: Library for automatic interpretable model building (Whitebox AutoML)
url: https://github.com/AILab-MLTools/AutoMLWhitebox
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autowoe-1.3.2-1.src.rpm
checksum_type: sha256
description:
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/autowoe?color=green&label=PyPI%20downloads&logo=pypi&logoColor=orange&style=plastic)


  This is the repository for **AutoWoE** library, developed by LightAutoML group. This library can be used for automatic creation of interpretable ML model based on feature binning, WoE features transformation, feature selection and Logistic Regression.

  **Authors:** Vakhrushev Anton, Grigorii Penkin, Alexander Kirilin

  **Library setup** can be done by one of three scenarios below:

  1. Installation from PyPI:
  ```bash
  pip install autowoe
  ```
  2. Installation from source code

  First of all you need to install [git](https://git-scm.com/downloads) and [poetry](https://python-poetry.org/docs/#installation).

  ```bash


  git clone https://github.com/AILab-MLTools/AutoMLWhitebox.git

  cd AutoMLWhiteBox/




  poetry config virtualenvs.in-project true


  poetry config virtualenvs.create false --local




  poetry install

  ```


  **Usage tutorials** are in Jupyter notebooks in the repository root. For **parameters description** take a look at `parameters_info.md`.

  **Bugs / Questions / Suggestions:**:
  - Vakhrushev Anton (btbpanda@gmail.com)


pkgId: 34c1edc8f7e996e023ed7e051bc1e585766934bc2702e46c38d77de2b765d580
name: python-autowrap
arch: src
version: 0.22.11
epoch: 0
release: 1
summary: Generates Python Extension modules from commented Cython PXD files
url: https://pypi.org/project/autowrap/
rpm_license: http://opensource.org/licenses/BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autowrap-0.22.11-1.src.rpm
checksum_type: sha256
description:
  autowrap automatically generates python extension modules for wrapping
  C++ libraries based on annotated (commented) cython pxd files.


pkgId: c29d4b6309ce0303c99448bb8358a9cc79cef3ebed268b72f2af682b9b54444f
name: python-autowsgr
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: Auto Warship Girls Framework.
url: https://pypi.org/project/autowsgr/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autowsgr-1.1.2-1.src.rpm
checksum_type: sha256
description:
  <div align=center>
  <img src="https://raw.githubusercontent.com/huan-yp/Auto-WSGR/main/.assets/logo.png">
  </div>



  ![](https://img.shields.io/github/repo-size/huan-yp/Auto-WSGR) ![](https://img.shields.io/pypi/v/autowsgr) ![](https://img.shields.io/pypi/dm/autowsgr) ![](https://img.shields.io/github/issues/huan-yp/Auto-WSGR) ![MIT licensed](https://img.shields.io/badge/license-MIT-brightgreen.svg)

  用 python 与 c++ 实现的 战舰少女R 的自动化流水线 & 数据统计一体化脚本, 提供 `WSGR` 游戏级别接口以及部分图像和原子操作接口.

  **如何使用：**[notion文档](https://sincere-theater-0e6.notion.site/56a26bfe32da4931a6a1ece332173211?v=428430662def42a2a7ea6dac48238d50)

  参与开发、用户交流、闲聊：qq群 568500514



  - 已弃用 Python 3.9，请升级 Python>=3.10. 2024/10/24
  - 计划弃用 `paddleocr` 后端, 请及时修改自己的 `user_settings.yaml` 中`ocr_backend`为`easyocr`. **2024/10/06**
  - 任务调度支持决战、战役、演习和活动. **2024/10/03**
  - 蓝叠模拟器的连接方法改为手动填写adb地址. **2024/10/02**
  - 支持当前活动 "征程启航",请重新下载example文件夹中的plans和event.py文件.活动先关的使用方法可以参考[这里](https://sincere-theater-0e6.notion.site/fb9bbe5a4b0a426db59ac7892645ee1b)**2024/09/30**
  - 更新到版本1.x.y.z,增加任务调度系统，决战配置参数更新，请对照example中的文件修改自己的参数。**2024/09/26**
  - 为简单战役添加plan，现在可以在战役练习战术. **2024/09/03**
  - 添加对常规地图9-4的支持,更新ship_name文件,修复决战出征的bug. **2024/08/31**



  如果你在运行本项目时遇到了无法运行的问题，请先在[常见报错](/documentation/FAQ.md)中查找是否有相同案例并尝试按照此方法解决.



  欢迎有一定python基础的同学加入开发，共同完善这个项目。您可以实现新的功能，也可以改进现有功能，或者修复bug。如果您有好的想法，也可以提出issue或加qq群讨论。开发者请**不要用pip安装autowsgr**，改为[本地模式](https://www.notion.so/AutoWSGR-efeb69811b544604b944d5b5727317a4?pvs=4#dc2833ce4b8449ca8293a98f0b2b3b71)安装。


  非常感谢我们所有的贡献者！如果你想贡献代码，欢迎发起一个Pull Request或创建一个Issue

  <a href="https://github.com/huan-yp/Auto-WSGR/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=huan-yp/Auto-WSGR" />
  </a>



  [![Star History Chart](https://api.star-history.com/svg?repos=huan-yp/Auto-WSGR&type=Date)](https://star-history.com/#huan-yp/Auto-WSGR&Date)


pkgId: 3ffc278332128592038e366c469cd011f41127e693eefd8241bd0ceb2637ad58
name: python-autoxgb
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: autoxgb: tuning xgboost with optuna
url: https://github.com/abhishekkrthakur/autoxgb
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autoxgb-0.2.2-1.src.rpm
checksum_type: sha256
description:
  XGBoost + Optuna:  no brainer

  - auto train xgboost directly from CSV files
  - auto tune xgboost using optuna
  - auto serve best xgboot model using fastapi

  NOTE: PRs are currently not accepted. If there are issues/problems, please create an issue.



  Install using pip

      pip install autoxgb



  Training a model using AutoXGB is a piece of cake. All you need is some tabular data.



  ```python






  train_filename = "data_samples/binary_classification.csv"


  output = "output"









  test_filename = None





  task = None




  idx = None







  targets = ["income"]




  features = None




  categorical_features = None





  use_gpu = True



  num_folds = 5



  seed = 42




  num_trials = 100




  time_limit = 360






  fast = False
  ```



  To train a new model, you can run:

  ```python
  from autoxgb import AutoXGB



  train_filename = "data_samples/binary_classification.csv"
  output = "output"


  test_filename = None
  task = None
  idx = None
  targets = ["income"]
  features = None
  categorical_features = None
  use_gpu = True
  num_folds = 5
  seed = 42
  num_trials = 100
  time_limit = 360
  fast = False


  axgb = AutoXGB(
      train_filename=train_filename,
      output=output,
      test_filename=test_filename,
      task=task,
      idx=idx,
      targets=targets,
      features=features,
      categorical_features=categorical_features,
      use_gpu=use_gpu,
      num_folds=num_folds,
      seed=seed,
      num_trials=num_trials,
      time_limit=time_limit,
      fast=fast,
  )
  axgb.train()
  ```



  Train the model using the `autoxgb train` command. The parameters are same as above.

  ```
  autoxgb train \
   --train_filename datasets/30train.csv \
   --output outputs/30days \
   --test_filename datasets/30test.csv \
   --use_gpu
  ```

  You can also serve the trained model using the `autoxgb serve` command.

  ```bash
  autoxgb serve --model_path outputs/mll --host 0.0.0.0 --debug
  ```

  To know more about a command, run:

      `autoxgb <command> --help`

  ```
  autoxgb train --help


  usage: autoxgb <command> [<args>] train [-h] --train_filename TRAIN_FILENAME [--test_filename TEST_FILENAME] --output
                                          OUTPUT [--task {classification,regression}] [--idx IDX] [--targets TARGETS]
                                          [--num_folds NUM_FOLDS] [--features FEATURES] [--use_gpu] [--fast]
                                          [--seed SEED] [--time_limit TIME_LIMIT]

  optional arguments:
    -h, --help            show this help message and exit
    --train_filename TRAIN_FILENAME
                          Path to training file
    --test_filename TEST_FILENAME
                          Path to test file
    --output OUTPUT       Path to output directory
    --task {classification,regression}
                          User defined task type
    --idx IDX             ID column
    --targets TARGETS     Target column(s). If there are multiple targets, separate by ';'
    --num_folds NUM_FOLDS
                          Number of folds to use
    --features FEATURES   Features to use, separated by ';'
    --use_gpu             Whether to use GPU for training
    --fast                Whether to use fast mode for tuning params. Only one fold will be used if fast mode is set
    --seed SEED           Random seed
    --time_limit TIME_LIMIT
                          Time limit for optimization
  ```


pkgId: 61c9e2338774808cbe1f21ae273f2e8cf4aba33690b61ec29bbd1e00a64cd871
name: python-autqec
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: Tools for finding Logical Clifford gates of QEC stabilizer codes from code automorphisms.
url: https://github.com/hsayginel/autqec
rpm_license: GNU General Public License v3.0, 29 June 2007
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autqec-0.0.1-1.src.rpm
checksum_type: sha256
description:
  autqec (optionally pronounced as 'oat cake') is a Python package for studying fault-tolerant logical Clifford gates on stabilizer quantum error correcting codes based on their symmetries. Given a set of stabilizer generators of a stabilizer code, it maps the stabilizer code to a related binary linear code, computes its automorphism group (using MAGMA software), and imposes constraints based on the Clifford operators permitted. The allowed permutation automorphisms translate to symplectic matrices which are represented as Clifford unitaries in $6$ layers of gates as $H-CNOT-S-CZ-X-C(X,X)$. The software also computes appropriate Pauli corrections to the physical circuits with a particular logical action by considering the destabilizers of the stabilizer code.

  autqec can identify transversal, *SWAP*-transversal and short-depth arbitrary Clifford circuits that preserve the stabilizer group and has non-trivial logical action on the logical qubits. Outline of the algorithms for finding logical Clifford operators via code automorphisms is given below.

  ![Algorithm Outline](algorithm_outline.png)


  Download a local copy and run:

  `pip install -e .`


  MAGMA V2.28-8: http://magma.maths.usyd.edu.au/magma/.


  H. Sayginel, S. Koutsioumpas, M. Webster, A. Rajput, and D. E. Browne, Fault-Tolerant Logical Clifford Gates from Code Automorphisms, (2024), arXiv:2409.18175 [quant-ph].


  This work is supported by various EPSRC grants.


pkgId: 5d8e769399c2d0e47f9c293165ca96a78d2324d2b29b1fd2c7772f68fb5a163e
name: python-autumn8
arch: src
version: 2.0.8
epoch: 0
release: 1
summary: Utilities to export models to the autumn8.ai service
url: https://pypi.org/project/autumn8/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-autumn8-2.0.8-1.src.rpm
checksum_type: sha256
description:
  Autumn8 CLI is a toolkit, which allows you to easily interact programatically
  with the Autumn8's ML service, AutoDL.



  For the official, up-to-date documentation for the CLI,
  go here:

  [DOCUMENTATION](https://docs.google.com/document/d/1zcjHvVzeNRnS9-L3HRWBxUb1_i14IcvE/view)



  ```
  $ autumn8-cli --help
  Usage: autumn8-cli [OPTIONS] COMMAND [ARGS]...

  Options:
    --version  Show the version and exit.
    --help     Show this message and exit.

  Commands:
    delete-model          Delete model from AutoDL
    deploy                Deploy a model from AutoDL onto cloud.
    get-model             Get model data from AutoDL
    list-deployments      List running deployments.
    login                 Store API credentials for the CLI for future use.
    run-docker            Run an inference on a given Docker image by...
    run-inference         Run an inference on a given deployment
    submit-checkpoint     Submit checkpoint to AutoDL
    submit-model          Submit a model to AutoDL.
    terminate-deployment  Terminate a running deployment.
    test-connection       Test AutoDL connection with the current API key.
  ```



  To use the CLI - as a prerequisite, you'll have to log in into
  autodl.autumn8.ai and generate an API key for you CLI from your Profile page.

  Follow the instructions on https://autodl.autumn8.ai/profile
  to authenticate your CLI.

  ```
  $ autumn8-cli login --user_id $YOUR_USER_ID --api_key $YOUR_API_KEY
  ```



  ```
  $ autumn8-cli submit-model --help
  Usage: autumn8-cli submit-model [OPTIONS] MODEL_FILEPATH_OR_URL
                                  [MODEL_SCRIPT_ARGS]...

    Submit a model to AutoDL.

  Options:
    -n, --name TEXT                 Name of the model to be used in AutoDL.
    -t, --quantization, --quants [FP32|FP16|INT8]
                                    Quantization for the model.
    --input_dims TEXT               The model input dimensions, specified as a
                                    JSON array.
    -w, --max_upload_workers INTEGER
                                    The count of workers to use for multipart
                                    uploads; defaults to 4.
    --input_file TEXT               The model input filepath.
    -y, --yes                       Skip all confirmation input from the user.
    --skip_inputs                   Don't ask about inputs, let AutoDL try to
                                    infer them.
    -o, --organization_id, --org_id INTEGER
                                    The ID of the Organization to use
    -q, --quiet                     Skip additional logging, printing only
                                    necessary info
    -g, --group_id TEXT             The ID of the model group to add the model
                                    to.
    --help                          Show this message and exit.
  ```

  Let's download an example input for our model:

  ```
  $ wget -O ./whisper.json \
      https://autodl-public-assets.s3.amazonaws.com/sample-inputs/whisper.json
  ```

  ... and upload it to the Autumn8 AutoDL service - run:

  ```
  $ autumn8-cli submit-model \
      --input_file ./whisper.json \
      https://autodl-public-assets.s3.amazonaws.com/sample-models/whisper.mar
  ```

  then follow the on-screen instructions.



  ```
  $ autumn8-cli deploy --help
  Usage: autumn8-cli deploy [OPTIONS]

    Deploy a model from AutoDL onto cloud.

  Options:
    -hw, -t, --machine_type TEXT    Server type to use for the deployment
    -o, --organization_id, --org_id INTEGER
                                    The ID of the Organization to use
    -q, --quiet                     Skip additional logging, printing only
                                    necessary info
    -m, --model_id INTEGER          Model ID to deploy
    -s, --schedule / -i, --immediate
                                    Schedule the deployment to run in the future
    --schedule_on TEXT              Schedule the deployment on given date
    --deployment_id TEXT            Update an existing deployment, retaining its
                                    URL
    -b, --deploy_best [latency|throughput|cost_performance|total_energy|emissions]
                                    Let Autumn8 pick the server type
                                    automatically for the deployment
    -c, --cloud_provider [a8f|gcp|aws|None|Amazon|Google Cloud Platform|Oracle|Azure|Autumn8]
                                    Cloud provider to use
    --help                          Show this message and exit.
  ```

  We can roll out a model deployment with:

  ```
  $ autumn8-cli deploy -c a8f -m $MODEL_ID -hw c5.large --org_id $YOUR_ORG_ID
  ```


pkgId: 88a77fce7d0f7ba1568935d50cdeaf47b1145fb6a9746a574ac115892c154afb
name: python-av2
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/argoai/av2-api
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-av2-0.2.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI Versions](https://img.shields.io/pypi/pyversions/av2)](https://pypi.org/project/av2/)
  ![CI Status](https://github.com/argoai/av2-api/actions/workflows/ci.yml/badge.svg)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)



  > _Official_ GitHub repository for the [Argoverse 2](https://www.argoverse.org) family of datasets.

  If you have any questions or run into any problems with either the data or API, please feel free to open a [GitHub issue](https://github.com/argoai/av2-api/issues)!




    - Argoverse 2
      - 3D Object Detection
        - Challenge Link: https://eval.ai/challenge/1710/overview
        - Baseline: https://github.com/benjaminrwilson/torchbox3d
      - Motion Forecasting
        - Challenge Link: https://eval.ai/challenge/1719/overview
    - Argoverse 1
      - Stereo
        - Challenge Link: https://eval.ai/challenge/1704/overview



  - Install the API: `pip install av2`
  - Read the [instructions](DOWNLOAD.md) to download the data.



  - [Setup](#setup)
  - [Datasets](#datasets)
  - [Testing](#testing)
  - [Contributing](#contributing)
  - [Citing](#citing)
  - [License](#license)





  The easiest way to install the API is via [pip](https://pypi.org/project/av2/) by running the following command:

  ```bash
  pip install av2
  ```



  The _Argoverse 2_ family consists of **four** distinct datasets:

  | Dataset Name   | Scenarios | Camera Imagery | Lidar| Maps | Additional Information|
  | ---------------| --------: | :------------: | :--: | :--: | :--------------------:|
  | Sensor | 1,000 | :white_check_mark: | :white_check_mark: | :white_check_mark: | [Sensor Dataset README](src/av2/datasets/sensor/README.md) |
  | Lidar  | 20,000 | | :white_check_mark: | :white_check_mark: | [Lidar Dataset README](src/av2/datasets/lidar/README.md) |
  | Motion Forecasting | 250,000 | | | :white_check_mark: | [Motion Forecasting Dataset README](src/av2/datasets/motion_forecasting/README.md) |
  | Map Change (Trust, but Verify) | 1,045 | :white_check_mark:  | :white_check_mark: | :white_check_mark: | [Map Change Dataset README](src/av2/datasets/tbv/README.md) |

  Please see [DOWNLOAD.md](DOWNLOAD.md) for detailed instructions on how to download each dataset.

  <div align="center">
    <h4> <a href="src/av2/datasets/sensor/README.md"> Sensor Dataset </a> </h4>
    <img src="https://user-images.githubusercontent.com/29715011/158742778-557f31a4-569d-44aa-a032-99836094dc97.gif" height="150">
    <img src="https://user-images.githubusercontent.com/29715011/158742776-069501c4-8dd4-4f9d-ac8c-f0421f855607.gif" height="150">
    <img src="https://user-images.githubusercontent.com/29715011/158739736-fe876299-23da-46ed-98ce-173f938d1702.gif" height="150">
    <img src="https://user-images.githubusercontent.com/29715011/158739767-886e1c2f-4613-495d-9204-a7b4813af16d.gif" height="150">
  </div>

  <div align="center">
    <h4> <a href="src/av2/datasets/lidar/README.md"> Lidar Dataset </a> </h4>
    <img src="https://user-images.githubusercontent.com/29715011/158715494-472339d1-a5d5-4d33-8fcf-3455c0d78d27.gif" height="150">
    <img src="https://user-images.githubusercontent.com/29715011/158715496-f439ccad-71af-4880-8b43-ade7b6c8f333.gif" height="150">
    <img src="https://user-images.githubusercontent.com/29715011/158715498-23d7a11f-12a1-4aeb-b9af-dbced217b340.gif" height="150">
    <img src="https://user-images.githubusercontent.com/29715011/158715497-d1603423-c32f-4cf0-ab1e-6bbc9c458535.gif" height="150">
  </div>


  <div align="center">
    <h4> <a href="src/av2/datasets/motion_forecasting/README.md"> Motion Forecasting Dataset </a> </h4>
    <img src="https://user-images.githubusercontent.com/29715011/158486284-1a0df794-ee0a-4ae6-a320-0dd0d1daad06.gif" height="150">
    <img src="https://user-images.githubusercontent.com/29715011/158486286-e734e654-b879-4994-a129-9957cc591af4.gif" height="150">
    <img src="https://user-images.githubusercontent.com/29715011/158486288-5e7c0971-de0c-4ff5-bea7-76f7922dd1e0.gif" height="150">
  </div>

  <div align="center">
    <h4> <a href="src/av2/datasets/tbv/README.md"> Map Change Dataset (Trust, but Verify) </a> </h4>
    <img src="https://user-images.githubusercontent.com/29715011/159289930-a58147c3-c6ed-4b4e-a2a8-e23c23feb43e.gif" height="150">
    <img src="https://user-images.githubusercontent.com/29715011/159289891-8aae12e7-136a-4f44-bbc1-8ef93f01e23e.gif" height="150">
    <img src="https://user-images.githubusercontent.com/29715011/159152108-3c3001fe-ec7c-48fd-8c08-4a473affb2a3.gif" height="150">
    <img src="https://user-images.githubusercontent.com/29715011/159152102-27c04180-9ca4-4725-be81-95ee6858d367.gif" height="150">
  </div>



  Please refer to the [map README](src/av2/map/README.md) for additional details about the common format for vector and
  raster maps that we employ across all AV2 datasets.



  | `Python Version` |       `linux`      |       `macOS`      |      `windows`     |
  | -------------    | :----------------: | :----------------: | :----------------: |
  | `3.8`            | :white_check_mark: | :white_check_mark: | :white_check_mark: |
  | `3.9`            | :white_check_mark: | :white_check_mark: | :white_check_mark: |
  | `3.10`           | :white_check_mark: | :white_check_mark: | :white_check_mark: |



  All incoming pull requests are tested using [nox](https://nox.thea.codes/en/stable/) as
  part of the CI process. This ensures that the latest version of the API is always stable on all supported platforms. You
  can run the full suite of automated checks and tests locally using the following command:

  ```bash
  nox -r
  ```



  Have a cool feature you'd like to add? Found an unhandled corner case? The Argoverse team welcomes contributions from
  the open source community - please open a PR using the following [template](.github/pull_request_template.md)!



  Please use the following citation when referencing the [Argoverse 2](https://datasets-benchmarks-proceedings.neurips.cc/paper/2021/file/4734ba6f3de83d861c3176a6273cac6d-Paper-round2.pdf) _Sensor_, _Lidar_, or _Motion Forecasting_ Datasets:

  ```BibTeX
  @INPROCEEDINGS { Argoverse2,
    author = {Benjamin Wilson and William Qi and Tanmay Agarwal and John Lambert and Jagjeet Singh and Siddhesh Khandelwal and Bowen Pan and Ratnesh Kumar and Andrew Hartnett and Jhony Kaesemodel Pontes and Deva Ramanan and Peter Carr and James Hays},
    title = {Argoverse 2: Next Generation Datasets for Self-Driving Perception and Forecasting},
    booktitle = {Proceedings of the Neural Information Processing Systems Track on Datasets and Benchmarks (NeurIPS Datasets and Benchmarks 2021)},
    year = {2021}
  }
  ```

  Use the following citation when referencing the [Argoverse 2](https://datasets-benchmarks-proceedings.neurips.cc/paper/2021/file/6f4922f45568161a8cdf4ad2299f6d23-Paper-round2.pdf) _Map Change_ Dataset:
  ```BibTeX
  @INPROCEEDINGS { TrustButVerify,
    author = {John Lambert and James Hays},
    title = {Trust, but Verify: Cross-Modality Fusion for HD Map Change Detection},
    booktitle = {Proceedings of the Neural Information Processing Systems Track on Datasets and Benchmarks (NeurIPS Datasets and Benchmarks 2021)},
    year = {2021}
  }
  ```



  All code provided within this repository is released under the **MIT license** and bound by the _Argoverse_ **terms of use**,
  please see [LICENSE](LICENSE) and [NOTICE](NOTICE) for additional details.


pkgId: ccd79be7f6bb927e71a9e12bbf6583de566742daefcf0f0d6ff7459a7bc9e8ad
name: python-avahiplatform
arch: src
version: 0.0.16
epoch: 0
release: 1
summary: An avahiai library which makes your Gen-AI tasks effortless
url: https://github.com/avahi-org/avahiplatform
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-avahiplatform-0.0.16-1.src.rpm
checksum_type: sha256
description:
  chatbot = avahiplatform.chatbot()
  chatbot.initialize_instance(system_prompt="You are a python developer, you only answer queries related to python only, if you get any other queries, then please say I don't know")
  chatbot_response = chatbot.chat(user_input="Create me a function to add 2 numbers")
  print(f"chatbot_response: {chatbot_response}")
  chatbot_response = chatbot.chat(user_input="What is avahi?")
  print(f"chatbot_response: {chatbot_response}")

  chatbot_history = chatbot.get_history()
  print(chatbot_history)


pkgId: 7f62d6853b4f41a0dbc51a4c5d622ee48d35fa26c34c1a36948491cc37b63f7d
name: python-availai
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: A library for computer vision and machine learning
url: https://pypi.org/project/availai/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-availai-0.2.0-1.src.rpm
checksum_type: sha256
description:
  **`availai`** is a Python library for managing and building computer vision workflows, including tools for dataset management, preprocessing, and seamless integration with [Weights & Biases (W&B)](https://wandb.ai/) and [Roboflow](https://roboflow.com/). Future updates will expand functionality to include broader machine learning, deep learning, audio processing, NLP, and large language models (LLMs).



  - **Dataset Management**:
    - Download datasets from **Weights & Biases** and **Roboflow** directly into your projects.
    - Upload and log datasets as artifacts on W&B for easy tracking and versioning.

  - **Integration with Roboflow**:
    - Download datasets in a variety of formats (e.g., YOLOv8).
    - Specify workspaces and projects for precise dataset retrieval.

  - **Integration with Weights & Biases**:
    - Fetch specific dataset versions using artifact versioning.
    - Log and visualize data tables and create reproducible dataset workflows.



  You can install `availai` from PyPI:

  ```bash
  pip install availai


pkgId: 3b8a9bcbcca6ee68ad9a7e1d8f5dbc3a55acf626586c23d2aebecd0e25fcaacf
name: python-avalanchesumhash20
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: ASH-20 Einweg-Hashfunktion
url: https://pypi.org/project/avalanchesumhash20/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-avalanchesumhash20-1.6.0-1.src.rpm
checksum_type: sha256
description:
  Die ASH-20 Hashfunktion ist eine kryptografisch sichere Hashfunktion, entwickelt von Joshua Dean Pond im Jahr 2023.



  Die ASH-20 Hashfunktion verwendet komplexe mathematische Operatoren, um eine sichere und nicht rückkehrbare Hashfunktion zu erstellen. Dies macht sie geeignet für kryptografische Anwendungen, bei denen die Integrität von Daten gewährleistet sein muss.



  bash: pip install avalanchesumhash20



  Eine ausführliche Dokumentation der ASH-20 Hashfunktion ist im Skript enthalten. Sie können sie finden und weitere Details in der [Script-Dokumentation](
  avalanchesumhash20/docs/script_documentation.pdf).



  ```
  from avalanchesumhash20 import AvalancheSumHash20

  def main():
      input_text = input("Text: ")
      output_length = 79357612835769157957719395357591595
      iterations = 420
      modulo_value = 93537791153957593571955971579179595

      hash_generator = AvalancheSumHash20(input_text, output_length, iterations, modulo_value)
      result = hash_generator.main()

      print("Eingabe-Text:", input_text)
      print("Verschlüsselter Wert:", result)

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

  ```
  C:\Users\Joshua\OneDrive\Desktop>ASH-20
  Text: Hello World
  Eingabe-Text: Hello World
  Verschlüsselter Wert: 72730973721879097623944926376665313

  C:\Users\Joshua\OneDrive\Desktop>
  ```
  Das ist ein beispiel wie sie einen Text verschlüsseln können



  Die ASH-20 Hashfunktion verwendet komplexe mathematische Operatoren, um eine sichere und nicht rückkehrbare Hashfunktion zu erstellen. Dies macht sie geeignet für kryptografische Anwendungen, bei denen die Integrität von Daten gewährleistet sein muss.

  Die ASH-20 Hashfunktion nutzt verschiedene mathematische Operatoren, um die Sicherheit und Einweg-Natur der Hashfunktion zu gewährleisten:


  Durch die Verwendung der Ableitungsfunktion cos wird ein Avalanche-Effekt erzeugt, bei dem kleine Änderungen im Eingabetext zu drastisch unterschiedlichen Hashwerten führen.


  Die XOR-Operation wird verwendet, um Bits im Hashwert zu kombinieren und dabei sicherzustellen, dass kleine Änderungen im Eingabetext zu unvorhersehbaren Änderungen im Hash führen. Siehe [XOR-Verknüpfung](avalanchesumhash20/docs/xor_verknüpfung.pdf)


  Die OR-Operation wird verwendet, um bestimmte Bits im Hashwert zu setzen, um die Komplexität und Sicherheit zu erhöhen.


  Die AND-Operation wird verwendet, um bestimmte Bits im Hashwert zu löschen und die Verteilung der Bits zu beeinflussen.


  Neben den grundlegenden Operationen werden auch Funktionen höheren Grades sowie quadratische Funktionen eingesetzt, um den Hash zu einem einweg Hash zu machen. Dies erhöht die Komplexität und erschwert das Zurückverfolgen des Hashwertes. Genaue beispiele siehe: [Math. Operatoren (Einwegfunktion)](avalanchesumhash20/docs/Einwegfunktion.pdf)


  Durch die Verschiebung der Bits im Hashwert um 7 Positionen wird die Verteilung der Bits weiter verändert und die Sicherheit erhöht.


  Die Anwendung des Modulo-Operators mit der Output-Length stellt sicher, dass der Hashwert innerhalb der gewünschten Länge bleibt.


  Der Hashwert wird zerstückelt und neu angeordnet, um die Einweg-Natur der Hashfunktion zu verstärken.



  Dieses Projekt ist unter der MIT-Lizenz lizenziert - siehe die [LICENSE](LICENSE)-Datei für Details.



  Joshua Dean Pond
  Email: joshua.pond11@gmail.com


pkgId: 047ed354d62899ca44dffc8e02c94489d74287c4df1d2bb3837911931951d54d
name: python-avantis-trader-sdk
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: SDK for interacting with Avantis trading contracts.
url: https://avantisfi.com/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-avantis-trader-sdk-0.4.0-1.src.rpm
checksum_type: sha256
description:
  Avantis Trader SDK is a powerful and flexible toolkit for trading on the Avantis platform. This documentation will guide you through the installation process, basic usage, and advanced features of the SDK.



  Contents:

  - [Introduction](#introduction)
    - [About Avantis](#about-avantis)
    - [Purpose of the Avantis Trader SDK](#purpose-of-the-avantis-trader-sdk)
  - [Getting Started](#getting_started)
    - [Installation](#installation)
    - [Next Steps](#next-steps)
    - [Examples](#examples)



  Welcome to the Avantis Trader SDK, a powerful tool designed to interact with the Avantis decentralized exchange (DEX) and leverage its advanced features for trading and market-making in cryptocurrencies, forex, and commodities.



  [Avantis](https://avantisfi.com/) is at the forefront of decentralized leveraged trading platforms, offering users the ability to take long or short positions in synthetic crypto, forex, and commodities using perpetuals—a financial instrument that provides leverage without an expiration date. With synthetic leverage and a USDC stablecoin liquidity pool, Avantis achieves high capital efficiency, enabling a diverse selection of tradable assets and leverage up to 100x.

  The platform also introduces fine-grained risk management for liquidity providers (LPs) through time and risk parameters. This innovation allows any LP to become a sophisticated market maker for a wide range of derivatives, starting with perpetuals.

  Read more about Avantis at [https://docs.avantisfi.com/](https://docs.avantisfi.com/).



  The Avantis Trader SDK is designed to simplify and enhance the experience of interacting with the Avantis DEX. It provides developers and traders with a set of tools to:

  - Access real-time price feeds for supported trading pairs.
  - Retrieve and analyze key parameters for assets, categories, and trading strategies.
  - Integrate live price updates into applications or trading algorithms.
  - Execute trades and manage positions on the Avantis platform.

  Whether you are a developer building decentralized finance (DeFi) applications, a trader seeking to automate your strategies, or a market maker looking to optimize your operations, the Avantis Trader SDK offers the functionality you need to succeed in the rapidly evolving world of decentralized trading.





  To get started with the Avantis Trader SDK, follow these steps to install the package:

  1. Ensure you have Python 3.6 or later installed on your system.
  2. Install the SDK using pip:

     ```bash
      pip install avantis-trader-sdk
     ```

     or

     ```bash
     pip install git+https://github.com/Avantis-Labs/avantis_trader_sdk.git
     ```

     Alternatively, if you have a local copy of the source:

     ```bash
     git clone https://github.com/yourusername/avantis-trader-sdk.git
     cd avantis-trader-sdk
     pip install .
     ```

  3. Verify the installation:

     ```python
     import avantis_trader_sdk
     print(avantis_trader_sdk.__version__)
     ```

     If the installation was successful, this command should print the version number of the Avantis Trader SDK.



  Once you have installed the Avantis Trader SDK, you can start using it to interact with the Avantis platform. Here are some things you might want to do next:

  - Explore the SDK’s features and capabilities.
  - Access real-time price feeds for various trading pairs.
  - Integrate the SDK into your trading algorithms or DeFi applications.



  You can find practical examples and sample code for using the Avantis Trader SDK in our GitHub repository. These examples are designed to help you get started quickly and explore the capabilities of the SDK.

  📂 [Browse the Examples on GitHub](https://github.com/Avantis-Labs/avantis_trader_sdk/tree/main/examples)


pkgId: dd89a980f20842610d98f2e8d01cc3917e573cc686e39135c6ca356c24a533b5
name: python-avanza-api
arch: src
version: 13.0.0
epoch: 0
release: 1
summary: A Python library for the unofficial Avanza API
url: https://github.com/Qluxzz/avanza
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-avanza-api-13.0.0-1.src.rpm
checksum_type: sha256
description:
  A Python library for the unofficial Avanza API. This library is based on the existing JavaScript library [Avanza](https://github.com/fhqvst/avanza).

  Please note that this is only a proof of concept, hence not meant to be used by anyone.

  It might also be valuable to note that I am not affiliated with Avanza Bank AB in any way. The underlying API can be taken down or changed without warning at any point in time.



  [![](https://img.shields.io/pypi/v/avanza-api?style=flat-square&logo=pypi "Shiprock, New Mexico by Beau Rogers")](https://pypi.org/project/avanza-api/)

  ```python
  pip install avanza-api
  ```



  **NOTE: Since May 2018 two-factor authentication is required to log in.**

  Here are the steps to get your TOTP Secret:

  1. Go to Profil > Inställningar > Sajtinställningar > Inloggning och utloggning > Användarnamn > Tvåfaktorsinloggning and click "Återaktivera". (_Only do this step if you have already set up two-factor auth._)
  1. Click "Aktivera" on the next screen.
  1. Select "Annan app för tvåfaktorsinloggning".
  1. Click "Kan du inte scanna QR-koden?" to reveal your TOTP Secret.
  1. Generate the TOTP code using the python code below and paste the TOTP code in the field below where you found the TOTP Secret.
  1. Done! From now on all you have to do is supply your secret in the constructor as in the examples below.



  ```Python
  import hashlib
  import pyotp
  totp = pyotp.TOTP('MY_TOTP_SECRET', digest=hashlib.sha1)
  print(totp.now())
  ```



  Authenticate and fetch account overview:

  ```python
  from avanza import Avanza
  avanza = Avanza({
      'username': 'MY_USERNAME',
      'password': 'MY_PASSWORD',
      'totpSecret': 'MY_TOTP_SECRET'
  })

  overview = avanza.get_overview()
  ```

  Get info about a certain account

  ```python
  from avanza import Avanza, TimePeriod

  avanza = Avanza({
      'username': 'MY_USERNAME',
      'password': 'MY_PASSWORD',
      'totpSecret': 'MY_TOTP_SECRET'
  })

  report = avanza.get_insights_report(
      account_id='XXXXXXX',
      time_period=TimePeriod.ONE_WEEK
  )
  ```

  Place an order

  ```python
  from avanza import Avanza, OrderType

  avanza = Avanza({
      'username': 'MY_USERNAME',
      'password': 'MY_PASSWORD',
      'totpSecret': 'MY_TOTP_SECRET'
  })

  result = avanza.place_order(
      account_id='XXXXXXX',
      order_book_id='XXXXXX',
      order_type=OrderType.BUY,
      price=13.37,
      valid_until=date.fromisoformat('2011-11-11'),
      volume=42
  )
  ```

  Subscribe to real time data

  ```python
  import asyncio
  from avanza import Avanza, ChannelType

  def callback(data):
      
      print(data)

  async def subscribe_to_channel(avanza: Avanza):
      await avanza.subscribe_to_id(
          ChannelType.QUOTES,
          "19002", # OMX Stockholm 30
          callback
      )

  def main():
      avanza = Avanza({
          'username': 'MY_USERNAME',
          'password': 'MY_PASSWORD',
          'totpSecret': 'MY_TOTP_SECRET'
      })

      asyncio.get_event_loop().run_until_complete(
          subscribe_to_channel(avanza)
      )
      asyncio.get_event_loop().run_forever()

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



  Tests are stored in [/tests](https://github.com/Qluxzz/avanza/tree/master/tests)

  The tests are using [Pydanctic](https://github.com/pydantic/pydantic) models which are used to validate that the response model is what's expected

  There are tests that call all available GET endpoints and validates that the response model of these endpoints are correct and that the endpoint still exists

  To run the tests you first need to create a `.env` file and have the following keys in it:

  ```
  USERNAME=
  PASSWORD=
  TOTP_SECRET=
  ACCOUNT_ID=
  PRICE_ALERT_ORDER_BOOK_ID=
  ```

  Then you can run the tests using `python -m unittest`



  MIT license. See the LICENSE file for details.



  The author of this software is not responsible for any indirect damages (foreseeable or unforeseeable), such as, if necessary, loss or alteration of or fraudulent access to data, accidental transmission of viruses or of any other harmful element, loss of profits or opportunities, the cost of replacement goods and services or the attitude and behavior of a third party.


pkgId: 59c66bbf6bd7a49cc933ec599a1755f7804cd49a7288b86820569250ed64cddd
name: python-avar
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Allan variance tools
url: https://gitlab.com/davidwoodburn/avar
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-avar-0.1.4-1.src.rpm
checksum_type: sha256
description:
  ```python
  avar.windows(K, density=64)
  ```

  This will create an array `M` of integer window sizes. The averaging period
  `tau` would equal `M*T`, where `T` is the sampling period. The `density` is the
  target number of window sizes in the array per decade. Obviously, in the first
  decade it is not possible to have more than 9 window sizes: 1 through 9.



  ```python
  avar.variance(y, M)
  ```

  To get the actual Allan variance of a signal `y`, use this function. You must
  supply the array of window sizes `M` for which to calculate the Allan variance
  values. This function can take for `y` either a one-dimensional array or a
  two-dimensional array in which each row will be treated as a data set.



  ```python
  avar.ideal(tau, p)
  ```

  The `ideal` function will calculate the ideal Allan variances over an array of
  averaging periods `tau`. For any noise components you wish not to be included,
  set their corresponding variances to zero.

  This function make use of the `params` class. Objects of this type store the
  five basic component noise variances (quantization, white, flicker, walk, and
  ramp), `vc`, any first-order, Gauss-Markov (FOGM) noise variances, `vfogm`, and
  the corresponding FOGM time constants, `tfogm`. The `p` parameter is one such
  object. You can define it as shown in the following example:

  ```python
  p = avar.params(
          vc=np.array([0.5, 1.0, 0, 0.5, 0.1]) * 1e-9,
          vfogm=[1e-8, 1e-7],
          tfogm=[0.1, 1.0])
  ```

  The `ideal` function will return the total Allan variance curve, `va`, as well
  as a matrix, `vac`, whose rows represent the component Allan variances over
  `tau`.



  ```python
  avar.fit(tau, va, mask=None, fogms=0, tol=0.007, vtol=0.0)
  ```

  Given the Allan variance curve of some signal, `va`, at various averaging
  periods `tau`, you can get the best fit using the five basic component noises
  and `fogms` number of first-order, Gauss-Markov (FOGM) noises. By default, this
  function will automatically attempt to determine if certain component noises are
  even at play based on the tolerance value `tol`. However, you can directly
  control which component noises you wish to include or exclude with the `mask`
  array. For each element of `mask` that is `False` the corresponding component
  noise will be excluded. This function will iterate through the various
  permutations of component noises, starting with 0 FOGMs. If a fit satisfies the
  specified `tol` tolerance, the search will end. Otherwise, the best fit will be
  used. The `vtol` parameter is the minimum allowed variance for any fitted
  component noise variance.

  The return values are the fitted Allan variance curve, `vf`, and a `params`
  object, `p` (see the section on Ideal Allan Variance), containing the variances
  of the basic component noise variances (quantization, white, flicker, walk, and
  ramp), `vc`, any first-order, Gauss-Markov (FOGM) noise variances, `vfogm`, and
  the corresponding FOGM time constants, `tfogm`.



  ```python
  avar.noise(K, T, p)
  ```

  Generate a noise signal of length `K`, sampling period `T`, and parameters `p`.
  Parameter `p` is a `params` object (see the section on Ideal Allan Variance).

  This function returns the noise signal `y`.

  For flicker (bias-instability) noise, multiple, balanced FOGMs are used.


pkgId: acdec55923466858ebdbe874d0a399d1ae8ab67bed25b782a7f4679547a52f4c
name: python-avassa-client
arch: src
version: 2024.8.0
epoch: 0
release: 1
summary: Library for integrating with the Avassa APIs
url: https://gitlab.com/avassa-public/avassa-client-py
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-avassa-client-2024.8.0-1.src.rpm
checksum_type: sha256
description:
  Use this library to integrate with the Avassa APIs from Python.



  The library consists of two modules.



  Functions for authentication using username/password as well as approle
  credentials. Also contains a generic rest_get function that can be used to talk
  to any API endpoint.



  Asynchronous library based on the websockets module for connecting to
  Volga topics.



  The Avassa Client is published to
  [PyPi](https://pypi.org/project/avassa-client/) and can be installed:
  ```shell
  python3 -m pip install --upgrade avassa-client
  ```

  See the Volga Applications how-to in the Avassa Documentation for
  further information.


  See BUILD-PUBLISH.md

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 Avassa Public  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: 2cf42d03639594603c08b42d18ccf79b857bb59ed72b64466471bf86e88b8a6a
name: python-avclass-malicialab
arch: src
version: 2.8.10
epoch: 0
release: 1
summary: AVClass is a Python package and command line tool to tag / label malware samples.
url: https://github.com/malicialab/avclass
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-avclass-malicialab-2.8.10-1.src.rpm
checksum_type: sha256
description:
  AVClass is a Python package and command line tool to tag / label
  malware samples.
  You input the AV labels for a large number of malware samples
  (e.g., VirusTotal JSON reports)
  and it outputs a list of tags extracted from the AV labels of each sample.

  By default, AVClass outputs the most likely family name for each sample,
  but it can also output other tags that capture
  the malware class (e.g., *worm*, *ransomware*, *grayware*),
  behaviors (e.g., *spam*, *ddos*), and
  file properties (e.g., *packed*, *themida*, *bundle*, *nsis*).

  If you are wondering if this is AVClass or AVClass2,
  the answer is this is the right place for both.
  The old AVClass code has been deprecated and
  AVClass2 has been renamed as AVClass.
  A longer explanation is below.


  ```shell
  pip install avclass-malicialab
  ```



  To obtain the most likely family name for each sample, run:

  ```shell
  avclass -f examples/vtv2_sample.json
  ```

  the output on stdout will be:

  ```
  602695c8f2ad76564bddcaf47b76edff  zeroaccess
  f117cc1477513cb181cc2e9fcaab39b2  winwebsec
  ```

  which simply reports the most common family name for each sample.

  For some samples, AVClass may return:

  ```
  5e31d16d6bf35ea117d6d2c4d42ea879	SINGLETON:5e31d16d6bf35ea117d6d2c4d42ea879
  ```

  This means that AVClass was not able to identify a family name for that sample.
  AVClass uses the SINGLETON:hash terminology,
  (e.g., instead of an empty string or NULL)
  so that the second column can be used as a cluster identifier where
  each unlabeled sample is placed in its own cluster.
  This prevents considering that all unlabeled samples are part of the
  same family / cluster.

  To extract all tags for each sample run:

  ```shell
  avclass -f examples/vtv2_sample.json -t
  ```

  the output on stdout will be:

  ```
  602695c8f2ad76564bddcaf47b76edff  52  FAM:zeroaccess|19,FILE:os:windows|16,BEH:server|8,CLASS:backdoor|8,FILE:packed|7
  f117cc1477513cb181cc2e9fcaab39b2  39  CLASS:rogueware|15,BEH:alertuser|15,FILE:os:windows|11,FAM:winwebsec|4,CLASS:grayware|4,CLASS:grayware:tool|3,FILE:packed|3
  ```
  which means sample *602695c8f2ad76564bddcaf47b76edff*
  was flagged by 52 AV engines and that
  19 of them mention it belongs to the *zeroaccess* family,
  16 that it runs on *windows*,
  8 that it is a *backdoor*, and
  7 that it is a *packed* file.
  Sample *f117cc1477513cb181cc2e9fcaab39b2* is flagged by 39 AV engines and
  15 of them mention its class to be *rogueware*,
  15 that it has the *alertuser* behavior,
  11 that it runs on *windows*,
  4 that it belongs to the *winwebsec* family,
  and so on.

  You can also place the output in a file of your choosing with the _-o_ option:

  ```shell
  avclass -f examples/vtv2_sample.json -o output.txt
  ```



  Because a lot of times security researchers want to extract family and other
  information from AV labels, but this process is not as simple as it looks,
  especially if you need to do it for large numbers (e.g., millions) of samples.
  Some advantages of AVClass are:

  1. *Automatic.* It avoids manual work that does not scale for large datasets.

  2. *Vendor-agnostic.* It operates on the labels of any available set of AV
  engines, which can vary from sample to sample.

  3. *Cross-platform.* It can be used for any platforms supported by AV
  engines, e.g., Windows or Android malware.

  4. *Does not require executables.* AV labels can be obtained from online
  services like VirusTotal using a sample's hash,
  even when the executable is not available.

  5. *Quantified accuracy.* We have evaluated AVClass on millions of
  samples and publicly available malware datasets with ground truth.
  Evaluation details are in the RAID 2016 and ACSAC 2020 papers
  (see References section).

  6. *Open source.* The code is available and we are happy to incorporate
  suggestions and improvements so that the security community benefits from
  the tool.



  The main limitations of AVClass is that its output depends
  on the input AV labels.
  AVClass tries to compensate for the noise on the AV labels,
  but it cannot identify tags if AV engines do not provide non-generic tokens
  in the labels of a sample.
  In particular, it only outputs tags that appear in the labels of
  at least 2 AV engines.

  Still, there are many samples that can be tagged
  and thus we believe you will find it useful.



  The short answer is that the current code in this repo is
  based on the code of AVClass2.
  The original AVClass code has been deprecated.
  Below, we detail this process.

  We originally published AVClass in RAID 2016 and made its code
  available in this repository in July 2016.
  AVClass extracted only the family names from the input samples.

  We published AVClass2 in ACSAC 2020 and made its code
  available in this repository in September 2020.
  AVClass2 extracted all tags from the input samples and included a
  compatibility option to provide only the family names in the
  same format as the original AVClass.

  For 2.5 years, both tools were available in this repository in
  separate directories.
  In February 2023, we decided to
  deprecate the original AVClass code,
  rename AVClass2 as AVClass,
  release a PyPI package to ease installation, and
  clean the command line options.



  AVClass supports four input JSONL formats
  (i.e., one JSON object per line).

  1. VirusTotal v3 API reports,
  where each line in the input *file* should be the full JSON of a
  VirusTotal API version 3 response with a *File* object report,
  e.g., obtained by querying https://www.virustotal.com/api/v3/files/{hash}
  There is an example VirusTotal v3 input file in examples/vtv3_sample.json

  ```shell
  avclass -f examples/vtv3_sample.json -o output.txt
  ```

  2. VirusTotal v2 API reports,
  where each line in the input *file* should be the full JSON of a
  VirusTotal v2 API response to the */file/report* endpoint,
  e.g., obtained by querying https://www.virustotal.com/vtapi/v2/file/report?apikey={apikey}&resource={hash}
  There is an example VirusTotal v2 input file in examples/vtv2_sample.json

  ```shell
  avclass -f examples/vtv2_sample.json -o output.txt
  ```

  3. OPSWAT MetaDefender reports,
  where each line in the input *file* should be the full JSON
  obtained from OPSWAT MetaDefender.
  There is an example OPSWAT MetaDefender input file in
  examples/opswat_md_sample.json

  ```shell
  avclass -f examples/opswat_md_sample.json -o output.txt
  ```

  4. Simplified format,
  where each line in the input *file* should be a JSON
  with (at least) these fields:
  {md5, sha1, sha256, av_labels}.
  There is an example of such input file in *examples/malheurReference_lb.json*
  If you are obtaining AV labels from sources other than VirusTotal you
  may want to convert them to this format.

  ```shell
  avclass -f examples/malheurReference_lb.json -o output.txt
  ```

  **Multiple input files and different formats**

  AVClass can handle multiple input files putting the results in the
  same output files
  (if you want results in separate files, process each input file separately).
  AVClass automatically detects the format of each file,
  so it is possible to mix input files.

  For example, you can provide as input the three test files
  (each of a different format) in the examples directory:

  ```shell
  avclass -f examples/vtv3_sample.json -f examples/vtv2_sample.json -f examples/malheurReference_lb.json -f examples/opswat_md_sample.json -o output.txt
  ```

  output.txt will have 3135 lines: 3130 samples from malheurReference_lb.json,
  3 samples from vtv2_sample.json, 1 sample from vtv3_sample.json, and
  1 sample from opswat_md_sample.json.

  You can also provide as input a directory with the -d option and
  AVClass will process all files in that directory.

  ```shell
  avclass -d <directory>
  ```

  It is also possible to combine -f with -d,
  Thus, this command works:

  ```shell
  avclass -f <file> -d <directory>
  ```

  At this point you have read the most important information on
  how to use AVClass.
  The following sections describe steps that most users will not need.



  By default, AVClass will use the labels of all AV engines that appear in
  the input reports.
  If you want to limit AVClass to use only the labels of certain AV engines,
  you can use the -av option to pass it a file where each line has the name of
  an AV engine (case-sensitive).

  For example, you could create a file engines.txt with three lines:
  BitDefender
  F-Secure
  Sophos

  ```shell
  avclass -av engines.txt -f examples/vtv2_sample.json -t -o output.txt
  ```

  would output into output.txt:
  ```
  602695c8f2ad76564bddcaf47b76edff  3 FAM:zeroaccess|2
  f117cc1477513cb181cc2e9fcaab39b2  3
  ```

  where only the labels of BitDefender, F-Secure, and Sophos have been used
  to extract tags.
  The output states all three selected engines flag both samples as malicious.
  Note that the number of detections is with respect to the provided engines,
  i.e., even if the first sample has 52 detections,
  the number of detections is a maximum of 3 in this case.
  For the first sample, two AV engines identify the family as *zeroaccess* but
  for the second sample no tags are identified in the labels
  of the three selected AV engines.



  If you have family ground truth for some malware samples,
  i.e., you know the true family for those samples,
  you can evaluate the accuracy of the family tags output by AVClass on
  those samples with respect to that ground truth.
  The evaluation metrics used are precision, recall, and F1 measure.
  See our
  [RAID 2016 paper](https://software.imdea.org/~juanca/papers/avclass_raid16.pdf) for their definition.
  Note that the ground truth evaluation does not apply to non-family tags,
  i.e., it only evaluates family labeling.

  ```shell
  avclass -f examples/malheurReference_lb.json -gt examples/malheurReference_gt.tsv -o malheurReference.labels
  ```

  The output includes these lines:

  ```
  Calculating precision and recall
  3131 out of 3131
  Precision: 90.81  Recall: 93.95 F1-Measure: 92.35
  ```

  Each line in the *examples/malheurReference_gt.tsv* file has
  three **tab-separated** columns (hash, AVClass family, GT family):

  ```
  afdd8f086dfcb8d2cf26c566e784476dd899ec10 adrotator ADROTATOR
  ```

  which indicates that sample afdd8f086dfcb8d2cf26c566e784476dd899ec10
  is identified as *adrotator* by AVClass and
  its ground truth family is *ADROTATOR*.
  Each sample in the input file should also appear in the ground truth file.
  Note that the particular label assigned to each family does not matter.
  What matters is that all samples in the same family are assigned
  the same family name (i.e., the same string in the second column)

  The ground truth can be obtained from publicly available malware datasets.
  The one in *examples/malheurReference_gt.tsv* comes from the
  [Malheur](http://www.mlsec.org/malheur/) dataset.
  There are other public datasets with ground truth such as
  [Drebin](https://www.sec.cs.tu-bs.de/~danarp/drebin/) or
  [Malicia](http://malicia-project.com/dataset.html).




  The update module can be used to suggest additions and changes to the input
  taxonomy, tagging rules, and expansion rules.
  By default, AVClass uses the default taxonomy, tagging, and expansion files
  included in the repository.
  Thus, we expect that most users will not need to run the update module.
  But, below we explain how to run in case you need to.

  Using the update module comprises of two steps.
  The first step is obtaining an alias file:

  ```shell
  avclass -f examples/malheurReference_lb.json -aliasdetect -o /dev/null
  ```

  The above command will create a file named \<file\>.alias,
  malheurReference_lb.alias in our example. This file has 7 columns:

  1. t1: token that is an alias
  2. t2: tag for which t1 is an alias
  3. |t1|: number of input samples where t1 was observed
  4. |t2|: number of input samples where t2 was observed
  5. |t1^t2|: number of input samples where both t1 and t2 were observed
  6. |t1^t2|/|t1|: ratio of input samples where both t1 and t2 were observed over the number of input samples where t1 was observed.
  7. |t1^t2|/|t2|: ratio of input samples where both t1 and t2 were observed over the number of input samples where t2 was observed.

  The Update Module takes the above file as input with the -alias option,
  as well as the default taxonomy, tagging, and expansion files
  in the data directory.
  It outputs updated taxonomy, tagging, and expansion files that include the
  suggested additions and changes.

  ```shell
  avclass-update -alias malheurReference_lb.alias -o output_prefix
  ```

  This will produce three files:
  output_prefix.taxonomy, output_prefix.tagging, output_prefix.expansion.
  You can diff the output and input files to analyze the proposed changes.

  You can also modify the input taxonomy, tagging, and expansion rules in place,
  rather than producing new files:

  ```shell
  avclass-update -alias malheurReference_lb.alias -update
  ```



  AVClass is fully customizable:
  Tagging, Expansion and Taxonomy files can be easily modified by the analyst
  either manually or by running the update module.

  If you change those files manually, we recommend running
  afterwards the normalization script to keep them tidy.
  It sorts the tags in the taxonomy and performs some basic cleaning like
  removing redundant entries:

  ```shell
  avclass-normalize -tax mytaxonomy -tag mytagging -exp myexpansions
  ```

  If the modifications are in the default files in the data directory you can
  simply run:

  ```shell
  avclass-normalize
  ```



  Other researchers may want to independently evaluate AVClass/AVClass2 and
  to compare it with their own approaches.
  We encourage such evaluation, feedback on limitations, and proposals for
  improvement.
  However, we have observed a number of common errors in such evaluations that
  should be avoided.
  Thus, if you need to compare your approach with AVClass/AVClass2,
  please read the [evaluation page](EVALUATION.md)



  AVClass is written in Python.
  It should run on Python versions above 2.7 and 3.0.

  It does not require installing any dependencies.



  If you have issues or want to contribute, please file a issue or perform a
  pull request through GitHub.



  AVClass is released under the MIT license



  The design and evaluation of AVClass is detailed in our
  [RAID 2016 paper](https://software.imdea.org/~juanca/papers/avclass_raid16.pdf):

  > Marcos Sebastián, Richard Rivera, Platon Kotzias, and Juan Caballero.<br>
  AVClass: A Tool for Massive Malware Labeling.<br>
  In Proceedings of the International Symposium on Research in
  Attacks, Intrusions and Defenses,
  September 2016.

  The design and evaluation of AVClass2 is detailed in our
  [ACSAC 2020 paper](https://arxiv.org/pdf/2006.10615.pdf):

  > Silvia Sebastián, Juan Caballero.<br>
  AVClass2: Massive Malware Tag Extraction from AV Labels.<br>
  In proceedings of the Annual Computer Security Applications Conference,
  December 2020.



  Several members of the MaliciaLab at the
  [IMDEA Software Institute](http://software.imdea.org)
  have contributed to AVClass:
  Marcos Sebastián, Richard Rivera, Platon Kotzias, Srdjan Matic,
  Silvia Sebastián, Kevin van Liebergen, and Juan Caballero.

  GitHub users with significant contributions to AVClass include
  (let us know if you believe you should be listed here):
  [eljeffeg](https://github.com/eljeffeg)

rpm_license:
  MIT License  Copyright (c) 2016-2020 MaliciaLab @ IMDEA Software Institute  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: 1e298162b433ca3755ce3284fc1c4977dca59e12bba812ad0ca9dbb45f8206ae
name: python-avcv
arch: src
version: 0.0.54
epoch: 0
release: 1
summary: Python package utils for computer vision
url: https://github.com/anhvth/avcv/tree/nbdev-convert/
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-avcv-0.0.54-1.src.rpm
checksum_type: sha256
description:
  > Optimized functions for vision problems




  `pip install avcv`

  Docs: https://anhvth.github.io/avcv/utils.html


pkgId: 3e426dd4189859c0350f8c6a5f643f404223591ac673a14f02d6b3d7a144cfc3
name: python-avdoc
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: CLI tool to generate HTML documentation for an Apache Avro schema
url: https://github.com/jeffbr13/avdoc
rpm_license: AGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-avdoc-0.4.0-1.src.rpm
checksum_type: sha256
description:
  CLI tool to generate human-readable HTML documentation for an [Apache Avro] schema AVSC file.
  Want Avro schema docs? 'avdoc!
  ![screenshot showing avdoc](screenshot.png)


  Software required outside of Python package dependencies:
  - [Graphviz] for the reference graph.

  Install the [`avdoc` package on PyPI]:
  ```shell
  pip install --upgrade avdoc
  ```

  ```shell
  [python -m] avdoc tests/example.avsc > out/example.html && open out/example.html
  ```
  To provide a version ID, e.g. the current git commit:
  ```shell
  [python -m] avdoc --schema-version $(git rev-parse --short head) example.avsc > out/example.html
  ```
  `$ avdoc --help`
  ```
  usage: avdoc [-h] [--schema-title SCHEMA_TITLE]
               [--schema-version SCHEMA_VERSION]
               avsc
  CLI tool to generate HTML documentation for an Apache Avro schema
  positional arguments:
    avsc
  options:
    -h, --help            show this help message and exit
    --schema-title SCHEMA_TITLE
    --schema-version SCHEMA_VERSION
  ```

  - [x] graph/diagram of which record schemas reference each other
    - [ ] reference graph for every complex (record) type
  - [x] Markdown support in `"doc"` strings
  - [ ] supports all [complex Avro types][]
    - [x] record
    - [x] enum
    - [x] array
    - [x] union
    - [ ] error
    - [ ] map
    - [ ] request

  The output should:
  - be well-formatted semantic HTML.
  - be legible in basic browsers without styling.
  - aid understanding of the underlying schema.
  - be a single static file for sharing without dependencies.
  - be linkable to reference specific schemas and fields.

  - [devenv] for development environment
  - [direnv] for automatic shell activation (optional)
  `devenv shell` should set up Python & Poetry with dependencies installed.
  Use `.venv/bin/python` as your Python interpreter.


  ```shell
  bumpversion major|minor|patch
  ```

  Run `mdsh`.

  [Configure Poetry credentials] with [PyPI token] and run:
  ```shell
  poetry publish --build
  ```

  Not much to speak of.
  `avdoc` is a couple of hundred lines of Python script
  generating static HTML, with a bit of string munging to get component outputs
  into the final HTML output page.
  This code is purpose-oriented.
  The output is opinionated, but not much time has been spent on the code
  past getting it working for my own needs.
  It's not intended to be exemplary of anything in particular.

  I probably won't pay too much attention to `avdoc` maintenance
  once it's suitable for my own needs.
  I'd like to try to ensure that dependencies are kept up to date.
  Fork for your own needs.
  Raise a PR if you'd like me to consider including your changes.
  Make sure you adhere to the [license](#license) by ensuring your users
  have access to your modifications.

  [AGPL]:
  > [[…] requires the operator of a network server to provide the source code of the modified version running there to the users of that server. Therefore, public use of a modified version, on a publicly accessible server, gives the public access to the source code of the modified version.](https://www.gnu.org/licenses/agpl-3.0.html#:~:text=It%20requires%20the%20operator%20of%20a%20network%20server)
  `avdoc` is released as copyleft software.
  If you modify `avdoc` then you must make changes available to your users.
  If the AGPL license is an issue, and you want to relicense `avdoc` privately,
  then reach out to discuss pricing.

  `avdoc` is intended as a replacement for [avrodoc-plus],
  which itself was intended as a replacement for [avrodoc],
  via a long line of forks.
  To run `avrodoc-plus` and see its output:
  ```shell
  npm install @mikaello/avrodoc-plus
  node_modules/@mikaello/avrodoc-plus/bin/avrodoc-plus.js example.avsc --output out/avrodocplus.html
  ```

  Unfortunately the original [avrodoc] and forks are all
  in varying stages of [software decay], mostly due to NodeJS ecosystem churn.
  Their NPM package dependencies include packages which have themselves
  gone unmaintained or had breaking changes in following versions,
  with CVEs piling up against the transitive dependencies.
  [avrodoc-plus] has about 10 critical CVEs in its dependency graph.
  This isn't necessarily an issue in itself unless you're running these
  avrodoc tools in an online capacity or on untrusted input.
  But at $WORK it was generating a lot of false-positives in automatic
  [SBOM] security scanners which had to be explained to infosec specialists.
  The HTML output from the avrodoc tools is also rather dynamic,
  requiring JS to render, when it could just be a classic HTML page.
  I have taken the opportunity to implement some quality-of-life
  improvements for readers.
  See [§Design Goals](#design-goals) for more info.
  Why the name `avdoc` specifically?
  The [Apache Software Foundation protects project name trademarks]
  (quite rightly) and I wanted to avoid the [kcat naming issue].
  `avdoc` is "Powered by Apache Avro™" but not a part of Apache Avro™.
  [//]: # (Links)
  [Apache Avro]: https://avro.apache.org
  [complex Avro types]: https://avro.apache.org/docs/1.11.1/specification/#complex-types-1
  [avrodoc-plus]: https://github.com/mikaello/avrodoc-plus
  [avrodoc]: https://github.com/ept/avrodoc
  [AGPL]: https://www.gnu.org/licenses/agpl-3.0.html
  [direnv]: https://direnv.net
  [devenv]: https://devenv.sh
  [Graphviz]: https://www.graphviz.org
  [software decay]: https://en.wikipedia.org/wiki/Software_rot
  [SBOM]: https://en.wikipedia.org/wiki/Software_supply_chain
  [kcat naming issue]: https://github.com/edenhill/kcat#what-happened-to-kafkacat
  [Apache Software Foundation protects project name trademarks]: https://www.apache.org/foundation/marks/faq/#products
  [Configure Poetry credentials]: https://python-poetry.org/docs/repositories/#configuring-credentials
  [PyPI token]: https://pypi.org/help/#apitoken
  [`avdoc` package on PyPI]: https://pypi.org/project/avdoc/


pkgId: b7d5f952e45db0080fa4609f1083b8ab6c0afd9a32c6f1ade4d51124964804d6
name: python-aveas-openlabel
arch: src
version: 0.4.16
epoch: 0
release: 1
summary: The AVEAS OpenLABEL specification
url: https://github.com/understand-ai/aveas_openlabel
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aveas-openlabel-0.4.16-1.src.rpm
checksum_type: sha256
description:
  This library can be installed via pip using `pip install aveas_openlabel` or with poetry using `poetry add aveas_openlabel`.
  The documentation with minimal examples can be found here: [understand-ai.github.io/aveas_openlabel/](https://understand-ai.github.io/aveas_openlabel/)




  This package uses Poetry, a tool for dependency management and packaging.
  Please install it via the official installer from [here](https://python-poetry.org/docs/).
  In the root of the repository, you install all dependencies into a virtual environment using `poetry install`.


  This repository employs several tools to ensure a constant and good code quality.


  [Black](https://black.readthedocs.io/en/stable/index.html) is a code formatter that we use to assure consistent code style across our projects.
  Use it in-between, or after your code changes, via `poetry run black .` in the root directory of this repository.
  Merge requests will only be merge-able if black has nothing to complain about.


  [Mypy](https://mypy.readthedocs.io/en/stable/) is a static type checker for Python.
  Is assures type safety throughout our code and is necessary to ensure that our AVEAS OpenLABEL format is consistent
  with the base ASAM OpenLABEL format.
  Mypy can be run with `poetry run mypy .` in the root directory of this repository.
  Merge requests will only be merge-able if MyPy has nothing to complain about.


  [Ruff](https://docs.astral.sh/ruff/) is a Python linter and code formatter.
  It can be run with `poetry run ruff .` in the root directory of this repository.


  Please write docstrings for the class itself and each of its class variables.
  For inspiration of what to write into the docstring, look at the description of the object or field
  in the official ASAM OpenLABEL spec ([link](https://www.asam.net/project-detail/asam-openlabel-v100/)).
  The docstrings allow the use of reStructuredText ([link](https://pydoctor.readthedocs.io/en/latest/docformat/restructuredtext.html)).

  We are using [pydoctor](https://pydoctor.readthedocs.io/en/latest/index.html) to automatically generate documentation from the docstrings in our code.
  The documentation generation can be run using `poetry run pydoctor` and is written in the directory `documentation/`
  in the root of this repository.

  If administrator privileges required for this operation under MS Windows and poetry is not installed for the administrator account, poetry can be run from Powershell via:

  ```Start-Process poetry -ArgumentList "run pydoctor" -Verb runAs```

  The documentation is ignored from Git, as it is better to generate it by hand from the latest commit.


pkgId: dcc3ac3c653e03e30d856c3c11061a5a37f09e37e8e8fd7540083468c71bd171
name: python-avendesora
arch: src
version: 1.26
epoch: 0
release: 1
summary: A password generator and account manager.
url: https://pypi.org/project/avendesora/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-avendesora-1.26-1.src.rpm
checksum_type: sha256
description:
  *Avendesora, the leaf of the Tree of Life is the key.*
  Avendesora replaces Abraxas, which are both alternatives to the traditional
  password vault.
  Please report all bugs and suggestions to avendesora@nurdletech.com


pkgId: e18c17d9c447620a02b4272a3202ab4bd6500c85bb526717655a76cefdaa04a2
name: python-average-facer
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Face averaging in Python made simple.
url: https://pypi.org/project/average-facer/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-average-facer-0.6.0-1.src.rpm
checksum_type: sha256
description:
  Face detection, alignment, and averaging using OpenCV and `dlib`.

  Facer draws heavily on [this tutorial](https://www.learnopencv.com/average-face-opencv-c-python-tutorial/) from [Satya Mallick](https://github.com/spmallick). I had to update the code pretty heavily to get the project to work, so I thought I'd share my modifications.



  The image below is an example of Facer's output for one of my posts on [`r/dataisbeautiful`](https://www.reddit.com/r/dataisbeautiful/comments/crxrud/the_average_faces_of_rap_rock_and_country/).

  [![Average faces of rap, rock, and country music](assets/average_face_example.png)](https://www.reddit.com/r/dataisbeautiful/comments/crxrud/the_average_faces_of_rap_rock_and_country/)



  You have my 100% money-back guarantee that the most difficult part of using this package is installing its requirements. Once you've got OpenCV installed, the rest ~~will~~ should be smooth sailing. I've had the best luck with the OpenCV using the `opencv-python` package from PyPI.


  The `requirements.txt` file lists the Python packages Facer depends on. Install the packages using `pip`:

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



  The face landmark detection relies on a pre-trained model that must be downloaded separately from the `dlib` package itself.

  ```shell
  wget http://dlib.net/files/shape_predictor_68_face_landmarks.dat.bz2
  ```

  Unzip the compressed file after it finishes downloading and move it into the `./Facer/model` directory.



  ```python
  from facer import facer
  import matplotlib.pyplot as plt



  path_to_images = "./face_images"  # Put your images here
  images = facer.load_images(path_to_images)


  landmarks, faces = facer.detect_face_landmarks(images)


  average_face = facer.create_average_face(faces, landmarks, save_image=True)


  plt.imshow(average_face)
  plt.show()
  ```

  Facer also supports creating animated GIFs of the averaging process:

  ```python
  from facer import facer

  path_to_images = "./face_images"
  gif, average_face = facer.create_animated_gif(path_to_images)
  ```


pkgId: f8bb153dbe7d21a0092acddcd4678252b7df76e4f52560942b319346022e34eb
name: python-average-facer
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Face averaging in Python made simple.
url: https://github.com/johnwmillr/Facer
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-average-facer-0.7.0-1.src.rpm
checksum_type: sha256
description:
  Face detection, alignment, and averaging using OpenCV and `dlib`.

  Facer draws heavily on [this tutorial](https://www.learnopencv.com/average-face-opencv-c-python-tutorial/) from [Satya Mallick](https://github.com/spmallick). I had to update the code pretty heavily to get the project to work, so I thought I'd share my modifications.



  The image below is an example of Facer's output for one of my posts on [`r/dataisbeautiful`](https://www.reddit.com/r/dataisbeautiful/comments/crxrud/the_average_faces_of_rap_rock_and_country/).

  [![Average faces of rap, rock, and country music](assets/average_face_example.png)](https://www.reddit.com/r/dataisbeautiful/comments/crxrud/the_average_faces_of_rap_rock_and_country/)



  You have my 100% money-back guarantee that the most difficult part of using this package is installing its requirements. Once you've got OpenCV installed, the rest ~~will~~ should be smooth sailing. I've had the best luck with the OpenCV using the `opencv-python` package from PyPI.

  Install `facer` using `pip`:

  ```bash
  pip install -U average-facer
  ```



  The face landmark detection relies on a pre-trained model that must be downloaded separately from the `dlib` package itself.

  ```shell
  wget http://dlib.net/files/shape_predictor_68_face_landmarks.dat.bz2
  ```

  Unzip the compressed file after it finishes downloading and move it into the `./Facer/model` directory.



  ```python
  from facer import facer
  import matplotlib.pyplot as plt



  path_to_images = "./face_images"  # Put your images here
  images = facer.load_images(path_to_images)


  landmarks, faces = facer.detect_face_landmarks(images)


  average_face = facer.create_average_face(faces, landmarks, save_image=True)


  plt.imshow(average_face)
  plt.show()
  ```

  Facer also supports creating animated GIFs of the averaging process:

  ```python
  from facer import facer

  path_to_images = "./face_images"
  gif, average_face = facer.create_animated_gif(path_to_images)
  ```


pkgId: d49540d9f89a0cad8faeff35ee059e64dcd30a6fbfb34b602dcdf45b1af64d5d
name: python-averbis-python-api
arch: src
version: 0.12.0
epoch: 0
release: 1
summary: Averbis REST API client for Python.
url: https://pypi.org/project/averbis-python-api/
rpm_license: Apache License, Version 2.0. Copyright Averbis GmbH
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-averbis-python-api-0.12.0-1.src.rpm
checksum_type: sha256
description:
  `Averbis <https://averbis.com>`_ is a leading text mining and machine learning company in Healthcare and Life Sciences. We extract information from texts, automate intellectual processes and make meaningful predictions.
  The **Averbis Python API** allows convenient access to the REST API of Averbis products. This includes in particular the ability to interact with the text mining pipelines offered by these products, e.g. to use these in data science environments such as Jupyter notebooks or for integration of the Averbis products in other enterprise systems.
  Supported products are:
  - `Health Discovery <https://averbis.com/health-discovery/>`_
  - `Information Discovery <https://averbis.com/information-discovery/>`_
  - `Patent Monitor <https://averbis.com/patent-monitor/>`_


pkgId: 112b17dad5ae86ca3f06899c6e1f48412a1b6a3dd422b350376751052b392fde
name: python-aviary.gsm8k
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: GSM8k environment implemented with aviary
url: https://pypi.org/project/aviary.gsm8k/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aviary.gsm8k-0.10.0-1.src.rpm
checksum_type: sha256
description:
  GSM8k environment implemented with aviary,
  allowing agents to solve math word problems from the GSM8k dataset.



  The citation for GSM8k is given below:

  ```bibtex
  @article{gsm8k-paper,
      title = {Training verifiers to solve math word problems},
      author = {Cobbe, Karl and Kosaraju, Vineet and Bavarian, Mohammad and Chen, Mark and Jun, Heewoo and Kaiser, Lukasz and
   Plappert, Matthias and Tworek, Jerry and Hilton, Jacob and Nakano, Reiichiro and others},
      journal = {arXiv preprint arXiv:2110.14168},
      year = {2021}
  }
  ```



  [1] Cobbe, K., Kosaraju, V., Bavarian, M., Chen, M., Jun, H., Kaiser, L., Plappert, M., Tworek, J., Hilton, J., Nakano,
  R. and Hesse, C., 2021.
  [Training verifiers to solve math word problems](https://arxiv.org/abs/2110.14168). arXiv preprint arXiv:2110.14168.



  To install the GSM8k environment, run the following command:

  ```bash
  pip install fhaviary[gsm8k]
  ```


pkgId: b48a30ecf4bbd60faf2ba8f95af485699e0c8f68af25cbcc14fabea7fe1ae822
name: python-aviary.hotpotqa
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: HotPotQA environment implemented with aviary
url: https://pypi.org/project/aviary.hotpotqa/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aviary.hotpotqa-0.10.0-1.src.rpm
checksum_type: sha256
description:
  HotPotQA environment implemented with aviary,
  allowing agents to perform multi-hop question answering on the HotPotQA dataset.



  [1] Yang et al. [HotpotQA: A Dataset for Diverse,
  Explainable Multi-Hop Question Answering](https://aclanthology.org/D18-1259/). EMNLP, 2018.

  [2] Yao et al.,
  [ReAct: Synergizing Reasoning and Acting in Language Models](https://openreview.net/forum?id=WE_vluYUL-X).
  In The Eleventh International Conference on Learning Representations. 2023



  To install the HotPotQA environment, run the following command:

  ```bash
  pip install fhaviary[hotpotqa]
  ```


pkgId: 01f83100c514ceca51741e05c35a69275482906363c5a9c0211fc66fb34c5a6a
name: python-avicortex
arch: src
version: 1.0.0
epoch: 0
release: 1
url: https://pypi.org/project/avicortex/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-avicortex-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  Python functions and classes to build connectivity graphs and datasets from Freesurfer's brain cortical measurements.

description:
  Python functions and classes to build connectivity graphs and datasets from Freesurfer's brain cortical measurements.

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 2024 Oytun Demirbilek  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: 3471096a840715d0b981ef0e0ee9d0627ef46477d75af7ccb487966e28e04a99
name: python-avidaq
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: controls for napari and micromanger
url: https://pypi.org/project/avidaq/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-avidaq-0.0.5-1.src.rpm
checksum_type: sha256
description:
  This [napari] plugin was generated with [Cookiecutter] using [@napari]'s [cookiecutter-napari-plugin] template.
  <!--
  Don't miss the full getting started guide to set up your new package:
  https://github.com/napari/cookiecutter-napari-plugin#getting-started
  and review the napari docs for plugin developers:
  https://napari.org/plugins/index.html
  -->


  You can install `avidaq` via [pip]:
  ```shell
  pip install napari[all] avidaq
  ```

  Alternatively you can install `avidaq` via the [napari] plugin menu:


  First start micromanager.  Make sure the server port checkbox is activated.
  Then to start napari with the avidaq plugin active run:
  `napari -w avidaq`
  ![](screenshot.png)

  MDA presets are stored in a json file in the user's home directory.
  ```shell
  `C:\\Users\YourName\.avidaq\mda_presets.json`
  ```
  This file should exist after plugin installation with some defaults. You do not need to create the file yourself.
  Add or modify the values and reload napari to see the changes.
  All parameter entries are optional, if not provided the default value will be used.
  The parameter names and their descriptions can be found [here] (https://github.com/micro-manager/pycro-manager/blob/main/pycromanager/acq_util.py#L102-L115)
  The format is as follows:
  ```json
  {
      "gui_display_name": {
          "parameter_name": value,
          "parameter_name": value,
      },
      "gui_display_name": {
          "parameter_name": value,
          "parameter_name": value,
      },
  }
  ```
  defaults:
  ```json
  {
    "Basic": {
      "num_time_points": 5,
      "z_start": 0,
      "z_end": 6,
      "z_step": 0.4
    },
    "Simple": {
      "num_time_points": 2,
      "z_start": 0,
      "z_end": 2,
      "z_step": 0.1
    },
    "Detailed": {
      "num_time_points": 10,
      "z_start": 0,
      "z_end": 12,
      "z_step": 0.2
    }
  }
  ```

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

  You should have python3.8 or higher installed.
  1. clone this repo
  2. create a virtual environment `python -m venv .venv && source .venv/bin/activate`
  3. run `pip install -e '.[testing,build]'`
  4. run `pre-commit install`

  `pytest`

  1. edit code in `/src`
  2. run napari -w avidaq
  3. repeat


