# packages

pkgId: 1df037fdad91347cb694fdf1dd6160d1bf921bb59833f8c4304015916ae36976
name: python-alphalens-tej
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: Performance analysis of predictive (alpha) stock factors
url: https://pypi.org/project/alphalens-tej/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alphalens-tej-2.0.2-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
  <a href="https://alphalens.ml4trading.io">
  <img src="https://i.imgur.com/uf8PmQO.png" width="35%">
  </a>
  </p>

  ![PyPI](https://img.shields.io/pypi/v/alphalens-reloaded)
  [![Anaconda](https://github.com/stefan-jansen/alphalens-reloaded/actions/workflows/conda_package.yml/badge.svg)](https://github.com/stefan-jansen/alphalens-reloaded/actions/workflows/conda_package.yml)
  [![Tests](https://github.com/stefan-jansen/alphalens-reloaded/actions/workflows/unit_tests.yml/badge.svg)](https://github.com/stefan-jansen/alphalens-reloaded/actions/workflows/unit_tests.yml)
  [![PyPI](https://github.com/stefan-jansen/alphalens-reloaded/actions/workflows/build_wheels.yml/badge.svg)](https://github.com/stefan-jansen/alphalens-reloaded/actions/workflows/build_wheels.yml)
  [![Coverage Status](https://coveralls.io/repos/github/stefan-jansen/alphalens-reloaded/badge.svg?branch=main)](https://coveralls.io/github/stefan-jansen/alphalens-reloaded?branch=main)
  ![GitHub issues](https://img.shields.io/github/issues/stefan-jansen/alphalens-reloaded)
  ![PyPI - License](https://img.shields.io/pypi/l/alphalens-reloaded)
  ![Discourse users](https://img.shields.io/discourse/users?server=https%3A%2F%2Fexchange.ml4trading.io%2F)
  ![Twitter Follow](https://img.shields.io/twitter/follow/ml4trading?style=social)

  Alphalens is a Python library for performance analysis of predictive
  (alpha) stock factors. Alphalens works great with the
  [Zipline](https://www.zipline.ml4trading.io/) open source backtesting library, and [Pyfolio](https://github.com/quantopian/pyfolio) which provides performance and risk analysis of financial portfolios.

  The main function of Alphalens is to surface the most relevant statistics and plots about an alpha factor, including:

  - Returns Analysis
  - Information Coefficient Analysis
  - Turnover Analysis
  - Grouped Analysis



  With a signal and pricing data creating a factor \"tear sheet\" is a two step process:

  ```python
  import alphalens


  factor_data = alphalens.utils.get_clean_factor_and_forward_returns(my_factor,
                                                                     pricing,
                                                                     quantiles=5,
                                                                     groupby=ticker_sector,
                                                                     groupby_labels=sector_names)


  alphalens.tears.create_full_tear_sheet(factor_data)
  ```



  Check out the [example notebooks](https://github.com/stefan-jansen/alphalens-reloaded/tree/master/alphalens/examples)
  for more on how to read and use the factor tear sheet.



  Install with pip:

      pip install alphalens-reloaded

  Install with conda:

      conda install -c ml4t alphalens-reloaded

  Install from the master branch of Alphalens repository (development code):

      pip install git+https://github.com/stefan-jansen/alphalens-reloaded

  Alphalens depends on:

  - [matplotlib](https://github.com/matplotlib/matplotlib)
  - [numpy](https://github.com/numpy/numpy)
  - [pandas](https://github.com/pandas-dev/pandas)
  - [scipy](https://github.com/scipy/scipy)
  - [seaborn](https://github.com/mwaskom/seaborn)
  - [statsmodels](https://github.com/statsmodels/statsmodels)



  A good way to get started is to run the examples in a [Jupyter notebook](https://jupyter.org/).

  To get set up with an example, you can:

  Run a Jupyter notebook server via:

  ```bash
  jupyter notebook
  ```

  From the notebook list page(usually found at `http://localhost:8888/`), navigate over to the examples directory, and open any file with a .ipynb extension.

  Execute the code in a notebook cell by clicking on it and hitting Shift+Enter.



  If you find a bug, feel free to open an issue on our [github tracker](https://github.com/stefan-jansen/alphalens-reloaded/issues).



  If you want to contribute, a great place to start would be the
  [help-wanted issues](https://github.com/stefan-jansen/alphalens-reloaded/issues?q=is%3Aopen+is%3Aissue+label%3A%22help+wanted%22).



  - [Andrew Campbell](https://github.com/a-campbell)
  - [James Christopher](https://github.com/jameschristopher)
  - [Thomas Wiecki](https://github.com/twiecki)
  - [Jonathan Larkin](https://github.com/marketneutral)
  - Jessica Stauth (<jstauth@quantopian.com>)
  - [Taso Petridis](https://github.com/tasopetridis)

  For a full list of contributors see the [contributors page.](https://github.com/stefan-jansen/alphalens-reloaded/graphs/contributors)



  Example factor courtesy of [ExtractAlpha](https://extractalpha.com/)



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



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



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



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


pkgId: 0470ab51e9eb91144fcd735273661c86931b562233e2fb5d89972fa5fc665027
name: python-alphalogic-api3
arch: src
version: 0.1.14
epoch: 0
release: 1
summary: Python3 stub library for Alphalogic adapters.
url: https://github.com/Alphaopen/alphalogic_api3
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alphalogic-api3-0.1.14-1.src.rpm
checksum_type: sha256
description:
  <h1>Alphalogic API
  <a href="https://alphalogic_api3.readthedocs.io">
      <img src="https://readthedocs.org/projects/alphalogic_api3/badge/?version=latest" alt="Documentation Status" />
  </a>
  </h1>
  The official library to develop the Alphalogic system adapters with Python3. <a href="https://alphalogic_api3.readthedocs.io">   Documentation</a>


pkgId: 231a8bc37feba117de9ca068604d20c765831d4e04cf054ee2f1e2d204358552
name: python-alphamed-federated
arch: src
version: 0.4.9
epoch: 0
release: 1
summary: AlphaMed Federated Learning Module
url: https://github.com/ssplabs/alphafed
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alphamed-federated-0.4.9-1.src.rpm
checksum_type: sha256
description:
  AlphaMed 是一个基于区块链技术的去中心化联邦学习解决方案，旨在使医疗机构能够在保证其医疗数据隐私和安全的同时，实现多机构联合建模。医疗机构可以在本地节点实现模型的训练，并支持以匿名的身份将加密的参数共享至聚合节点，从而实现更安全、可信的联邦学习。

  相比于传统的联邦学习，AlphaMed 平台不仅能够确保只有合法的且经过许可的参与者才能加入网络，同时支持节点的匿名化的参与联合建模。同时，区块链的共识算法能够确保网络中的节点得到一直的决策，恶意的参与者或者数据投毒等攻击将被拒绝，从而保证了联邦学习更好的安全性。

  在联邦学习的过程中，各个参与方都受到智能合约的约束，并且所有的事件、操作都将被记录在区块链的分布式账本上，可追溯、可审计，使得联合机器学习的安全性和隐私保护能力极大的提升。

  [开始构建第一个联邦学习任务](src/alphafed/docs/fed_avg/README.md)

  [在不同结构的数据源之间构建异构联邦学习任务](src/alphafed/docs/hetero_nn/README.md)

  如果 AlphaMed 平台预置的现有算法依然无法满足业务需要，还可以自行设计联邦学习算法，并使其运行在 AlphaMed 平台之上。[这里](src/alphafed/docs/customized_scheduler/README.md)展示了如果自定义联邦学习算法，并通过 AlphaMed 平台实际执行联邦学习任务。为了帮助开发者调试自己的代码，AlphaMed 平台还提供了一套[模拟运行环境](src/alphafed/docs/mock/README.md)，以在本地节点模拟实际运行环境，包括联邦学习运行环境。

  AlphaMed 平台除面向算法工程师提供了开发联邦学习模型的支持外，还面向模型使用者提供了预训练模型的支持。与传统预训练模型相比，AlphaMed 平台上的预训练模型支持功能更为强大、使用更为方便。在 AlphaMed 平台上，不仅可以寻找并下载心仪的预训练模型，更可以利用私有数据微调、部署预训练模型，使其更加适配于私有的业务数据。

  AlphaMed 平台预置了一定数量的预训练模型，同时也支持第三方开发者开发上传自己的预训练模型。[这里展示了如何设计自己的预训练模型。](src/alphafed/docs/auto_ml/README.md)



  src/alphafed
  ├── auto_ml  *AutoML 模块*
  │   └── cvat  *CVAT 工具*
  ├── contractor  *合约消息工具*
  ├── data_channel  *数据传输工具*
  ├── docs  *说明文档*
  │   ├── auto_ml  *AutoML 说明文档*
  │   ├── customized_scheduler  *自定义调度器说明文档*
  │   ├── fed_avg  *FedAvg 横向联邦说明文档*
  │   ├── hetero_nn  *HeteroNN 异构联邦说明文档*
  │   ├── mock  *模拟调试说明文档*
  │   └── tutorial  *tutorial 示例说明文档，包含所有主要功能*
  ├── examples  *脚本测试代码 / 示例代码*
  ├── fed_avg  *FedAvg 横向联邦模块*
  ├── hetero_nn  *HeteroNN 异构联邦模块*
  │   └── psi  *隐私求交模块*
  ├── secure  *安全工具*
  ├── fs.py  *文件系统工具*
  ├── loggers.py  *日志工具*
  ├── mock.py  *模拟调试工具*
  └── utils.py  *其它工具*

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


pkgId: 5ee7f804978509efc3a9677d2c6c6721f2a65db1743e030423b1f408971e1ef7
name: python-alphamini
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: python sdk for ubtech alpha mini robot
url: https://pypi.org/project/alphamini/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alphamini-1.2.0-1.src.rpm
checksum_type: sha256
description:
  ﻿# AlphaMini PythonSDK
  Documents: <br/>
  [Chinese](http://docs.ubtrobot.com/alphamini/python-sdk/index.html)
  <br/>
  [English](http://docs.ubtrobot.com/alphamini/python-sdk-en/index.html)


pkgId: 3d2c1646d46301cad0cbadd0d55711c4b27eff8c37cc5a4550031f113f26b187
name: python-alphanet
arch: src
version: 0.0.20
epoch: 0
release: 1
summary: A recurrent neural network for predicting stock market performance
url: https://github.com/Congyuwang/AlphaNetV3
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alphanet-0.0.20-1.src.rpm
checksum_type: sha256
description:
  ![unittest](https://github.com/Congyuwang/AlphaNetV3/actions/workflows/tests.yml/badge.svg)
  [![Congyuwang](https://circleci.com/gh/Congyuwang/AlphaNetV3.svg?style=shield)](https://circleci.com/gh/Congyuwang/AlphaNetV3)
  ![publish](https://github.com/Congyuwang/AlphaNetV3/actions/workflows/python-publish.yml/badge.svg)





  Below is the structure of AlphaNetV2

  ```
  input: (batch_size, history time steps, features)

                stride = 5
  input -> expand features -> BN -> LSTM -> BN -> Dense(linear)
  ```



  Below is the structure of AlphaNetV3

  ```
  input: (batch_size, history time steps, features)

                   stride = 5
          +-> expand features -> BN -> GRU -> BN -+
  input --|       stride = 10                     |- concat -> Dense(linear)
          +-> expand features -> BN -> GRU -> BN -+
  ```


  Either clone this repository or just use pypi: ``pip install alphanet``.

  The pypi project is here: [alphanet](https://pypi.org/project/alphanet/).




  ```python
  from alphanet import AlphaNetV3, load_model
  from alphanet.data import TrainValData, TimeSeriesData
  from alphanet.metrics import UpDownAccuracy
  ```


  ```python

  df = pd.read_csv("some_data.csv")


  df_future_return = here_you_compute_it_by_your_self
  df = df_future_return.merge(df,
                              how="inner",
                              left_on=["date", "security_code"],
                              right_on=["date", "security_code"])


  stock_data_list = []


  security_codes = df["security_code"].unique()
  for code in security_codes:
      table_part = df.loc[df["security_code"] == code, :]
      stock_data_list.append(TimeSeriesData(dates=table_part["date"].values,                   # date column
                                            data=table_part.iloc[:, 3:].values,                # data columns
                                            labels=table_part["future_10_cum_return"].values)) # label column


  train_val_data = TrainValData(time_series_list=stock_data_list,
                                train_length=1200,   # 1200 trading days for training
                                validate_length=150, # 150 trading days for validation
                                history_length=30,   # each input contains 30 days of history
                                sample_step=2,       # jump to days forward for each sampling
                                train_val_gap=10     # leave a 10-day gap between training and validation
  ```


  ```python

  train, val, dates_info = train_val_data.get(20110131, order="by_date")
  print(dates_info)
  ```


  ```python

  model = AlphaNetV3(l2=0.001, dropout=0.0)


  model.compile(metrics=[tf.keras.metrics.RootMeanSquaredError(),
                         UpDownAccuracy()]


  model.fit(train.batch(500).cache(),
            validation_data=val.batch(500).cache(),
            epochs=100)
  ```




  ```python

  model.save("path_to_your_model")


  model.save_weights("path_to_your_weights")
  ```


  ```python

  model = load_model("path_to_your_model")


  model = AlphaNetV3(l2=0.001, dropout=0.0)
  model.load_weights("path_to_your_weights")
  ```

  Note: only `alphanet.load_model(filename)` recognizes custom `UpDownAccuracy`.
  If you do not use `UpDownAccuracy`,
  you can _also_ use `tf.keras.models.load_model(filename)`.


  For detailed documentation, go to
  [alphanet documentation](https://github.com/Congyuwang/AlphaNetV3/tree/master/docs).

  For implementation details, go to
  [alphanet source folder](https://github.com/Congyuwang/AlphaNetV3/tree/master/src).


  The model expands features quadratically.
  So, if you have 5 features, it will be expanded to more than 50 features (for AlphaNetV3),
  and if you have 10 features, it will be expanded to more than 200 features.
  Therefore, do not put too many features inside.


  ``alphanet.data``module is completely independent from ``alphanet`` module,
  and can be a useful tool for training any timeseries neural network.


pkgId: ae9562697672dd2380ed358afaa8f0672196ba1d96a10404ffc0c3d164e45807
name: python-alphapulldown
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Pipeline allows massive screening using alphafold
url: https://github.com/KosinskiLab/AlphaPulldown
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alphapulldown-2.0.1-1.src.rpm
checksum_type: sha256
description:
  > AlphaPulldown fully **maintains backward compatibility** with input files and scripts from versions 1.x.



  <!-- TOC start (generated with https://github.com/derlin/bitdowntoc) -->

  - [AlphaPulldown: Version 2.0.0 (Beta)](#alphapulldown-version-200-beta)
     * [Table of Contents](#table-of-contents)
  - [About AlphaPulldown](#about-alphapulldown)
     * [Overview](#overview)
  - [Alphafold databases](#alphafold-databases)
  - [Snakemake AlphaPulldown ](#snakemake-alphapulldown)
     * [1. Installation](#1-installation)
     * [2. Configuration](#2-configuration)
     * [3. Execution](#3-execution)
  - [Run AlphaPulldown Python Command Line Interface](#run-alphapulldown-python-command-line-interface)
     * [0. Installation](#0-installation)
        + [0.1. Create Anaconda environment](#01-create-anaconda-environment)
        + [0.2. Installation using pip](#02-installation-using-pip)
        + [0.3. Installation for the Downstream analysis tools](#03-installation-for-the-downstream-analysis-tools)
        + [0.4. Installation for cross-link input data by AlphaLink2 (optional!)](#04-installation-for-cross-link-input-data-by-alphalink2-optional)
        + [0.5. Installation for developers](#05-installation-for-developers)
     * [1. Compute multiple sequence alignment (MSA) and template features (CPU stage)](#1-compute-multiple-sequence-alignment-msa-and-template-features-cpu-stage)
        + [1.1. Basic run](#11-basic-run)
           - [Input](#input)
           - [Script Execution](#script-execution)
           - [Output](#output)
           - [Next step](#next-step)
        + [1.2. Example bash scripts for SLURM (EMBL cluster)](#12-example-bash-scripts-for-slurm-embl-cluster)
           - [Input](#input-1)
           - [Script Execution](#script-execution-1)
           - [Next step](#next-step-1)
        + [1.3. Run using MMseqs2 and ColabFold Databases (Faster)](#13-run-using-mmseqs2-and-colabfold-databases-faster)
           - [Run MMseqs2 Remotely](#run-mmseqs2-remotely)
           - [Output](#output-1)
           - [Run MMseqs2 Locally](#run-mmseqs2-locally)
           - [Next step](#next-step-2)
        + [1.4. Run with custom templates (TrueMultimer)](#14-run-with-custom-templates-truemultimer)
           - [Input](#input-2)
           - [Script Execution](#script-execution-2)
           - [Output](#output-2)
           - [Next step](#next-step-3)
     * [2. Predict structures (GPU stage)](#2-predict-structures-gpu-stage)
        + [2.1. Basic run](#21-basic-run)
           - [Input](#input-3)
           - [Script Execution: Structure Prediction](#script-execution-structure-prediction)
           - [Output](#output-3)
           - [Next step](#next-step-4)
        + [2.2. Example run with SLURM (EMBL cluster)](#22-example-run-with-slurm-embl-cluster)
           - [Input](#input-4)
           - [Script Execution](#script-execution-3)
           - [Output and the next step](#output-and-the-next-step)
        + [2.3. Pulldown mode](#23-pulldown-mode)
           - [Multiple inputs "pulldown" mode](#multiple-inputs-pulldown-mode)
        + [2.4. All versus All mode](#24-all-versus-all-mode)
           - [Output and the next step](#output-and-the-next-step-1)
        + [2.5. Run with Custom Templates (TrueMultimer)](#25-run-with-custom-templates-truemultimer)
           - [Input](#input-5)
           - [Script Execution for TrueMultimer Structure Prediction](#script-execution-for-truemultimer-structure-prediction)
           - [Output and the next step](#output-and-the-next-step-2)
        + [2.6. Run with crosslinking-data (AlphaLink2)](#26-run-with-crosslinking-data-alphalink2)
           - [Input](#input-6)
           - [Run with AlphaLink2 prediction via AlphaPulldown](#run-with-alphalink2-prediction-via-alphapulldown)
           - [Output and the next step](#output-and-the-next-step-3)
     * [3. Analysis and Visualization](#3-analysis-and-visualization)
        + [Create Jupyter Notebook](#create-jupyter-notebook)
           - [Next step](#next-step-5)
        + [Create Results table](#create-results-table)
           - [Next step](#next-step-6)
  - [Downstream analysis](#downstream-analysis)
     * [Jupyter notebook](#jupyter-notebook)
     * [Results table ](#results-table)
     * [Results management scripts](#results-management-scripts)
        + [Decrease the size of AlphaPulldown output](#decrease-the-size-of-alphapulldown-output)
        + [Convert Models from PDB Format to ModelCIF Format](#convert-models-from-pdb-format-to-modelcif-format)
           - [1. Convert all models to separate ModelCIF files](#1-convert-all-models-to-separate-modelcif-files)
           - [2. Only convert a specific single model for each complex](#2-only-convert-a-specific-single-model-for-each-complex)
           - [3. Have a representative model and keep associated models](#3-have-a-representative-model-and-keep-associated-models)
           - [Associated Zip Archives](#associated-zip-archives)
           - [Miscellaneous Options](#miscellaneous-options)
  - [Features Database](#features-database)
     * [Installation](#installation)
        + [Steps:](#steps)
        + [Verify installation:](#verify-installation)
     * [Configuration](#configuration)
     * [Downloading Features](#downloading-features)
        + [List available organisms:](#list-available-organisms)
        + [Download specific protein features:](#download-specific-protein-features)
        + [Download all features for an organism:](#download-all-features-for-an-organism)

  <!-- TOC end -->



  AlphaPulldown is a customized implementation of [AlphaFold-Multimer](https://github.com/google-deepmind/alphafold) designed for customizable high-throughput screening of protein-protein interactions. It extends AlphaFold’s capabilities by incorporating additional run options, such as customizable multimeric structural templates (TrueMultimer), [MMseqs2](https://github.com/soedinglab/MMseqs2) multiple sequence alignment (MSA) via [ColabFold](https://github.com/sokrypton/ColabFold) databases, protein fragment predictions, and the ability to incorporate mass spec data as an input using [AlphaLink2](https://github.com/Rappsilber-Laboratory/AlphaLink2/tree/main).

  AlphaPulldown can be used in two ways: either by a two-step pipeline made of **python scripts**, or by a **Snakemake pipeline** as a whole. For details on using the Snakemake pipeline, please refer to the separate GitHub [**repository**](https://github.com/KosinskiLab/AlphaPulldownSnakemake).



  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="./manuals/AP_pipeline_dark.png">
    <source media="(prefers-color-scheme: light)" srcset="./manuals/AP_pipeline.png">
    <img alt="Shows an illustrated sun in light mode and a moon with stars in dark mode." src="./manuals/AP_pipeline.png">
  </picture>

  <p align='center'> <strong>Figure 1</strong> Overview of AlphaPulldown worflow </p>

  The AlphaPulldown workflow involves the following 3 steps:

  1. **Create and store MSA and template features**:

     In this step, AlphaFold searches preinstalled databases using HMMER for each queried protein sequence and calculates multiple sequence alignments (MSAs) for all found homologs. It also searches for homolog structures to use as templates for feature generation. This step only requires CPU.

     Customizable options include:
     * To speed up the search process, [MMSeq2](https://doi.org/10.1038/s41592-022-01488-1) can be used instead of the default HHMER.
     * Use custom MSA.
     * Use a custom structural template, including a multimeric one (TrueMultimer mode).

  2. **Structure prediction**:

     In this step, the AlphaFold neural network runs and produces the final protein structure, requiring GPU. A key strength of AlphaPulldown is its ability to flexibly define how proteins are combined for the structure prediction of protein complexes. Here are the three main approaches you can use:

     <picture>
       <source media="(prefers-color-scheme: dark)" srcset="./manuals/AP_modes_dark.png">
       <source media="(prefers-color-scheme: light)" srcset="./manuals/AP_modes.png">
       <img alt="Shows an illustrated sun in light mode and a moon with stars in dark mode." src="./manuals/AP_modes.png">
     </picture>

     <p align='center'> <strong>Figure 2</strong> Three typical scenarios covered by AlphaPulldown</p>

     * **Single file** (custom mode or homo-oligomer mode): Create a file where each row lists the protein sequences you want to predict together or each row tells the program to model homo-oligomers with your specified number of copies.

     * **Multiple Files** (pulldown mode): Provide several files, each containing protein sequences. AlphaPulldown will automatically generate all possible combinations by pairing rows of protein names from each file.

     * **All versus all**: AlphaPulldown will generate all possible non-redundant combinations of proteins in the list.

     Additionally, AlphaPulldown also allows:
     * Select only region(s) of proteins that you want to predict instead of the full-length sequences.
     * Adjust MSA depth to control the influence of the initial MSA on the final model.
     * Integrate high-throughput crosslinking data with AlphaFold modeling via [AlphaLink2](https://github.com/Rappsilber-Laboratory/AlphaLink2/tree/main).

  3. **Downstream analysis of results**:

     The results for all predicted models can be systematized using one of the following options:
     * A table containing various scores and physical parameters of protein complex interactions.
     * A Jupyter notebook with interactive 3D protein models and PAE plots.

  <br>


  For the standard MSA and features calculation, AlphaPulldown requires genetic databases. Check if you have downloaded the necessary parameters and databases (e.g., BFD, MGnify, etc.) as instructed in [AlphaFold's documentation](https://github.com/KosinskiLab/alphafold). You should have a directory structured as follows:

  <details>
  <summary>
  <b>Databases directory</b>
  </summary>

  ```plaintext
  alphafold_database/                             # Total: ~ 2.2 TB (download: 438 GB)
     bfd/                                   # ~ 1.7 TB (download: 271.6 GB)
         
     mgnify/                                # ~ 64 GB (download: 32.9 GB)
         mgy_clusters_2018_12.fa
     params/                                # ~ 3.5 GB (download: 3.5 GB)
         
         
         
         
         
     pdb70/                                 # ~ 56 GB (download: 19.5 GB)
         
     pdb_mmcif/                             # ~ 206 GB (download: 46 GB)
         mmcif_files/
             
         obsolete.dat
     pdb_seqres/                            # ~ 0.2 GB (download: 0.2 GB)
         pdb_seqres.txt
     small_bfd/                             # ~ 17 GB (download: 9.6 GB)
         bfd-first_non_consensus_sequences.fasta
     uniref30/                            # ~ 86 GB (download: 24.9 GB)
             
     uniprot/                               # ~ 98.3 GB (download: 49 GB)
         uniprot.fasta
     uniref90/                              # ~ 58 GB (download: 29.7 GB)
         uniref90.fasta
  ```
  </details>

  > [!NOTE]
  > Uniclust30 is the version of the database generated before 2019, UniRef30 is the one generated after 2019. Please note that AlphaPulldown is using UniRef30_2023_02 by default. This version can be downloaded by [this script](https://github.com/KosinskiLab/alphafold/blob/main/scripts/download_uniref30.sh). Alternatively, please overwrite the default path to the uniref30 database using the --uniref30_database_path flag of create_individual_features.py.

  > [!NOTE]
  > Since the local installation of all genetic databases is space-consuming, you can alternatively use the [remotely-run MMseqs2 and ColabFold databases](https://github.com/sokrypton/ColabFold). Follow the corresponding [instructions](#13-run-using-mmseqs2-and-colabfold-databases-faster). However, for AlphaPulldown to function, you must download the parameters stored in the `params/` directory of the AlphaFold database.

  <br>
  <br>



  AlphaPulldown is available as a Snakemake pipeline, allowing you to sequentially execute **(1)** Generation of MSAs and template features, **(2)** Structure prediction, and **(3)** Results analysis without manual intervention between steps. For more details, please refer to the [**AlphaPulldownSnakemake**](https://github.com/KosinskiLab/AlphaPulldownSnakemake) repository.

  > [!Warning]
  > The Snakemake version of AlphaPulldown differs slightly from the conventional scripts-based AlphaPulldown in terms of input file specifications.



  Before installation, make sure your python version is at least 3.10.

  ```bash
  python3 --version
  ```

  **Install Dependencies**

  ```bash
  pip install snakemake==7.32.4 snakedeploy==0.10.0 pulp==2.7 click==8.1 cookiecutter==2.6
  ```

  **Snakemake Cluster Setup**

  In order to allow snakemake to interface with a compute cluster, we are going to use the [Snakemake-Profile for SLURM](https://github.com/Snakemake-Profiles/slurm). If you are not working on a SLURM cluster you can find profiles for different architectures [here](https://github.com/Snakemake-Profiles/slurm). The following will create a profile that can be used with snakemake and prompt you for some additional information.

  ```bash
  git clone https://github.com/Snakemake-Profiles/slurm.git
  profile_dir="${HOME}/.config/snakemake"
  mkdir -p "$profile_dir"
  template="gh:Snakemake-Profiles/slurm"
  cookiecutter --output-dir "$profile_dir" "$template"
  ```

  During the setup process, you will be prompted to answer several configuration questions. Below are the questions and the recommended responses:

  - `profile_name [slurm]:` **slurm_noSidecar**
  - `Select use_singularity:` **1 (False)**
  - `Select use_conda:` **1 (False)**
  - `jobs [500]:` *(Press Enter to accept default)*
  - `restart_times [0]:` *(Press Enter to accept default)*
  - `max_status_checks_per_second [10]:` *(Press Enter to accept default)*
  - `max_jobs_per_second [10]:` *(Press Enter to accept default)*
  - `latency_wait [5]:` **30**
  - `Select print_shell_commands:` **1 (False)**
  - `sbatch_defaults []:` **qos=low nodes=1**
  - `Select cluster_sidecar:` **2 (no)**
  - `cluster_name []:` *(Press Enter to leave blank)*
  - `cluster_jobname [%r_%w]:` *(Press Enter to accept default)*
  - `cluster_logpath [logs/slurm/%r/%j]:` *(Press Enter to accept default)*
  - `cluster_config []:` *(Press Enter to leave blank)*

  After responding to these prompts, your Slurm profile named *slurm_noSidecar* for Snakemake will be configured as specified.

  **Singularity (Probably Installed Already)**: This pipeline makes use of containers for reproducibility. If you are working on the EMBL cluster singularity is already installed and you can skip this step. Otherwise, please install Singularity using the [official Singularity guide](https://sylabs.io/guides/latest/user-guide/quick_start.html#quick-installation-steps).


  **Download The Pipeline**:
  This will download the version specified by '--tag' of the snakemake pipeline and create the repository AlphaPulldownSnakemake or any other name you choose.

  ```bash
  snakedeploy deploy-workflow \
    https://github.com/KosinskiLab/AlphaPulldownSnakemake \
    AlphaPulldownSnakemake \
    --tag 1.4.0
  cd AlphaPulldownSnakemake
  ```
  >[!NOTE]
  >If you want to use the latest version from GitHub replace `--tag X.X.X` to `--branch main`

  **Install CCP4 package**:
  To install the software needed for [the analysis step](https://github.com/KosinskiLab/AlphaPulldown?tab=readme-ov-file#3-analysis-and-visualization), please follow these instructions:

  Download so-called Singularity image with our analysis software package
  ```bash
  singularity pull docker://kosinskilab/fold_analysis:latest
  singularity build --sandbox <writable_image_dir> fold_analysis_latest.sif
  ```
  <writable_image_dir> can be any temporary directory and can be deleted later.

  Download CCP4 from https://www.ccp4.ac.uk/download/#os=linux and copy to your server
  ```bash
  tar xvzf ccp4-9.0.003-linux64.tar.gz
  cd ccp4-9
  cp bin/pisa bin/sc <writable_image_dir>/software/
  cp /lib/* <writable_image_dir>/software/lib64/
  ```

  Create a new Singularity with CCP4 included
  ```bash
  cd <directory where you want to keep your local software>
  singularity build fold_analysis_latest_withCCP4.sif <writable_image_dir>
  ```
  It should create `fold_analysis_latest_withCCP4.sif` file.

  You can delete the <writable_image_dir> now.



  Adjust `config/config.yaml` for your particular use case.

  If you want to use CCP4 for analysis, open `config/config.yaml` in a text editor and change the path to the analysis container to:

  ```yaml
  analysis_container : "/path/to/fold_analysis_latest_withCCP4.sif"
  ```

  **input_files**
  This variable holds the path to your sample sheet, where each line corresponds to a folding job. For this pipeline we use the following format specification:

  ```
  protein:N:start-stop[_protein:N:start-stop]*
  ```

  where protein is a path to a file with '.fasta' extension or uniprot ID, N is the number of monomers for this particular protein and start and stop are the residues that should be predicted. However, only protein is required, N, start and stop can be omitted. Hence the following folding jobs for the protein example containing residues 1-50 are equivalent:

  ```
  example:2
  example_example
  example:2:1-50
  example:1-50_example:1-50
  example:1:1-50_example:1:1-50
  ```

  This format similarly extends for the folding of heteromers:

  ```
  example1_example2
  ```

  Assuming you have two sample sheets config/sample_sheet1.csv and config/sample_sheet2.csv. The following would be equivalent to computing all versus all in sample_sheet1.csv:

  ```
  input_files :
    - config/sample_sheet1.csv
    - config/sample_sheet1.csv
  ```

  while the snippet below would be equivalent to computing the pulldown between sample_sheet1.csv and sample_sheet2.csv

  ```
  input_files :
    - config/sample_sheet1.csv
    - config/sample_sheet2.csv
  ```

  This format can be extended to as many files as you would like, but keep in mind the number of folds will increase dramatically.

  ```
  input_files :
    - config/sample_sheet1.csv
    - config/sample_sheet2.csv
    - ...
  ```

  **alphafold_data_directory**
  This is the path to your alphafold database.

  **output_directory**
  Snakemake will write the pipeline output to this directory. If it does not exist, it will be created.

  **save_msa, use_precomputed_msa, predictions_per_model, number_of_recycles, report_cutoff**
  Command line arguments that were previously pasesed to AlphaPulldown's run_multimer_jobs.py and create_notebook.py (report_cutoff).

  **alphafold_inference_threads, alphafold_inference**
  Slurm specific parameters that do not need to be modified by non-expert users.

  **only_generate_features**
  If set to True, stops after generating features and does not perform structure prediction and reporting.



  After following the Installation and Configuration steps, you are now ready to run the snakemake pipeline. To do so, navigate into the cloned pipeline directory and run:

  ```bash
  snakemake \
    --use-singularity \
    --singularity-args "-B /scratch:/scratch \
      -B /g/kosinski:/g/kosinski \
      --nv " \
    --jobs 200 \
    --restart-times 5 \
    --profile slurm_noSidecar \
    --rerun-incomplete \
    --rerun-triggers mtime \
    --latency-wait 30 \
    -n

  ```

  Here's a breakdown of what each argument does:

  - `--use-singularity`: Enables the use of Singularity containers. This allows for reproducibility and isolation of the pipeline environment.

  - `--singularity-args`: Specifies arguments passed directly to Singularity. In the provided example:
    - `-B /scratch:/scratch` and `-B /g/kosinski:/g/kosinski`: These are bind mount points. They make directories from your host system accessible within the Singularity container. `--nv` ensures the container can make use of the hosts GPUs.

  - `--profile name_of_your_profile`: Specifies the Snakemake profile to use (e.g., the SLURM profile you set up for cluster execution).

  - `--rerun-triggers mtime`: Reruns a job if a specific file (trigger) has been modified more recently than the job's output. Here, `mtime` checks for file modification time.

  - `--jobs 500`: Allows up to 500 jobs to be submitted to the cluster simultaneously.

  - `--restart-times 10`: Specifies that jobs can be automatically restarted up to 10 times if they fail.

  - `--rerun-incomplete`: Forces the rerun of any jobs that were left incomplete in previous Snakemake runs.

  - `--latency-wait 30`: Waits for 30 seconds after a step finishes to check for the existence of expected output files. This can be useful in file-systems with high latencies.

  - `-n`: Dry-run flag. This makes Snakemake display the commands it would run without actually executing them. It's useful for testing. To run the pipeline for real, simply remove this flag.

  Executing the command above will perform submit the following jobs to the cluster:

  ![Snakemake rulegraph](manuals/dag.png)

  <br>
  <br>



  AlphaPulldown can be used as a set of scripts for every particular step.
  1. [`create_individual_features.py`](#1-compute-multiple-sequence-alignment-msa-and-template-features-cpu-stage): Generates multiple sequence alignments (MSA), identifies structural templates, and stores the results in monomeric feature `.pkl` files.
  2. [`run_multimer_jobs.py`](#2-predict-structures-gpu-stage): Executes the prediction of structures.
  3. [`create_notebook.py`](#create-jupyter-notebook) and [`alpha-analysis.sif`](#create-results-table): Prepares an interactive Jupyter Notebook and a Results Table, respectively.





  **Firstly**, install [Anaconda](https://www.anaconda.com/) and create an AlphaPulldown environment, gathering necessary dependencies. We recommend to use mamba to speed up solving of dependencies:

  ```bash
  conda create -n AlphaPulldown -c omnia -c bioconda -c conda-forge python==3.11 openmm==8.0 pdbfixer==1.9 kalign2 hhsuite hmmer modelcif
  ```

  ```bash
  source activate AlphaPulldown
  ```
  This usually works, but on some compute systems, users may prefer to use other versions or optimized builds of HMMER and HH-suite that are already installed.



  Activate the AlphaPulldown environment and install AlphaPulldown:

  ```bash
  source activate AlphaPulldown
  python3 -m pip install alphapulldown
  ```

  ```bash
  pip install -U "jax[cuda12]"
  ```

  > [!NOTE]
  > **For older versions of AlphaFold**:
  > If you haven't updated your databases according to the requirements of AlphaFold 2.3.0, you can still use AlphaPulldown with your older version of the AlphaFold database. Please follow the installation instructions on the [dedicated branch](https://github.com/KosinskiLab/AlphaPulldown/tree/AlphaFold-2.2.0).



  **Install CCP4 package**:
  To install the software needed for [the anaysis step](https://github.com/KosinskiLab/AlphaPulldown?tab=readme-ov-file#3-analysis-and-visualization), please follow these instructions:

  ```bash
  singularity pull docker://kosinskilab/fold_analysis:latest
  singularity build --sandbox <writable_image_dir> fold_analysis_latest.sif

  tar xvzf ccp4-9.0.003-linux64.tar.gz
  cd ccp4-9
  cp bin/pisa bin/sc <writable_image_dir>/software/
  cp /lib/* <writable_image_dir>/software/lib64/
  singularity build <new_image.sif> <writable_image_dir>
  ```



  $\text{\color{red}Update the installation manual after resolving the dependency conflict.}$

  1. Make sure you have installed PyTorch corresponding to the CUDA version you have. Here will take CUDA 11.7 and PyTorch 1.13.0 as an example:
      ```bash
      pip install torch==1.13.0+cu117 --extra-index-url https://download.pytorch.org/whl/cu117
      ```
  2. Compile [UniCore](https://github.com/dptech-corp/Uni-Core).
      ```bash
      source activate AlphaPulldown
      git clone https://github.com/dptech-corp/Uni-Core.git
      cd Uni-Core
      python setup.py install --disable-cuda-ext

      
      python -c "import unicore"
      ```
      You may see the following warning, but it's fine:

      ```plaintext
      fused_multi_tensor is not installed corrected
      fused_rounding is not installed corrected
      fused_layer_norm is not installed corrected
      fused_softmax is not installed corrected
      ```
  4. Download the PyTorch checkpoints from [Zenodo](https://zenodo.org/records/8007238), unzip it, then you should obtain a file named: `AlphaLink-Multimer_SDA_v3.pt`



  Only for the developers who would like to modify AlphaPulldown's codes and test their modifications.
  Please [add your SSH key to your GitHub account](https://docs.github.com/en/authentication/connecting-to-github-with-ssh/adding-a-new-ssh-key-to-your-github-account)

  <details>
  <summary><b>Instructions</b></summary>

  1. Clone the GitHub repo

      ```bash
      git clone --recurse-submodules git@github.com:KosinskiLab/AlphaPulldown.git
      cd AlphaPulldown
      git submodule init
      git submodule update
      ```

  2. Create the Conda environment as described in [Create Anaconda environment](#1-create-anaconda-environment)
  3. Install AlphaPulldown package and add its submodules to the Conda environment (does not work if you want to update the dependencies)

      ```bash
      source activate AlphaPulldown
      cd AlphaPulldown
      pip install .
      pip install -e . --no-deps
      pip install -e ColabFold --no-deps
      pip install -e alphafold --no-deps
      ```

      You need to do it only once.

  4. When you want to develop, activate the environment, modify files, and the changes should be automatically recognized.
  5. Test your package during development using tests in `test/`, e.g.:

      ```bash
      pip install pytest
      pytest -s test/
      pytest -s test/test_predictions_slurm.py
      pytest -s test/test_features_with_templates.py::TestCreateIndividualFeaturesWithTemplates::test_1a_run_features_generation
      ```

  6. Before pushing to the remote or submitting a pull request:

      ```bash
      pip install .
      pytest -s test/
      ```
      to install the package and test. Pytest for predictions only works if SLURM is available. Check the created log files in your current directory.
  </details>

  <br>



  >[!Note]
  >If you work with proteins from model organisms you can directly download the features files from the [AlphaPulldown Features Database](#features-database) and skip this step.



  This is a general example of `create_individual_features.py` usage. For information on running specific tasks or parallel execution on a cluster, please refer to the corresponding sections of this chapter.



  At this step, you need to provide a [protein FASTA format](https://www.ncbi.nlm.nih.gov/WebSub/html/help/protein.html) file with all protein sequences that will be used for complex prediction.

  Example of a FASTA file (`sequences.fasta`):

  ```plaintext
  >proteinA
  SEQUENCEOFPROTEINA
  >proteinB
  SEQUENCEOFPROTEINB
  ```



  Activate the AlphaPulldown environment and run the script `create_individual_features.py` as follows:

  ```bash
  source activate AlphaPulldown
  create_individual_features.py \
    --fasta_paths=<sequences.fasta> \
    --data_dir=<path to alphafold databases> \
    --output_dir=<dir to save the output objects> \
    --max_template_date=<any date you want, format like: 2050-01-01> \
  ```

  * Instead of `<sequences.fasta>` provide a path to your input FASTA file. You can also provide multiple comma-separated files.<br>
  * Instead of `<path to alphafold databases>` provide a path to the genetic database (see [0. Alphafold-databases](#installation) of the installation part).<br>
  * Instead of `<dir to save the output objects>` provide a path to the output directory, where your features files will be saved.<br>
  * A date in the flag `--max_template_date` is needed to restrict the search of protein structures that are deposited before the indicated date. Unless the date is later than the date of your local genomic database's last update, the script will search for templates among all available structures.

  Features calculation script `create_individual_features.py` has several optional FLAGS:

  <details>
  <summary>
  Full list of arguments (FLAGS):
  </summary>

  * `--[no]save_msa_files`: By default is **False** to save storage stage but can be changed into **True**. If it is set to `True`, the program will create an individual folder for each protein. The output directory will look like:

     ```plaintext
     output_dir
          |- proteinA.pkl
          |- proteinA
                |- uniref90_hits.sto
                |- pdb_hits.sto
                |- etc.
          |- proteinB.pkl
          |- proteinB
                |- uniref90_hits.sto
                |- pdb_hits.sto
                |- etc.
     ```

     If `save_msa_files=False` then the `output_dir` will look like:

     ```plaintext
     output_dir
          |- proteinA.pkl
          |- proteinB.pkl
     ```

  * `--[no]use_precomputed_msas`: Default value is `False`. However, if you have already had MSA files for your proteins, please set the parameter to be True and arrange your MSA files in the format as below:

     ```plaintext
     example_directory
          |- proteinA
                |- uniref90_hits.sto
                |- pdb_hits.sto
                |- ***.a3m
                |- etc
          |- proteinB
                |- ***.sto
                |- etc
     ```

     Then, in the command line, set the `output_dir=/path/to/example_directory`.

  * `--[no]skip_existing`: Default is `False` but if you have run the 1st step already for some proteins and now add new proteins to the list, you can change `skip_existing` to `True` in the command line to avoid rerunning the same procedure for the previously calculated proteins.

  * `--seq_index`: Default is `None` and the program will run predictions one by one in the given files. However, you can set `seq_index` to a different number if you wish to run an array of jobs in parallel then the program will only run the corresponding job specified by the `seq_index`. e.g. the program only calculates features for the 1st protein in your FASTA file if `seq_index` is set to be 1. See also the Slurm sbatch script above for an example of how to use it for parallel execution. :exclamation: `seq_index` starts from 1.

  * `--[no]use_mmseqs2`: Use mmseqs2 remotely or not. Default is False.

  FLAGS related to TrueMultimer mode:

  * `--path_to_mmt`: Path to directory with multimeric template mmCIF files.

  * `--description_file`: Path to the text file with descriptions for generating features. **Please note**, the first column must be an exact copy of the protein description from your FASTA files. Please consider shortening them in FASTA files using your favorite text editor for convenience. These names will be used to generate pickle files with monomeric features!
  The description.csv for the NS1-P85B complex should look like:

  ```plaintext
  >sp|P03496|NS1_I34A1,3L4Q.cif,A
  >sp|P23726|P85B_BOVIN,3L4Q.cif,C
  ```

  In this example, we refer to the NS1 protein as chain A and to the P85B protein as chain C in multimeric template 3L4Q.cif.

  **Please note**, that your template will be renamed to a PDB code taken from *_entry_id*. If you use a *.pdb file instead of *.cif, AlphaPulldown will first try to parse the PDB code from the file. Then it will check if the filename is 4-letter long. If it is not, it will generate a random 4-letter code and use it as the PDB code.

  * `--threshold_clashes`: Threshold for VDW overlap to identify clashes. The VDW overlap between two atoms is defined as the sum of their VDW radii minus the distance between their centers. If the overlap exceeds this threshold, the two atoms are considered to be clashing. A positive threshold is how far the VDW surfaces are allowed to interpenetrate before considering the atoms to be clashing. (default: 1000, i.e. no threshold, for thresholding, use 0.6-0.9).

  * `--hb_allowance`: Additional allowance for hydrogen bonding (default: 0.4) used for identifying clashing residues to be removed from a multimeric template. An allowance > 0 reflects the observation that atoms sharing a hydrogen bond can come closer to each other than would be expected from their VDW radii. The allowance is only subtracted for pairs comprised of a donor (or donor-borne hydrogen) and an acceptor. This is equivalent to using smaller radii to characterize hydrogen-bonding interactions.

  * `--plddt_threshold`: Threshold for pLDDT score (default: 0) to be removed from a multimeric template (all residues with pLDDT>plddt_threshold are removed and modeled from scratch). Can be used only when multimeric templates are models generated by AlphaFold.

  * `--new_uniclust_dir`: Please use this if you want to overwrite the default path to the uniclust database.

  * `--[no]use_hhsearch`: Use hhsearch instead of hmmsearch when looking for structure template. Default is False.

  * `--[no]multiple_mmts`: Use multiple multimeric templates per chain. Default is False.
  </details>



  The result of `create_individual_features.py` run is pickle format features for each protein from the input FASTA file (e.g. `sequence_name_A.pkl` and `sequence_name_B.pkl`) stored in the `output_dir`.

  > [!NOTE]
  > The name of the pickles will be the same as the descriptions of the sequences in FASTA files (e.g. `>protein_A` in the FASTA file will yield `proteinA.pkl`). Note that special symbols such as `| : ; #`, after `>` will be replaced with `_`.



  Proceed to the next step [2.1 Basic Run](#21-basic-run).



  If you run AlphaPulldown on a computer cluster, you may want to execute feature creation in parallel. Here, we provide an example of code that is suitable for a cluster that utilizes SLURM Workload Manager.

  <details>
  <summary>For more details about the SLURM on the EMBL cluster, please refer to the [EMBL Cluster wiki](https://wiki.embl.de/cluster/Main_Page) using the EMBL network.</summary>



  For the following example, we will use [`example_2_sequences.fasta`](../example_data/example_2_sequences.fasta) as input.



  Create the `create_individual_features_SLURM.sh` script and place the following code in it using vi, nano, or any other text editor. Replace input parameters with the appropriate arguments for the `create_individual_features.py` script as described in [Basic run](#11-basic-run) or any other type of run you intend to execute:

  ```bash




















  module load HMMER/3.4-gompi-2023a
  module load HH-suite/3.3.0-gompi-2023a
  eval "$(conda shell.bash hook)"
  module load CUDA/11.8.0
  module load cuDNN/8.7.0.84-CUDA-11.8.0
  conda activate AlphaPulldown



  create_individual_features.py \
    --fasta_paths=example_1_sequences.fasta \
    --data_dir=/scratch/AlphaFold_DBs/2.3.2

  / \
    --output_dir=/scratch/mydir/test_AlphaPulldown/ \
    --max_template_date=2050-01-01 \
    --skip_existing=True \
    --seq_index=$SLURM_ARRAY_TASK_ID

  ```

  Make the script executable by running:

  ```bash
  chmod +x create_individual_features_SLURM.sh
  ```

  Next, execute the following commands, replacing `<sequences.fasta>` with the path to your input FASTA file:

  ```bash
  mkdir logs

  count=`grep ">" <sequences.fasta> | wc -l`

  sbatch --array=1-$count%100 create_individual_features_SLURM.sh
  ```
  <details>
  <summary>If you have several FASTA files, use the following commands:</summary>

  Example for two files (For more files, create `count3`, `count4`, etc., variables and add them to the sum of counts):
  ```bash
  mkdir logs

  count1=`grep ">" <sequences1.fasta> | wc -l`
  count2=`grep ">" <sequences2.fasta> | wc -l`
  count=$(( $count1 + $count2 ))

  sbatch --array=1-$count%100 create_individual_features_SLURM.sh
  ```
  </details>



  Proceed to the next step [2.2 Example run with SLURM (EMBL cluster)](#22-example-run-with-slurm-embl-cluster).

  </details>



  MMseqs2 is another method for homolog search and MSA generation. It offers an alternative to the default HMMER and HHblits used by AlphaFold. The results of these different approaches might lead to slightly different protein structure predictions due to variations in the captured evolutionary information within the MSAs. AlphaPulldown supports the implementation of MMseqs2 search made by [ColabFold](https://github.com/sokrypton/ColabFold), which also provides a web server for MSA generation, so no local installation of databases is needed.

  > **Cite:** If you use MMseqs2, please remember to cite:
  Mirdita M, Schütze K, Moriwaki Y, Heo L, Ovchinnikov S, Steinegger M. ColabFold: Making protein folding accessible to all. Nature Methods (2022) doi: 10.1038/s41592-022-01488-1

  <details>



  > **CAUTION:** To avoid overloading the remote server, do not submit a large number of jobs simultaneously. If you want to calculate MSAs for many sequences, please use [MMseqs2 locally](#run-mmseqs2-locally).

  To run `create_individual_features.py` using MMseqs2 remotely, add the `--use_mmseqs2=True` flag:

  ```bash
  source activate AlphaPulldown
  create_individual_features.py \
    --fasta_paths=<sequences.fasta> \
    --data_dir=<path to alphafold databases> \
    --output_dir=<dir to save the output objects> \
    --use_mmseqs2=True \
    --max_template_date=<any date you want, format like: 2050-01-01> \
  ```



  After the script run is finished, your `output_dir` will look like this:

  ```plaintext
  output_dir
     |-proteinA.a3m
     |-proteinA_env/
     |-proteinA.pkl
     |-proteinB.a3m
     |-proteinB_env/
     |-proteinB.pkl
     ...
  ```

  Proceed to the next step [2.1 Basic Run](#21-basic-run).



  AlphaPulldown does **NOT** provide an interface or code to run MMseqs2 locally, nor will it install MMseqs2 or any other required programs. The user must install MMseqs2, ColabFold databases, ColabFold search, and other required dependencies and run MSA alignments first. An example guide can be found on the [ColabFold GitHub](https://github.com/sokrypton/ColabFold).

  Suppose you have successfully run MMseqs2 locally using the `colab_search` program; it will generate an A3M file for each protein of your interest. Thus, your `output_dir` should look like this:

  ```plaintext
  output_dir
     |-0.a3m
     |-1.a3m
     |-2.a3m
     |-3.a3m
     ...
  ```

  These a3m files from `colabfold_search` are inconveniently named. Thus, we have provided a `rename_colab_search_a3m.py` script to help you rename all these files. Download the script from https://github.com/KosinskiLab/AlphaPulldown/blob/main/alphapulldown/scripts/rename_colab_search_a3m.py and run:

  ```bash
  cd output_dir
  python rename_colab_search_a3m.py path_to_fasta_file_you_used_as_input_for_colabfold_search
  ```

  Then your `output_dir` will become:

  ```plaintext
  output_dir
     |-proteinA.a3m
     |-proteinB.a3m
     |-proteinC.a3m
     |-proteinD.a3m
     ...
  ```

  Here, `proteinA`, `proteinB`, etc., correspond to the names in your input FASTA file (e.g., `>proteinA` will give you `proteinA.a3m`, `>proteinB` will give you `proteinB.a3m`, etc.).

  > **NOTE:** You can also provide your own custom MSA file in `.a3m` format instead of using the files created by MMSeq2 or standard HHMER. Place appropriately named files in the output directory and use the code as follows.

  After this, go back to your project directory with the original FASTA file and point to this directory in the command:

  ```bash
  source activate AlphaPulldown
  create_individual_features.py \
    --fasta_paths=<sequences.fasta> \
    --data_dir=<path to alphafold databases> \
    --output_dir=<output_dir> \
    --skip_existing=False \
    --use_mmseqs2=True \
    --seq_index=<any number you want or skip the flag to run all one after another>
  ```

  AlphaPulldown will automatically search each protein's corresponding a3m files. In the end, your `output_dir` will look like:

  ```plaintext
  output_dir
     |-proteinA.a3m
     |-proteinA.pkl
     |-proteinB.a3m
     |-proteinB.pkl
     |-proteinC.a3m
     |-proteinC.pkl
     ...
  ```



  Proceed to the next step [2.1 Basic Run](#21-basic-run).

  </details>



  Instead of using the default search through the PDB database for structural templates, you can provide a custom database. AlphaPulldown supports a feature called "True Multimer," which allows AlphaFold to use multi-chain structural templates during the prediction process. This can be beneficial for protein complexes where the arrangement of the chains may vary.

  <details>
  <summary>Details</summary>



  1. **Prepare a FASTA File:** Create a FASTA file containing all protein sequences that will be used for predictions as outlined in [1.1 Basic run](#11-basic-run).
  3. **Create a Template Directory:** Designate a folder (e.g., `templates`) to store your custom template files in PDB or CIF format.
  4. **Create a description file:** This `description.csv` file links protein sequences to templates:

  ```plaintext
  >proteinA,TMPL.cif,A
  >proteinB,TMPL.cif,B
  ```

  * **Column 1** (>proteinA): Must exactly match protein descriptions from your FASTA file, including the `>` symbol.
  * **Column 2** (TMPL.cif): The filename of your template structure in PDB or CIF format.
  * **Column 3** (A): The chain ID within the template that the query sequence corresponds to.

  The result pkl files will be stored as: `proteinA.TMPL.cif.A.pkl` and `proteinA.TMPL.cif.A.pkl`.

  **For Multiple Templates:** If you want to provide multiple templates for a single protein, add additional rows with the same protein name but different templates and chain IDs and **use flag --multiple_template=True**:

  ```plaintext
  >proteinA,TMPL.cif,A
  >proteinA,TMP2.cif,B
  >proteinB,TMPL.cif,B
  ```

  >**CAUTION:** Even though you can use multiple templates for a single chain, this feature is not fully supported in AlphaPulldown yet and might bring unexpected results.

  >**NOTE:** Your template will be renamed to a PDB code taken from *_entry_id*. If you use a *.pdb file instead of *.cif, AlphaPulldown will first try to parse the PDB code from the file. Then it will check if the filename is 4-letter long. If it is not, it will generate a random 4-letter code and use it as the PDB code.



  >**Tip:** If you have already generated feature files (`.pkl`) for protein sequences without custom templates or with the

   different templates, instead of generating them once again with the new template, you can go directly to the [prediction step](#24-run-with-custom-templates-truemultimer) and use `templates` and `description.csv` in combination with previously generated features. During the run, it will replace templates in the features `.pkl` file with the new one.

  Run the following script:

  ```bash
  create_individual_features.py \
    --fasta_paths=<sequences.fasta> \
    --path_to_mmt=<path to template directory> \
    --description_file=<description.csv> \
    --data_dir=<path to alphafold databases> \
    --output_dir=<dir to save the output objects> \
    --max_template_date=<any date you want, format like: 2050-01-01> \
    --save_msa_files=True \
    --use_precomputed_msas=True \
    --skip_existing=True
  ```

  Compared to [1.1. Basic run](#11-basic-run), this example differs in:

  * `--path_to_mmt=<path to template directory>`: Path to your `templates` directory with custom template files in PDB or CIF format.
  * `--description_file=<description.csv>`: Path to the description file.

  >**Warning!** Feature files generated with custom templates have the same names as standard feature files. To avoid overwriting existing feature files or skipping their generation if `--skip_existing=True`, please create a separate directory to save custom features.



  Pickle format features for each protein in the `description.csv` file stored in the `output_dir`.



  Go to the next step [2.4. Run with custom templates (TrueMultimer)](#24-run-with-custom-templates-truemultimer).

  </details>

  <br>





  This is a general example of `run_multimer_jobs.py` usage. For information on running specific tasks or parallel execution on a cluster, please refer to the corresponding sections of this chapter.



  This step requires the pickle files (.pkl) generated during the [first step](#1-compute-multiple-sequence-alignment-msa-and-template-features-cpu-stage). Additionally, you'll need to provide a list of protein combinations `protein_list.txt` you intend to predict.

  Here's how to structure your combinations file `protein_list.txt`. Protein names should correspond to the names of features files (`proteinA` for `proteinA.pkl`):

  **Prediction of monomers**:

  ```plaintext
  proteinA
  proteinB
  proteinC,1-100
  ```

  * Each line is a separate prediction.
  * Lines like `proteinA` will trigger a prediction of the entire sequence.
  * To predict specific residue ranges (e.g., the first 100 residues of proteinC), use the format "proteinC,1-100".

  **Prediction of complexes**:

  ```plaintext
  proteinA;proteinB;proteinC
  proteinB;proteinB
  proteinB,4
  proteinC,2;proteinA
  proteinA,4,1-100;proteinB
  ```

  * Use semicolons (`;`) to separate protein names within a complex.
  * Instead of repeating the protein name for homo-oligomers, specify the number of copies after the protein's name (e.g., `proteinB,4` for a tetramer).
  * Combine residue ranges and homooligomer notation for specific predictions (e.g., `proteinA,4,1-100;proteinB`).



  To predict structures, activate the AlphaPulldown environment and run the script `run_multimer_jobs.py` as follows:

  ```bash
  source activate AlphaPulldown
  run_multimer_jobs.py \
    --mode=custom \
    --monomer_objects_dir=<dir that stores feature pickle files> \
    --data_dir=<path to alphafold databases> I am running a few minutes late; my previous meeting is running over.
    --protein_lists=<protein_list.txt> \
    --output_path=<path to output directory> \
    --num_cycle=<any number e.g. 3> \
    --num_predictions_per_model=1
  ```

  Explanation of arguments:

  * Instead of `<dir that stores feature pickle files>` provide the path to the directory containing the `.pkl` feature files generated in the [first step](#11-basic-run). The path is the same as `--output_dir` for `create_individual_features.py`.
  * Instead of `<protein_list.txt>` provide the path to a text file containing a list of protein combinations to be modeled.
  * Instead of `<path to output directory>` provide a path where subdirectories containing the final structures will be saved.
  * Instead of `<path to alphafold databases>` provide a path to the genetic database (see [0. Alphafold-databases](#installation) of the installation part).
  * `--num_cycle`: specifies the number of times the AlphaFold neural network will run, using the output of one cycle as input for the next. Increasing this number may improve the quality of the final structures (especially for large complexes), but it will also increase the runtime.
  * `--num_predictions_per_model`: Specifies the number of predictions per model. The number of predicted structures is N\*5.  The default value is 1, which gives 5 structures.

  <details>
  <summary>
  Full list of arguments (FLAGS):
  </summary>

  * `--alphalink_weight`: Path to AlphaLink neural network weights
  * `--data_dir`: Path to params directory
  *  --[no]dry_run: Report number of jobs that would be run and exit without running them. Default is False.
  * `--job_index`: index of sequence in the FASTA file, starting from 1 (an integer)
  * `--mode`: <pulldown|all_vs_all|homo-oligomer|custom>: choose the mode of running multimer jobs (default: 'pulldown')
  * `--models_to_relax`: <None|All|Best>: Which models to relax. Default is None, meaning no model will be relaxed (default: 'None')
  * `--monomer_objects_dir`: a list of directories where monomer objects are stored (a comma-separated list)
  * `--oligomer_state_file`: path to oligomer state files
  * `--output_path`: output directory where the region data is going to be stored
  * `--protein_lists`: protein list files (a comma-separated list)
  * `--unifold_model_name`: <multimer_af2|multimer_ft|multimer|multimer_af2_v3|multimer_af2_model45_v3>: choose unifold model structure (default: 'multimer_af2')
  * `--unifold_param`: Path to UniFold neural network weights
  * `--[no]use_alphalink`: Whether AlphaLink models are going to be used. Default is False (default: 'false')
  * `--[no]use_unifold`: Whether UniFold models are going to be used. Default is False (default: 'false')

  alphapulldown.scripts.run_structure_prediction:

  * `--[no]benchmark`: Run multiple JAX model evaluations to obtain a timing that excludes the compilation time, which should be more indicative of the time required for inferencing many proteins (default: 'false')
  * `--[no]compress_result_pickles`: Whether the result pickles are going to be gzipped. Default is False (default: 'false')
  * `--crosslinks`: Path to crosslink information pickle for AlphaLink
  * `--data_directory`: Path to directory containing model weights and parameters
  * `--description_file`: Path to the text file with multimeric template instruction
  * `--desired_num_msa`: A desired number of msa to pad (an integer)
  * `--desired_num_res`: A desired number of residues to pad (an integer)
  * `--features_directory`: Path to computed monomer features; repeat this option to specify a list of values
  * `--fold_backend`: Folding backend that should be used for structure prediction (default: 'alphafold')
  * `-i,--input`: Folds in format [fasta_path:number:start-stop],; repeat this option to specify a list of values
  * `--model_names`: Names of models to use, e.g. model_2_multimer_v3 (default: all models)
  * `--model_preset`: <monomer|monomer_casp14|monomer_ptm|multimer>: Choose preset model configuration - the monomer model, the monomer model with extra ensembling, monomer model with pTM head, or multimer model (default: 'monomer')
  * `--msa_depth`: Number of sequences to use from the MSA (by default is taken from AF model config) (an integer)
  * `--[no]msa_depth_scan`: Run predictions for each model with logarithmically distributed MSA depth (default: 'false')
  * `--[no]multimeric_template`: Whether to use multimeric templates (default: 'false')
  * `--[no]no_pair_msa`: Do not pair the MSAs when constructing multimer objects (default: 'false')
  * `--num_cycle`: Number of recycles, defaults to 3 (default: '3') (an integer)
  * `--num_predictions_per_model`: Number of predictions per model, defaults to 1 (default: '1') (an integer)
  * `-o,--output_directory`: Path to output directory. Will be created if not exists
  * `--path_to_mmt`: Path to directory with multimeric template mmCIF files
  * `--protein_delimiter`: Delimiter for proteins of a single fold (default: '+')
  * `

  --random_seed`: The random seed for the data pipeline. By default, this is randomly generated. Note that even if this is set, Alphafold may still not be deterministic, because processes like GPU inference are nondeterministic (an integer)
  * `--[no]remove_result_pickles`: Whether the result pickles are going to be removed (default: 'true')
  * `--[no]skip_templates`: Do not use template features when modeling (default: 'false')
  * `--[no]use_ap_style`: Change output directory to include a description of the fold as seen in previous alphapulldown versions (default: 'false')
  * `--[no]use_gpu_relax`: Whether to run Amber relaxation on GPU. Default is True (default: 'true')

  </details>



  The `run_multimer_jobs.py` script generates a set of directories for each specified protein complex. The full structure of the output directories is the following:

  ```plaintext
  <complex_name>/
      <complex_name>_PAE_plot_ranked_{0,1,2,3,4}.png
      ranked_{0,1,2,3,4}.pdb
      ranked_{0,1,2,3,4}.cif
      ranked_{0,1,2,3,4}.zip
      ranking_debug.json
      result_model_{1,2,3,4,5}_*.pkl
      timings.json
      confidence_model_{1,2,3,4,5}.json
      pae_model_{1,2,3,4,5}_ptm_pred_0.json
      unrelaxed_model_{1,2,3,4,5}_*.pdb
  ```

  Please refer to the [AlphaFold manual](https://github.com/google-deepmind/alphafold) for more details on output files.

  **Key files**:

  * `ranked_{0,1,2,3,4}.cif`: Structure files ranked from best to worst predicted quality in modelcif format.
  * `<complex_name>_PAE_plot_ranked_{0,1,2,3,4}.png`: Plots of predicted aligned errors (PAE) providing a visual representation of the structure's confidence.

  > [!Caution]
  > AlphaPulldown is designed for screening, so its default output doesn't relax structures. To relax the top-ranked structure (`ranked_0.pdb`), you can run AlphaPulldown with the `--models_to_relax=Best` flag, or `--models_to_relax=All` to relax all models.



  Proceed to the next step [3. Analysis and Visualization](#3-analysis-and-visualization).

  The results of structure predictions can be very large. To copy the cropped output results for storage, use the `truncate_pickles.py` script by following the instructions provided [Decrease the size of AlphaPulldown output](#decrease-the-size-of-alphapulldown-output).

  Additionally, you can prepare the structures for deposition by creating `.cif` files containing all the necessary information about your predicted models. To do this, follow the instructions provided [Convert Models from PDB Format to ModelCIF Format](#convert-models-from-pdb-format-to-modelcif-format).



  If you run AlphaPulldown on a computer cluster, you may want to execute feature creation in parallel. Here, we provide an example of code that is suitable for a cluster that utilizes SLURM Workload Manager.

  <details>
  <summary>Details</summary>



  For this step, you need an example input file: [`custom_mode.txt`](../example_data/custom_mode.txt) and features (`.pkl`) files generated in the previous step [1.2. Example run with SLURM (EMBL cluster)](12-example-run-with-slurm-embl-cluster).



  Create the `run_multimer_jobs_SLURM.sh` script and place the following code in it using vi, nano, or any other text editor. Replace input parameters with the appropriate arguments for the `run_multimer_jobs.sh` script as described in  [Basic run](#2-predict-structures-gpu-stage) or any other type of run you intend to execute:

  ```bash



























  module load Anaconda3
  module load CUDA/11.8.0
  module load cuDNN/8.7.0.84-CUDA-11.8.0
  source activate AlphaPulldown

  MAXRAM=$(echo `ulimit -m` '/ 1024.0'|bc)
  GPUMEM=`nvidia-smi --query-gpu=memory.total --format=csv,noheader,nounits|tail -1`
  export XLA_PYTHON_CLIENT_MEM_FRACTION=`echo "scale=3;$MAXRAM / $GPUMEM"|bc`
  export TF_FORCE_UNIFIED_MEMORY='1'



  run_multimer_jobs.py \
    --mode=custom \
    --monomer_objects_dir=<dir that stores feature pickle files> \
    --protein_lists=<protein_list.txt> \
    --output_path=<path to output directory> \
    --num_cycle=<any number e.g. 3> \
    --data_dir=/scratch/AlphaFold_DBs/2.3.2/ \
    --num_predictions_per_model=1 \
    --job_index=$SLURM_ARRAY_TASK_ID

  ```

  Make the script executable by running:

  ```bash
  chmod +x run_multimer_jobs_SLURM.sh
  ```

  Next, for `custom` mode, execute the following commands, replacing `<protein_list.txt>` with the path to your protein combinations file:

  ```bash
  mkdir -p logs

  count=`grep -c "" <protein_list.txt>` #count lines even if the last one has no end of line
  sbatch --array=1-$count example_data/run_multimer_jobs_SLURM.sh
  ```

  For [`pulldown` mode](#23-pulldown-mode) for two files (for more files, create `count3`, `count4`, etc. variables and add them as a multiplier to the product):

  ```bash
  mkdir -p logs

  count1=`grep -c "" <protein_list1.txt>` #count lines even if the last one has no end of line
  count2=`grep -c "" <protein_list2.txt>` #count lines even if the last one has no end of line
  count=$(( $count1 * $count2 ))
  sbatch --array=1-$count example_data/run_multimer_jobs_SLURM.sh
  ```

  For [`all_vs_all` mode](#23-all-versus-all-mode):

  ```bash
  mkdir -p logs

  count1=`grep -c "" <protein_list.txt>` #count lines even if the last one has no end of line
  count=$(( $count1 * ( $count1 + 1) / 2 ))
  sbatch --array=1-$count example_data/run_multimer_jobs_SLURM.sh
  ```



  The [output](#output-3) and [next step](#next-step-4) are the same as those for the [2.1. Basic Run](#21-basic-run).

  </details>



  Instead of manually typing all combinations of proteins, AlphaPulldown provides two different modes of automatic generation of such combinations.
  <details>
  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="./manuals/AP_modes_dark.png">
    <source media="(prefers-color-scheme: light)" srcset="./manuals/AP_modes.png">
    <img alt="Shows an illustrated sun in light mode and a moon with stars in dark mode." src="./manuals/AP_modes.png">
  </picture>



  This mode allows providing two or more lists of proteins that will generate all combinations of proteins from one list with all proteins from another list. If you want to emulate _in silico_ pulldown of some hypothetical proteinA bait against proteins B-G you can use two `protein_list.txt` files:

  The first `protein_list1.txt`:

  ```plaintext
  proteinA
  ```

  The second `protein_list2.txt`:

  ```plaintext
  proteinB
  proteinC
  proteinD
  proteinE
  proteinF
  proteinG
  ```

  This results in the following combinations of proteins: A-B, A-C, A-D, A-E, A-F, A-G.

  You can add a third `protein_list3.txt`:

  ```plaintext
  proteinX


  proteinZ
  ```

  The resulting models will contain proteins A-B-X, A-B-Z, A-C-X, A-C-Z...

  In fact, you can provide as many files as you wish, the number of combinations you will receive is the product of numbers of lines in the input files.

  Lines in the files do not necessarily have to be single proteins. Input files follow the same rules as described for [2.1 Basic run](#21-basic-run). It can contain several protein names, indicate a number of oligomers, and have residue ranges.

  To run `run_multimer_jobs.py` in `pulldown` mode, use the following script:

  ```bash
  run_multimer_jobs.py \
    --mode=pulldown \
    --monomer_objects_dir=<dir that stores feature pickle files> \
    --protein_lists=<protein_list1.txt>,<protein_list2.txt> \
    --output_path=<path to output directory> \
    --data_dir=<path to AlphaFold data directory> \
    --num_cycle=<any number e.g. 3>
  ```

  Compared to [2.1 Basic run](#21-basic-run), this example differs in:

  * `--mode=pulldown` flag that defines the mode of the run.
  * Instead of `<protein_list1.txt>,<protein_list2.txt>`, provide the paths to the files containing the list of protein combinations to be modeled.

  </details>



  In this mode, AlphaPulldown takes lines from the input `protein_list.txt` file and generates all possible combinations of these lines.
  It is useful when you have a set of proteins, and you want to find out which interact with which.
  <details>
  If you provide the list of proteins:

  ```plaintext
  proteinA
  proteinB
  proteinC
  proteinD
  proteinE
  ```

  The resulting models will be all possible combinations of proteins A-A, A-B, A-C, A-D, A-E, B-B, B-C, B-D, B-E, C-C, C-D...

  >[!Caution]
  > The number of predictions rapidly increases with the number of lines in the input `protein_list.txt`.

  Lines in files should not necessarily be single proteins. Input files follow the same rules as described for [2.1 Basic run](#21-basic-run). It can contain several protein names, indicate a number of oligomers, and have residue ranges.

  To run `run_multimer_jobs.py` in `all_vs_all` mode, use the following script:

  ```bash
  run_multimer_jobs.py \
    --mode=all_vs_all \
    --monomer_objects_dir=<dir that stores feature pickle files> \
    --protein_lists=<protein_list.txt> \
    --output_path=<path to output directory> \
    --data_dir=<path to AlphaFold data directory> \
    --num_cycle=<any number e.g. 3>
  ```

  Compared to [2.1 Basic run](#21-basic-run), this example differs in:

  * `--mode=all_vs_all` flag that defines the mode of the run.



  The [output](#output-3) and [next step](#next-step-4) are the same as those for the [2.1. Basic Run](#21-basic-run).

  </details>



  If you have some experimental models you want to integrate into AlphaFold pipeline to guide the modeling, you can do so using custom multimeric databases created on the fly.

  <details>



  This step requires the feature files (`.pkl`) generated with custom templates during the [first step](#14-run-with-custom-templates-truemultimer). Additionally, you'll need to provide a list of protein combinations in `protein_list.txt` that you intend to predict.

  Alternatively, if you haven't generated feature files with a custom template but have feature files from the [1.1. Basic Run](#11-basic-run) or features with different templates, you can provide those feature files in combination with the `templates` directory containing custom templates and `description.csv` as outlined in [1.4. Run with Custom Templates (TrueMultimer)](#14-run-with-custom-templates-truemultimer).



  Run the script `create_individual_features.py` as described in the [2.1. Basic Run](#21-basic-run) but with the flag `--multimeric_mode=True`.

  > [!NOTE]
  > To increase the impact of the custom templates on the final prediction (making the model more similar to the template), you can decrease the influence of the MSA by specifying the MSA depth with the `--msa_depth=<number>` flag.

  Alternatively, run the script `create_individual_features.py` with features, new templates, and a description file by adding the following flags:

  * `--path_to_mmt=<path to template directory>`: Path to your templates directory with custom template files in PDB or CIF format. Same as for [1.4. Run with Custom Templates (TrueMultimer)](#14-run-with-custom-templates-truemultimer)
  * `--description_file=<description.csv>`: Path to the description file. Same as for [1.4. Run with Custom Templates (TrueMultimer)](#14-run-with-custom-templates-truemultimer)
  * `--multimeric_mode=True`



  The [output](#output-3) and [next step](#next-step-4) are the same as those for the [2.1. Basic Run](#21-basic-run).

  </details>



  As [Stahl et al., 2023](https://www.nature.com/articles/s41587-023-01704-z) showed, integrating cross-link data with AlphaFold could improve the modelling quality in some challenging cases. Thus, AlphaPulldown has integrated the [AlphaLink2](https://github.com/Rappsilber-Laboratory/AlphaLink2/tree/main) pipeline, allowing users to combine cross-link data with AlphaFold Multimer inference without needing to calculate MSAs from scratch again.

  > **Cite:** If you use AlphaLink2, please remember to cite:
  > Stahl, K., Demann, L., Bremenkamp, R., Warneke, R., Hormes, B., Stülke, J., Brock, O., Rappsilber, J., Der, S.-M. ", & Mensch, S. (2024). Modelling protein complexes with crosslinking mass spectrometry and deep learning. BioRxiv, 2023.06.07.544059. https://doi.org/10.1101/2023.06.07.544059

  Before using, install AlphaLink2 as described [here](#4-installation-for-cross-link-input-data-by-alphalink2-optional).

  <details>



  Besides features (`.pkl`) files generated in the [1.1. Basic Run](#11-basic-run) you need to prepare cross-link input data:

  As instructed by [AlphaLink2](https://github.com/Rappsilber-Laboratory/AlphaLink2/tree/main), information of cross-linked residues between 2 proteins, inter-protein crosslinks A->B 1,50 and 30,80 and an FDR=20%, should look like:

  ```plaintext
  {'proteinA': {'proteinB': [(1, 50, 0.2), (30, 80, 0.2)]}}
  ```

  and intra-protein crosslinks follow the same format:

  ```plaintext
  {'proteinA': {'proteinA': [(5, 20, 0.2)]}}
  ```

  The keys in these dictionaries should be the same as your pickle files created in the [first step of AlphaPulldown](#11-basic-run). For example, you should have `proteinA.pkl` and `proteinB.pkl` already calculated.

  Dictionaries like these should be stored in **```.pkl.gz```** files and provided to AlphaPulldown in the next step. You can use the script from [AlphaLink2](https://github.com/Rappsilber-Laboratory/AlphaLink2/tree/main) to prepare these pickle files.

  >**Warning!** The dictionaries are 0-indexed, i.e., residues start from 0.



  Within the same conda environment, run in e.g. `custom` mode:

  ```bash
  run_multimer_jobs.py --mode=custom \
  --num_predictions_per_model=1 \
  --output_path=/scratch/scratch/user/output/models \
  --data_dir=/g/alphafold/AlphaFold_DBs/2.3.0/ \
  --protein_lists=custom.txt \
  --monomer_objects_dir=/scratch/user/output/features \
  --job_index=$SLURM_ARRAY_TASK_ID --alphalink_weight=/scratch/user/alphalink_weights/AlphaLink-Multimer_SDA_v3.pt \
  --use_alphalink=True --crosslinks=/path/to/crosslinks.pkl.gz
  ```

  The other modes provided by AlphaPulldown also work in the same way.



  The [output](#output-3) and [next step](#next-step-4) are the same as those for the [2.1. Basic Run](#21-basic-run).

  </details>



  The resulting predictions from the [step 2](#2-predict-structures-gpu-stage) can be used directly as they are. However, for evaluation systematization and ranking of the prediction, you can use an interactive [Jupyter Notebook](https://jupyter.org/) and/or table with models scores.



  Go to the model's output directory from the [step 2](#2-predict-structures-gpu-stage).

  ```bash
  cd <models_output_dir>
  ```

  And run the script in the activated conda environment:

  ```bash
  source activate AlphaPulldown
  create_notebook.py --cutoff=5.0 --output_dir=<models_output_dir>
  ```

  * `--cutoff`:
    check the value of PAE between chains. In the case of multimers, the analysis program will create the notebook only from models with inter-chain PAE values smaller than the cutoff. Increase this parameter if you miss predictions in your notebook (e.g., 50).
  * `--output_dir`:
    Directory where predicted models are stored in this, `.` in this example.
  * `--pae_figsize`:
     Figsize of pae_plot, default is 50.

  This command will generate an `output.ipynb`, which you can open using JupyterLab. JupyterLab is installed with AlphaPulldown. To view the notebook, launch it with:

  ```bash
  jupyter-lab output.ipynb
  ```



  For usage of the Jupyter Notebook, refer to the [Downstream analysis](#downstream-analysis) section of this manual.



  Making a CSV table with structural properties and scores requires the download of the singularity image `fold_analysis.sif`. Please refer to the installation [instruction](#03-installation-for-the-downstream-analysis-tools).

  To execute the singularity image (i.e. the sif file) run:

  ```bash
  singularity exec \
      --no-home \
      --bind </path/to/output/dir/with/predictions>:/mnt \
      <path to your downloaded image>/fold_analysis.sif \
      run_get_good_pae.sh \
      --output_dir=/mnt \
      --cutoff=10
  ```

  `cutoff` is to check the value of PAE between chains. In the case of multimers, the analysis program will create the notebook only from models with inter-chain PAE values smaller than the cutoff. If you do not want to filter out the models use very high cutoff e.g. `--cutoff=100`.



  For usage of the Results table, refer to the [Downstream analysis](#downstream-analysis) section of this manual.

  <br>





  Jupyter notebook `output.ipynb` is

  * Generated during the [Create Jupyter Notebook](#create-jupyter-notebook) for [**Scripts-Based Alphapulldown**](#scripts-based-alphapulldown).
  * Stored in the `output/reports` directory for [**Snakemake AlphaPulldown**](#snakemake-alphapulldown). **Snakemake AlphaPulldown** also generates a notebook with all cells executed in the `report.html` file, which can be copied locally and opened in a browser without JupyterLab.

  You can `output.ipynb` open using JupyterLab. JupyterLab is installed with AlphaPulldown. To view the notebook, launch it with:

  ```bash
  jupyter-lab output.ipynb
  ```

  >[!Note]
  >If you run AlphaPulldown on a remote computer cluster, you will need a graphical connection, network mount of the remote directory, or a copy of the entire `<models_output_dir>` to open the notebook in a browser.

  <details>
  <summary><b>Jupyter Notebook remote access</b></summary>

  To connect remotely, first launch Jupyter Notebook on the cluster. You can choose a different port number if the selected one is already in use:

  ```bash
  jupyter-lab --no-browser --port=8895 output.ipynb
  ```

  The output of this command will provide you with a link and a token for connection. The token is a unique string that is required for authentication when you first access the Jupyter Notebook interface. Here is an example of what the output might look like:

  ```
  http://localhost:8895/?token=abc123def456
  ```

  Next, establish an SSH tunnel using your local machine's command line. The port numbers should match those used in the previous command. Replace <login> with your EMBL login, or if you are using a different cluster, provide the address of that cluster and your login in the format `<login>@<address>`:

  ```bash
  ssh -N -f -L localhost:8895:localhost:8895 <login>@login01.cluster.embl.de
  ```

  After establishing the SSH tunnel, you can access the Jupyter Notebook in your web browser. Open your browser and navigate to the following URL:

  ```
  http://localhost:8895
  ```

  You will be prompted to enter the token provided earlier when you launched Jupyter Lab on the cluster. Copy and paste the token from the command output into the browser prompt to gain access.

  </details>

  In the JupyterLab window, choose output.ipynb if it does not open automatically. Then, go to **Run** > **Run All Cells**. After all cells have been executed for every protein complex, you will see PAE plots, interactive structures colored by pLDDT, and interactive structures colored by a chain.

  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="./manuals/Jupyter_results_dark.png">
    <source media="(prefers-color-scheme: light)" srcset="./manuals/Jupyter_results.png">
    <img alt="Shows an illustrated sun in light mode and a moon with stars in dark mode." src="./manuals/Jupyter_results.png">
  </picture>

  <br>

  To zoom in on PAE plots, double-click on them. To increase the number of displayed interactive models, add the argument `models` to the `parse_results()` or `parse_results_colour_chains()` functions.

  ```python
  parse_results('./ProteinA_and_ProteinB', models=10)
  ```

  > [!WARNING]
  > If the Jupyter Notebook contains too many proteins, some interactive structures may disappear due to memory limitations. To restore the output of the cell, simply rerun it by selecting the cell and going to **Run** > **Run Selected Cell** or pressing **Shift + Enter**.



  Results table:

  * `predictions_with_good_interpae.csv` is generated during the [Create Results table](#create-results-table) for [**Scripts-Based Alphapulldown**](#scripts-based-alphapulldown).
  * `analysis.csv` generated in the `output/reports` for [**Snakemake AlphaPulldown**](#snakemake-alphapulldown)

  $\text{\color{red}Change description, add explain scores}$

  By default, you will have a CSV file named `predictions_with_good_interpae.txt` created in the directory `/path/to/your/output/dir` as you have given in the command above. `predictions_with_good_interpae.txt` reports: 1. iptm, iptm+ptm scores provided by AlphaFold 2. mpDockQ score developed by [Bryant _et al._, 2022](https://gitlab.com/patrickbryant1/molpc)  3. PI_score developed by [Malhotra _et al._, 2021](https://gitlab.com/sm2185/ppi_scoring/-/wikis/home). The detailed explanations of these scores can be found in our paper and an example screenshot of the table is below. ![example](./manuals/example_table_screenshot.png)



  AlphaPulldown provides scripts to help optimize data storage and prepare structures for deposition.



  The most space-consuming part of the [structure prediction results](#2-predict-structures-gpu-stage) are pickle files `result_model_{1,2,3,4,5}_*.pkl files`. Please refer to the [AlphaFold manual](https://github.com/google-deepmind/alphafold) for more details on output files. Some information in these files is needed only for very special tasks. The `truncate_pickles.py` script copies the output of AlphaPulldown to a new directory and deletes the specified information from the pickle files. It may decrease the size of the output up to 100 times.

  ```bash
  source activate AlphaPulldown
  truncate_pickles.py \
    --src_dir=</path/to/source> \
    --dst_dir=</path/to/destination> \
    --keys_to_exclude=aligned_confidence_probs,distogram,masked_msa \
    --number_of_threads=4
  ```

  * `--src_dir=</path/to/source>`: Replace `</path/to/source>` with the path to the structures output directory. This should be the same as the `--output_path` for the `run_multimer_jobs.py` script from the [Predict Structures](#2-predict-structures-gpu-stage) step.
  * `--dst_dir=</path/to/destination>`: Replace `</path/to/destination>` with the path of the directory to copy the truncated results to.
  * `--keys_to_exclude=aligned_confidence_probs,distogram,masked_msa`: A comma-separated list of keys that should be excluded from the copied pickle files. The default keys are "aligned_confidence_probs,distogram,masked_msa".
  * `--number_of_threads=4`: Number of threads to run in parallel.



  With PDB files now being marked

   as a legacy format, here is a way to convert PDB files produced by the [AlphaPulldown](https://github.com/KosinskiLab/AlphaPulldown) pipeline into [mmCIF](https://mmcif.wwpdb.org) files, including the [ModelCIF](https://mmcif.wwpdb.org/dictionaries/mmcif_ma.dic/Index/) extension.

  In addition to the general mmCIF tables, ModelCIF adds information relevant for a modeling experiment. This includes target-sequence annotation and a modeling protocol, describing the process by which a model was created, including software used with its parameters. To help users assess the reliability of a model, various quality metrics can be stored directly in a ModelCIF file or in associated files registered in the main file. ModelCIF is also the preferred format for [ModelArchive](https://www.modelarchive.org).

  As AlphaPulldown relies on [AlphaFold](https://github.com/google-deepmind/alphafold) to produce model coordinates, multiple models may be predicted in a single experiment. To accommodate different needs, `convert_to_modelcif.py` offers three major modes:

  * Convert all models into ModelCIF in separate files.
  * Only convert a specific single model.
  * Convert a specific model to ModelCIF but keep additional models in a Zip archive associated with the representative ModelCIF formatted model.



  The most general call of the conversion script, without any non-mandatory arguments, will create a ModelCIF file and an associated Zip archive for each model of each complex found in the `--ap_output` directory:

  ```bash
  source activate AlphaPulldown
  convert_to_modelcif.py \
    --ap_output <output path of run_multimer_jobs.py>
  ```

  * `--ap_output`: Path to the structures directory. This should be the same as the `--output_path` for the `run_multimer_jobs.py` script from the [Predict Structures](#2-predict-structures-gpu-stage) step.

  The output is stored in the path that `--ap_output` points to. After running `convert_to_modelcif.py`, you should find a ModelCIF file and a Zip archive for each model PDB file in the AlphaPulldown output directory:

  <details>
  <summary>Output</summary>

  ```plaintext
  ap_output
      protein1_and_protein2
          |-ranked_0.cif
          |-ranked_0.pdb
          |-ranked_0.zip
          |-ranked_1.cif
          |-ranked_1.pdb
          |-ranked_1.zip
          |-ranked_2.cif
          |-ranked_2.pdb
          |-ranked_2.zip
          |-ranked_3.cif
          |-ranked_3.pdb
          |-ranked_3.zip
          |-ranked_4.cif
          |-ranked_4.pdb
          |-ranked_4.zip
          ...
      ...
  ```

  </details>



  If only a single model should be translated to ModelCIF, use the `--model_selected` option. Provide the ranking of the model as the value. For example, to convert the model ranked 0:

  ```bash
  source activate AlphaPulldown
  convert_to_modelcif.py \
    --ap_output <output path of run_multimer_jobs.py> \
    --model_selected 0
  ```

  This will create only one ModelCIF file and Zip archive in the path pointed at by `--ap_output`:

  <details>
  <summary>Output</summary>

  ```plaintext
  ap_output
      protein1_and_protein2
          |-ranked_0.cif
          |-ranked_0.pdb
          |-ranked_0.zip
          |-ranked_1.pdb
          |-ranked_2.pdb
          |-ranked_3.pdb
          |-ranked_4.pdb
          ...
      ...
  ```

  </details>

  Besides `--model_selected`, the arguments are the same as for scenario 1.



  Sometimes you want to focus on a certain model from the AlphaPulldown pipeline but don't want to completely discard the other models generated. For this, `convert_to_modelcif.py` can translate all models to ModelCIF but store the excess in the Zip archive of the selected model. This is achieved by adding the option `--add_associated` together with `--model_selected`.

  ```bash
  source activate AlphaPulldown
  convert_to_modelcif.py \
    --ap_output <output path of run_multimer_jobs.py> \
    --model_selected 0 \
    --add-associated
  ```

  Arguments are the same as in scenarios 1 and 2 but include `--add_associated`.

  The output directory looks similar to when only converting a single model:

  <details>
  <summary>Output</summary>

  ```plaintext
  ap_output
      protein1_and_protein2
          |-ranked_0.cif
          |-ranked_0.pdb
          |-ranked_0.zip
          |-ranked_1.pdb
          |-ranked_2.pdb
          |-ranked_3.pdb
          |-ranked_4.pdb
          ...
      ...
  ```

  </details>

  But a peek into `ranked_0.zip` shows that it stored ModelCIF files and Zip archives for all remaining models of this modeling experiment:

  <details>
  <summary>Output</summary>

  ```plaintext
  ranked_0.zip
      |-ranked_0_local_pairwise_qa.cif
      |-ranked_1.cif
      |-ranked_1.zip
      |-ranked_2.cif
      |-ranked_2.zip
      |-ranked_3.cif
      |-ranked_3.zip
      |-ranked_4.cif
      |-ranked_4.zip
  ```

  </details>



  `convert_to_modelcif.py` produces two kinds of output: ModelCIF files and Zip archives for each model. The latter are called "associated files/archives" in ModelCIF terminology. Associated files are registered in their corresponding ModelCIF file by categories [`ma_entry_associated_files`](https://mmcif.wwpdb.org/dictionaries/mmcif_ma.dic/Categories/ma_entry_associated_files.html) and [`ma_associated_archive_file_details`](https://mmcif.wwpdb.org/dictionaries/mmcif_ma.dic/Categories/ma_associated_archive_file_details.html). Historically, this scheme was created to offload AlphaFold's pairwise alignment error lists, which drastically increase file size. Nowadays, the Zip archives are used for all kinds of supplementary information on models, not handled by ModelCIF.



  At this time, there is only one option left unexplained: `--compress`. It tells the script to compress ModelCIF files using Gzip. In the case of `--add_associated`, the ModelCIF files in the associated Zip archive are also compressed.

  <br>



  Instead of generating feature files locally, you can download them from the **AlphaPulldown Features Database**, which contains precomputed protein **features for major model organisms**.



  >[!NOTE]
  >For EMBL cluster users:
  >You can access the directory with generated features files at
  >`/g/alphafold/input_features/`

  To access the Features Database, you need to install the [MinIO Client](https://min.io/docs/minio/linux/reference/minio-mc.html) (`mc`).



  1. [Download](https://min.io/docs/minio/linux/reference/minio-mc.html#install-mc) the `mc` binary.
  2. Make the binary executable.
  3. Move it to your `PATH` for system-wide access.

  Example for AMD64 architecture:

  ```bash
  curl -O https://dl.min.io/client/mc/release/linux-amd64/mc
  chmod +x mc
  sudo mv mc /usr/local/bin/
  ```



  To ensure `mc` is correctly installed, you can run:

  ```bash
  mc --help
  ```



  Set up an alias for easy access to the AlphaPulldown Features Database hosted at EMBL:

  ```bash
  mc alias set embl https://s3.embl.de "" "" --api S3v4
  ```

  This alias allows you to interact with the Features Database as if it were a local directory.



  Once `mc` is installed and configured, you can start accessing the Features Database. The `mc` commands mimic standard bash commands.



  To view the list of available organisms with precomputed feature files, run:

  ```bash
  mc ls embl/alphapulldown/input_features
  ```

  Each organism directory contains compressed `.pkl.xz` feature files, named according to their **UniProt ID**.



  For example, to download the feature file for the protein with UniProt ID Q6BF25 from *Escherichia coli*, use:

  ```bash
  mc cp embl/alphapulldown/input_features/Escherichia_coli/Q6BF25.pkl.xz Q6BF25.pkl.xz
  ```



  To download all feature files for proteins from a specific organism, such as *E. coli*, copy the entire directory:

  ```bash
  mc cp --recursive embl/alphapulldown/input_features/Escherichia_coli/ ./Escherichia_coli/
  ```

  Alternatively, you can mirror the contents of the organism’s directory, ensuring all files are synced between the source and your local directory:

  ```bash
  mc mirror embl/alphapulldown/input_features/Escherichia_coli/ Escherichia_coli/
  ```

  This command mirrors the remote directory to your local system, keeping both locations in sync.


pkgId: afc7b0f581b161511e971f84112df15996c8699a1b8bdfdd714531c0fcf463b0
name: python-alphapy
arch: src
version: 2.5.0
epoch: 0
release: 1
summary: AlphaPy: A Machine Learning Pipeline for Speculators
url: https://github.com/ScottFreeLLC/AlphaPy
rpm_license: Apache License, Version 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alphapy-2.5.0-1.src.rpm
checksum_type: sha256
description:
  alphapy is a Python library for machine learning using scikit-learn. We have a stock market pipeline and a sports pipeline so that speculators can test predictive models, along with functions for trading systems and portfolio management.


pkgId: 74f18198c793d739b9d4e341b57ac9d4790b95de54458752c431e67f898a5eef
name: python-alphashape
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: Toolbox for generating alpha shapes.
url: https://github.com/bellockk/alphashape
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alphashape-1.3.1-1.src.rpm
checksum_type: sha256
description:
  [![Travis](https://api.travis-ci.org/bellockk/alphashape.svg?branch=master)](https://travis-ci.org/bellockk/alphashape/)
  [![Documentation Status](https://readthedocs.org/projects/alphashape/badge/?version=latest)](http://alphashape.readthedocs.io/?badge=latest)
  [![CodeCov](https://codecov.io/gh/bellockk/alphashape/branch/master/graph/badge.svg)](https://codecov.io/gh/bellockk/alphashape)
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/bellockk/alphashape/master)
  [![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](https://lbesson.mit-license.org/)
  [![DOI](https://zenodo.org/badge/183085167.svg)](https://zenodo.org/badge/latestdoi/183085167)


  [![PyPI version](https://img.shields.io/pypi/v/alphashape.svg)](https://pypi.python.org/pypi/alphashape/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/alphashape.svg)](https://pypi.python.org/pypi/alphashape/)
  [![PyPI downloads](https://img.shields.io/pypi/dm/alphashape)](https://pypi.python.org/pypi/alphashape/)


  [![Anaconda version](https://anaconda.org/conda-forge/alphashape/badges/version.svg)](https://anaconda.org/conda-forge/alphashape)
  [![Anaconda downloads](https://anaconda.org/conda-forge/alphashape/badges/downloads.svg)](https://anaconda.org/conda-forge/alphashape)
  [![Anaconda platforms](https://anaconda.org/conda-forge/alphashape/badges/platforms.svg)](https://anaconda.org/conda-forge/alphashape)
  [![Anaconda lastupdated](https://anaconda.org/conda-forge/alphashape/badges/latest_release_date.svg)](https://anaconda.org/conda-forge/alphashape)

  Toolbox for generating n-dimensional alpha shapes.

  Alpha shapes are often used to generalize bounding polygons containing sets of points.  The alpha parameter is defined as the value `a`, such that an edge of a  disk of radius 1/`a` can be drawn between any two edge members of a set of points and still contain all the points. The convex hull, a shape resembling what you would see if you wrapped a rubber band around pegs at all the data points, is an alpha shape where the alpha parameter is equal to zero.  In this toolbox we will be generating alpha complexes, which are closely related to alpha shapes, but which consist of straight lines between the edge points instead of arcs of circles.

  https://en.wikipedia.org/wiki/Alpha_shape

  https://en.wikipedia.org/wiki/Convex_hull

  Creating alpha shapes around sets of points usually requires a visually interactive step where the alpha parameter for a concave hull is determined by iterating over or bisecting values to approach a best fit.  The alpha shape toolbox provides workflows to shorten the development loop on this manual process, or to bypass it completely by solving for an alpha shape with particular characteristics.  A python API is provided to aid in the scripted generation of alpha shapes.  A console application is also provided as an example usage of the alpha shape toolbox, and to facilitate generation of alpha shapes from the command line.

  * Free software: MIT license
  * Documentation: https://alphashape.readthedocs.io.






  ```python
  import os
  import sys
  import pandas as pd
  import numpy as np
  from descartes import PolygonPatch
  import matplotlib.pyplot as plt
  sys.path.insert(0, os.path.dirname(os.getcwd()))
  import alphashape
  ```





  ```python
  points_2d = [(0., 0.), (0., 1.), (1., 1.), (1., 0.),
            (0.5, 0.25), (0.5, 0.75), (0.25, 0.5), (0.75, 0.5)]
  ```




  ```python
  fig, ax = plt.subplots()
  ax.scatter(*zip(*points_2d))
  plt.show()
  ```


  ![png](https://raw.github.com/bellockk/alphashape/master/media/output_5_0.png)



  Every convex hull is an alpha shape, but not every alpha shape is a convex hull.  When the `alphashape` function is called with an alpha parameter of 0, a convex hull will always be returned.



  You can visualize the shape within Jupyter notebooks using the built-in shapely renderer as shown below.

  ```python
  alpha_shape = alphashape.alphashape(points_2d, 0.)
  alpha_shape
  ```


  ![png](https://raw.github.com/bellockk/alphashape/master/media/output_9_0.png)





  ```python
  fig, ax = plt.subplots()
  ax.scatter(*zip(*points_2d))
  ax.add_patch(PolygonPatch(alpha_shape, alpha=0.2))
  plt.show()
  ```


  ![png](https://raw.github.com/bellockk/alphashape/master/media/output_10_0.png)



  As we increase the alpha parameter value, the bounding shape will begin to fit the sample data with a more tightly fitting bounding box.




  ```python
  alpha_shape = alphashape.alphashape(points_2d, 2.0)
  alpha_shape
  ```

  ![png](https://raw.github.com/bellockk/alphashape/master/media/output_14_1.png)





  ```python
  fig, ax = plt.subplots()
  ax.scatter(*zip(*points_2d))
  ax.add_patch(PolygonPatch(alpha_shape, alpha=0.2))
  plt.show()
  ```


  ![png](https://raw.github.com/bellockk/alphashape/master/media/output_15_0.png)



  If you go too high on the alpha parameter, you will start to lose points from the original data set.




  ```python
  alpha_shape = alphashape.alphashape(points_2d, 3.5)
  alpha_shape
  ```


  ![png](https://raw.github.com/bellockk/alphashape/master/media/output_19_0.png)




  ```python
  fig, ax = plt.subplots()
  ax.scatter(*zip(*points_2d))
  ax.add_patch(PolygonPatch(alpha_shape, alpha=0.2))
  plt.show()
  ```


  ![png](https://raw.github.com/bellockk/alphashape/master/media/output_20_0.png)



  If you go too far, you will lose everything.


  ```python
  alpha_shape = alphashape.alphashape(points_2d, 5.0)
  print(alpha_shape)
  ```

      GEOMETRYCOLLECTION EMPTY


  The alpha parameter can be defined locally within a region of points by supplying a callback that will return what alpha parameter to use.  This can be utilized to create tighter fitting alpha shapes where point densitities are different in different regions of a data set.  In the following example, the alpha parameter is changed based off of the value of the x-coordinate of the points.

  ```python
  alpha_shape = alphashape.alphashape(
      points_2d,
      lambda ind, r: 1.0 + any(np.array(points_2d)[ind][:,0] == 0.0))
  alpha_shape
  ```

  ![png](https://raw.github.com/bellockk/alphashape/master/media/output_25_0.png)




  ```python
  fig, ax = plt.subplots()
  ax.scatter(*zip(*points_2d))
  ax.add_patch(PolygonPatch(alpha_shape, alpha=0.2))
  plt.show()
  ```


  ![png](https://raw.github.com/bellockk/alphashape/master/media/output_27_1.png)



  The alpha parameter can be solved for if it is not provided as an argument, but with large datasets this can take a long time to calculate.




  ```python
  alpha_shape = alphashape.alphashape(points_2d)
  alpha_shape
  ```

  ![png](https://raw.github.com/bellockk/alphashape/master/media/output_14_1.png)





  ```python
  fig, ax = plt.subplots()
  ax.scatter(*zip(*points_2d))
  ax.add_patch(PolygonPatch(alpha_shape, alpha=0.2))
  plt.show()
  ```


  ![png](https://raw.github.com/bellockk/alphashape/master/media/output_27_0.png)






  ```python
  points_3d = [
      (0., 0., 0.), (0., 0., 1.), (0., 1., 0.),
      (1., 0., 0.), (1., 1., 0.), (1., 0., 1.),
      (0., 1., 1.), (1., 1., 1.), (.25, .5, .5),
      (.5, .25, .5), (.5, .5, .25), (.75, .5, .5),
      (.5, .75, .5), (.5, .5, .75)
  ]
  ```




  ```python
  fig = plt.figure()
  ax = plt.axes(projection='3d')
  ax.scatter(df_3d['x'], df_3d['y'], df_3d['z'])
  plt.show()
  ```


  ![png](https://raw.github.com/bellockk/alphashape/master/media/output_37_0.png)



  You can visualize the shape within Jupyter notebooks using the built-in trimesh renderer by calling the `.show()` method as shown below.

  ```python
  alpha_shape = alphashape.alphashape(points_3d, 1.1)
  alpha_shape.show()
  ```

  ![png](https://raw.github.com/bellockk/alphashape/master/media/3d-1.1.png)

  ```python
  fig = plt.figure()
  ax = plt.axes(projection='3d')
  ax.plot_trisurf(*zip(*alpha_shape.vertices), triangles=alpha_shape.faces)
  plt.show()
  ```

  ![png](https://raw.github.com/bellockk/alphashape/master/media/output_40_0.png)



  ```python
  alpha_shape = alphashape.alphashape(points_3d, lambda ind, r: 1.0 + any(
      np.array(points_3d)[ind][:,0] == 0.0))
  alpha_shape.show()
  ```

  ![png](https://raw.github.com/bellockk/alphashape/master/media/3d-vary.png)

  ```python
  fig = plt.figure()
  ax = plt.axes(projection='3d')
  ax.plot_trisurf(*zip(*alpha_shape.vertices), triangles=alpha_shape.faces)
  plt.show()
  ```

  ![png](https://raw.github.com/bellockk/alphashape/master/media/output_43_0.png)



  ```python
  alpha_shape = alphashape.alphashape(points_3d)
  alpha_shape.show()
  ```

  ![png](https://raw.github.com/bellockk/alphashape/master/media/3d-solve.png)

  ```python
  fig = plt.figure()
  ax = plt.axes(projection='3d')
  ax.plot_trisurf(*zip(*alpha_shape.vertices), triangles=alpha_shape.faces)
  plt.show()
  ```

  ![png](https://raw.github.com/bellockk/alphashape/master/media/output_46_0.png)






  ```python
  points_4d = [
      (0., 0., 0., 0.), (0., 0., 0., 1.), (0., 0., 1., 0.),
      (0., 1., 0., 0.), (0., 1., 1., 0.), (0., 1., 0., 1.),
      (0., 0., 1., 1.), (0., 1., 1., 1.), (1., 0., 0., 0.),
      (1., 0., 0., 1.), (1., 0., 1., 0.), (1., 1., 0., 0.),
      (1., 1., 1., 0.), (1., 1., 0., 1.), (1., 0., 1., 1.),
      (1., 1., 1., 1.), (.25, .5, .5, .5), (.5, .25, .5, .5),
      (.5, .5, .25, .5), (.5, .5, .5, .25), (.75, .5, .5, .5),
      (.5, .75, .5, .5), (.5, .5, .75, .5), (.5, .5, .5, .75)
  ]
  df_4d = pd.DataFrame(points_4d, columns=['x', 'y', 'z', 'r'])
  ```




  ```python
  fig = plt.figure()
  ax = plt.axes(projection='3d')
  ax.scatter(df_4d['x'], df_4d['y'], df_4d['z'], c=df_4d['r'])
  plt.show()
  ```


  ![png](https://raw.github.com/bellockk/alphashape/master/media/output_51_0.png)



  ```python
  alphashape.alphashape(points_4d, 1.0)
  ```

  ```python
  {(16, 1, 2, 0),
   (16, 1, 3, 0),
   (16, 2, 3, 0),
   (16, 4, 2, 3),
   (16, 4, 7, 2),
   (16, 4, 7, 3),
   (16, 5, 1, 3),
   (16, 5, 7, 1),
   (16, 5, 7, 3),
   (16, 6, 1, 2),
   (16, 6, 7, 1),
   (16, 6, 7, 2),
   (17, 1, 2, 0),
   (17, 1, 8, 0),
   (17, 2, 8, 0),
   (17, 6, 1, 2),
   (17, 6, 14, 1),
   (17, 6, 14, 2),
   (17, 9, 1, 8),
   (17, 9, 14, 1),
   (17, 9, 14, 8),
   (17, 10, 2, 8),
   (17, 10, 14, 2),
   (17, 10, 14, 8),
   (18, 1, 3, 0),
   (18, 1, 8, 0),
   (18, 3, 8, 0),
   (18, 5, 1, 3),
   (18, 5, 13, 1),
   (18, 5, 13, 3),
   (18, 9, 1, 8),
   (18, 9, 13, 1),
   (18, 9, 13, 8),
   (18, 11, 3, 8),
   (18, 11, 13, 3),
   (18, 11, 13, 8),
   (19, 2, 3, 0),
   (19, 2, 8, 0),
   (19, 3, 8, 0),
   (19, 4, 2, 3),
   (19, 4, 12, 2),
   (19, 4, 12, 3),
   (19, 10, 2, 8),
   (19, 10, 12, 2),
   (19, 10, 12, 8),
   (19, 11, 3, 8),
   (19, 11, 12, 3),
   (19, 11, 12, 8),
   (20, 9, 13, 8),
   (20, 9, 14, 8),
   (20, 9, 14, 13),
   (20, 10, 12, 8),
   (20, 10, 14, 8),
   (20, 10, 14, 12),
   (20, 11, 12, 8),
   (20, 11, 13, 8),
   (20, 11, 13, 12),
   (20, 13, 12, 15),
   (20, 14, 12, 15),
   (20, 14, 13, 15),
   (21, 4, 7, 3),
   (21, 4, 7, 12),
   (21, 4, 12, 3),
   (21, 5, 7, 3),
   (21, 5, 7, 13),
   (21, 5, 13, 3),
   (21, 7, 12, 15),
   (21, 7, 13, 15),
   (21, 11, 12, 3),
   (21, 11, 13, 3),
   (21, 11, 13, 12),
   (21, 13, 12, 15),
   (22, 4, 7, 2),
   (22, 4, 7, 12),
   (22, 4, 12, 2),
   (22, 6, 7, 2),
   (22, 6, 7, 14),
   (22, 6, 14, 2),
   (22, 7, 12, 15),
   (22, 7, 14, 15),
   (22, 10, 12, 2),
   (22, 10, 14, 2),
   (22, 10, 14, 12),
   (22, 14, 12, 15),
   (23, 5, 7, 1),
   (23, 5, 7, 13),
   (23, 5, 13, 1),
   (23, 6, 7, 1),
   (23, 6, 7, 14),
   (23, 6, 14, 1),
   (23, 7, 13, 15),
   (23, 7, 14, 15),
   (23, 9, 13, 1),
   (23, 9, 14, 1),
   (23, 9, 14, 13),
   (23, 14, 13, 15)}
  ```





  The data used in this notebook can be obtained from the Alaska Department of Transportation and Public Facilities website at the link below.  It consists of a point collection for each of the public airports in Alaska.

  [http://www.dot.alaska.gov/stwdplng/mapping/shapefiles.shtml](http://www.dot.alaska.gov/stwdplng/mapping/shapefiles.shtml)




  ```python
  import os
  import geopandas
  data = os.path.join(os.getcwd(), 'data', 'Public_Airports_March2018.shp')
  gdf = geopandas.read_file(data)
  ```


  ```python
  %matplotlib inline
  gdf.plot()
  ```

  ![png](https://raw.github.com/bellockk/alphashape/master/media/output_4_1.png)



  ```python
  gdf.crs
  ```




      {'init': 'epsg:4269'}




  The alpha shape will be generated in the coordinate frame the geodataframe is in.  In this example, we will project into an Albers Equal Area projection, construct our alpha shape in that coordinate system, and then convert back to the source projection.




  ```python
  import cartopy.crs as ccrs
  gdf_proj = gdf.to_crs(ccrs.AlbersEqualArea().proj4_init)
  gdf_proj.plot()
  ```

  ![png](https://raw.github.com/bellockk/alphashape/master/media/output_8_1.png)





  ```python
  import alphashape
  alpha_shape = alphashape.alphashape(gdf_proj)
  alpha_shape.plot()
  ```

  ![png](https://raw.github.com/bellockk/alphashape/master/media/output_10_1.png)






  ```python
  import matplotlib.pyplot as plt
  ax = plt.axes(projection=ccrs.PlateCarree())
  ax.scatter([p.x for p in gdf_proj['geometry']],
             [p.y for p in gdf_proj['geometry']],
             transform=ccrs.AlbersEqualArea())
  ax.add_geometries(
      alpha_shape['geometry'],
      crs=ccrs.AlbersEqualArea(), alpha=.2)
  plt.show()
  ```


  ![png](https://raw.github.com/bellockk/alphashape/master/media/output_12_0.png)





  ```python
  import matplotlib.pyplot as plt
  ax = plt.axes(projection=ccrs.Robinson())
  ax.scatter([p.x for p in gdf_proj['geometry']],
             [p.y for p in gdf_proj['geometry']],
             transform=ccrs.AlbersEqualArea())
  ax.add_geometries(
      alpha_shape['geometry'],
      crs=ccrs.AlbersEqualArea(), alpha=.2)
  plt.show()
  ```


  ![png](https://raw.github.com/bellockk/alphashape/master/media/output_14_0.png)




  The following data can be obtained from the Lib E57 example data set found at the link below.  To reduce the amount of data included in the `alphashape` toolbox repository, only a subset of point data was converted to a shapefile format and all data except point locations were dropped.

  [http://www.libe57.org/data.html](http://www.libe57.org/data.html)

  ![St Sulpice](https://raw.github.com/bellockk/alphashape/master/media/Paris-TrimbleRealWorks.png "St Sulpice Point Cloud")

  ```python
  import os
  import geopandas
  data = os.path.join(os.getcwd(), 'data', 'Trimble_StSulpice-Cloud-50mm.shp')
  gdf = geopandas.read_file(data)
  ```

  ```python
  from alphashape import alphashape
  alphashape([point.coords[0] for point in gdf['geometry'][0]], 0.7).show()
  ```

  ![png](https://raw.github.com/bellockk/alphashape/master/media/3d-stsulpice.png)



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






  * Small bug fixes
  * Documentation cleanup



  * Support for generating alphashapes for 3 or more dimensional input data.
  * GeoJSON support in command line interface.



  * Adding in support for Python 3.6 and 3.9



  * Updated dependencies for geopandas notebook examples.
  * Updated source information for Alaska Airports example data set.
  * Dropping support for Python 3.6.



  * Updated dependency version numbers.
  * Including optional bounds for alpha paramter solver.



  * Added gallery plot for optimized alpha function.
  * Documentation cleanup.



  * [#1 Update features in README.md](https://github.com/bellockk/alphashape/issues/1)
  * [#2 Create Application Utilizing the alphashape Toolbox](https://github.com/bellockk/alphashape/issues/2)



  * Correcting formatting on PyPi long description.



  * [#7 Include GeoPandas Integration](https://github.com/bellockk/alphashape/issues/7)



  * [#8 Include capability to optimize alpha parameter](https://github.com/bellockk/alphashape/issues/8)



  * Complete code coverage of existing capabilities.



  * [#6 Include Jupyter Notebook in Examples](https://github.com/bellockk/alphashape/issues/6)



  * [#5 Create an Example Gallery in the Documentation](https://github.com/bellockk/alphashape/issues/5)



  * Bug fixes.



  * Bug fixes.



  * Bug fixes.



  * Bug fixes.



  * First release on PyPI.


pkgId: a3e616024def56193db3f241779d8ddc52a9714d538e1bb8609ea5c84e02f86d
name: python-alphashapy
arch: src
version: 0.2.0
epoch: 0
release: 1
url: https://github.com/itaipelles/alphashapy
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alphashapy-0.2.0-1.src.rpm
checksum_type: sha256
summary:
  A Python package for constructing alpha shapes and alpha hulls for both positive and negative alphas.

description:
  [![PyPI](https://img.shields.io/pypi/v/alphashapy.svg)](https://pypi.org/project/alphashapy/)
  [![Docs](https://readthedocs.org/projects/alphashapy/badge/?version=latest)](https://alphashapy.readthedocs.io/en/latest/)
  [![Tests](https://github.com/itaipelles/alphashapy/actions/workflows/test.yml/badge.svg)](https://github.com/itaipelles/alphashapy/actions/workflows/test.yml)
  [![Changelog](https://img.shields.io/github/v/release/itaipelles/alphashapy?include_prereleases&label=changelog)](https://github.com/itaipelles/alphashapy/releases)
  [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/itaipelles/alphashapy/blob/main/LICENSE)

  A Python package for constructing 2D alpha hulls for negative alphas. The algorithm is from the [paper](https://ieeexplore.ieee.org/abstract/document/1056714):

  H. Edelsbrunner, D. Kirkpatrick and R. Seidel, "On the shape of a set of points in the plane," in IEEE Transactions on Information Theory, vol. 29, no. 4, pp. 551-559, July 1983, doi: 10.1109/TIT.1983.1056714.

  And the implementation relies on Qhull's implementation of Voronoi diagrams, wrapped nicely for Python by Scipy [here](https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.Voronoi.html).

  In the future I will try to add alpha shapes for negative alphas as well, today there is no python package that does that.

  For alpha shapes with positive alphas, please use [alphashape](https://github.com/bellockk/alphashape) (which also supports higher dimensions) or [alpha_shapes](https://github.com/panosz/alpha_shapes), both are great but do not currently (August 2024) support alpha hulls nor negative alphas.



  Install this library using `pip`:
  ```bash
  pip install alphashapy
  ```


  ```python
  import numpy as np
  from alphashapy import alphahull_negative_alpha
  points = np.random.rand(100,2)
  alpha = -1
  alphahull_negative_alpha(points, alpha)
  ```



  To contribute to this library, first checkout the code. Then create a new virtual environment:
  ```bash
  cd alphashapy
  python -m venv venv
  source venv/bin/activate
  ```
  Now install the dependencies and test dependencies:
  ```bash
  python -m pip install -e '.[test]'
  ```
  To run the tests:
  ```bash
  python -m pytest
  ```


pkgId: 7c6768435e32a91bc53ec791580c3b34e0964124aff5277a5b4dd9d8a19204ac
name: python-alphasquared-py
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: The unofficial Python client for the AlphaSquared API
url: https://github.com/rhettre/alphasquared-py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alphasquared-py-0.3.0-1.src.rpm
checksum_type: sha256
description:
  This is an unofficial Python client for the AlphaSquared API. It allows users to interact with the API to retrieve asset information, strategy values, and hypothetical data for cryptocurrency trading.



  - Easy-to-use Python wrapper for the AlphaSquared API
  - Supports authentication using API tokens
  - Implements rate limiting to comply with API usage rules
  - Provides methods to retrieve asset information, strategy values, and hypothetical data
  - Includes error handling and logging functionality
  - Fetch comprehensive asset data (price, risk, market cap, etc.)
  - Get custom strategy values
  - Built-in caching to reduce API calls
  - Automatic rate limiting to comply with API rules



  Install the package using pip:

  ```bash
  pip install alphasquared-py
  ```



  To use the AlphaSquared API, you need to obtain an API token from your AlphaSquared account dashboard. Once you have your token, you can authenticate as follows:

  ```python
  from alphasquared import AlphaSquared

  api = AlphaSquared("YOUR_API_TOKEN")
  ```





  ```python
  btc_info = api.get_asset_info("BTC")
  print(btc_info)
  ```



  ```python
  strategy_values = api.get_strategy_values("My Custom Strat")
  print(strategy_values)
  ```



  ```python
  eth_hypotheticals = api.get_hypotheticals("ETH")
  print(eth_hypotheticals)
  ```



  ```python
  btc_comprehensive = api.get_comprehensive_asset_data("BTC")
  print(btc_comprehensive)
  ```



  ```python
  action, value = api.get_strategy_value_for_risk("My Custom Strat", 50)
  print(f"Action: {action}, Value: {value}")
  ```



  ```python
  current_risk = api.get_current_risk("BTC")
  print(current_risk)
  ```



  This example demonstrates how to get the current risk for an asset, then use that risk level to determine the strategy action and value:

  ```python

  btc_risk = api.get_current_risk("BTC")
  print(f"Current BTC Risk: {btc_risk}")


  strategy_name = "My Custom Strat"


  action, value = api.get_strategy_value_for_risk(strategy_name, btc_risk)
  print(f"For risk {btc_risk}: Action = {action.upper()}, Value = {value}")
  ```



  The client includes built-in error handling. You can check for errors in the API responses:

  ```python
  result = api.get_asset_info("INVALID_ASSET")
  if api.has_error(result):
      print("An error occurred:", result["error"])
  ```



  The client automatically handles rate limiting to ensure compliance with the API's usage rules (6 requests per minute).



  The client uses caching to reduce the number of API calls. You can set the cache TTL (time-to-live) when initializing the client. The default cache TTL is 5 minutes.

  ```python
  api = AlphaSquared("YOUR_API_TOKEN", cache_ttl=300)  # 5 minutes
  ```



  For more information about the AlphaSquared API, consult the [official API documentation](https://alphasquared.io/api-docs).



  This project is licensed under the MIT License. See the LICENSE file for more information.



  This project is not affiliated with, maintained, or endorsed by AlphaSquared. Use this software at your own risk. Trading cryptocurrencies carries a risk of financial loss. The developers of this software are not responsible for any financial losses or damages incurred while using this software.



  For any issues, questions, or assistance, please open an issue on the GitHub repository or contact AlphaSquared support at admin@alphasquared.io.


pkgId: 7847f516a065318b663d295e607ff0d5ffe0c25b9542f80b6feb0d09c1151c6d
name: python-alphatwirl
arch: src
version: 0.30.0
epoch: 0
release: 1
summary: A Python library for summarizing event data
url: https://github.com/alphatwirl/alphatwirl
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alphatwirl-0.30.0-1.src.rpm
checksum_type: sha256
description:
  A Python library for summarizing event data into multivariate categorical data

  _AlphaTwirl_ is a Python library that summarizes event data into multivariate categorical data as data frames. Event data, input to AlphaTwirl, are data with one entry (or row) for one event: for example, data in [ROOT](https://root.cern.ch/) [TTrees](https://root.cern.ch/doc/master/classTTree.html) with one entry per collision event of an [LHC](https://home.cern/topics/large-hadron-collider) experiment at [CERN](http://home.cern/). Event data are often large&mdash;too large to be loaded in memory&mdash;because they have as many entries as events. Multivariate categorical data, the output of AlphaTwirl, have one row for one category. They are usually small&mdash;small enough to be loaded in memory&mdash;because they only have as many rows as categories. Users can, for example, import them as data frames into [R](https://www.r-project.org/) and [pandas](http://pandas.pydata.org/), which usually load all data in memory, and can perform categorical data analyses with a rich set of data operations available in R and pandas.
  ****

  - Jupyter Notebook: [*Quick start of AlphaTwirl*](https://github.com/alphatwirl/notebook-tutorial-2019-02)<br />
  &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/alphatwirl/notebook-tutorial-2019-02/master?filepath=tutorial_01.ipynb)
  ****

  - Tai Sakuma, *"AlphaTwirl: A Python library for summarizing event data into multivariate categorical data"*,
    EPJ Web of Conferences **214**, 02001 (2019), [doi:10.1051/epjconf/201921402001](https://doi.org/10.1051/epjconf/201921402001),
    [1905.06609](https://arxiv.org/abs/1905.06609)
  ****

  - AlphaTwirl is licensed under the BSD license.
  *****

  - Tai Sakuma - tai.sakuma@gmail.com


pkgId: 15709c822a8aeb131ad9378ccd3fabb2a0ac9bd1252c9236bfed02aa25c0cb3e
name: python-alphazerocode
arch: src
version: 1.10.1.1
epoch: 0
release: 1
summary: AlphaZeroCode
url: https://pypi.org/project/alphazerocode/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alphazerocode-1.10.1.1-1.src.rpm
checksum_type: sha256
description:
  ![image](https://github.com/Michi-123/AlphaZeroCode/assets/26673104/3b773129-74d2-4e11-bcab-d39f17c10980)
  https://www.udemy.com/course/alphazero/<br>
  <h1>AlphaZeroの意外な構造</h1>
  <h2>またはAlphaGoは如何にして棋譜データの利用を止めて自分の経験に頼るようになったか</h2>
  囲碁AIのAlphaGoから、人の知識なしでゼロから学習に成功した強化学習モデル のゲームＡＩ「AlphaZero」 を、初心者・中級者向けに、イラストなどで解説していきます。AlphaZeroは、将棋ＡＩとしても成果を出しています。<br>

  <pre>
  pip install AlphaZeroCode
  </pre>
  <pre>
  import AlphaZeroCode
  </pre>
  You must implement tain code using Udemy recture.


pkgId: 9b4a6ac1df1964834247a53ee2a50feb3cdd2883c0fbb3800c7ba67f092740bb
name: python-alphonse
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: A wrapper around SQLAlchemy to make it easier to make more complex queries
url: https://pypi.org/project/alphonse/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alphonse-0.1.4-1.src.rpm
checksum_type: sha256
description:
  - SQLAlchemy version `1.4` or higher  (`2.0+` for best performance)
  - A SQLAlchemy "Engine" object.
    - This is the connection to the database.  It can be created using the `sqlalchemy.create_engine` method.
  - A list of all defined SQLAlchemy models that all inherit from the same instance of a `sqlalchemy.ext.declarative.declarative_base.`

  ```python
  """ Example setup for Alphonse Database Manager """
  from alphonse import DbManager
  from sqlalchemy import create_engine
  from sqlalchemy.engine import Engine
  from my_models import MyModel1, MyModel2, MyModel3

  db_connection_url: str = "postgresql://user:password@localhost:port/my_db_name"
  engine: Engine = create_engine(db_connection_url)


  model_list: list = [MyModel1, MyModel2, MyModel3]

  db_manager: DbManager = DbManager(engine, model_list)

rpm_license:
  Copyright (c) 2024 Wavelynx Technologies Corporation  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: 14630c8bdad85823f34c6c4a0ea7a506c3569747a45f444aa7b33d4651d7cc74
name: python-alpinepkgs
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/ludeeus/alpinepkgs
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alpinepkgs-2.0.0-1.src.rpm
checksum_type: sha256
description:
  _Give you information about packages from pkgs.alpinelinux.org._

  **NOTE!: This package uses web scraping to gather the information.**



  ```bash
  pip install alpinepkgs
  ```



  ```python
  from alpinepkgs.packages import get_package
  print(get_package('python3'))

  > {'package': 'python3', 'branch': 'v3.16', 'x86_64': {'version': '3.10.5-r0', 'date': '2022-07-25', 'licence': 'PSF-2.0', 'maintainer': 'Natanael Copa', 'url': 'https://www.python.org/'}, 'x86': {'version': '3.10.5-r0', 'date': '2022-07-25', 'licence': 'PSF-2.0', 'maintainer': 'Natanael Copa', 'url': 'https://www.python.org/'}, 'aarch64': {'version': '3.10.5-r0', 'date': '2022-07-25', 'licence': 'PSF-2.0', 'maintainer': 'Natanael Copa', 'url': 'https://www.python.org/'}, 'armhf': {'version': '3.10.5-r0', 'date': '2022-07-25', 'licence': 'PSF-2.0', 'maintainer': 'Natanael Copa', 'url': 'https://www.python.org/'}, 's390x': {'version': '3.10.5-r0', 'date': '2022-07-25', 'licence': 'PSF-2.0', 'maintainer': 'Natanael Copa', 'url': 'https://www.python.org/'}, 'armv7': {'version': '3.10.5-r0', 'date': '2022-07-25', 'licence': 'PSF-2.0', 'maintainer': 'Natanael Copa', 'url': 'https://www.python.org/'}, 'ppc64le': {'version': '3.10.5-r0', 'date': '2022-07-25', 'licence': 'PSF-2.0', 'maintainer': 'Natanael Copa', 'url': 'https://www.python.org/'}, 'versions': ['3.10.5-r0']}
  ```


pkgId: f476fd5d46b01f69aaecfa65134d663d7694fe55cc8036cef1901cf8c963f955
name: python-alpsplot
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Python plotting library of alps-lab style using matplotlib.
url: https://github.com/ain-soph/alpsplot
rpm_license: GPL-3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alpsplot-1.2.0-1.src.rpm
checksum_type: sha256
description:
  [![contact](https://img.shields.io/badge/contact-rbp5354@psu.edu-yellow)](mailto:rbp5354@psu.edu)
  [![License](https://img.shields.io/github/license/ain-soph/alpsplot)](https://opensource.org/licenses/GPL-3.0)

  ![python>=3.10](https://img.shields.io/badge/python->=3.10-informational.svg)
  [![docs](https://github.com/ain-soph/alpsplot/workflows/docs/badge.svg)](https://ain-soph.github.io/alpsplot/)
  [![codecov](https://codecov.io/gh/ain-soph/alpsplot/branch/main/graph/badge.svg?token=BBYZUPVK3I)](https://codecov.io/gh/ain-soph/alpsplot)

  [![release](https://img.shields.io/github/v/release/ain-soph/alpsplot)](https://github.com/ain-soph/alpsplot/releases)
  [![pypi](https://img.shields.io/pypi/v/alpsplot)](https://pypi.org/project/alpsplot/)
  [![docker](https://img.shields.io/pypi/v/alpsplot?label=docker)](https://hub.docker.com/r/local0state/alpsplot)

  Python plotting library of alps-lab style using matplotlib.


pkgId: e89ce74c556ec2744170891ad7a39ef7bdd077d4441d265c54a88407efad399e
name: python-alpyca
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: API library for all ASCOM Alpaca devices, management, and discovery
url: https://github.com/BobDenny/alpyca
rpm_license: LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alpyca-3.0.0-1.src.rpm
checksum_type: sha256
description:
  <img align="right" width="210" height="166" hspace="20" vspace="20" src="https://ascom-standards.org/alpyca/readme-assets/AlpacaLogo210.png">

  Produced by the [ASCOM Initiative](https://ascom-standards.org/), and derived from Ethan Chappel's
  Alpyca 1.0.0. Ethan kindly released the name **Alpyca** to the ASCOM Initiative, hence this expanded
  package started life as Version 2.0. With 3.0.0 it has been expanded to support the additions in
  ASCOM Platform 7. **NOTE** This package runs on Linux, MacOS, and Windows. It has no depencence on the
  Windows ASCOM PLatform. Alpaca does not depend on Windows.



  This package runs under Python 3.7 or later. It is compatible with most Linux distros, Windows , and MacOS.
  Dependencies are minimal: [requests](https://pypi.org/project/requests/),
  [netifaces](https://pypi.org/project/netifaces/),
  [typing-extensions](https://pypi.org/project/typing-extensions/),
  [python-dateutil](https://pypi.org/project/python-dateutil/), and
  [enum-tools](https://pypi.org/project/enum-tools/).



  The package installs from [PyPi](https://pypi.org/) as

  ```sh
  pip install alpyca
  ```

  or if you have the source code in a tar file, extract it and run (with **Python 3**)

  ```sh
  python setup.py install
  ```

  The dependencies listed above (and others they may depend on) are automatically
  installed with alpyca.



  This version 3.0.0. This release incorporates the additions to the ASCOM Interfaces that
  were introduced with ASCOM Platform 7.

  The documentation is extensive and available online as **[Alpyca: API Library
  for Alpaca](https://ascom-standards.org/alpyca/)** as well as a **[PDF Document
  here](https://ascom-standards.org/alpyca/alpyca.pdf)**. Each element of the
  package references the relevant documentation in the **[ASCOM Master Interfaces
  Document](https://ascom-standards.org/newdocs/)** See
  **[CHANGES.rst](https://github.com/ASCOMInitiative/alpyca/blob/master/CHANGES.rst)**
  (on GitHub) for change log.



  Feedback can be given on the
  [ASCOM Driver and Application Development Support Forum](https://ascomtalk.groups.io/g/Developer).
  Please note that the protocols are universal and strictly curated. This library is an
  _implementation_ of the protocols, not the protocols themselves. For background please visit
  [About Alpaca and ASCOM](https://ascom-standards.org/About/Index.htm), as well as the
  [ASCOM Interface Principle](https://ascom-standards.org/Standards/InterfacePrinciple.htm),
  [The Standards Process](https://ascom-standards.org/Standards/StandardsProcess.htm), and
  the [General Requirements](https://ascom-standards.org/Standards/Requirements.htm).



  This requires the _cross-platform_ ASCOM Omni Simulators which will give you
  fully functional simulators for _all_ Alpaca devices, as well as a _live_
  OpenAPI/Swagger interface to the Alpaca RESTful endpoints (_see the details
  below_). If you are on a Windows system, the Omni Simulators are included with
  the [ASCOM Platform 7](https://ascom-standards.org/). If you are on Linux or
  MacOS, you can get the _cross-platform_ OmniSimulators from GitHub at the
  **[Omni Simulators
  Repo](https://github.com/ASCOMInitiative/ASCOM.Alpaca.Simulators/releases)**.

  This example will
  use the Telescope simulator. Assuming you are running the Omni Simulator on your local host
  at its default port of 32323, its address is then <code>localhost:32323</code>. Here is a sample
  program using Alpaca:

  **REQUIRES [LATEST OMNI SIM](https://github.com/ASCOMInitiative/ASCOM.Alpaca.Simulators/releases) WITH PLATFORM 7 CONNECTION SEMANTICS**:

  ```python
      import time
      from alpaca.telescope import *      # Multiple Classes including Enumerations
      from alpaca.exceptions import *     # Or just the exceptions you want to catch

      T = Telescope('localhost:32323', 0) # Local Omni Simulator
      T.Connect()                         # New async connect
      while T.Connecting
          time.sleep(1)
      print(f'Connected to {T.Name}')
      print(T.Description)
      T.Tracking = True               # Needed for slewing (see below)
      try:
          print('Starting slew...')
          T.SlewToCoordinatesAsync(T.SiderealTime + 2, 50)    # 2 hrs east of meridian
          while(T.Slewing):
              time.sleep(5)               # What do a few seconds matter?
          print('... slew completed successfully.')
          print(f'RA={T.RightAscension} DE={T.Declination}')
          print('Turning off tracking then attempting to slew...')
          T.Tracking = False
          T.SlewToCoordinatesAsync(T.SiderealTime + 2, 55)    # 5 deg slew N
          
          print("... you won't get here!")
      except Exception as e:              # Should catch specific InvalidOperationException
          print(f'Slew failed: {str(e)}')
      finally:                            # Assure that you disconnect
          print("Disconnecting...")
          T.Disconnect()
  ```



  ```tt
      Connected to Alpaca Telescope Sim
      Software Telescope Simulator for ASCOM
      Starting slew...
      ... slew completed successfully.
      RA=10.939969572854931 DE=50
      Turning off tracking then attempting to slew...
      Slew failed: SlewToCoordinatesAsync is not allowed when tracking is False
      Disconnecting...
      done
  ```

  See how easliy  exceptions are handled? The error message came from the OmniSim.



  The ASCOM Alpaca Simulators are included in [ASCOM Platform
  7](https://ascom-standards.org/) or if you are on Linux or MacOS, they are
  [available via GitHub
  here](https://github.com/ASCOMInitiative/ASCOM.Alpaca.Simulators). Scroll down
  to the Assets section and pick the package for your OS and CPU type.

  ```sh
  ./ascom-alpaca.simulators
  ```

  (or the equivalent on Windows or MacOS). You may need to open a web browser to
  `http://localhost:32323` if that option is off in the server settings. This is
  the primary user interface to the simulator server and simulated devices. Once
  you get this running you are ready to try the sample above.

  ![Initial OmniSim Display](https://ascom-standards.org/alpyca/readme-assets/InitialBrowserAnnotated.png)



  Any current ASCOM COM device that is hosted on a Windows system can have an Alpaca interface added via the
  **[ASCOM Remote Windows app](https://github.com/ASCOMInitiative/ASCOMRemote/releases/latest)**. This app allows you to
  expose any of your Windows-hosted astronomy devices to the Alpaca world, making them reachable from programs
  using alpyca.



  If you are interested in monitoring the HTTP/REST traffic that alpyca creates and exchanges with the
  Alpaca devices, you can install the [Wireshark network protocol analyzer](https://www.wireshark.org/).
  One thing that trips people up is making the installation so that Wireshark has access to all of the
  network insterfaces without needing root privs (linux) or running "As Administrator" on Windows. Pay close
  attention the installation steps on this. On WIndows the capture driver installation will require elevation,
  as it is a privileged module. For example installing on Linux (e.g Debian/Raspberry Pi) you'll see this,
  and **be sure to answer Yes**.

  ![Wireshark Privileges](https://ascom-standards.org/alpyca/readme-assets/WireSharkPrivs.png)

  To watch Alpaca traffic, set this simple display filter <code>http and tcp.port == 32323</code>
  (with <code>32323</code> being the port of the OmniSim, see above). You'll get a nice analysis
  of the Alpaca traffic like this

  ![Wireshark Privileges](https://ascom-standards.org/alpyca/readme-assets/Wireshark1.png)


pkgId: 897d580f92aa9e798cf8461b46b01b35bc25378f7277659d33b542db434c3018
name: python-alpyvision
arch: src
version: 0.0.93
epoch: 0
release: 1
summary: AlPyVision is a Python wrapper to work with openCV and the Albion Online game client.
url: https://github.com/MadMowgli/AlPyVision
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alpyvision-0.0.93-1.src.rpm
checksum_type: sha256
description:
  > AlPyVision (**Al**bion **Py**thon **Vision**) is a package that provides API-like functionality and acts as a
  > middleman between the [Python OpenCV](https://docs.opencv.org/4.x/index.html) library and the
  > [Albion Online](https://albiononline.com/en/news) game client.


  > Cheating or botting is not allowed in Albion Online. This package is for learning-purposes only, such as getting
  > into the field of computer vision or artificial intelligence. Do not use this package to violate the rules.


  > The ground-lying idea and much of the basic architecture is heavily inspired by the
  > [OpenCV Object Detection in Games YouTube series](https://www.youtube.com/c/LearnCodeByGaming/playlists)
  > made by [Learn Code By Gaming](https://learncodebygaming.com/). Ben produces tutorials of exceptionally high quality,
  > covering the whole stretch from the basic 'What is a Python class?' to Canny Edge Detection with stunningly precise
  > explanations. You should definitely check out his content, if you want to learn more about Object Detection and
  > Python. Thank you, Ben!


pkgId: c75be60cef9091a1b6aadbc87c2884369e095d9df6449e737de5188e148b789d
name: python-alrocar-weather-service
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: A MCP server project
url: https://pypi.org/project/alrocar-weather-service/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alrocar-weather-service-0.2.0-1.src.rpm
checksum_type: sha256
description:
  A MCP server project





  The server implements a simple note storage system with:
  - Custom note:// URI scheme for accessing individual notes
  - Each note resource has a name, description and text/plain mimetype



  The server provides a single prompt:
  - summarize-notes: Creates summaries of all stored notes
    - Optional "style" argument to control detail level (brief/detailed)
    - Generates prompt combining all current notes with style preference



  The server implements one tool:
  - add-note: Adds a new note to the server
    - Takes "name" and "content" as required string arguments
    - Updates server state and notifies clients of resource changes



  [TODO: Add configuration details specific to your implementation]







  On MacOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`
  On Windows: `%APPDATA%/Claude/claude_desktop_config.json`

  <details>
    <summary>Development/Unpublished Servers Configuration</summary>
    ```
    "mcpServers": {
      "weather_service": {
        "command": "uv",
        "args": [
          "--directory",
          "/Users/alrocar/gr/weather_service",
          "run",
          "weather_service"
        ]
      }
    }
    ```
  </details>

  <details>
    <summary>Published Servers Configuration</summary>
    ```
    "mcpServers": {
      "weather_service": {
        "command": "uvx",
        "args": [
          "weather_service"
        ]
      }
    }
    ```
  </details>





  To prepare the package for distribution:

  1. Sync dependencies and update lockfile:
  ```bash
  uv sync
  ```

  2. Build package distributions:
  ```bash
  uv build
  ```

  This will create source and wheel distributions in the `dist/` directory.

  3. Publish to PyPI:
  ```bash
  uv publish
  ```

  Note: You'll need to set PyPI credentials via environment variables or command flags:
  - Token: `--token` or `UV_PUBLISH_TOKEN`
  - Or username/password: `--username`/`UV_PUBLISH_USERNAME` and `--password`/`UV_PUBLISH_PASSWORD`



  Since MCP servers run over stdio, debugging can be challenging. For the best debugging
  experience, we strongly recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector).


  You can launch the MCP Inspector via [`npm`](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) with this command:

  ```bash
  npx @modelcontextprotocol/inspector uv --directory /Users/alrocar/gr/weather_service run weather-service
  ```


  Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.


pkgId: cf98bc7c198a476308648ba5f06fb22f5f74b5e9e55118db48ab7b682466e519
name: python-alsi-py
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: A library to query ALSI data
url: https://pypi.org/project/alsi-py/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alsi-py-1.1.1-1.src.rpm
checksum_type: sha256
description:
  Python client for the ALSI API (Aggregated LNG Storage Inventory)

  Documentation of the API can be found on: https://alsi.gie.eu/GIE_API_documentation_v004.pdf

  Documentation of the client API can be found on: https://roiti-ltd.github.io/alsi-py/


  `python3 -m pip3 install alsi-py `


  The package is split in two clients:
  1. AlsiRawClient: Returns data in raw JSON format.
  2. AlsiPandasClient: Returns parsed data in the form of a pandas dataframe.

  ```
  from alsi.raw_client import AlsiRawClient
  from alsi.pandas_client import AlsiPandasClient
  from alsi.mappings import Area
  from datetime import datetime
  import asyncio

  API_KEY = '<API_KEY>'

  country_code = Area.ES # Also could be string: 'ES' or 'Spain'
  company_code = '21X000000001254A'
  facility_code = '21W0000000000370'

  async def main():
      client = AlsiRawClient(api_key=API_KEY)

      
      client.query_data_for_facility(facility_code, company_code, country_code)
      client.query_agg_data_for_europe_or_noneurope(europe='eu')
      client.query_agg_data_by_country(contry_code='BE')
      client.query_data_by_company_and_country(company_code, country_code)

      
      client.query_agg_data_by_country(country_code, start=datetime(2017,1,1), end=datetime(2018,1,1), limit=10)

      
      pandas_client = AlsiPandasClient(api_key=API_KEY)

      
      await client.close_session()
      
      await pandas_client.close_session()

  asyncio.run(main())

  ```




  Tell pytest where to look for unit tests and create env for ALSI API key
  ```
  export PYTHONPATH=./alsi
  export ALSI_KEY='...'
  ```

  Run unit tests in coverage mode
  ```
  python -m pytest ./tests --import-mode=append --cov
  ```



  Pull the repository:
  ```
  git clone https://github.com/ROITI-Ltd/alsi-py.git
  cd ./alsi-py
  ```

  Set up your working environment:
  ```
  python3 -m venv env
  source env/bin/activate
  ```

  Install required packages:
  ```
  pip3 install -r requirements.txt
  pip3 install -r requirements-dev.txt
  ```

  Bumping the package version after making changes:
  ```
  bumpversion major|minor|patch|build
  ```

  For more general guidelines on contributing see: [Contributing to alsi-py](https://github.com/ROITI-Ltd/alsi-py/blob/main/CONTRIBUTING.md).



  Many thanks to the [entsoe-py](https://github.com/EnergieID/entsoe-py) library for serving as inspiration for this library.


pkgId: b3c08b35455d5902b093672b08cb2d655752404430b75566101c1d032ef1bc2d
name: python-also
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: UNKNOWN
url: https://github.com/Doboy/Also
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-also-0.0.2-1.src.rpm
checksum_type: sha256
description:
  Ever had lots of methods that do the same thing?!
  You want to set them to the same thing but dont want to do something lame like
  ```python
     def method(self):
         pass

     othermethod = method
  ```

  Rather you want to do it with style like

  ```python
     @also('othermethod')
     def method(self):
         pass
  ```

  Then do I have a solution for you!


  ```
  pip install also
  ```


  ```python
  from also import also, AlsoMetaClass

  class Foo:
      __metaclass__ = AlsoMetaClass

      @also('getThing')
      @also('get_thing')
      def getthing(self):
          return 'go bears'

  foo = Foo()
  assert (foo.getthing() == foo.get_thing() ==
          foo.getThing() == 'go bears')
  ```


pkgId: 7be7daa4db2f733f3738052c263f60434c25457c0d5a30c7a28d28c73febf3e6
name: python-alt-gym-wordle
arch: src
version: 0.8.6
epoch: 0
release: 1
summary: OpenAI gym environment for training agents on Wordle
url: https://github.com/ryan-snyder/gym-wordle
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alt-gym-wordle-0.8.6-1.src.rpm
checksum_type: sha256
description:
  A wordle environment for openai/gym


  Install [openai-gym](https://gym.openai.com/docs/)

  then install this package with
  `pip install -e .`


  ```
  import gym
  import gym_wordle
  env = gym.make('Wordle-v0')
  ```
  See the [docs](https://gym.openai.com/docs/) for more info



  This environment simulates a game of wordle using a wordle python clone from https://github.com/bellerb/wordle_solver

  The action space is a discrete space of 12972 numbers which corresponds to a word from a list of all allowed wordle guesses and answers
  The observation space is a dict with the guesses and colors for the current game.
  Guesses is an array of `shape(5,6) #5 letters and 6 rows` where each element is a number from 0-26 where 0 is `''` and 26 is `z`
  Colors is an array of the same shape, only each element is a number from 0-2 where 0 is a blank (or black or grey) square, 1 is a yellow square, and 2 is a green square

  The reward calculation is as follows:

  The agent gets 1-6 points depending on how fast the agent guesses the word. For example, getting the word on the first guesses rewards 6 points, getting the word on the second guess rewards 5 points, etc

  The agent also is rewarded for colors in the current row (so the current guess).
  Right now, the agent is rewarded 3 points for each green tile, and 1 point for each yellow tile.
  No points are giving for grey tiles


pkgId: 36cdcc8ecbcb5cdf8bac63a2e01843d6063ccf2b088fe13050986d0586f07574
name: python-alt-profanity-check
arch: src
version: 1.5.2
epoch: 0
release: 1
url: https://github.com/dimitrismistriotis/alt-profanity-check
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alt-profanity-check-1.5.2-1.src.rpm
checksum_type: sha256
summary:
  A fast, robust library to check for offensive language in strings. Dropdown replacement of "profanity-check".

description:
  Alt profanity check is a drop-in replacement of the `profanity-check` library for the not so well
  maintained <https://github.com/vzhou842/profanity-check>:

  > A fast, robust Python library to check for profanity or offensive language in strings.
  > Read more about how and why `profanity-check` was built in
  > [this blog post](https://victorzhou.com/blog/better-profanity-detection-with-scikit-learn/).

  Our aim is to follow scikit-learn's (main dependency) versions and post models trained with the
  same version number, example alt-profanity-check version 1.2.3.4 should be trained with the
  1.2.3.4 version of the scikit-learn library.

  For joblib which is the next major dependency we will be using the latest one which was available
  when we trained the models.

  Last but not least we aim to clean up the codebase a bit and **maybe** introduce some features or
  datasets.

  | Learn Python from the Maintainer of alt-profanity-check 🎓🧑‍💻️⌨️                                                                                                                                                                                                         |
  |----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | I am teaching Python through Mentorcruise, aiming both to beginners and seasoned developers who want to get to the next level in their learning journey: <https://mentorcruise.com/mentor/dimitriosmistriotis/>. Please mention that you found me through this repository. |



  See
  [CHANGELOG.md](https://github.com/dimitrismistriotis/alt-profanity-check/blob/master/CHANGELOG.md)



  `profanity-check` uses a linear SVM model trained on 200k human-labeled samples of clean and
  profane text strings. Its model is simple but surprisingly effective, meaning
  **`profanity-check` is both robust and extremely performant**.





  Many profanity detection libraries use a hard-coded list of bad words to detect and filter
  profanity. For example, [profanity](https://pypi.org/project/profanity/) uses
  [this wordlist](https://github.com/ben174/profanity/blob/master/profanity/data/wordlist.txt),
  and even [better-profanity](https://pypi.org/project/better-profanity/) still uses
  [a wordlist](https://github.com/snguyenthanh/better_profanity/blob/master/better_profanity/profanity_wordlist.txt).
  There are obviously glaring issues with this approach, and, while they might be performant,
  **these libraries are not accurate at all**.

  A simple example for which `profanity-check` is better is the phrase

  - "You cocksucker"\* - `profanity` thinks this is clean because it doesn't have
  - "cocksucker"\* in its wordlist.



  Other libraries like [profanity-filter](https://github.com/rominf/profanity-filter)
  use more sophisticated methods that are much more accurate but at the cost of performance.
  A benchmark (performed December 2018 on a new 2018 Macbook Pro) using
  [a Kaggle dataset of Wikipedia comments](https://www.kaggle.com/c/jigsaw-toxic-comment-classification-challenge/data) yielded roughly
  the following results:

  | Package          | 1 Prediction (ms) | 10 Predictions (ms) | 100 Predictions (ms) |
  |------------------|-------------------|---------------------|----------------------|
  | profanity-check  | 0.2               | 0.5                 | 3.5                  |
  | profanity-filter | 60                | 1200                | 13000                |
  | profanity        | 0.3               | 1.2                 | 24                   |

  `profanity-check` is anywhere from **300 - 4000 times faster** than `profanity-filter` in this
  benchmark!



  This table speaks for itself:

  | Package          | Test Accuracy | Balanced Test Accuracy | Precision | Recall | F1 Score |
  |------------------|---------------|------------------------|-----------|--------|----------|
  | profanity-check  | 95.0%         | 93.0%                  | 86.1%     | 89.6%  | 0.88     |
  | profanity-filter | 91.8%         | 83.6%                  | 85.4%     | 70.2%  | 0.77     |
  | profanity        | 85.6%         | 65.1%                  | 91.7%     | 30.8%  | 0.46     |

  See the How section below for more details on the dataset used for these results.



  ```shell
  pip install alt-profanity-check
  ```



  Reference: <https://scikit-learn.org/stable/install.html>

  > Scikit-learn 0.20 was the last version to support Python 2.7 and Python 3.4. Scikit-learn
  > 0.21 supported Python 3.5-3.7. Scikit-learn 0.22 supported Python 3.5-3.8. Scikit-learn 0.23-0.24
  > required Python 3.6 or newer. Scikit-learn 1.0 supported Python 3.7-3.10. Scikit-learn 1.1, 1.2 and 1.3
  > support Python 3.8-3.12 Scikit-learn 1.4 requires Python 3.9 or newer.



  Seems that for some reason 1.4.* branches worked with Python 3.8 with that in mind last Python 3.8 version of this
  libreary supported is **1.4.2**.



  From 1.1.2 and later, Python 3.7 is not supported, hence if you are using 3.6 pin alt-profanity-check to **1.0.2.1**.



  Following Scikit-learn, **Python3.6** is not supported after its 1.0 version if you are using 3.6 pin
  alt-profanity-check to **0.24.2**.



  You can test from the command line:

  ```shell
  profanity_check "Check something" "Check something else"
  ```

  ```python
  from profanity_check import predict, predict_prob

  predict(['predict() takes an array and returns a 1 for each string if it is offensive, else 0.'])


  predict(['fuck you'])


  predict_prob(['predict_prob() takes an array and returns the probability each string is offensive'])


  predict_prob(['go to hell, you scum'])

  ```

  Note that both `predict()` and `predict_prob` return [`numpy`](https://pypi.org/project/numpy/)
  arrays.





  Special thanks to the authors of the datasets used in this project. `profanity-check` hence also
  `alt-profanity-check` is trained on a combined dataset from 2 sources:

  - [t-davidson/hate-speech-and-offensive-language](https://github.com/t-davidson/hate-speech-and-offensive-language/tree/master/data),
    used in their paper _Automated Hate Speech Detection and the Problem of Offensive Language_
  - the [Toxic Comment Classification Challenge](https://www.kaggle.com/c/jigsaw-toxic-comment-classification-challenge/data) on Kaggle.

  `profanity-check` relies heavily on the excellent [`scikit-learn`](https://scikit-learn.org/)
  library. It's mostly powered by `scikit-learn` classes
  [`CountVectorizer`](https://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.CountVectorizer.html),
  [`LinearSVC`](https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html), and
  [`CalibratedClassifierCV`](https://scikit-learn.org/stable/modules/generated/sklearn.calibration.CalibratedClassifierCV.html).
  It uses a [Bag-of-words model](https://en.wikipedia.org/wiki/Bag-of-words_model)
  to vectorize input strings before feeding them to a linear classifier.



  One simplified way you could think about why `profanity-check` works is this:
  during the training process, the model learns which words are "bad" and how "bad" they are
  because those words will appear more often in offensive texts. Thus, it's as if the training
  process is picking out the "bad" words out of all possible words and using those to make future
  predictions. This is better than just relying on arbitrary word blacklists chosen by humans!



  This library is far from perfect. For example, it has a hard time picking up on less common
  variants of swear words like _"f4ck you"_ or _"you b1tch"_ because they don't appear often
  enough in the training corpus. **Never treat any prediction from this library as
  unquestionable truth, because it does and will make mistakes.** Instead, use this library as a
  heuristic.



  - Create a virtual environment from the project
  - `pip install -r development_requirements.txt`



  With the above in place:

  ```shell
  cd profanity_check/data
  python train_model.py
  ```



  Currently trying to automate it using Github Actions; see:
  `.github/workflows/package_release_dry_run.yml`.

  Setup:

  - Set up your "~/.pypirc" with the appropriate token
  - `pip install -r requirements_for_uploading.txt` which installs twine

  New Version:

  With `x.y.z` as the version to be uploaded:

  First tag:

  ```shell
  git tag -a vx.y.z -m "Version x.y.z"
  git push --tags
  ```

  Then upload:

  ```shell
  python setup.py sdist
  twine upload dist/alt-profanity-check-x.y.z.tar.gz
  ```


pkgId: 22d992475c1656cf961b9246b94fab7f999c1c378dd80845f2ef2b9d38965a07
name: python-alt-pytest-asyncio
arch: src
version: 0.8.2
epoch: 0
release: 1
summary: Alternative pytest plugin to pytest-asyncio
url: https://github.com/delfick/alt-pytest-asyncio
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alt-pytest-asyncio-0.8.2-1.src.rpm
checksum_type: sha256
description:
  This plugin allows you to have async pytest fixtures and tests.
  This plugin only supports python 3.6 and above.
  The code here is influenced by pytest-asyncio but with some differences:
  * Error tracebacks from are from your tests, rather than asyncio internals
  * There is only one loop for all of the tests
  * You can manage the lifecycle of the loop yourself outside of pytest by using
    this plugin with your own loop
  * No need to explicitly mark your tests as async. (pytest-asyncio requires you
    mark your async tests because it also supports other event loops like curio
    and trio)
  Like pytest-asyncio it supports async tests, coroutine fixtures and async
  generator fixtures.


pkgId: 9fd9bb7fe0f814f12f56a880a1711a044cc5df04a82f2fb13c4e0cbb42bfb687
name: python-alt-pytest-asyncio
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: Alternative pytest plugin to pytest-asyncio
url: https://github.com/delfick/alt-pytest-asyncio
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alt-pytest-asyncio-0.9.1-1.src.rpm
checksum_type: sha256
description:
  This plugin allows you to have async pytest fixtures and tests.
  This plugin only supports python 3.11 and above.
  The code here is influenced by pytest-asyncio but with some differences:
  * Error tracebacks from are from your tests, rather than asyncio internals
  * There is only one loop for all of the tests
  * You can manage the lifecycle of the loop yourself outside of pytest by using
    this plugin with your own loop
  * No need to explicitly mark your tests as async. (pytest-asyncio requires you
    mark your async tests because it also supports other event loops like curio
    and trio)
  Like pytest-asyncio it supports async tests, coroutine fixtures and async
  generator fixtures.
  Full documentation can be found at https://alt-pytest-asyncio.readthedocs.io


pkgId: bf90d78f70debbbe833c48ebc0017f96d8b6a6395d939d1d5c826a242818d58a
name: python-altair
arch: src
version: 5.4.1
epoch: 0
release: 1
summary: Vega-Altair: A declarative statistical visualization library for Python.
url: https://pypi.org/project/altair/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-altair-5.4.1-1.src.rpm
checksum_type: sha256
description:
  [![github actions](https://github.com/vega/altair/workflows/build/badge.svg)](https://github.com/vega/altair/actions?query=workflow%3Abuild)
  [![typedlib_mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://www.mypy-lang.org)
  [![JOSS Paper](https://joss.theoj.org/papers/10.21105/joss.01057/status.svg)](https://joss.theoj.org/papers/10.21105/joss.01057)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/altair)](https://pypi.org/project/altair)

  **Vega-Altair** is a declarative statistical visualization library for Python. With Vega-Altair, you can spend more time understanding your data and its meaning. Vega-Altair's
  API is simple, friendly and consistent and built on top of the powerful
  [Vega-Lite](https://github.com/vega/vega-lite) JSON specification. This elegant
  simplicity produces beautiful and effective visualizations with a minimal amount of code.

  *Vega-Altair was originally developed by [Jake Vanderplas](https://github.com/jakevdp) and [Brian
  Granger](https://github.com/ellisonbg) in close collaboration with the [UW
  Interactive Data Lab](https://idl.cs.washington.edu/).*
  *The Vega-Altair open source project is not affiliated with Altair Engineering, Inc.*



  See [Vega-Altair's Documentation Site](https://altair-viz.github.io) as well as the [Tutorial Notebooks](https://github.com/altair-viz/altair_notebooks). You can
  run the notebooks directly in your browser by clicking on one of the following badges:

  [![Binder](https://beta.mybinder.org/badge.svg)](https://beta.mybinder.org/v2/gh/altair-viz/altair_notebooks/master)
  [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/altair-viz/altair_notebooks/blob/master/notebooks/Index.ipynb)



  Here is an example using Vega-Altair to quickly visualize and display a dataset with the native Vega-Lite renderer in the JupyterLab:

  ```python
  import altair as alt


  from vega_datasets import data
  cars = data.cars()

  alt.Chart(cars).mark_point().encode(
      x='Horsepower',
      y='Miles_per_Gallon',
      color='Origin',
  )
  ```

  ![Vega-Altair Visualization](https://raw.githubusercontent.com/altair-viz/altair/main/images/cars.png)

  One of the unique features of Vega-Altair, inherited from Vega-Lite, is a declarative grammar of not just visualization, but _interaction_.
  With a few modifications to the example above we can create a linked histogram that is filtered based on a selection of the scatter plot.

  ```python
  import altair as alt
  from vega_datasets import data

  source = data.cars()

  brush = alt.selection_interval()

  points = alt.Chart(source).mark_point().encode(
      x='Horsepower',
      y='Miles_per_Gallon',
      color=alt.condition(brush, 'Origin', alt.value('lightgray'))
  ).add_params(
      brush
  )

  bars = alt.Chart(source).mark_bar().encode(
      y='Origin',
      color='Origin',
      x='count(Origin)'
  ).transform_filter(
      brush
  )

  points & bars
  ```

  ![Vega-Altair Visualization Gif](https://raw.githubusercontent.com/altair-viz/altair/main/images/cars_scatter_bar.gif)



  * Carefully-designed, declarative Python API.
  * Auto-generated internal Python API that guarantees visualizations are type-checked and
    in full conformance with the [Vega-Lite](https://github.com/vega/vega-lite)
    specification.
  * Display visualizations in JupyterLab, Jupyter Notebook, Visual Studio Code, on GitHub and
    [nbviewer](https://nbviewer.jupyter.org/), and many more.
  * Export visualizations to various formats such as PNG/SVG images, stand-alone HTML pages and the
  [Online Vega-Lite Editor](https://vega.github.io/editor/#/).
  * Serialize visualizations as JSON files.



  Vega-Altair can be installed with:
  ```bash
  pip install altair
  ```

  If you are using the conda package manager, the equivalent is:
  ```bash
  conda install altair -c conda-forge
  ```

  For full installation instructions, please see [the documentation](https://altair-viz.github.io/getting_started/installation.html).



  If you have a question that is not addressed in the documentation,
  you can post it on [StackOverflow](https://stackoverflow.com/questions/tagged/altair) using the `altair` tag.
  For bugs and feature requests, please open a [Github Issue](https://github.com/vega/altair/issues).



  [![Hatch project](https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg)](https://github.com/pypa/hatch)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![pytest](https://img.shields.io/badge/logo-pytest-blue?logo=pytest&labelColor=5c5c5c&label=%20)](https://github.com/pytest-dev/pytest)

  You can find the instructions on how to install the package for development in [the documentation](https://altair-viz.github.io/getting_started/installation.html).

  To run the tests and linters, use

  ```bash
  hatch test
  ```

  For information on how to contribute your developments back to the Vega-Altair repository, see
  [`CONTRIBUTING.md`](https://github.com/vega/altair/blob/main/CONTRIBUTING.md)



  [![JOSS Paper](https://joss.theoj.org/papers/10.21105/joss.01057/status.svg)](https://joss.theoj.org/papers/10.21105/joss.01057)

  If you use Vega-Altair in academic work, please consider citing https://joss.theoj.org/papers/10.21105/joss.01057 as

  ```bib
  @article{VanderPlas2018,
      doi = {10.21105/joss.01057},
      url = {https://doi.org/10.21105/joss.01057},
      year = {2018},
      publisher = {The Open Journal},
      volume = {3},
      number = {32},
      pages = {1057},
      author = {Jacob VanderPlas and Brian Granger and Jeffrey Heer and Dominik Moritz and Kanit Wongsuphasawat and Arvind Satyanarayan and Eitan Lees and Ilia Timofeev and Ben Welsh and Scott Sievert},
      title = {Altair: Interactive Statistical Visualizations for Python},
      journal = {Journal of Open Source Software}
  }
  ```
  Please additionally consider citing the [Vega-Lite](https://vega.github.io/vega-lite/) project, which Vega-Altair is based on: https://dl.acm.org/doi/10.1109/TVCG.2016.2599030

  ```bib
  @article{Satyanarayan2017,
      author={Satyanarayan, Arvind and Moritz, Dominik and Wongsuphasawat, Kanit and Heer, Jeffrey},
      title={Vega-Lite: A Grammar of Interactive Graphics},
      journal={IEEE transactions on visualization and computer graphics},
      year={2017},
      volume={23},
      number={1},
      pages={341-350},
      publisher={IEEE}
  }
  ```


pkgId: f8bdb2680b5281d1994d21a81679afbda998c0a155f06180e2d8dcd3f32e09e0
name: python-altair-ally
arch: src
version: 0.1.1
epoch: 0
release: 1
url: https://joelostblom.github.io/altair_ally
rpm_license: BSD-3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-altair-ally-0.1.1-1.src.rpm
checksum_type: sha256
summary:
  Altair Ally is a companion package to Altair, which provides shortcuts to create common plots for exploratory data analysis, particularly those involving visualization of an entire dataset.

description:
  *This package is in early development and its API might change.*

  Altair Ally is a companion package to Altair,
  which provides a few shortcuts to create common plots
  for exploratory data analysis (EDA),
  particularly those involving visualizing an entire dataset.
  The goal is to encourage good EDA habits
  by making it quick and simple to create these visualizations,
  and to provide useful default interactions with the plots.

  Thanks to the excellent API in Altair / Vega-Lite,
  some configuration is possible
  by using the built-in methods of the returned chart objects,
  but the general philosophy is that highly customized plots
  are better made in Altair directly.
  Check out the examples section to get started
  and the API reference for all available options.

  The package name is a nod to ggally
  which complements ggplot2 in a similar,
  but much more extensive manner.



  ```
  pip install altair-ally
  ```



  [This Jupyter Book contains the documentation with more info and examples.](https://joelostblom.github.io/altair_ally/)


pkgId: 8aa42be03f6f430f3922188072a6c0e3a193f43dd1d166013077687a26827e99
name: python-altair-data-server
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: A background data server for Altair charts.
url: http://github.com/altair-viz/altair_data_server/
rpm_license: BSD 3-clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-altair-data-server-0.4.1-1.src.rpm
checksum_type: sha256
description:
  [![build status](http://img.shields.io/travis/altair-viz/altair_data_server/master.svg?style=flat)](https://travis-ci.org/altair-viz/altair_data_server)
  [![github actions](https://github.com/altair-viz/altair_data_server/workflows/build/badge.svg)](https://github.com/altair-viz/altair_data_server/actions?query=workflow%3Abuild)
  [![github actions](https://github.com/altair-viz/altair_data_server/workflows/lint/badge.svg)](https://github.com/altair-viz/altair_data_server/actions?query=workflow%3Alint)
  [![code style black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/altair-viz/altair_data_server/master?urlpath=lab/tree/AltairDataServer.ipynb)
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/altair-viz/altair_data_server/blob/master/AltairDataServer.ipynb)


  This is a data transformer plugin for [Altair](http://altair-viz.github.io)
  that transparently serves data for Altair charts via a background WSGI server.

  Note that charts will only render as long as your Python session is active.

  The data server is a good option when you'll be **generating multiple charts as
  part of an exploration of data**.



  First install the package and its dependencies:

  ```
  $ pip install altair_data_server
  ```

  Next import altair and enable the data server:

  ```python
  import altair as alt
  alt.data_transformers.enable('data_server')
  ```
  Now when you create an Altair chart, the data will be served in the background
  rather than embedded in the chart specification.

  Once you are finished with exploration and want to generate charts that
  will have their data fully embedded in the notebook, you can restore the
  default data transformer:

  ```python
  alt.data_transformers.enable('default')
  ```

  and carry on from there.


  Remotely-hosted notebooks (like JupyterHub or Binder) usually do not allow the end
  user to access arbitrary ports. To enable users to work on that setup, make sure
  [jupyter-server-proxy](https://github.com/jupyterhub/jupyter-server-proxy) is
  installed on the jupyter server, and use the proxied data server transformer:

  ```python
  alt.data_transformers.enable('data_server_proxied')
  ```



  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/altair-viz/altair_data_server/master?urlpath=lab/tree/AltairDataServer.ipynb)
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/altair-viz/altair_data_server/blob/master/AltairDataServer.ipynb)

  You can see this in action, as well as read some of the motivation for this
  plugin, in the example notebook: [AltairDataServer.ipynb](AltairDataServer.ipynb).
  Click the Binder or Colab links above to try it out in your browser.



  Because [jupyter-server-proxy](https://github.com/jupyterhub/jupyter-server-proxy)
  requires at least Python 3.5, the methods described in
  [Remote Systems](#remote-systems) do not work do not work for older versions of Python.


pkgId: 9a76c8e90db44098b518c914f08603b726e9d6e41c7b7b272ab6232aee63acc1
name: python-altair-saver
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Altair extension for saving charts to various formats.
url: http://github.com/altair-viz/altair_saver/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-altair-saver-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![github actions](https://github.com/altair-viz/altair_saver/workflows/build/badge.svg)](https://github.com/altair-viz/altair_saver/actions?query=workflow%3Abuild)
  [![github actions](https://github.com/altair-viz/altair_saver/workflows/lint/badge.svg)](https://github.com/altair-viz/altair_saver/actions?query=workflow%3Alint)
  [![code style black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/altair-viz/altair_saver/blob/master/AltairSaver.ipynb)


  This packge provides extensions to [Altair](http://altair-viz.github.io) for saving charts
  to a variety of output types. Supported output formats are:

  - ``.json``/``.vl.json``: Vega-Lite JSON specification
  - ``.vg.json``: Vega JSON specification
  - ``.html``: HTML output
  - ``.png``: PNG image
  - ``.svg``: SVG image
  - ``.pdf``: PDF image


  The ``altair_saver`` library has a single public function, ``altair_saver.save()``.
  Given an Altair chart named ``chart``, you can use it as follows:
  ```python
  from altair_saver import save

  save(chart, "chart.vl.json")              # Vega-Lite JSON specification
  save(chart, "chart.vg.json")              # Vega JSON specification
  save(chart, "chart.html")                 # HTML document
  save(chart, "chart.html", inline=True)    # HTML document with all JS code included inline
  save(chart, "chart.png")                  # PNG Image
  save(chart, "chart.svg")                  # SVG Image
  save(chart, "chart.pdf")                  # PDF Image
  ```


  Additionally, altair_saver provides an [Altair Renderer](https://altair-viz.github.io/user_guide/display_frontends.html#altair-s-renderer-framework)
  entrypoint that can display the above outputs directly in Jupyter notebooks.
  For example, you can specify a vega-lite mimetype (supported by JupyterLab, nteract, and other
  platforms) with a PNG fallback for other frontends as follows:
  ```python
  alt.renderers.enable('altair_saver', ['vega-lite', 'png'])
  ```


  The ``altair_saver`` package can be installed with:
  ```
  $ pip install altair_saver
  ```
  Saving as ``vl.json`` and as ``html`` requires no additional setup.

  To install with conda, use
  ```
  $ conda install -c conda-forge altair_saver
  ```
  The conda package installs the *NodeJS* dependencies described below, so charts can be
  saved to ``png``, ``svg``, and ``pdf`` without additional setup.



  Output to ``png``, ``svg``, and ``pdf`` requires execution of Javascript code, which
  ``altair_saver`` can do via one of two backends.


  The *selenium* backend supports the following formats:

  - `.vg.json`
  - `.png`
  - `.svg`.

  To be used, it requires the [Selenium](https://selenium.dev/selenium/docs/api/py/) Python package,
  and a properly configured installation of either [chromedriver](https://chromedriver.chromium.org/) or
  [geckodriver](https://firefox-source-docs.mozilla.org/testing/geckodriver/).

  On Linux systems, this can be setup as follows:
  ```bash
  $ pip install selenium
  $ apt-get install chromium-chromedriver
  ```
  Using conda, the required packages can be installed as follows (a compatible version of
  [Google Chrome](https://www.google.com/chrome/) must be installed separately):
  ```bash
  $ conda install -c python-chromedriver-binary
  ```
  Selenium supports [other browsers](https://selenium-python.readthedocs.io/installation.html) as well,
  but altair-saver is currently only tested with Chrome.


  The *nodejs* backend supports the following formats:

  - `.vg.json`
  - `.png`
  - `.svg`
  - `.pdf`

  It requires [NodeJS](https://nodejs.org/), along with the [vega-lite](https://www.npmjs.com/package/vega-lite),
  [vega-cli](https://www.npmjs.com/package/vega-cli), and [canvas](https://www.npmjs.com/package/canvas) packages.

  First install NodeJS either by [direct download](https://nodejs.org/en/download/) or via a
  [package manager](https://nodejs.org/en/download/package-manager/), and then use the `npm` tool
  to install the required packages:
  ```bash
  $ npm install vega-lite vega-cli canvas
  ```
  Using conda, node and the required packages can be installed as follows:
  ```bash
  $ conda install -c conda-forge vega-cli vega-lite-cli
  ```
  These packages are included automatically when installing ``altair_saver`` via conda-forge.


pkgId: de2d5ed14efea90b219db2fb8b5de67dfd4835b514957a9a6af0c2b50fd02295
name: python-altair-viewer
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Viewer for Altair and Vega-Lite visualizations.
url: http://github.com/altair-viz/altair_viewer/
rpm_license: BSD 3-clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-altair-viewer-0.4.0-1.src.rpm
checksum_type: sha256
description:
  Offline chart viewer for [Altair](http://altair-viz.github.io) visualizations

  [![github actions](https://github.com/altair-viz/altair_viewer/workflows/build/badge.svg)](https://github.com/altair-viz/altair_viewer/actions?query=workflow%3Abuild)
  [![github actions](https://github.com/altair-viz/altair_viewer/workflows/lint/badge.svg)](https://github.com/altair-viz/altair_viewer/actions?query=workflow%3Alint)
  [![code style black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  This package provides tools for viewing Altair charts without a web connection in arbitrary Python
  environments. Charts can be displayed either inline in a Jupyter notebook environment, or in a
  separate browser window for use in any environment.

  ![Altair Viewer Gif](https://raw.githubusercontent.com/altair-viz/altair_viewer/master/images/viewer.gif)


  Altair Viewer can be installed from the
  [Python Package Index](http://pypi.org/project/altair_viewer) with ``pip``:
  ```
  $ pip install altair_viewer
  ```


  Altair viewer provides two top-level functions for displaying charts: ``display()`` and ``show()``.
  Their intended use is slightly different:
  ```python
  import altair_viewer
  altair_viewer.display(chart)
  ```
  ``display(chart)`` is meant for use in interactive computing environments where
  a single Python process is used interactively. It will serve a chart viewer at a localhost
  URL, and any susequent chart created within the session will appear in the same window.
  The background server will be terminated when the main Python process terminates, so this
  is not suitable for standalone scripts.

  ```python
  import altair_viewer
  altair_viewer.show(chart)
  ```
  ``show(chart)`` is meant for use once at the end of a Python script. It does the
  same as ``display()``, but automatically opens a browser window, and adds an input
  prompt to prevent the script (and the server it creates) from terminating.


  Within Jupyter notebook, IPython terminal, and related environments that support
  [Mimetype-based display](https://jupyterlab.readthedocs.io/en/stable/user/file_formats.html),
  altair viewer can be used by enabling the ``altair_viewer`` renderer:
  ```python
  import altair as alt
  alt.renderers.enable('altair_viewer')
  ```
  This will cause charts at the end of a Jupyter notebook cell to be rendered in a
  separate browser window, as with the ``display()`` and ``show()`` methods.

  If enabled with ``inline=True``, charts will be rendered inline in the notebook:
  ```python
  import altair as alt
  alt.renderers.enable('altair_viewer', inline=True)
  ```

  To display a single inline chart using Altair viewer in an IPython environment without
  globally enabling the associated renderer, you can use the ``display`` method directly:
  ```python
  import altair_viewer
  altair_viewer.display(chart, inline=True)
  ```

  Note that the display based on altair viewer will only function correctly as long as the
  kernel that created the charts is running, as it depends on the background server started
  by the kernel. In particular, this means that if you save a notebook and reopen it later,
  charts will not display until the associated cells are re-run.


pkgId: 2c9f89fd0031d1d60162704d8ec5b982b63b434c7c47464ec16a358e85e8dba3
name: python-altair_tiles
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: altair_tiles
url: https://pypi.org/project/altair_tiles/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-altair_tiles-0.3.0-1.src.rpm
checksum_type: sha256
description:
  <img src="https://raw.githubusercontent.com/altair-viz/altair_tiles/main/doc/logo.svg" height="110"></img>

  This package is in an early development stage. You should expect things to break unannounced until we release a version `1.0.0`.

  You can use altair_tiles to add tiles from any xyz tile provider such as OpenStreetMap to your Altair chart. It is a counterpart to the amazing [contextily](https://github.com/geopandas/contextily) package which provides this functionality for [matplotlib](https://matplotlib.org/).

  You can find the documentation [here](https://altair-viz.github.io/altair_tiles). For a general introduction to plotting geographic data with Altair, see [Geoshape - Vega-Altair](https://altair-viz.github.io/user_guide/marks/geoshape.html) and [Specifying Data - Vega-Altair](https://altair-viz.github.io/user_guide/data.html#spatial-data).


  ```bash
  pip install altair_tiles
  ```

  altair-tiles requires at least Vega version `5.26.0`. If you use an IDE such as a Jupyter Notebook or VS Code, you usually don't have to worry about this.


  ```bash
  python -m venv .venv
  source .venv/bin/activate
  pip install -e '.[dev]'
  ```

  Run linters and tests with
  ```bash
  hatch run test
  ```

  Build and view the documentation with
  ```bash
  hatch run doc:clean
  hatch run doc:build
  hatch run doc:serve
  ```

  To run a clean build and publish, run
  ```bash
  hatch run doc:build-and-publish
  ```


pkgId: 067d1280c96d0cab0e8fe329759f555736896bd665286a1a2f6f9b167c79cbf4
name: python-altamisa
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Implementation of ISA-tools data model and ISA-TAB
url: https://github.com/bihealth/altamisa
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-altamisa-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/altamisa.svg)](https://badge.fury.io/py/altamisa)
  [![codecov](https://codecov.io/gh/bihealth/altamisa/graph/badge.svg?token=R5GXUKCUYJ)](https://codecov.io/gh/bihealth/altamisa)
  [![Install with Bioconda](https://img.shields.io/badge/install%20with-bioconda-brightgreen.svg?style=flat)](http://bioconda.github.io)
  ![Continuous Integration Status](https://github.com/bihealth/altamisa/workflows/CI/badge.svg)
  [![Documentation Status](https://readthedocs.org/projects/altamisa/badge/?version=latest)](https://altamisa.readthedocs.io/en/latest/?badge=latest)
  [![DOI](https://joss.theoj.org/papers/10.21105/joss.01610/status.svg)](https://doi.org/10.21105/joss.01610)
  [![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)



  <img align="right" width="200" height="312" src="https://raw.githubusercontent.com/bihealth/altamisa/master/docs/images/Peruvian_Ragweed-small.png" />

  AltamISA is an alternative implementation of [ISA-tools](http://isa-tools.org/) [data model](http://isa-specs.readthedocs.io/en/latest/isamodel.html) and [ISA-Tab file format](http://isa-specs.readthedocs.io/en/latest/isatab.html).

  also:

  > *Ambrosia peruviana* is a species of plant in the family Asteraceae. It occurs from Mexico south to Argentina, being common in the Antilles and the Andes.
  >
  > In its native range, A. peruviana is used as a medicinal plant with analgesic, antiinflammatory, anthelmintic and antiseptic properties.
  >
  > -- [Ambrosia peruviana, Wikipedia](https://en.wikipedia.org/wiki/Ambrosia_peruviana)



  ```bash
  $ pip install altamisa

  $ conda install altamisa
  ```



  The ISA (Investigation-Study-Assay) defines a data model for describing life science experiments ([specification](https://isa-specs.readthedocs.io/en/latest/)).
  ISA-Tab defines a file format based on TSV (tab-separated values) for storing of ISA data in files.
  Shortly, experiments are encoded by DAGs (directed acyclic graphs) of samples being taken from sources (e.g., donor individuals) and then subjected to "operations" (e.g., extraction, assays, transformations) leading to different downstream "materials".



  Attempting to use the official `isa-api` Python package in early 2018 led to quite some frustration.
  Even the official ISA-tab examples parsed into non-expected graph structures.
  Attempting bug fixes to `isa-api` proofed difficult because of not having complete automated tests.
  Further, the scope of `isa-api` was much broader (including between ISA-Tab and other formats) such that we expected high maintenance costs (development [had apparently stalled](https://github.com/ISA-tools/isa-api/graphs/code-frequency)).



  - Programming Language: Python 3 (with **full type annotations**)
  - License: MIT
  - Test Coverage: >90%
  - Documentation: [see here](https://altamisa.readthedocs.org)
  - Code Style: [black](https://github.com/python/black), 100 characters/line






  - Mostly meta adjustments.



  - Adding exception for duplicate node annotations



  - Minor fixes regarding investigation file names and comments.



  - Minor fixes of validation and warnings.
  - Fixes optional parameter `filename` of `AssayReader`.



  - Ensuring that input order is output order.
    This is true except for the corner case where materials are not located in "blocks".
    Such corner cases would require storing the tabular representation (and keeping it in sync) at all times and does not yield to a robustly usable implementation.
    NB: the input is also not sorted the test adjusted with this patch shows.
  - Adding optional parameter `filename` to the various readers.
  - Exposing `RefTableBuilder` class with slightly changed interface.



  - Minor fixes and additions with focus on improving the export.



  - Updating documentation for JOSS.



  - Adding JOSS paper draft.
  - Fixing problem with writing empty lines on Windows (#52).
  - Update documentation with examples for manual model creation.
  - Fixing authorship documentation.
  - Fixing package (#58).



  - Switching to `attrs` instead of using `Namedtuple`.
    This gets rid of some warts regarding constructor overriding but should offer the same functionality otherwise.
  - Various updates to the documentation.



  First public release.

  - Started out with ISA-TAB parser and `NamedTuple`-based data model.


pkgId: f65fae30bc4c7286e8daf93329cd1c5e427715b42c8d23dbe2a7741dc347de75
name: python-altb
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: Cli tool for tracking over binaries and easily swapping between them
url: https://github.com/IamShobe/altb
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-altb-0.5.2-1.src.rpm
checksum_type: sha256
description:
  altb is a cli utility influenced by `update-alternatives` of ubuntu.
  Linked paths are added to `$HOME/.local/bin` according to [XDG Base Directory Specification](https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html).
  Config file is located at `$HOME/.config/altb/config.yaml`.



  **Must use Python > 3.9**
  execute:
  ```bash
  pipx install altb
  ```

  to track new binary use:
  ```bash
  altb track path <app_name>@<app_tag> /path/to/binary
  ```
  for example:
  ```bash
  altb track path python@2.7 /bin/python2.7
  altb track path python@3.8 /bin/python3.8

  ```

  List all tracked versions:
  ```bash
  $ altb list -a
  python
  |----   2.7 - /bin/python2.7
  |----   3.8 - /bin/python3.8
  ```

  Use specific version:
  ```bash
  altb use <app_name>[@<app_tag>]
  ```

  example:
  ```bash
  altb use python@2.7
  ```
  this will link the tracked path to `~/.local/bin/<app_name>` in this case - `~/.local/bin/python`

  Copy specific standalone binary automatically to `~/.local/share/altb/versions/<app_name>/<app_name>_<tag>`
  ```bash
  altb track path helm@3 ~/Downloads/helm --copy
  ```

  You can run custom commands using:
  ```bash
  altb track command special_command@latest "echo This is a command"
  ```
  this especially useful for latest developments, example:
  ```bash
  altb track command special_command@latest "go run ./cmd/special_command" --working-directory "$HOME/special_command"
  ```




  - [Migrate to v0.5.0 and above from lower versions](./docs/migrations/migrate_to_0_5_0.md)


pkgId: 0ed62ba06279306042b4a1525208b1b77d8009db355c329e27bb7a2a76c384e5
name: python-altcha
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: A library for creating and verifying challenges for ALTCHA.
url: https://github.com/altcha-org/altcha-lib-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-altcha-0.1.6-1.src.rpm
checksum_type: sha256
description:
  The ALTCHA Python Library is a lightweight, zero-dependency library designed for creating and verifying [ALTCHA](https://altcha.org) challenges, specifically tailored for Python applications.



  This library is compatible with:

  - Python 3.9+



  - [Demo server](https://github.com/altcha-org/altcha-starter-py)



  To install the ALTCHA Python Library, use the following command:

  ```sh
  pip install altcha
  ```



  ```sh
  python -m build
  ```



  ```sh
  python -m unittest discover tests
  ```



  Here’s a basic example of how to use the ALTCHA Python Library:

  ```python
  from altcha import ChallengeOptions, create_challenge, verify_solution

  def main():
      hmac_key = "secret hmac key"

      
      options = ChallengeOptions(
          max_number=100000, # The maximum random number
          hmac_key=hmac_key,
      )
      challenge = create_challenge(options)
      print("Challenge created:", challenge)

      
      payload = {
          "algorithm": challenge.algorithm,
          "challenge": challenge.challenge,
          "number": 12345,  # Example number
          "salt": challenge.salt,
          "signature": challenge.signature,
      }

      
      ok, err = verify_solution(payload, hmac_key, check_expires=True)
      if err:
          print("Error:", err)
      elif ok:
          print("Solution verified!")
      else:
          print("Invalid solution.")

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





  Creates a new challenge for ALTCHA.

  **Parameters:**

  - `options (dict)`:
    - `algorithm (str)`: Hashing algorithm to use (`'SHA-1'`, `'SHA-256'`, `'SHA-512'`, default: `'SHA-256'`).
    - `max_number (int)`: Maximum number for the random number generator (default: 1,000,000).
    - `salt_length (int)`: Length of the random salt in bytes (default: 12).
    - `hmac_key (str)`: Required HMAC key.
    - `salt (str)`: Optional salt string. If not provided, a random salt will be generated.
    - `number (int)`: Optional specific number to use. If not provided, a random number will be generated.
    - `expires (datetime)`: Optional expiration time for the challenge.
    - `params (dict)`: Optional URL-encoded query parameters.

  **Returns:** `Challenge`



  Verifies an ALTCHA solution.

  **Parameters:**

  - `payload (dict)`: The solution payload to verify.
  - `hmac_key (str)`: The HMAC key used for verification.
  - `check_expires (bool)`: Whether to check if the challenge has expired.

  **Returns:** `(bool, str or None)`



  Extracts URL parameters from the payload's salt.

  **Parameters:**

  - `payload (dict)`: The payload containing the salt.

  **Returns:** `dict`



  Verifies the hash of form fields.

  **Parameters:**

  - `form_data (dict)`: The form data to hash.
  - `fields (list)`: The fields to include in the hash.
  - `fields_hash (str)`: The expected hash value.
  - `algorithm (str)`: Hashing algorithm (`'SHA-1'`, `'SHA-256'`, `'SHA-512'`).

  **Returns:** `bool`



  Verifies the server signature.

  **Parameters:**

  - `payload (dict or str)`: The payload to verify (base64 encoded JSON string or dictionary).
  - `hmac_key (str)`: The HMAC key used for verification.

  **Returns:** `(bool, ServerSignatureVerificationData, str or None)`



  Finds a solution to the given challenge.

  **Parameters:**

  - `challenge (str)`: The challenge hash.
  - `salt (str)`: The challenge salt.
  - `algorithm (str)`: Hashing algorithm (`'SHA-1'`, `'SHA-256'`, `'SHA-512'`).
  - `max_number (int)`: Maximum number to iterate to.
  - `start (int)`: Starting number.

  **Returns:** `Solution or None`



  MIT


pkgId: d209bc87e600f7c88ec03fd65d106016f8536e89083aba785d1f97234e5b8201
name: python-alteia
arch: src
version: 2.13.0
epoch: 0
release: 1
summary: High-level Python interface to Alteia API
url: https://github.com/alteia-ai/alteia-python-sdk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alteia-2.13.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
  <img src="https://raw.githubusercontent.com/alteia-ai/alteia-python-sdk/master/docs/images/SDK_Python.png" alt="logo" style="max-width:100%;">

  <p align="center">
  <a href="https://pypi.org/project/alteia/" rel="nofollow"><img src="https://img.shields.io/pypi/v/alteia.svg" alt="pypi version" style="max-width:100%;"></a>
  <a href="https://pypi.org/project/alteia/" rel="nofollow"><img src="https://img.shields.io/pypi/pyversions/alteia.svg" alt="compatible python versions" style="max-width:100%;"></a>
  </p>

  > This SDK offers a high-level Python interface to [Alteia APIs](https://www.alteia.com).



  ```bash
  pip install alteia
  ```

  **requires Python >= 3.6.1, pip >= 20.3*



  ```python
  import alteia

  sdk = alteia.SDK(user="YOUR_EMAIL_ADDRESS", password="YOUR_ALTEIA_PASSWORD")

  projects = sdk.projects.search()

  for project in projects:
      print(project.name)


  ```

  <p>&nbsp;</p>



  - [Reference documentation](https://alteia.readthedocs.io/en/latest/index.html)
  - [Jupyter notebook tutorials](https://github.com/alteia-ai/tutorials)



  Package installation:

  ```bash
  poetry install
  ```

  (Optional) To install pre-commit hooks (and detect problems before the pipelines):

  ```bash
  pip install pre-commit
  pre-commit install
  pre-commit run --all-files
  pre-commit autoupdate  # Optional, to update pre-commit versions
  ```


pkgId: 3a156e247a3773f777e2a57ef831131143916758980b090204773d24ea05bdf6
name: python-alteza
arch: src
version: 0.8.9
epoch: 0
release: 1
summary: Super-flexible Static Site Generator
url: https://github.com/arjun-menon/alteza
rpm_license: AGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alteza-0.8.9-1.src.rpm
checksum_type: sha256
description:
  This project is licensed under the AGPL v3, but I'm reserving the right to re-license it under a license with fewer restrictions, e.g. the Apache License 2.0, and any PRs constitute consent to re-license as such.


pkgId: 76789e39e5186e25d5e9149405f1df31a2ec975ec235ce977783539eea9b3fa0
name: python-altissimo
arch: src
version: 0.1.12
epoch: 0
release: 1
summary: Altissimo Python package
url: https://github.com/altissimo/altissimo
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-altissimo-0.1.12-1.src.rpm
checksum_type: sha256
description:
  ```
  from altissimo.firestore import Firestore

  f = Firestore(project=project, credentials=credentials, database=database)


  items = f.get_collection("collection")
  ```



  ```
  from altissimo.secretmanager import SecretManager

  s = SecretManager(project=project, credentials=credentials)


  secret = s.get_secret(secret, version="latest", project=project)
  ```





  ```
  from altissimo.tools import chunks


  for chunk in chunks(my_list, 5):
      
      pass
  ```

  * `chunks(list, n)`: Return successive n-sized chunks from list.
  * `list_to_dict(list, key="id")`: Return a dict of items by key from list.


pkgId: 59a5a6c231b9cd3f5a341c0c27732e10e0ea42e2129aff332eeea88baee07843
name: python-altmindpy
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: The official Python library for the altmind API
url: https://github.com/AltermindLabs/altmind-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-altmindpy-0.4.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/altmindpy.svg)](https://pypi.org/project/altmindpy/)

  The Altmind Python library provides convenient access to the Altmind REST API from any Python 3.7+
  application. The library includes type definitions for all request params and response fields,
  and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).

  It is generated with [Stainless](https://www.stainlessapi.com/).



  The REST API documentation can be found on [localhost](https://localhost:8000/docs). The full API of this library can be found in [api.md](https://github.com/AltermindLabs/altmind-python/tree/main/api.md).



  ```sh

  pip install altmindpy
  ```



  The full API of this library can be found in [api.md](https://github.com/AltermindLabs/altmind-python/tree/main/api.md).

  ```python
  import os
  from altmindpy import Altmind

  client = Altmind(
      
      access_token=os.environ.get("ALTMIND_ACCESS_TOKEN"),
  )

  token = client.login.access_token(
      password="password",
      username="username",
  )
  print(token.access_token)
  ```

  While you can provide a `access_token` keyword argument,
  we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
  to add `ALTMIND_ACCESS_TOKEN="My Access Token"` to your `.env` file
  so that your Access Token is not stored in source control.



  Simply import `AsyncAltmind` instead of `Altmind` and use `await` with each API call:

  ```python
  import os
  import asyncio
  from altmindpy import AsyncAltmind

  client = AsyncAltmind(
      
      access_token=os.environ.get("ALTMIND_ACCESS_TOKEN"),
  )


  async def main() -> None:
      token = await client.login.access_token(
          password="password",
          username="username",
      )
      print(token.access_token)


  asyncio.run(main())
  ```

  Functionality between the synchronous and asynchronous clients is otherwise identical.



  Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods for things like:

  - Serializing back into JSON, `model.to_json()`
  - Converting to a dictionary, `model.to_dict()`

  Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.



  When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `altmindpy.APIConnectionError` is raised.

  When the API returns a non-success status code (that is, 4xx or 5xx
  response), a subclass of `altmindpy.APIStatusError` is raised, containing `status_code` and `response` properties.

  All errors inherit from `altmindpy.APIError`.

  ```python
  import altmindpy
  from altmindpy import Altmind

  client = Altmind()

  try:
      client.login.access_token(
          password="password",
          username="username",
      )
  except altmindpy.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except altmindpy.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except altmindpy.APIStatusError as e:
      print("Another non-200-range status code was received")
      print(e.status_code)
      print(e.response)
  ```

  Error codes are as followed:

  | Status Code | Error Type                 |
  | ----------- | -------------------------- |
  | 400         | `BadRequestError`          |
  | 401         | `AuthenticationError`      |
  | 403         | `PermissionDeniedError`    |
  | 404         | `NotFoundError`            |
  | 422         | `UnprocessableEntityError` |
  | 429         | `RateLimitError`           |
  | >=500       | `InternalServerError`      |
  | N/A         | `APIConnectionError`       |



  Certain errors are automatically retried 2 times by default, with a short exponential backoff.
  Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
  429 Rate Limit, and >=500 Internal errors are all retried by default.

  You can use the `max_retries` option to configure or disable retry settings:

  ```python
  from altmindpy import Altmind


  client = Altmind(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).login.access_token(
      password="password",
      username="username",
  )
  ```



  By default requests time out after 1 minute. You can configure this with a `timeout` option,
  which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/#fine-tuning-the-configuration) object:

  ```python
  from altmindpy import Altmind


  client = Altmind(
      
      timeout=20.0,
  )


  client = Altmind(
      timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
  )


  client.with_options(timeout=5.0).login.access_token(
      password="password",
      username="username",
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/AltermindLabs/altmind-python/tree/main/#retries).





  We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.

  You can enable logging by setting the environment variable `ALTMIND_LOG` to `debug`.

  ```shell
  $ export ALTMIND_LOG=debug
  ```



  In an API response, a field may be explicitly `null`, or missing entirely; in either case, its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`:

  ```py
  if response.my_field is None:
    if 'my_field' not in response.model_fields_set:
      print('Got json like {}, without a "my_field" key present at all.')
    else:
      print('Got json like {"my_field": null}.')
  ```



  The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g.,

  ```py
  from altmindpy import Altmind

  client = Altmind()
  response = client.login.with_raw_response.access_token(
      password="password",
      username="username",
  )
  print(response.headers.get('X-My-Header'))

  login = response.parse()  # get the object that `login.access_token()` would have returned
  print(login.access_token)
  ```

  These methods return an [`APIResponse`](https://github.com/AltermindLabs/altmind-python/tree/main/src/altmindpy/_response.py) object.

  The async client returns an [`AsyncAPIResponse`](https://github.com/AltermindLabs/altmind-python/tree/main/src/altmindpy/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.



  The above interface eagerly reads the full response body when you make the request, which may not always be what you want.

  To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.

  ```python
  with client.login.with_streaming_response.access_token(
      password="password",
      username="username",
  ) as response:
      print(response.headers.get("X-My-Header"))

      for line in response.iter_lines():
          print(line)
  ```

  The context manager is required so that the response will reliably be closed.



  This library is typed for convenient access to the documented API.

  If you need to access undocumented endpoints, params, or response properties, the library can still be used.



  To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other
  http verbs. Options on the client will be respected (such as retries) will be respected when making this
  request.

  ```py
  import httpx

  response = client.post(
      "/foo",
      cast_to=httpx.Response,
      body={"my_param": True},
  )

  print(response.headers.get("x-foo"))
  ```



  If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` request
  options.



  To access undocumented response properties, you can access the extra fields like `response.unknown_prop`. You
  can also get all the extra fields on the Pydantic model as a dict with
  [`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra).



  You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:

  - Support for proxies
  - Custom transports
  - Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality

  ```python
  from altmindpy import Altmind, DefaultHttpxClient

  client = Altmind(
      
      base_url="http://my.test.server.example.com:8083",
      http_client=DefaultHttpxClient(
          proxies="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```

  You can also customize the client on a per-request basis by using `with_options()`:

  ```python
  client.with_options(http_client=DefaultHttpxClient(...))
  ```



  By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.



  This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes that only affect static types, without breaking runtime behavior.
  2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals)_.
  3. Changes that we do not expect to impact the vast majority of users in practice.

  We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

  We are keen for your feedback; please open an [issue](https://www.github.com/AltermindLabs/altmind-python/issues) with questions, bugs, or suggestions.



  Python 3.7 or higher.


pkgId: 27e7bf42fa4c2ad4487b0bd90581c37d2bee539dfd3260adedd399c54e0311ba
name: python-altvmasterlist
arch: src
version: 3.2.3
epoch: 0
release: 1
summary: A package to use the alt:V Masterlist api.
url: https://github.com/Nickwasused/altv-python-masterlist
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-altvmasterlist-3.2.3-1.src.rpm
checksum_type: sha256
description:
  <p align="center"> This is a python3 package to interface with the <a href="https://altv.mp">alt:V</a> Masterlist API.
      <br>
  </p>

  - [About](#about)
  - [Getting Started](#getting_started)
  - [Deployment](#deployment)
  - [Usage](#usage)
  - [Built Using](#built_using)
  - [Affiliation](#affiliation)

  This is a python3 package to interface with the <a href="https://altv.mp">alt:V</a> Masterlist API.

  These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See [deployment](#deployment) for notes on how to deploy the project on a live system.

  What things you need to install the software and how to install them.
  ``python3`` is required.
  ``poetry`` [is required](https://python-poetry.org/)

  Install the required packages by running:
  ```
  poetry install --all-extras
  ```
  To run the tests:
  ```
  poetry run pytest
  ```
  To build the project:
  ```
  poetry run build
  ```

  See the docs: [https://nickwasused.com/altv-python-masterlist/altvmasterlist.html](https://nickwasused.com/altv-python-masterlist/altvmasterlist.html)

  None

  The code is formatted and checked with [ruff](https://github.com/astral-sh/ruff)s default settings.

  - [Poetry](https://python-poetry.org/) - Python packaging and dependency management
  - [Pytest](https://pytest.org/) - Code tests

  I am not affiliated with the [altMP](https://alt-mp.com/) team.


pkgId: d2b6ae467d493ac1715e3e81f53ac14a4b2dd69f39230efd3dccec9e28e86765
name: python-alumnium
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Pave the way towards AI-powered test automation.
url: https://alumnium.ai
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alumnium-0.2.0-1.src.rpm
checksum_type: sha256
description:
  <h1>
      <img src="https://github.com/user-attachments/assets/44e63cc3-d0e8-4b79-bfc1-015ce91a92f7" height="48px" />
      <sup>Alumnium</sup>
  </h1>

  _Pave the way towards AI-powered test automation._

  Aluminum is an experimental project that builds upon the existing test automation ecosystem, offering a higher-level abstraction for testing. It aims to simplify interactions with web pages and provide more robust mechanisms for verifying assertions.

  Currently in the very early stages of development and not recommended for production use.



  ```bash
  pip install alumnium
  ```



  Alumnium uses OpenAI by default, but you can change it by following the steps below.

  _At the moment of writing, Google AI Studio provides free access to its models, so you can use it for playing around with Alumnium._



  1. Get the API key from [OpenAI][1].
  2. Give Alumnium access to the API.

  ```bash
  export OPENAI_API_KEY="sk-proj-..."
  ```



  1. Get the API key from [Anthropic][2].
  2. Tell Alumnium to use Claude and provide access.

  ```bash
  export ALUMNIUM_MODEL="anthropic"
  export ANTHROPIC_API_KEY="sk-ant-..."
  ```



  1. Get the API key from [Google AI Studio][3].
  2. Tell Alumnium to use Gemini and provide access.

  ```bash
  export ALUMNIUM_MODEL="google"
  export GOOGLE_API_KEY="..."
  ```



  Start Alumnium using your Selenium driver and begin interacting with the webpage and check assertions.

  ```python
  from alumnium import Alumni
  from selenium.webdriver import Chrome

  driver = Chrome()
  driver.get("https://google.com")

  al = Alumni(driver)
  al.do("search for selenium")
  al.check("selenium in page title")
  al.check("selenium.dev is present in the search results")
  ```

  Check out more [examples][4]!



  - Cross-browser support (currently only Chrome and Edge are working).
  - Mobile applications support via Appium.
  - Playwright support.
  - Open LLMs support (currently only Anthropic, Google and OpenAI are proven to work).
  - Automatic handling of flakiness.
  - Improved caching for faster performance.
  - High-level multi-step instructions and verifications (currently the instructions must be very concrete).
  - Other languages support (C#, Java, JavaScript, Ruby, etc.)





  Set to `1` to enable debug logs and print them to stdout.



  Select AI provider to use. Supported values are:

  - `anthropic`
  - `azure_openai`
  - `aws_anthropic`
  - `google`
  - `openai`



  Setup the project:

  ```bash
  pipx install poetry
  poetry install
  ```

  Configure access to AI providers:

  ```bash
  export ANTHROPIC_API_KEY="sk-ant-..."
  export OPENAI_API_KEY="sk-proj-..."
  export GOOGLE_API_KEY="..."
  ```

  To run REPL for demo, use the following command:

  ```
  poetry run python -i demo.py
  ```

  To run Cucumber examples, use the following command:

  ```
  poetry run behave
  ```

  To run the Pytest test use the following command:

  ```
  poetry run pytest
  ```




  [1]: https://help.openai.com/en/articles/4936850-where-do-i-find-my-openai-api-key
  [2]: https://docs.anthropic.com/en/api/getting-started
  [3]: https://aistudio.google.com/app/apikey
  [4]: examples/


pkgId: 238997e3a22254a44d25c3c0db01de78f9105c32b06800caf42272f4f958ebe8
name: python-alvin-api-client
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: Python SDK implementing a Client of the Alvin API
url: https://github.com/alvindotai/alvin/tree/master/alvin_api_client
rpm_license: AGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alvin-api-client-1.4.1-1.src.rpm
checksum_type: sha256
description:
  Alvin API Client is a sdk package developed at Alvin. This is a dependency package for Alvin CLI and is installed during installation of the
  CLI package.

  Find the

  - Alvin CLI [here](https://pypi.org/project/alvin-cli)

  - Alvin [docs](https://docs.alvin.ai)

  - Request Invite [here](https://www.alvin.ai)


pkgId: e733a75d9a760706d2b828ff04e4b40ec405d4a64a01328d3b7cd3d15d0885be
name: python-alvin-simple-cli
arch: src
version: 0.0.35
epoch: 0
release: 1
summary: Alvin Simple CLI
url: https://pypi.org/project/alvin-simple-cli/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-alvin-simple-cli-0.0.35-1.src.rpm
checksum_type: sha256
rpm_license:
  GNU AFFERO GENERAL PUBLIC LICENSE Version 3, 19 November 2007  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The GNU Affero General Public License is a free, copyleft license for software and other kinds of works, specifically designed to ensure cooperation with the community in the case of network server software.  The licenses for most software and other practical works are designed to take away your freedom to share and change the works.  By contrast, our General Public Licenses are intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users.  When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.  Developers that use our General Public Licenses protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License which gives you legal permission to copy, distribute and/or modify the software.  A secondary benefit of defending all users' freedom is that improvements made in alternate versions of the program, if they receive widespread use, become available for other developers to incorporate.  Many developers of free software are heartened and encouraged by the resulting cooperation.  However, in the case of software used on network servers, this result may fail to come about. The GNU General Public License permits making a modified version and letting the public access it on a server without ever releasing its source code to the public.  The GNU Affero General Public License is designed specifically to ensure that, in such cases, the modified source code becomes available to the community.  It 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.  An older license, called the Affero General Public License and published by Affero, was designed to accomplish similar goals.  This is a different license, not a version of the Affero GPL, but Affero has released a new version of the Affero GPL which permits relicensing under this license.  The precise terms and conditions for copying, distribution and modification follow.  TERMS AND CONDITIONS  0. Definitions.  "This License" refers to version 3 of the GNU Affero General Public License.  "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.  "The Program" refers to any copyrightable work licensed under this License.  Each licensee is addressed as "you".  "Licensees" and "recipients" may be individuals or organizations.  To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy.  The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.  A "covered work" means either the unmodified Program or a work based on the Program.  To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy.  Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.  To "convey" a work means any kind of propagation that enables other parties to make or receive copies.  Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.  An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License.  If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.  1. Source Code.  The "source code" for a work means the preferred form of the work for making modifications to it.  "Object code" means any non-source form of a work.  A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.  The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form.  A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.  The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities.  However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.  For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.  The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.  The Corresponding Source for a work in source code form is that same work.  2. Basic Permissions.  All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met.  This License explicitly affirms your unlimited permission to run the unmodified Program.  The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work.  This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.  You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force.  You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright.  Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.  Conveying under any other circumstances is permitted solely under the conditions stated below.  Sublicensing is not allowed; section 10 makes it unnecessary.  3. Protecting Users' Legal Rights From Anti-Circumvention Law.  No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.  When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.  4. Conveying Verbatim Copies.  You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.  You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.  5. Conveying Modified Source Versions.  You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:  a) The work must carry prominent notices stating that you modified it, and giving a relevant date.  b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7.  This requirement modifies the requirement in section 4 to "keep intact all notices".  c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy.  This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged.  This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.  d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.  A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit.  Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.  6. Conveying Non-Source Forms.  You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:  a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.  b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.  c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source.  This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.  d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge.  You need not require recipients to copy the Corresponding Source along with the object code.  If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source.  Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.  e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.  A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.  A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling.  In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage.  For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product.  A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.  "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source.  The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.  If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information.  But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).  The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed.  Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.  Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.  7. Additional Terms.  "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law.  If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.  When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it.  (Additional permissions may be written to require their own removal in certain cases when you modify the work.)  You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.  Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:  a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or  b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or  c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or  d) Limiting the use for publicity purposes of names of licensors or authors of the material; or  e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or  f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.  All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10.  If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term.  If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.  If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.  Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.  8. Termination.  You may not propagate or modify a covered work except as expressly provided under this License.  Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).  However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.  Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.  Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License.  If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.  9. Acceptance Not Required for Having Copies.  You are not required to accept this License in order to receive or run a copy of the Program.  Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance.  However, nothing other than this License grants you permission to propagate or modify any covered work.  These actions infringe copyright if you do not accept this License.  Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.  10. Automatic Licensing of Downstream Recipients.  Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License.  You are not responsible for enforcing compliance by third parties with this License.  An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations.  If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.  You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.  For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.  11. Patents.  A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based.  The work thus licensed is called the contributor's "contributor version".  A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version.  For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.  Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.  In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement).  To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.  If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients.  "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.  If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.  A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License.  You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.  Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.  12. No Surrender of Others' Freedom.  If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all.  For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.  13. Remote Network Interaction; Use with the GNU General Public License.  Notwithstanding any other provision of this License, if you modify the Program, your modified version must prominently offer all users interacting with it remotely through a computer network (if your version supports such interaction) an opportunity to receive the Corresponding Source of your version by providing access to the Corresponding Source from a network server at no charge, through some standard or customary means of facilitating copying of software.  This Corresponding Source shall include the Corresponding Source for any work covered by version 3 of the GNU General Public License that is incorporated pursuant to the following paragraph.  Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU General Public License into a single combined work, and to convey the resulting work.  The terms of this License will continue to apply to the part which is the covered work, but the work with which it is combined will remain governed by version 3 of the GNU General Public License.  14. Revised Versions of this License.  The Free Software Foundation may publish revised and/or new versions of the GNU Affero General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Program specifies that a certain numbered version of the GNU Affero General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of the GNU Affero General Public License, you may choose any version ever published by the Free Software Foundation.  If the Program specifies that a proxy can decide which future versions of the GNU Affero General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.  Later license versions may give you additional or different permissions.  However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.  15. Disclaimer of Warranty.  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. Limitation of Liability.  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  17. Interpretation of Sections 15 and 16.  If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Programs  If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.  To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  <one line to give the program's name and a brief idea of what it does.> Copyright (C) <year>  <name of author>  This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.  You should have received a copy of the GNU Affero General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.  Also add information on how to contact you by electronic and paper mail.  If your software can interact with users remotely through a computer network, you should also make sure that it provides a way for users to get its source.  For example, if your program is a web application, its interface could display a "Source" link that leads users to an archive of the code.  There are many ways you could offer source, and different solutions will be better for different programs; see section 13 for the specific requirements.  You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU AGPL, see <https://www.gnu.org/licenses/>.


pkgId: 2668768dbb35bdf5b36576fb78ac6db45390fb942ca959401b179e454fec39a0
name: python-am2r-yams
arch: src
version: 2.8.1
epoch: 0
release: 1
summary: An open source randomizer patcher for AM2R.
url: https://pypi.org/project/am2r-yams/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-am2r-yams-2.8.1-1.src.rpm
checksum_type: sha256
description:
  A patcher for providing a different randomization experience to AM2R different to what the game has built-in. It was primarily designed for [Randovania](https://github.com/randovania/randovania), but it's also usable as a standalone patcher.
  Usage:
  `./YAMS-CLI [path-to-original-data-file] [path-to-output-data-file] [path-to-json-file]`

  The API/Schema for the input json file will soon be documented. In the meantime, one can look at [this source file](https://github.com/randovania/YAMS/blob/main/YAMS-LIB/SeedObject.cs).


  This project uses git submodules. So before compiling, please ensure you have cloned them (either by doing `git clone --recursive https://github.com/randovania/YAMS`, or if you have already cloned the repo, `git submodule update --init`).
  After that, you can use the standard dotnet compilation step: `dotnet build YAMS-CLI`.


  All code is licensed under the GNU Public License version 3. See the `LICENSE-CODE` file for full details.
  Art assets are licensed under [CC-BY-SA 4.0](https://creativecommons.org/licenses/by/4.0/). For the full list of authors and more details, please read the `Attribution.md` file located in [`YAMS-LIB/sprites/`](./YAMS-LIB/sprites/Attribution.md).

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


pkgId: 64cc54fc0036096eaa488a1230155856a8207210cf19090032cfc465d6393483
name: python-am4894hubspot
arch: src
version: 0.0.14
epoch: 0
release: 1
summary: A helper library for hubspot api
url: https://github.com/andrewm4894/am4894hubspot/tree/master/
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-am4894hubspot-0.0.14-1.src.rpm
checksum_type: sha256
description:
  > Helper library for working with hubspot api.


  [![pypi package](https://img.shields.io/pypi/v/am4894hubspot.svg)](https://pypi.python.org/pypi/am4894hubspot/)

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



  `pip install am4894hubspot`


pkgId: 023fcb7393cf14f523cc1cd9a1c254ac1314872f6842602f2af0d5841e6d20b6
name: python-ama-xiv-combat-sim
arch: src
version: 2024.10.27.1
epoch: 0
release: 1
summary: Ama's FF14 Combat Sim
url: https://github.com/Amarantine-xiv/Amas-FF14-Combat-Sim_source
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ama-xiv-combat-sim-2024.10.27.1-1.src.rpm
checksum_type: sha256
description:
  Open source code for Ama's FF14 Combat Sim.


  If you would like to run the sim but do not want to install it, go to the [Python Notebook Github](https://github.com/Amarantine-xiv/Amas-FF14-Combat-Sim) and follow the instruction to open and use *CoreSimulator.ipynb*.

  If you would like to install the sim to run locally, run ```pip install ama-xiv-combat-sim``` on your machine to install the core packages. You may want to refer to some of the code in the [Python Notebook](https://github.com/Amarantine-xiv/Amas-FF14-Combat-Sim/blob/main/CoreSimulator.ipynb) to grab some visualization/plotting code that visualizes the sim's output.


  This open-source package simulates the damage of given gearsets and rotations, producing the full distributions over damage values and various statistics, like the expected max damage over N runs (useful for parsers). Currently, all lvl 90 standard combat classes are supported (lvl 100 and Dawntrail support will come in the future, after Dawntrail is released). For issues/feature requests and news, join the [Discord](https://discord.gg/CV6sHj8h9D) server.

  Unlike other simulators/spreadsheets, this gives more than just expected damage with an approximation of damage variance- this is an accurate [Monte Carlo](https://en.wikipedia.org/wiki/Monte_Carlo_method) simulation that gives the full range and distribution over all possible damage values. This tool is an installable pip package, and is also in a standalone [Python Notebook](https://github.com/Amarantine-xiv/Amas-FF14-Combat-Sim/blob/main/CoreSimulator.ipynb) that can be run on Google's Colab in 2 mouse clicks.

  The sim's main computation engine is written in Numpy, relying on parallelized matrix-based computations for the heavy lifting. It runs fairly fast (a typical ~30s opener with 1M samples takes about 1-2 seconds on a single CPU).

  The tool has four advantages over existing simulators/spreadsheets:

  1) handles the simulation of all FF14 job classes in a single place- no need to maintain multiple spreadsheets, etc.,

  2) incorporates all damage rolls and crit/dh procs on a per-damage-instance basis, and rolls them every time the sim is run,

  3) enables the building of several useful community tools that either don't exist, or can be streamlined, using this sim as a backend, and

  4) allows for the incorporation of procs in the simulation process itself.

  Some examples of useful tools is a *kill time estimator*, that takes a 1) full 8-player rotation including LB usage, and 2) a target boss HP values, and outputs a distribution over expected kill times. To see a demonstration of this and other capabilities built on top of the sim, please refer to the [Python Notebook Github](https://github.com/Amarantine-xiv/Amas-FF14-Combat-Sim).




  After installation, make sure to *import ama-xiv-combat-sim* so that paths, etc. are set up. After this, you can import sub-packages/functions/files as you wish, and use them. Rotations can be specified both in code in the sim itself, and by passing in CSV files.


  ```
  import ama_xiv_combat_sim

  from ama_xiv_combat_sim.simulator.damage_simulator import DamageSimulator
  from ama_xiv_combat_sim.simulator.rotation_import_utils.csv_utils import CSVUtils
  from ama_xiv_combat_sim.simulator.skills import create_skill_library, SkillModifier
  from ama_xiv_combat_sim.simulator.stats import Stats
  from ama_xiv_combat_sim.simulator.timeline_builders.damage_builder import DamageBuilder
  from ama_xiv_combat_sim.simulator.timeline_builders.rotation_builder import RotationBuilder


  SKILL_LIBRARY = create_skill_library()


  stats = Stats(wd=132, weapon_delay=3.36, main_stat=3330, det_stat=2182, crit_stat=2596, dh_stat=940, speed_stat=400, tenacity=601, job_class = 'WAR')

  rb = RotationBuilder(stats, SKILL_LIBRARY, ignore_trailing_dots=True, enable_autos=True)



  rb.add(6.3, 'Chain Stratagem', job_class='SCH')
  rb.add(7.1, 'Battle Litany', job_class='DRG')
  rb.add(0.8, 'Arcane Circle', job_class='RPR')
  rb.add(6.28, 'Embolden', job_class='RDM')

  rb.add(6.3, 'Mug', job_class='NIN', skill_modifier=SkillModifier(with_condition='Debuff Only'))



  rb.add_next('Tomahawk')
  rb.add_next('Infuriate')
  rb.add_next('Heavy Swing')
  rb.add_next('Maim')
  rb.add_next('Grade 8 Tincture')
  rb.add_next("Storm's Eye")
  rb.add_next('Inner Release')
  rb.add_next('Inner Chaos')
  rb.add_next('Upheaval')
  rb.add_next('Onslaught')
  rb.add_next('Primal Rend')
  rb.add_next('Inner Chaos')
  rb.add_next('Onslaught')
  rb.add_next('Fell Cleave')
  rb.add_next('Onslaught')
  rb.add_next('Fell Cleave')
  rb.add_next('Fell Cleave')
  rb.add_next('Heavy Swing')
  rb.add_next('Maim')
  rb.add_next("Storm's Path")
  rb.add_next('Fell Cleave')
  rb.add_next('Inner Chaos')


  db = DamageBuilder(stats, SKILL_LIBRARY)
  sim = DamageSimulator(stats, db.get_damage_instances(rb.get_skill_timing()), num_samples=100000) #for speed, we only use 100k samples.
  dps = sim.get_dps() # dps values of our WAR rotation
  damage = sim.get_raw_damage() # raw damage of our WAR rotation
  per_skill_damage = sim.get_per_skill_damage(rb) # get per-damage-instance information
  damage_ranges = sim.get_damage_ranges() # get damage ranges on each skill, detailing crit/dh damage ranges and probabilities.


  ```


  ```
  import ama_xiv_combat_sim
  import os

  from ama_xiv_combat_sim.simulator.damage_simulator import DamageSimulator
  from ama_xiv_combat_sim.simulator.rotation_import_utils.csv_utils import CSVUtils
  from ama_xiv_combat_sim.simulator.skills import create_skill_library, SkillModifier
  from ama_xiv_combat_sim.simulator.stats import Stats
  from ama_xiv_combat_sim.simulator.timeline_builders.damage_builder import DamageBuilder
  from ama_xiv_combat_sim.simulator.timeline_builders.rotation_builder import RotationBuilder


  csv_filename = 'my_rotation.csv'


  SKILL_LIBRARY = create_skill_library()


  stats = Stats(wd=132, weapon_delay=3.36, main_stat=3330, det_stat=2182, crit_stat=2596, dh_stat=940, speed_stat=400, tenacity=601, job_class = 'WAR')

  rb = RotationBuilder(stats, SKILL_LIBRARY, ignore_trailing_dots=True, enable_autos=True)

  if not os.path.exists(csv_filename):
    print('File does not exist: {}. Make sure you are in the right directory and have the right file name: '.format(csv_filename))
  else:
      rb, _ = CSVUtils.populate_rotation_from_csv(rb, csv_filename)


  db = DamageBuilder(stats, SKILL_LIBRARY)
  sim = DamageSimulator(stats, db.get_damage_instances(rb.get_skill_timing()), num_samples=100000) #for speed, we only use 100k samples.
  dps = sim.get_dps()
  damage = sim.get_raw_damage()
  per_skill_damage = sim.get_per_skill_damage(rb) # get per-damage-instance information
  damage_ranges = sim.get_damage_ranges() # get damage ranges on each skill, detailing crit/dh damage ranges and probabilities.

  ```



  I'd like to thank the following people/groups for their help! Without them, this sim would not be at all possible:

  [The Balance](https://www.thebalanceffxiv.com/)

  Io Whitespirit

  Hint and [Hint's damage calc repo](https://github.com/hintxiv/reassemble)

  Fürst

  Apollo Van-waddleburg

  IAmPythagoras and [IAmPythagoras's FFXIV-Combat-Simulator](https://github.com/IAmPythagoras/FFXIV-Combat-Simulator) and [Discord](https://discord.com/invite/mZXKUNy2sw)

  Cless

  Kaiser08259

  Mahdi (from the Allagan Studies Discord server)

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


pkgId: 08b1459a8734531db63462adc2731e2cdadb6b3bf05c564bf481e7f713696a01
name: python-ama-xiv-combat-sim
arch: src
version: 2024.11.22.3
epoch: 0
release: 1
summary: Ama's FF14 Combat Sim
url: https://github.com/Amarantine-xiv/Amas-FF14-Combat-Sim_source
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ama-xiv-combat-sim-2024.11.22.3-1.src.rpm
checksum_type: sha256
description:
  Open source code for Ama's FF14 Combat Sim.


  If you would like to run the sim but do not want to install it, go to the [Python Notebook Github](https://github.com/Amarantine-xiv/Amas-FF14-Combat-Sim) and follow the instruction to open and use *CoreSimulator.ipynb*.

  If you would like to install the sim to run locally, run ```pip install ama-xiv-combat-sim``` on your machine to install the core packages. You may want to refer to some of the code in the [Python Notebook](https://github.com/Amarantine-xiv/Amas-FF14-Combat-Sim/blob/main/CoreSimulator.ipynb) to grab some visualization/plotting code that visualizes the sim's output.


  This open-source package simulates the damage of given gearsets and rotations, producing the full distributions over damage values and various statistics, like the expected max damage over N runs (useful for parsers). Currently, all lvl 100 standard combat classes are supported. For issues/feature requests and news, join the [Discord](https://discord.gg/CV6sHj8h9D) server.

  Unlike other simulators/spreadsheets, this gives more than just expected damage with an approximation of damage variance- this is an accurate [Monte Carlo](https://en.wikipedia.org/wiki/Monte_Carlo_method) simulation that gives the full range and distribution over all possible damage values. This tool is an installable pip package, and is also in a standalone [Python Notebook](https://github.com/Amarantine-xiv/Amas-FF14-Combat-Sim/blob/main/CoreSimulator.ipynb) that can be run on Google's Colab in 2 mouse clicks.

  The sim's main computation engine is written in Numpy, relying on parallelized matrix-based computations for the heavy lifting. It runs fairly fast (a typical ~30s opener with 1M samples takes about 1-2 seconds on a single CPU).

  The tool has four advantages over existing simulators/spreadsheets:

  1) handles the simulation of all FF14 job classes in a single place- no need to maintain multiple spreadsheets, etc.,

  2) incorporates all damage rolls and crit/dh procs on a per-damage-instance basis, and rolls them every time the sim is run,

  3) enables the building of several useful community tools that either don't exist, or can be streamlined, using this sim as a backend, and

  4) allows for the incorporation of procs in the simulation process itself.

  Some examples of useful tools is a *kill time estimator*, that takes a 1) full 8-player rotation including LB usage, and 2) a target boss HP values, and outputs a distribution over expected kill times. To see a demonstration of this and other capabilities built on top of the sim, please refer to the [Python Notebook Github](https://github.com/Amarantine-xiv/Amas-FF14-Combat-Sim).




  After installation, make sure to *import ama-xiv-combat-sim* so that paths, etc. are set up. After this, you can import sub-packages/functions/files as you wish, and use them. Rotations can be specified both in code in the sim itself, and by passing in CSV files.


  ```
  import ama_xiv_combat_sim

  from ama_xiv_combat_sim.simulator.damage_simulator import DamageSimulator
  from ama_xiv_combat_sim.simulator.rotation_import_utils.csv_utils import CSVUtils
  from ama_xiv_combat_sim.simulator.skills import create_skill_library, SkillModifier
  from ama_xiv_combat_sim.simulator.stats import Stats
  from ama_xiv_combat_sim.simulator.timeline_builders.damage_builder import DamageBuilder
  from ama_xiv_combat_sim.simulator.timeline_builders.rotation_builder import RotationBuilder


  SKILL_LIBRARY = create_skill_library()


  stats = Stats(wd=132, weapon_delay=3.36, main_stat=3330, det_stat=2182, crit_stat=2596, dh_stat=940, speed_stat=400, tenacity=601, job_class = 'WAR')

  rb = RotationBuilder(stats, SKILL_LIBRARY, ignore_trailing_dots=True, enable_autos=True)



  rb.add(6.3, 'Chain Stratagem', job_class='SCH')
  rb.add(7.1, 'Battle Litany', job_class='DRG')
  rb.add(0.8, 'Arcane Circle', job_class='RPR')
  rb.add(6.28, 'Embolden', job_class='RDM')
  rb.add(6.3, 'Dokumori', job_class='NIN')



  rb.add_next('Tomahawk')
  rb.add_next('Infuriate')
  rb.add_next('Heavy Swing')
  rb.add_next('Maim')
  rb.add_next('Grade 8 Tincture')
  rb.add_next("Storm's Eye")
  rb.add_next('Inner Release')
  rb.add_next('Inner Chaos')
  rb.add_next('Upheaval')
  rb.add_next('Onslaught')
  rb.add_next('Primal Rend')
  rb.add_next('Inner Chaos')
  rb.add_next('Onslaught')
  rb.add_next('Fell Cleave')
  rb.add_next('Onslaught')
  rb.add_next('Fell Cleave')
  rb.add_next('Fell Cleave')
  rb.add_next('Heavy Swing')
  rb.add_next('Maim')
  rb.add_next("Storm's Path")
  rb.add_next('Fell Cleave')
  rb.add_next('Inner Chaos')


  db = DamageBuilder(stats, SKILL_LIBRARY)
  sim = DamageSimulator(stats, db.get_damage_instances(rb.get_skill_timing()), num_samples=100000) #for speed, we only use 100k samples.
  dps = sim.get_dps() # dps values of our WAR rotation
  damage = sim.get_raw_damage() # raw damage of our WAR rotation
  per_skill_damage = sim.get_per_skill_damage(rb) # get per-damage-instance information
  damage_ranges = sim.get_damage_ranges() # get damage ranges on each skill, detailing crit/dh damage ranges and probabilities.


  ```


  ```
  import ama_xiv_combat_sim
  import os

  from ama_xiv_combat_sim.simulator.damage_simulator import DamageSimulator
  from ama_xiv_combat_sim.simulator.rotation_import_utils.csv_utils import CSVUtils
  from ama_xiv_combat_sim.simulator.skills import create_skill_library, SkillModifier
  from ama_xiv_combat_sim.simulator.stats import Stats
  from ama_xiv_combat_sim.simulator.timeline_builders.damage_builder import DamageBuilder
  from ama_xiv_combat_sim.simulator.timeline_builders.rotation_builder import RotationBuilder


  csv_filename = 'my_rotation.csv'


  SKILL_LIBRARY = create_skill_library()


  stats = Stats(wd=132, weapon_delay=3.36, main_stat=3330, det_stat=2182, crit_stat=2596, dh_stat=940, speed_stat=400, tenacity=601, job_class = 'WAR')

  rb = RotationBuilder(stats, SKILL_LIBRARY, ignore_trailing_dots=True, enable_autos=True)

  if not os.path.exists(csv_filename):
    print('File does not exist: {}. Make sure you are in the right directory and have the right file name: '.format(csv_filename))
  else:
      rb, _ = CSVUtils.populate_rotation_from_csv(rb, csv_filename)


  db = DamageBuilder(stats, SKILL_LIBRARY)
  sim = DamageSimulator(stats, db.get_damage_instances(rb.get_skill_timing()), num_samples=100000) #for speed, we only use 100k samples.
  dps = sim.get_dps()
  damage = sim.get_raw_damage()
  per_skill_damage = sim.get_per_skill_damage(rb) # get per-damage-instance information
  damage_ranges = sim.get_damage_ranges() # get damage ranges on each skill, detailing crit/dh damage ranges and probabilities.

  ```



  I'd like to thank the following people/groups for their help! Without them, this sim would not be at all possible:

  [The Balance](https://www.thebalanceffxiv.com/)

  Io Whitespirit

  Hint and [Hint's damage calc repo](https://github.com/hintxiv/reassemble)

  Fürst

  Apollo Van-waddleburg

  IAmPythagoras and [IAmPythagoras's FFXIV-Combat-Simulator](https://github.com/IAmPythagoras/FFXIV-Combat-Simulator) and [Discord](https://discord.com/invite/mZXKUNy2sw)

  Cless

  Kaiser08259

  Mahdi (from the Allagan Studies Discord server)

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


pkgId: c6d0abe845e965d9a0b6775076f5b6b3b2f2947cb49e83ae49ae8a6af8501eba
name: python-amaazetools
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: Python package for mesh processing tools developed by AMAAZE
url: https://github.com/jwcalder/AMAAZETools
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amaazetools-0.1.9-1.src.rpm
checksum_type: sha256
description:
  The AMAAZETools Python package contains Python implementations of mesh processing tools developed by [AMAAZE](https://amaaze.umn.edu/). The examples directory contains a series of test scripts showing how to use the package.


  The package is now available on the python package index, and can be installed with
  ```
  pip install amaazetools
  ```
  To install the most recent developers version of the package, run

  ```
  git clone https://github.com/jwcalder/AMAAZETools
  cd AMAAZETools
  pip install -r requirements.txt
  pip install .
  ```



  Detailed documentation for all of the Python code within this repository can be found at <https://jwcalder.github.io/AMAAZETools/>.



  Email <jwcalder@umn.edu> with any questions or comments.



  Several people have contributed to the development of this software:

  1. David Floeder
  2. Riley O'Neill
  3. Brendan Cook


pkgId: ab2f3d6cec91872f90f9476d152df57d22d4b79961cad4f1ef14e6bc89fad89b
name: python-amanobot
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Python framework for Telegram Bot API forked from Telepot
url: https://github.com/AmanoTeam/amanobot
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amanobot-2.1.0-1.src.rpm
checksum_type: sha256
description:
  <h6 align="center">
    <img src="https://i.imgur.com/CQ7S8hN.png" alt="Amanobot" height="150px">
    <h2 align="center">Amanobot</h2>
    <h6 align="center">Python framework for Telegram Bot API forked from Telepot</h6>
  </h6>
  <h6 align="center">
    <a href="https://pypi.org/project/amanobot"><img src="https://img.shields.io/pypi/v/amanobot.svg" /></a>
    <a href="https://core.telegram.org/bots/api"><img src="https://img.shields.io/badge/bot api-v5.0-0688CB.svg" /></a>
  </h6>


pkgId: a1eedc2915915d9d707858b098f394e6bbde3a98ccf7a5c664b907839133a136
name: python-amap-distance-matrix
arch: src
version: 0.4.5
epoch: 0
release: 1
summary: amap distance matrix service based on Redis and MySQL
url: https://github.com/Euraxluo/distance_matrix
rpm_license: The MIT LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amap-distance-matrix-0.4.5-1.src.rpm
checksum_type: sha256
description:
  - name = "amap_distance_matrix"
  - version = "0.4.4"
  - description = "amap distance matrix service based on Redis/Cluster Redis and MySQL"
  - authors = ["Euraxluo <euraxluo@outlook.com>"]
  - license = "The MIT LICENSE"
  - readme = "README.md"
  - homepage = "https://github.com/Euraxluo/distance_matrix"
  - repository = "https://github.com/Euraxluo/distance_matrix"


  `pip install amap-distance-matrix`

  ![](https://gitee.com/Euraxluo/images/raw/master/pycharm/MIK-RHfzjB.png)


  this project is only a pilot project


pkgId: 1ae48469ab908dbd7516610bce74dcf8898a95eee35de99dbc7e5e693d9ddbab
name: python-amarillo-grfs-exporter
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: GRFS export plugin for Amarillo
url: https://pypi.org/project/amarillo-grfs-exporter/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amarillo-grfs-exporter-2.0.2-1.src.rpm
checksum_type: sha256
description:
  This plugin for Amarillo adds endpoints `/region/{region_id}/grfs` and `/region/{region_id}/grfs-rt` for serving the GRFS data on your Amarillo instance. Serves the grfs zip files from the `data/gtfs` folder. If the files don't exist or are out of date (from yesterday in the case of GRFS and older than a minute for GRFS-RT) the plugin will retrieve them from the configured `generator_url`.



  ```
  pip install amarillo-grfs-exporter
  ```

  This package will install inside the amarillo/plugins folder in your python environment. Next time you launch Amarillo, it should be discovered automatically and you should see messages like this:

  ```
  INFO - Discovered plugins: ['amarillo.plugins.grfs_export', ...]
  ...
  INFO - Running setup function for amarillo.plugins.grfs_export
  ```

  The `setup()` function will be called automatically and it will add the necessary endpoints to your Amarillo FastAPI application.



  You can configure the `generator_url` through an environment variable, or by adding it to the `config` file in the amarillo root folder:

  ```
  generator_url = 'http://localhost:8002'
  ```

  The default value is `http://localhost:8002`.

  The generator_url should point to a running instance of [amarillo-grfs-generator](https://github.com/mitanand/amarillo-grfs-generator/).




  Make GET requests to the `/region/{region_id}/grfs` and `/region/{region_id}/grfs-rt`. The GRFS data will be returned as a zip file, while realtime data can be requested in .pbf or .json using the format query parameter.

  <!-- TODO: remove code that is unused because it has been moved to generator -->

rpm_license:
  GNU AFFERO GENERAL PUBLIC LICENSE Version 3, 19 November 2007  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The GNU Affero General Public License is a free, copyleft license for software and other kinds of works, specifically designed to ensure cooperation with the community in the case of network server software.  The licenses for most software and other practical works are designed to take away your freedom to share and change the works.  By contrast, our General Public Licenses are intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users.  When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.  Developers that use our General Public Licenses protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License which gives you legal permission to copy, distribute and/or modify the software.  A secondary benefit of defending all users' freedom is that improvements made in alternate versions of the program, if they receive widespread use, become available for other developers to incorporate.  Many developers of free software are heartened and encouraged by the resulting cooperation.  However, in the case of software used on network servers, this result may fail to come about. The GNU General Public License permits making a modified version and letting the public access it on a server without ever releasing its source code to the public.  The GNU Affero General Public License is designed specifically to ensure that, in such cases, the modified source code becomes available to the community.  It 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.  An older license, called the Affero General Public License and published by Affero, was designed to accomplish similar goals.  This is a different license, not a version of the Affero GPL, but Affero has released a new version of the Affero GPL which permits relicensing under this license.  The precise terms and conditions for copying, distribution and modification follow.  TERMS AND CONDITIONS  0. Definitions.  "This License" refers to version 3 of the GNU Affero General Public License.  "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.  "The Program" refers to any copyrightable work licensed under this License.  Each licensee is addressed as "you".  "Licensees" and "recipients" may be individuals or organizations.  To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy.  The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.  A "covered work" means either the unmodified Program or a work based on the Program.  To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy.  Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.  To "convey" a work means any kind of propagation that enables other parties to make or receive copies.  Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.  An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License.  If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.  1. Source Code.  The "source code" for a work means the preferred form of the work for making modifications to it.  "Object code" means any non-source form of a work.  A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.  The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form.  A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.  The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities.  However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.  For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.  The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.  The Corresponding Source for a work in source code form is that same work.  2. Basic Permissions.  All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met.  This License explicitly affirms your unlimited permission to run the unmodified Program.  The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work.  This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.  You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force.  You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright.  Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.  Conveying under any other circumstances is permitted solely under the conditions stated below.  Sublicensing is not allowed; section 10 makes it unnecessary.  3. Protecting Users' Legal Rights From Anti-Circumvention Law.  No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.  When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.  4. Conveying Verbatim Copies.  You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.  You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.  5. Conveying Modified Source Versions.  You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:  a) The work must carry prominent notices stating that you modified it, and giving a relevant date.  b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7.  This requirement modifies the requirement in section 4 to "keep intact all notices".  c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy.  This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged.  This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.  d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.  A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit.  Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.  6. Conveying Non-Source Forms.  You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:  a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.  b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.  c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source.  This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.  d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge.  You need not require recipients to copy the Corresponding Source along with the object code.  If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source.  Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.  e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.  A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.  A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling.  In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage.  For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product.  A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.  "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source.  The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.  If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information.  But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).  The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed.  Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.  Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.  7. Additional Terms.  "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law.  If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.  When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it.  (Additional permissions may be written to require their own removal in certain cases when you modify the work.)  You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.  Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:  a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or  b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or  c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or  d) Limiting the use for publicity purposes of names of licensors or authors of the material; or  e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or  f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.  All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10.  If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term.  If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.  If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.  Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.  8. Termination.  You may not propagate or modify a covered work except as expressly provided under this License.  Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).  However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.  Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.  Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License.  If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.  9. Acceptance Not Required for Having Copies.  You are not required to accept this License in order to receive or run a copy of the Program.  Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance.  However, nothing other than this License grants you permission to propagate or modify any covered work.  These actions infringe copyright if you do not accept this License.  Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.  10. Automatic Licensing of Downstream Recipients.  Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License.  You are not responsible for enforcing compliance by third parties with this License.  An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations.  If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.  You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.  For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.  11. Patents.  A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based.  The work thus licensed is called the contributor's "contributor version".  A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version.  For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.  Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.  In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement).  To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.  If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients.  "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.  If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.  A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License.  You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.  Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.  12. No Surrender of Others' Freedom.  If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all.  For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.  13. Remote Network Interaction; Use with the GNU General Public License.  Notwithstanding any other provision of this License, if you modify the Program, your modified version must prominently offer all users interacting with it remotely through a computer network (if your version supports such interaction) an opportunity to receive the Corresponding Source of your version by providing access to the Corresponding Source from a network server at no charge, through some standard or customary means of facilitating copying of software.  This Corresponding Source shall include the Corresponding Source for any work covered by version 3 of the GNU General Public License that is incorporated pursuant to the following paragraph.  Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU General Public License into a single combined work, and to convey the resulting work.  The terms of this License will continue to apply to the part which is the covered work, but the work with which it is combined will remain governed by version 3 of the GNU General Public License.  14. Revised Versions of this License.  The Free Software Foundation may publish revised and/or new versions of the GNU Affero General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Program specifies that a certain numbered version of the GNU Affero General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of the GNU Affero General Public License, you may choose any version ever published by the Free Software Foundation.  If the Program specifies that a proxy can decide which future versions of the GNU Affero General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.  Later license versions may give you additional or different permissions.  However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.  15. Disclaimer of Warranty.  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. Limitation of Liability.  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  17. Interpretation of Sections 15 and 16.  If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Programs  If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.  To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  <one line to give the program's name and a brief idea of what it does.> Copyright (C) <year>  <name of author>  This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.  You should have received a copy of the GNU Affero General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.  Also add information on how to contact you by electronic and paper mail.  If your software can interact with users remotely through a computer network, you should also make sure that it provides a way for users to get its source.  For example, if your program is a web application, its interface could display a "Source" link that leads users to an archive of the code.  There are many ways you could offer source, and different solutions will be better for different programs; see section 13 for the specific requirements.  You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU AGPL, see <https://www.gnu.org/licenses/>.


pkgId: 96a2d73d5946d84c04c8ec439792e8898943cf5660a547408c1b89ddf8afea76
name: python-amarna
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Amarna is a static-analyzer for the Cairo programming language.
url: https://github.com/crytic/amarna
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amarna-0.1.5-1.src.rpm
checksum_type: sha256
description:
  Amarna is a static-analyzer and linter for the Cairo programming language.


   - Finds code-smells and potential vulnerabilities in Cairo code
   - Compiler-identical parsing of Cairo code and StarkNet contracts
   - Supports creating local and global rules
   - Exports the parsed AST of a Cairo file
   - Exports static-analysis results to the [SARIF](https://sarifweb.azurewebsites.net/) format.


  Analyze a Cairo project in the current directory and export the SARIF results to a file:
   ```bash
   amarna . -o out.sarif
   ```

  Analyze a single file `file.cairo` and export the SARIF results to a file:
   ```bash
   amarna file.cairo -o out.sarif
   ```

  Analyze a single file `file.cairo` and print a summary of the results:
   ```bash
   amarna file.cairo -s
   ```


   - For GitHub action integration, use [amarna-action](https://github.com/crytic/amarna-action).



  | #   | Rule                        | What it finds                                                                                                             | Impact  | Precision |
  | --- | --------------------------- | ------------------------------------------------------------------------------------------------------------------------- | ------- | --------- |
  | 1   | Arithmetic operations       | All uses of arithmetic operations +, -, *, and /                                                                          | Info    | High      |
  | 2   | Unused arguments            | Function arguments that are not used in the functions in which they appear                                                | Warning | High      |
  | 3   | Unused imports              | Unused imports                                                                                                            | Info    | High      |
  | 4   | Mistyped decorators         | Mistyped code decorators                                                                                                  | Info    | High      |
  | 5   | Unused functions            | Functions that are never called                                                                                           | Info    | Medium    |
  | 6   | Error codes                 | Function calls that have return values that must be checked                                                               | Info    | High      |
  | 7   | Inconsistent assert usage   | Asserts that use the same constant in different ways, e.g., `assert_le(amount, BOUND)` and `assert_le(amount, BOUND - 1)` | Warning | High      |
  | 8   | Dead stores                 | Variables that are assigned values but not used before a return statement                                                 | Info    | Medium    |
  | 9   | Unchecked overflows         | Function calls that ignore the returned overflow flags, e.g., `uint256_add`                                               | Warning | High      |
  | 10  | Caller address return value | Function calls to the `get_caller_address` function.                                                                      | Info    | High      |
  | 11  | Storage variable collision  | Multiple `@storage_var` with the same name. (deprecated)                                                                  | Warning | High      |
  | 12  | Implicit function import    | Function with decorator `@external, @view, @l1_handler` that is being implicitly imported. (deprecated)                   | Info    | High      |
  | 13  | Unenforced view function    | State modification within a `@view` function                                                                              | Info    | High      |
  | 14  | Uninitialized variable      | Local variables that are never initialized.                                                                               | Info    | High      |



  Analyze a Cairo project in the current directory and export results to a file:
   ```bash
   amarna . -o out.sarif
   ```

  Analyze a single file `deleverage.cairo` and export results to a file:
   ```bash
   amarna deleverage.cairo -o deleverage.sarif
   ```

  Analyze a single file `code.cairo` and print a summary of the results:
   ```bash
   amarna code.cairo -s
   ```

  Parse a Cairo file and output the recovered AST in `png`:
   ```bash
   amarna file.cairo -png
   ```

  Analyze a Cairo file with the unused_import rule:
   ```bash
   amarna file.cairo --rules=unused-imports
   ```

  Analyze a Cairo file using all rules except the arithmetic-add rule:
   ```bash
   amarna file.cairo --except-rules=arithmetic-add
   ```

  The full help menu is:
  ```
  usage: amarna [-h] [-p] [-o OUTPUT] [-s] [-png] [-rules RULES] [-exclude-rules EXCLUDE_RULES] [-show-rules] [-disable-inline] -f

  Amarna is a static-analyzer for the Cairo programming language.

  positional arguments:
    -f                    the name of the .cairo file or directory with .cairo files to analyze

  optional arguments:
    -h, --help            show this help message and exit
    -p, --print           print output
    -o OUTPUT, --output OUTPUT
                          file to write the output results in sarif format
    -s, -summary, --summary
                          output summary
    -png, --png           save a png with the AST of a file
    -rules RULES, --rules RULES
                          Only run this set of rules. Enter rule names comma-separated, e.g., dead-store,unused-arguments
    -exclude-rules EXCLUDE_RULES, --exclude-rules EXCLUDE_RULES
                          Exclude these rules from the analysis. Enter rule names comma-separated, e.g., dead-store,unused-arguments
    -show-rules, --show-rules
                          Show all supported rules and descriptions.
    -disable-inline, --disable-inline
                          Disable rules with inline comments. The comments should be the first line and of the form: # amarna: disable=rulename1,rulename2
  ```


  The [SARIF](https://sarifweb.azurewebsites.net/) file format is a standard format for static-analysis tools and can be viewed in vscode with the [official extension](https://github.com/Microsoft/sarif-vscode-extension/).



  ```bash
  pip install amarna
  ```



  The static-analysis rules can be:
     - local rules, which analyse each file independently.
     - gatherer rules, which analyse each file independently and gather data to be used in post-process rules.
     - post-process rules, which run after all files were analyzed can use the data gathered in the gatherer rules.

  Examples of these are:
   - local rules: find all arithmetic operations in a file
   - gatherer rules: gather all declared functions, and called functions
   - post-process rules: find unused functions using the gathered data, i.e., functions that were declared but never called.





  Obtain the names of the currently implemented rules with:
  ```bash
   amarna --show-rules
  ```


  Run amarna with a defined set of rules using
  ```bash
   amarna --rules=rule1,rule2 .
  ```

  The following command will only run the `unused-imports` rule and print the summary result
  ```bash
   amarna --rules=unused-imports . -s
  ```


  Run amarna with all rules except a defined set of rules using
  ```bash
   amarna --exclude-rules=arithmetic-add,arithmetic-sub . -s
  ```


  You can change the first line of a cairo file to disable a specific rule set on that file.
  For example, adding the line
  ```c
  // amarna: disable=arithmetic-div,arithmetic-sub,arithmetic-mul,arithmetic-add
  ```
  as the first line of `file.cairo` and running amarna with
  ```bash
  amarna directory/ --disable-inline -s
  ```
  will not report any arithmetic rule to the `file.cairo` file.


pkgId: f8448aabeb0abf41b899ab199ae6b8ba4eb625e1204c6596f68aff30516f3bce
name: python-amaryllis
arch: src
version: 1.0.11
epoch: 0
release: 1
summary: To calculate insurance value
url: https://pypi.org/project/amaryllis/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amaryllis-1.0.11-1.src.rpm
checksum_type: sha256
description:
  You can install Amaryllis by using pip.

  ```
  pip install amaryllis
  ```


  ・ [interest](/docs/interest.md)
  ・ [calc_base](/docs/calc_base.md)
  ・ [population](/docs/population.md)
  ・ [pension](/docs/pension.md)
  ・ [single](/docs/single.md)


pkgId: dac86d49548165141a51e42d59a0d557c54c0c33f1bcece3bc6097d7a3ed45a0
name: python-amazon-appflow-custom-connector-sdk
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: Amazon AppFlow Custom Connector SDK
url: https://github.com/awslabs/aws-appflow-custom-connector-python
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amazon-appflow-custom-connector-sdk-1.0.4-1.src.rpm
checksum_type: sha256
description:
  Amazon AppFlow is a fully managed integration service that enables you to securely transfer data between Software-as-a-Service (SaaS) applications like Salesforce, SAP, Zendesk, Slack, and ServiceNow, and AWS services like Amazon S3 and Amazon Redshift, in just a few clicks. With AppFlow, you can run data flows at enterprise scale at the frequency you choose - on a schedule, in response to a business event, or on demand. You can configure data transformation capabilities like filtering and validation to generate rich, ready-to-use data as part of the flow itself, without additional steps. AppFlow automatically encrypts data in motion, and it allows users to restrict data from flowing over the public internet for SaaS applications that are integrated with AWS PrivateLink, reducing exposure to security threats. For more details about AppFlow, see https://aws.amazon.com/appflow/.

  The AppFlow Custom Connector SDK enables customers and third party developers to build custom source and/or destination connectors for the AppFlow service. With the SDK, you can connect to private APIs, on-premise proprietary systems, and other cloud services by adding to AppFlow's library of connectors (https://aws.amazon.com/appflow/integrations/).

  The Amazon AppFlow Custom Connector SDK simplifies connector development through the use of a normalized interface and data model. It provides authentication, pagination, throttling, error handling, deployment scripts, and a test framework. Connectors developed with the SDK can be used privately, shared within your organization or partners, or published on AWS Marketplace (https://aws.amazon.com/marketplace).

  This document is a guide for developing AppFlow custom connectors.  The SDK includes a complete working example of a sample connector in Python/Java.



  A connector translates the normalized AppFlow requests (read and write calls) to the requests compatible for the underlying application. The translation includes protocol, API format, query format, data model etc. Connectors support queries, partial queries (paginated) and write calls (insert, update, upsert and delete operations).

  AppFlow transfers data between source and destination connectors using an incremental query model. It constructs a query based on the Flow configuration and uses that to pull a configurable number of records from the source connector. For subsequent runs, AppFlow pulls only the records that have changed or were created since the last run. For structured data, the queries are based on entities (e.g. Accounts, Orders, Contact, Benefit, Report etc) as declared by a given connector.



  AppFlow manages authentication information for each connector, and it makes those credentials available to the connectors with the request for data reads and writes. AppFlow depends on the connector to provide the authentication scheme(s) the connectors support and the corresponding configuration parameters. It then gives an option to the AppFlow user to pick the desired authentication scheme from the list of supported schemes for that connector. Apart from authentication configuration, connector can also declare the implementation specific runtime settings. For these settings, input from AppFlow users is required during the ConnectorProfile creation or Flow creation. AppFlow stores the user credentials in user’s security manager. The authentication credentials ARN and the runtime settings are stored along with the ConnectorProfile state, and they are passed along with every request to the connector.



  AppFlow support dynamic discovery of schema and depends on the connectors to provide the required metadata. Therefore,
  AppFlow depends on two metadata queries from the connectors:
  1. `listEntities`. This API is recursive in nature and provides a hierarchical entity listing based on entityPath. If the
  `listEntities` response has `hasChildren=true`, that that indicates that there are more entities in the next level.
  2. `describeEntity`. This API provides field-level details of a given entity.
  After retrieving the metadata from the connector, AppFlow caches the metadata as per the ttl value returned by the connector
  along with the metadata response in the CacheControl structure. If no ttl value is specified, AppFlow defaults to
  1 hour.




  | Interfaces           | Description                                                                  |
  |----------------------|------------------------------------------------------------------------------|
  | ConfigurationHandler | Defines the functionality to be implemented for configurations, credentials related operations  |
  | MetadataHandler      | Defines the functionality to be implemented for metadata operations |
  | RecordHandler        | Defines the functionality to be implemented for record related CRUD operations|

  In the next section, we take a closer look at these interfaces. AppFlow uses these interfaces to interact with connectors
  for fetching data from the source connector or pushing data into the destination connector. It also uses these interfaces
  for the connector registration using the configuration returned by the connector and also to retrieve
  metadata dynamically. Therefore, along with the data interfaces, the connector developers are required to implement
  the interface to declare supported authentication types, configuration, and also the metadata interface
  which helps the connector declare the supported entities and their shape.

  The connector developers therefore are essentially writing the wiring code to translate to/from from vendor’s API to
  the generic AppFlow custom connector interface. The connector code needs to handle the following:
  - Necessary protocol and data model transformations.
  - Normalization to standard error-codes.
  - If the token was found to be expired, the connector can propagate the exception. Then AppFlow can handle
  the exception and refresh the token and reissue the request.
  - Pagination support.
  - Vendors specific versioning differences.



  Allows the connector to declare connector runtime settings and authentication config etc using the
  describeConnectorConfiguration method.

  It also includes the implementation for the following callbacks:
  1. validateConnectorRuntimeSettings: to validate user input for connector runtime settings.
  2. validateCredentials: to validate user credentials entered by the AppFlow user.
  ```python
  class ConfigurationHandler(metaclass=abc.ABCMeta):
      """This abstract base class defines the functionality to be implemented by custom connectors for configurations,
      credentials related operations.
      """
      @abc.abstractmethod
      def describe_connector_configuration(self, request: requests.DescribeConnectorConfigurationRequest) -> \
              responses.DescribeConnectorConfigurationResponse:
          """Describes the Connector Configuration supported by the connector.

          Parameters:
          request (DescribeConnectorConfigurationRequest)

          Return:
          DescribeConnectorConfigurationResponse
          """
          pass

      @abc.abstractmethod
      def validate_connector_runtime_settings(self, request: requests.ValidateConnectorRuntimeSettingsRequest) -> \
              responses.ValidateConnectorRuntimeSettingsResponse:
          """Validates the user inputs corresponding to the connector settings for a given ConnectorRuntimeSettingScope

          Parameters:
          request (ValidateConnectorRuntimeSettingsRequest)

          Return:
          ValidateConnectorRuntimeSettingsResponse
          """
          pass

      @abc.abstractmethod
      def validate_credentials(self, request: requests.ValidateCredentialsRequest) -> \
              responses.ValidateCredentialsResponse:
          """Validates the user provided credentials.

          Parameters:
          request (ValidateCredentialsRequest)

          Return:
          ValidateCredentialsResponse
          """
          pass

  ```



  Allows the connector to declare the entity metadata for the underlying application
  - listEntities
  - describeEntity
  ```python
  class MetadataHandler(metaclass=abc.ABCMeta):
      """This abstract base class defines the functionality to be implemented by custom connectors for metadata
      operations.
      """
      @abc.abstractmethod
      def list_entities(self, request: requests.ListEntitiesRequest) -> responses.ListEntitiesResponse:
          """Lists all the entities available in a paginated fashion. This API is recursive in nature
          and provides a heretical entity listing based on entityPath. If the ListEntitiesResponse
          returns has_children=true, that indicates that there are more entities in the next level.

          Parameters:
          request (ListEntitiesRequest)

          Return:
          ListEntitiesResponse
          """
          pass

      @abc.abstractmethod
      def describe_entity(self, request: requests.DescribeEntityRequest) -> responses.DescribeEntityResponse:
          """Describes the entity definition with its field level metadata.

          Parameters:
          request (DescribeEntityRequest)

          Return:
          DescribeEntityResponse
          """
          pass

  ```



  This is where the main functionality of data exchange is implemented:
  - retrieveData: lookup records against a batch of ids
  - queryData: queries the underlying application by translating the incoming filterExpress that follows a specific
  AppFlow DSL (SDK contains a parser to help parse the filterExpression)
  - writeData: writes a batch of records to the underlying application
  ```python
  class RecordHandler(metaclass=abc.ABCMeta):
      """This abstract base class defines the functionality to be implemented by custom connectors for record related
      operations.
      """
      @abc.abstractmethod
      def retrieve_data(self, request: requests.RetrieveDataRequest) -> responses.RetrieveDataResponse:
          """Retrieves the batch of records against a set of identifiers from the source application.

          Parameters:
          request (RetrieveDataRequest)

          Return:
          RetrieveDataResponse
          """
          pass

      @abc.abstractmethod
      def query_data(self, request: requests.QueryDataRequest) -> responses.QueryDataResponse:
          """Writes batch of records to the destination application.

          Parameters:
          request (QueryDataResponse)

          Return:
          WriteDataResponse
          """
          pass

      @abc.abstractmethod
      def write_data(self, request: requests.WriteDataRequest) -> responses.WriteDataResponse:
          """Writes batch of records to the destination application.

          Parameters:
          request (WriteDataRequest)

          Return:
          WriteDataResponse
          """
          pass

  ```



  AppFlow uses an incremental query model to fetch data from the source. The initial pull queries records modified/created in
  the past 30 days (configurable). In the next flow execution onwards, it runs incremental queries to pull data modified/created since the
  last execution. The AppFlow query engine takes the user input for filtering from the flow definition and translates it to
  a normalized DSL and passes it on to connectors. Connectors then take that normalized expression and translate it to
  application-specific format. The domain specific language (DSL) that defines the filter expressions grammar is AppFlow
  specific. For example: “price > 100 and accountName contains 'Alexa'". The query expression DSL is a normalized DSL
  and not specific to DSLs used by specific underlying applications. The connector's job is to provide the necessary
  translation from AppFlow DSL to application-specific DSL or other syntax the underlying application requires. In order
  to simplify the work needed to parse the filter expression the parser has been included. Please see the README.md under
  the `custom_connector_queryfilter` module for the details.



  The following is a sample end-to-end processing flow to help understand how AppFlow interacts with the custom connectors using
  the above interfaces:

  - Step 1: Connector implementation declares the supported authentication types using the ConfigurationHandler class.
  AppFlow uses `describeConnectorConfiguration` function to retrieve the connector configuration. The
  `DescribeConnectorConfigurationResponse` includes `AuthenticationConfig` and `ConnectorRuntimeSettings` data structures.
  AuthenticationConfig defines the auth scheme supported by the connector (OAuth2/BASIC etc) and
  ConnectorRuntimeSettings represents the setting that the connector needs at runtime, input for which are provided by
  the AppFlow user.(e.g. timeout values or any other implementation dependent inputs)

  - Step 2: AppFlow customer deploys this connector Lambda stack into their account and registers a `Connector` against the
  Lambda using the `register_connector` AppFlow public API.

  - Step 3: AppFlow customer creates a new `ConnectorProfile` against this newly registered connector and picks an
  authentication type (for this example, let’s assume they picked OAuth2)

  - Step 4: AppFlow Console presents them with the corresponding authentication flow and AppFlow takes user inputs and
  invokes `validateCredentials` function on the connector. If that succeeds, the console presents the screen to take user input for
  the "connector runtime settings" declared by the connector. When user inputs the values corresponding to the settings (example:
  var1=10, var2=“Foo”). AppFlow invokes `validateConnectorRuntimeSettings` function on the connector so that it can validate the
  user input. Upon successful validation the credentials and connector runtime settings are stored along with the newly created
  `ConnectorProfile`.

  - Step 5: AppFlow user then uses that `ConnectorProfile` to create `Flow` definitions. During the flow creation AppFlow
  invokes `listEntity` and `describeEntity` functions on the connector to retrieve the list of supported entities and the entity
  detail of the specific entity AppFlow user selected on the console / API.

  - Step 6: When the flow is started AppFlow invokes the connector to execute the query constructed using the user input
  during the AppFlow definition using the `queryData` function.

  - Step 7: For incremental flows AppFlow adds the timestamp based filter on the query and passes it on the connector to
  invoke it again for incremental data pulls using the query_data function.

  - Step 8: If the destination connector is also a custom connector, AppFlow processes the incoming records as per the
  task definitions and prepares the payload as per the entity shape of the destination connector and hands it over to the
  destination connector by invoking the `writeData` function.




  - Clone the `custom-connector-example` module and modify the implementation to fit the underlying application you are
  writing the connector for.
  - Edit the implementations for the three lambda handlers: `ConfigurationHandler`, `MetadataHandler` and `RecordHandler`.
  - Add unit tests.
  - This SDK productivity scripts under the `custom-connector-tools` module, to help build and export the package into
  S3 using AWS CloudFormation template and then deploy the Lambda stack into your account.
  - Login into the AppFlow console and register a `Connector` against the new Lambda.
  - Create a `ConnectorProfile` against the newly registered `Connector`.
  - Create a flow using the new `Connector` and `ConnectorProfile`.
  - Execute the flow.






  The Amazon AppFlow documentation is located here: https://docs.aws.amazon.com/appflow/index.html. The API reference guide can be found here: https://docs.aws.amazon.com/appflow/1.0/APIReference/API_Operations.html.




  The Amazon AppFlow Custom Connector SDK is available for both Java and Python on github at the following link: https://github.com/orgs/awslabs/teams/amazon-appflow/repositories

  * Java SDK - You can find the Java SDK in [AppFlowJavaSdk](https://github.com/awslabs/aws-appflow-custom-connector-java)/
  * Python SDK - You can find the Python SDK .whl file in [AppFlowPythonSDK/](https://github.com/awslabs/aws-appflow-custom-connector-python)





  Once you have the jar, create the Amazon AppFlow client instance and invoke the AppFlow APIs.

  ```
  AmazonAppflow appflowClient = AmazonAppflowClientBuilder.standard()
         .withRegion(region)
          .build();
  ```



  Once you have the python whl file, install the whl files using pip3 install. Create the AppFlow client using the boto3 and call the AppFlow APIs.

  **Commands to install the Python SDK:**

  ```
  python3 -m pip install botocore-1.21.25-py3-none-any.whl
  python3 -m pip install boto3-1.18.25-py3-none-any.whl
  ```

  ```
  import boto3

  appflowClient = boto3.client('appflow')
  ```



  In order for AppFlow to invoke the custom connector Lambda function while executing customer flows, the following permissions need to be added manually (or by simply using the `deploy.sh` script provided in the custom-connector-tools package):

  ```
  {
      "Version": "*2012-10-17*",
      "Id": "default",
      "Statement": [{
          "Sid": "*appflow-example-01*",
          "Effect": "Allow",
          "Principal": {
              "Service": "appflow.amazonaws.com"
          },
          "Action": "lambda:InvokeFunction",
          "Resource": "arn:aws:lambda:*us-east-1*:123456789012:function:*my-function*",
          "Condition": {
              "StringEquals": {
                  "AWS:SourceAccount": "*123456789012*"
              },
              "ArnLike": {
                  "AWS:SourceArn": "arn:aws:appflow:*us-east-1*:*123456789012*:*"
              }
          }
      }]
  }
  ```

  * source account: the customers account
  * source arn: all of the Amazon AppFlow resources present in the customers account

  The Source Account and the Source ARN condition helps to prevent the “confused deputy” security vulnerability. The allow-listed service principal allows all of the AWS accounts under the “appflow” service principal to access the customer Lambda.





  i) Go to the Amazon AppFlow console and select “Connectors” on the left-side menu.

  ![](https://github.com/awslabs/aws-appflow-custom-connector-python/blob/main/images/appflow-console-home.png?raw=True)

  ii) Click on the “Register New Connector” button on the console.

  ![](https://github.com/awslabs/aws-appflow-custom-connector-python/blob/main/images/appflow-console-connectors-page.png?raw=True)

  iii) Your custom connector Lambda function will be available on this webpage. If not, ensure that the appropriate Lambda permissions are set, as described in the section “Updating Lambda Permissions and Resource Policy Required."

  ![](https://github.com/awslabs/aws-appflow-custom-connector-python/blob/main/images/appflow-console-lambda-function.png?raw=True)

  iv) Provide the label for your connector. The label must be unique per account per region. Click on the “Register” button.

  ![](https://github.com/awslabs/aws-appflow-custom-connector-python/blob/main/images/appflow-console-connector-label.png?raw=True)

  v) Once registered, you’ll see the connector in the list of custom connectors.

  ![](https://github.com/awslabs/aws-appflow-custom-connector-python/blob/main/images/appflow-console-test-connector.png?raw=True)



  Invoke the `registerConnector` public API endpoint with the following request payload:

  ```
  {
     "connectorLabel":"TestCustomConnector", [The unique Label]
     "connectorProvisioningType":"LAMBDA",   [The provisioning type of the connector.
      Currently only supported value is LAMBDA]
     "connectorProvisioningConfig":{
        "lambda":{
           "lambdaArn":"arn:aws:lambda:us-west-2:364320160620:function:
           banvipulCustomConnectorBugBash" [The arn of the deployed lambda]
        }
     }
  }
  ```







  i) Go to the “Connections” link from the left menu and select the registered connector from the list.

  ![](https://github.com/awslabs/aws-appflow-custom-connector-python/blob/main/images/appflow-console-registered-connector.png?raw=True)

  ii) Once selected click on the ‘Create Connection’ button.

  ![](https://github.com/awslabs/aws-appflow-custom-connector-python/blob/main/images/appflow-console-create-connection.png?raw=True)

  iii) A pop-up appears asking for the required details to create a connection. Please fill in the details and scroll down to click on the ‘Continue’ button.

  ![](https://github.com/awslabs/aws-appflow-custom-connector-python/blob/main/images/appflow-console-connection-details.png?raw=True)

  iv) Your connection now appears in the list.



  For custom connectors, a new parameter has been added in the request object for this API.

  ```
  {
     .............................
     .............................
     .............................
     "connectorLabel":"TestCustomConnector", [The Label provided while registering the
     connector]
     .............................
     .............................
     .............................
  }
  ```

  Please follow the sample API request here https://docs.aws.amazon.com/appflow/1.0/APIReference/API_CreateConnectorProfile.html





  i) Click on the Flow tab in the left menu, select Create Flow, then follow the standard AppFlow flow configuration steps.

  ![](https://github.com/awslabs/aws-appflow-custom-connector-python/blob/main/images/appflow-console-create-flow.png?raw=True)



  Follow the sample API request here:
  https://docs.aws.amazon.com/appflow/1.0/APIReference/API_CreateFlow.html

  In addition to this, for the custom connectors we have added the following parameters in the request object for this API:





  Go the Amazon AppFlow console and click on “Connectors” on the left menu. Select “Custom connectors” in the drop down list.

  ![](https://github.com/awslabs/aws-appflow-custom-connector-python/blob/main/images/appflow-console-custom-connectors-dropdown.png?raw=True)



  Call the listConnectors API with the following request format, this will list all the custom connectors registered in your account:

  ```
  {
    "maxResults" : 100 // default is 20 and accepted values are between 1 to 100.
  }
  ```





  Go the Amazon AppFlow console, click on “Connectors” on the left menu, then click “View details” on the connector of interest.

  ![](https://github.com/awslabs/aws-appflow-custom-connector-python/blob/main/images/appflow-console-custom-connectors-view-details.png?raw=True)



  Please call describeConnector API. Please follow the sample API request here:

  ```
  {
    "connectorType" : `"CustomConnector",
    "connectorLabel": <YourConnectorLabel>`
  }
  ```





  * After your connector is deployed, you can access the connector through the AWS Lambda console.
  * You can go to the test tab, and define the payloads as per the request format and then invoke the Lambda to test this.
  * To the request payload, you can build the request using the Request model defined as SDK and then convert it to JSON string and then use that on console.
  * You can also use our Testing Tools in `custom-connector-tests` and `custom-connector-integ-test` to test your connector.



  Please refer to the below READMEs to learn more about the SDK:
  - You can find QueryFilter README in `custom-connector-queryfilter`
  - You can find Example README in `custom-connector-example`
  - You can find Deployment Tools README in `custom-connector-tools`
  - You can find Testing Tools README in `custom-connector-tests` and `custom-connector-integ-test`


pkgId: b49b81ac25eb02f441f1f1dff68493c9fb4b3d6cce83cd4088787c8ac57f6cba
name: python-amazon-bedrock
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: A simplified Python client for Amazon Bedrock
url: https://github.com/boto/boto3
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amazon-bedrock-0.0.3-1.src.rpm
checksum_type: sha256
description:
  A Python library for easy interaction with Amazon Bedrock, providing streamlined access to foundation models and AI capabilities.



  - Simple interface for the Amazon Bedrock API
  - Support for multiple foundation models
  - Easy text generation and completion



  Install the package using pip:

  ```shell
  pip install amazon-bedrock
  ```



  ```python
  from amazon_bedrock import Bedrock

  client = Bedrock(region="us-west-2")

  models = client.models.list()
  model_ids = [model["modelId"] for model in models]

  print(model_ids)

  model_id = "claude-3-5-haiku"
  model = client.models.retrieve(model_id)

  print(model)
  ```



  The client uses standard AWS credentials. You can configure these in several ways:

  1. Environment variables:

  ```shell
  export AWS_ACCESS_KEY_ID="your-access-key"
  export AWS_SECRET_ACCESS_KEY="your-secret-key"
  export AWS_REGION="us-west-2"
  ```

  2. AWS credentials file (`~/.aws/credentials`)

  3. IAM role when running on AWS services



  - Python 3.8+
  - boto3
  - An AWS account with Bedrock access



  This project is licensed under the MIT License - see the LICENSE file for details.


pkgId: dc56ee2bc7a489c6e4800ca8679c1dbdf6ee3c20fb16faebdc91aecc1230c4fb
name: python-amazon-bedrock-haystack
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: An integration of Amazon Bedrock as an AmazonBedrockGenerator component.
url: https://pypi.org/project/amazon-bedrock-haystack/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amazon-bedrock-haystack-1.1.0-1.src.rpm
checksum_type: sha256
description:
  **Table of Contents**
  - [Installation](#installation)
  - [Contributing](#contributing)
  - [License](#license)

  ```console
  pip install amazon-bedrock-haystack
  ```

  `hatch` is the best way to interact with this project, to install it:
  ```sh
  pip install hatch
  ```
  With `hatch` installed, to run all the tests:
  ```
  hatch run test
  ```
  > Note: there are no integration tests for this project.
  To run the linters `ruff` and `mypy`:
  ```
  hatch run lint:all
  ```

  `amazon-bedrock-haystack` is distributed under the terms of the [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html) license.


pkgId: d9dbf5f2cf082b9e92438ef3fa5c4cbcbe56745c650bb6f04b46ae2a98acd5c8
name: python-amazon-braket-algorithm-library
arch: src
version: 1.5.1
epoch: 0
release: 1
summary: An open source library of quantum computing algorithms implemented on Amazon Braket
url: https://github.com/amazon-braket/amazon-braket-algorithm-library
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amazon-braket-algorithm-library-1.5.1-1.src.rpm
checksum_type: sha256
description:
  Currently, Braket algorithms are tested on Linux, Windows, and Mac.
  Running notebooks locally requires additional dependencies located in [notebooks/textbook/requirements.txt](https://github.com/amazon-braket/amazon-braket-algorithm-library/blob/main/notebooks/textbook/requirements.txt). See notebooks/textbook/README.md for more information.
  | Textbook algorithms | Notebook | References |
  | ----- | ----- | ----- |
  | Bell's Inequality     | [Bells_Inequality.ipynb](notebooks/textbook/Bells_Inequality.ipynb)     | [Bell1964](https://journals.aps.org/ppf/abstract/10.1103/PhysicsPhysiqueFizika.1.195), [Greenberger1990](https://doi.org/10.1119/1.16243)     |
  | Bernstein–Vazirani | [Bernstein_Vazirani_Algorithm.ipynb](notebooks/textbook/Bernstein_Vazirani_Algorithm.ipynb) | [Bernstein1997](https://epubs.siam.org/doi/10.1137/S0097539796300921) |
  | CHSH Inequality | [CHSH_Inequality.ipynb](notebooks/textbook/CHSH_Inequality.ipynb) | [Clauser1970](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.23.880) |
  | Deutsch-Jozsa | [Deutsch_Jozsa_Algorithm.ipynb](notebooks/textbook/Deutsch_Jozsa_Algorithm.ipynb) | [Deutsch1992](https://royalsocietypublishing.org/doi/10.1098/rspa.1992.0167) |
  | Grover's Search | [Grovers_Search.ipynb](notebooks/textbook/Grovers_Search.ipynb) | [Figgatt2017](https://www.nature.com/articles/s41467-017-01904-7), [Baker2019](https://arxiv.org/abs/1904.01671) |
  | QAOA | [Quantum_Approximate_Optimization_Algorithm.ipynb](notebooks/textbook/Quantum_Approximate_Optimization_Algorithm.ipynb) | [Farhi2014](https://arxiv.org/abs/1411.4028) |
  | Quantum Circuit Born Machine | [Quantum_Circuit_Born_Machine.ipynb](notebooks/textbook/Quantum_Circuit_Born_Machine.ipynb) | [Benedetti2019](https://www.nature.com/articles/s41534-019-0157-8),  [Liu2018](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.98.062324) |
  | QFT | [Quantum_Fourier_Transform.ipynb](notebooks/textbook/Quantum_Fourier_Transform.ipynb) | [Coppersmith2002](https://arxiv.org/abs/quant-ph/0201067) |
  | QPE | [Quantum_Phase_Estimation_Algorithm.ipynb](notebooks/textbook/Quantum_Phase_Estimation_Algorithm.ipynb) | [Kitaev1995](https://arxiv.org/abs/quant-ph/9511026) |
  | Quantum Walk | [Quantum_Walk.ipynb](notebooks/textbook/Quantum_Walk.ipynb) | [Childs2002](https://arxiv.org/abs/quant-ph/0209131) |
  |Shor's| [Shors_Algorithm.ipynb](notebooks/textbook/Shors_Algorithm.ipynb) | [Shor1998](https://arxiv.org/abs/quant-ph/9508027) |
  | Simon's | [Simons_Algorithm.ipynb](notebooks/textbook/Simons_Algorithm.ipynb) | [Simon1997](https://epubs.siam.org/doi/10.1137/S0097539796298637) |
  | Advanced algorithms | Notebook | References |
  | ----- | ----- | ----- |
  | Quantum PCA | [Quantum_Principal_Component_Analysis.ipynb](notebooks/advanced_algorithms/Quantum_Principal_Component_Analysis.ipynb) | [He2022](https://ieeexplore.ieee.org/document/9669030) |
  | QMC | [Quantum_Computing_Quantum_Monte_Carlo.ipynb](notebooks/advanced_algorithms/Quantum_Computing_Quantum_Monte_Carlo.ipynb) | [Motta2018](https://wires.onlinelibrary.wiley.com/doi/10.1002/wcms.1364), [Peruzzo2014](https://www.nature.com/articles/ncomms5213) |
  | Auxiliary functions | Notebook |
  | ----- | ----- |


pkgId: ac284f7ed3c962ea930c3d81eae7fd6ef4919b2c9aad143a752133e26a5547da
name: python-amazon-braket-build-tools
arch: src
version: 0.2.12
epoch: 0
release: 1
summary: A set of build tools for Amazon Braket
url: https://github.com/aws/amazon-braket-build-tools
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amazon-braket-build-tools-0.2.12-1.src.rpm
checksum_type: sha256
description:
  The Amazon Braket Build Tools can be installed with pip as follows:

  ```bash
  pip install amazon-braket-build-tools
  ```

  You can also install from source by cloning this repository and running a pip install command in the root directory of the repository:

  ```bash
  git clone https://github.com/aws/amazon-braket-build-tools.git
  cd amazon-braket-build-tools
  pip install .
  ```



  This tool checks python source code for Braket checkstyle standards as a Flake8 plugin.
  Installing amazon-braket-build-tools automatically registers this plugin with flake8 and
  will be run by default whenever flake8 is used.


  To test if the extension has been installed run:
  ```bash
  flake8 --enable-extensions=BCS --help
  ```
  At the bottom of the output you should see braket checkstyle among your installed plugins:
  ```
  Installed plugins: braket.flake8_plugins.braket_checkstyle_plugin: 0.1.0
  ```


  To run with the extension enabled, just run flake8 on the module of your choice.
  For example:
  ```bash
  flake8 --enable-extensions=BCS src
  ```




  See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.



  This project is licensed under the Apache-2.0 License.


pkgId: 35a6544721bd11b2274fc6d26bcb456cc849dc6134a44aacd05b184ceb1de6c4
name: python-amazon-braket-default-simulator
arch: src
version: 1.26.0
epoch: 0
release: 1
summary: An open source quantum circuit simulator to be run locally with the Amazon Braket SDK
url: https://github.com/amazon-braket/amazon-braket-default-simulator-python
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amazon-braket-default-simulator-1.26.0-1.src.rpm
checksum_type: sha256
description:
  [![Latest Version](https://img.shields.io/pypi/v/amazon-braket-default-simulator.svg)](https://pypi.python.org/pypi/amazon-braket-default-simulator)
  [![Supported Python Versions](https://img.shields.io/pypi/pyversions/amazon-braket-default-simulator.svg)](https://pypi.python.org/pypi/amazon-braket-default-simulator)
  [![Build status](https://github.com/amazon-braket/amazon-braket-default-simulator-python/actions/workflows/python-package.yml/badge.svg)](https://github.com/amazon-braket/amazon-braket-default-simulator-python/actions/workflows/python-package.yml)
  [![codecov](https://codecov.io/gh/amazon-braket/amazon-braket-default-simulator-python/branch/main/graph/badge.svg?token=FZEG1AQU3S)](https://codecov.io/gh/amazon-braket/amazon-braket-default-simulator-python)
  [![Documentation Status](https://img.shields.io/readthedocs/amazon-braket-default-simulator-python.svg?logo=read-the-docs)](https://amazon-braket-default-simulator-python.readthedocs.io/en/latest/?badge=latest)

  The Amazon Braket Default Simulator is a Python open source library that provides an implementation of a quantum simulator
  that you can run locally. You can use the simulator to test quantum tasks that you construct for the [Amazon Braket SDK](https://github.com/amazon-braket/amazon-braket-sdk-python)
  before you submit them to the Amazon Braket service for execution.


  You must have the [Amazon Braket SDK](https://github.com/amazon-braket/amazon-braket-sdk-python) installed to use the local simulator.
  Follow the instructions in the [README](https://github.com/amazon-braket/amazon-braket-sdk-python/blob/main/README.md) for setup.

  **Checking the version of the default simulator**

  You can check your currently installed version of `amazon-braket-default-simulator` with `pip show`:

  ```bash
  pip show amazon-braket-default-simulator
  ```

  or alternatively from within Python:

  ```
  >>> from braket import default_simulator
  >>> default_simulator.__version__
  ```


  The quantum simulator implementations `StateVectorSimulator` and `DensityMatrixSimulator` plug into the `LocalSimulator` interface in
  [Amazon Braket SDK](https://github.com/amazon-braket/amazon-braket-sdk-python), with the `backend` parameters as `"braket_sv"` and `"braket_dm"`, respectively.
  Alternatively, to use `StateVectorSimulator`, you can instantiate `LocalSimulator` with no arguments or with `backend="default"`:

  **Executing a circuit using the default simulator**
  ```python
  from braket.circuits import Circuit
  from braket.devices import LocalSimulator

  device = LocalSimulator()

  bell = Circuit().h(0).cnot(0, 1)
  print(device.run(bell, shots=100).result().measurement_counts)
  ```



  Detailed documentation, including the API reference, can be found on [Read the Docs](https://amazon-braket-default-simulator-python.readthedocs.io/en/latest/)

  **To generate the API Reference HTML in your local environment**

  First, install tox:

  ```bash
  pip install tox
  ```

  To generate the HTML, first change directories (`cd`) to position the cursor in the `amazon-braket-default-simulator-python` directory. Then, run the following command to generate the HTML documentation files:

  ```bash
  tox -e docs
  ```

  To view the generated documentation, open the following file in a browser:
  `../amazon-braket-default-simulator-python/build/documentation/html/index.html`



  If you want to contribute to the project, be sure to run unit tests and get a successful result
  before you submit a pull request. To run the unit tests, first install the test dependencies using the following command:

  ```bash
  pip install -e "amazon-braket-default-simulator-python[test]"
  ```

  To run the unit tests:

  ```bash
  tox -e unit-tests
  ```

  You can also pass in various pytest arguments to run selected tests:

  ```bash
  tox -e unit-tests -- your-arguments
  ```

  For more information, please see [pytest usage](https://docs.pytest.org/en/stable/usage.html).

  To run linters and doc generators and unit tests:

  ```bash
  tox
  ```

  To run the performance tests:

  ```bash
  tox -e performance-tests
  ```

  These tests will compare the performance of a series of simulator executions for your changes against the latest commit on the main branch.
  *Note*: The execution times for the performance tests are affected by the other processes running on the system.
  In order to get stable results, stop other applications when running these tests.



  This project is licensed under the Apache-2.0 License.


pkgId: f2053693f251cda843df15372a17ad724bfc89faf393f100bd8e04a3ce2a5df3
name: python-amazon-braket-pennylane-plugin
arch: src
version: 1.30.1
epoch: 0
release: 1
url: https://github.com/amazon-braket/amazon-braket-pennylane-plugin-python
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amazon-braket-pennylane-plugin-1.30.1-1.src.rpm
checksum_type: sha256
summary:
  An open source framework for using Amazon Braket devices with the PennyLane quantum machine learning library

description:
  Provides four devices to be used with PennyLane:
  * Two gate-based devices, ``braket.aws.qubit`` for running on the Amazon Braket service,
    and ``braket.local.qubit`` for running on the Amazon Braket SDK's local simulator.
  * Two analog Hamiltonian simulation devices, ``braket.aws.ahs`` for running on QPU via the Amazon Braket service,
    and ``braket.local.ahs`` for running on the Amazon Braket SDK's local simulator.
  * Combines Amazon Braket with PennyLane's automatic differentiation and optimization.
  For the gate-based devices:
  * Both devices support most core qubit PennyLane operations.
  * All PennyLane observables are supported.
  * Provides custom PennyLane operations to cover additional Braket operations: ``ISWAP``, ``PSWAP``, and many more.
    Every custom operation supports analytic differentiation.
  For the analog Hamiltonian simulation devices:
  * The devices support ``ParametrizedEvolution`` operators created via the
    `PennyLane pulse programming <https://docs.pennylane.ai/en/stable/code/qml_pulse.html>`_ module.
  * PennyLane observables in the measurement (Z) basis are supported
  * Provides translation of user-defined pulse level control to simulation and hardware implementation


pkgId: aafeedb83e42dd2361862bb506ca4a418a9d09c5290c2971c0278c85f0e1ec2a
name: python-amazon-braket-schemas
arch: src
version: 1.22.1
epoch: 0
release: 1
summary: An open source library that contains the schemas for Amazon Braket
url: https://github.com/amazon-braket/amazon-braket-schemas-python
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amazon-braket-schemas-1.22.1-1.src.rpm
checksum_type: sha256
description:
  [![Latest Version](https://img.shields.io/pypi/v/amazon-braket-schemas.svg)](https://pypi.python.org/pypi/amazon-braket-schemas)
  [![Supported Python Versions](https://img.shields.io/pypi/pyversions/amazon-braket-schemas.svg)](https://pypi.python.org/pypi/amazon-braket-schemas)
  [![Build status](https://github.com/amazon-braket/amazon-braket-schemas-python/actions/workflows/python-package.yml/badge.svg)](https://github.com/amazon-braket/amazon-braket-schemas-python/actions/workflows/python-package.yml)
  [![codecov](https://codecov.io/gh/amazon-braket/amazon-braket-schemas-python/branch/main/graph/badge.svg?token=XV9R0dUbr1)](https://codecov.io/gh/amazon-braket/amazon-braket-schemas-python)
  [![Documentation Status](https://img.shields.io/readthedocs/amazon-braket-schemas-python.svg?logo=read-the-docs)](https://amazon-braket-schemas-python.readthedocs.io/en/latest/?badge=latest)

  Amazon Braket Python Schemas is an open source library that contains the schemas for Braket, including:
  * intermediate representations (IR) for Amazon Braket quantum tasks and offers serialization and deserialization of those IR payloads. Think of the IR as the contract between the Amazon Braket SDK and Amazon Braket API for quantum programs.
  * schemas for the S3 results of each quantum task
  * schemas for the device capabilities of each device




  - Python 3.9+



  The preferred way to get Amazon Braket Python Schemas is by installing the [Amazon Braket Python SDK](https://github.com/amazon-braket/amazon-braket-sdk-python), which will pull in the schemas.
  Follow the instructions in the [README](https://github.com/amazon-braket/amazon-braket-sdk-python/blob/main/README.md) for setup.

  However, if you only want to use the schemas, it can be installed on its own as follows:

  ```shell
  pip install amazon-braket-schemas
  ```

  You can install from source by cloning this repository and running a pip install command in the root directory of the repository:

  ```shell
  git clone https://github.com/amazon-braket/amazon-braket-schemas-python.git
  cd amazon-braket-schemas-python
  pip install .
  ```

  You can check your currently installed version of `amazon-braket-schemas` with `pip show`:

  ```shell
  pip show amazon-braket-schemas
  ```

  or alternatively from within Python:

  ```
  >>> import braket._schemas as braket_schemas
  >>> braket_schemas.__version__
  ```


  OpenQASM (Open Quantum Assembly Language) is one type of IR. See below for its usage.

  **Serializing python structures**
  ```python
  from braket.ir.openqasm import Program as OpenQASMProgram

  program = OpenQASMProgram(source="OPENQASM 3.0; cnot $0, $1;")
  print(program.json(indent=2))

  """
  {
    "braketSchemaHeader": {
      "name": "braket.ir.openqasm.program",
      "version": "1"
    },
    "source": "OPENQASM 3.0; cnot $0, $1;",
    "inputs": null
  }
  """
  ```

  **Deserializing into python structures**
  ```python
  from braket.ir.openqasm import Program as OpenQASMProgram

  openqasm_string = """
  {
    "braketSchemaHeader": {
      "name": "braket.ir.openqasm.program",
      "version": "1"
    },
    "source": "OPENQASM 3.0; cnot $0, $1;"
  }"""

  program = OpenQASMProgram.parse_raw(openqasm_string)
  print(program)

  """
  braketSchemaHeader=BraketSchemaHeader(name='braket.ir.openqasm.program', version='1') source='OPENQASM 3.0; cnot $0, $1;' inputs=None
  """

  ```



  Detailed documentation, including the API reference, can be found on [Read the Docs](https://amazon-braket-schemas-python.readthedocs.io/en/latest/).

  You can also generate the docs from source. First, install tox:

  ```shell
  pip install tox
  ```

  To build the Sphinx docs, run the following command in the root repo directory:

  ```shell
  tox -e docs
  ```

  You can then find the generated HTML files in `build/documentation/html`.



  Make sure to install test dependencies first:

  ```shell
  pip install -e "amazon-braket-schemas-python[test]"
  ```

  To run the unit tests:
  ```bash
  tox -e unit-tests
  ```

  You can also pass in various pytest arguments to run selected tests:

  ```bash
  tox -e unit-tests -- your-arguments
  ```

  To run linters and doc generators and unit tests:
  ```bash
  tox
  ```

  For more information, please see [pytest usage](https://docs.pytest.org/en/stable/usage.html).



  This project is licensed under the Apache-2.0 License.


pkgId: 44bfb6c1e387d654de136642df8cd0a31c078103dc3c8efa87f83ea8d38feee0
name: python-amazon-braket-sdk
arch: src
version: 1.88.1
epoch: 0
release: 1
summary: An open source library for interacting with quantum computing devices on Amazon Braket
url: https://github.com/amazon-braket/amazon-braket-sdk-python
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amazon-braket-sdk-1.88.1-1.src.rpm
checksum_type: sha256
description:
  [![Latest Version](https://img.shields.io/pypi/v/amazon-braket-sdk.svg)](https://pypi.python.org/pypi/amazon-braket-sdk)
  [![Supported Python Versions](https://img.shields.io/pypi/pyversions/amazon-braket-sdk.svg)](https://pypi.python.org/pypi/amazon-braket-sdk)
  [![Build status](https://github.com/amazon-braket/amazon-braket-sdk-python/actions/workflows/python-package.yml/badge.svg?branch=main)](https://github.com/amazon-braket/amazon-braket-sdk-python/actions/workflows/python-package.yml)
  [![codecov](https://codecov.io/gh/amazon-braket/amazon-braket-sdk-python/branch/main/graph/badge.svg?token=1lsqkZL3Ll)](https://codecov.io/gh/amazon-braket/amazon-braket-sdk-python)
  [![Documentation Status](https://img.shields.io/readthedocs/amazon-braket-sdk-python.svg?logo=read-the-docs)](https://amazon-braket-sdk-python.readthedocs.io/en/latest/?badge=latest)
  [![Stack Overflow](https://img.shields.io/badge/StackExchange-Ask%20questions-blue?logo=stackexchange)](https://quantumcomputing.stackexchange.com/questions/tagged/amazon-braket)

  The Amazon Braket Python SDK is an open source library that provides a framework that you can use to interact with quantum computing hardware devices through Amazon Braket.


  Before you begin working with the Amazon Braket SDK, make sure that you've installed or configured the following prerequisites.


  Download and install Python 3.9 or greater from [Python.org](https://www.python.org/downloads/).


  Install Git from https://git-scm.com/downloads. Installation instructions are provided on the download page.


  As a managed service, Amazon Braket performs operations on your behalf on the AWS hardware that is managed by Amazon Braket. Amazon Braket can perform only operations that the user permits. You can read more about which permissions are necessary in the AWS Documentation.

  The Braket Python SDK should not require any additional permissions aside from what is required for using Braket. However, if you are using an IAM role with a path in it, you should grant permission for iam:GetRole.

  To learn more about IAM user, roles, and policies, see [Adding and Removing IAM Identity Permissions](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html).



  Follow the installation [instructions](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html) for Boto3 and setting up AWS credentials.

  **Note:** Make sure that your AWS region is set to one supported by Amazon Braket. You can check this in your AWS configuration file, which is located by default at `~/.aws/config`.


  If you are new to Amazon Braket, onboard to the service and create the resources necessary to use Amazon Braket using the [AWS console](https://console.aws.amazon.com/braket/home ).



  The Amazon Braket Python SDK can be installed with pip as follows:

  ```bash
  pip install amazon-braket-sdk
  ```

  You can also install from source by cloning this repository and running a pip install command in the root directory of the repository:

  ```bash
  git clone https://github.com/amazon-braket/amazon-braket-sdk-python.git
  cd amazon-braket-sdk-python
  pip install .
  ```


  You can view the version of the amazon-braket-sdk you have installed by using the following command:
  ```bash
  pip show amazon-braket-sdk
  ```

  You can also check your version of `amazon-braket-sdk` from within Python:

  ```
  >>> import braket._sdk as braket_sdk
  >>> braket_sdk.__version__
  ```


  You can update the version of the amazon-braket-sdk you have installed by using the following command:
  ```bash
  pip install amazon-braket-sdk --upgrade --upgrade-strategy eager
  ```





  ```python
  import boto3
  from braket.aws import AwsDevice
  from braket.circuits import Circuit

  device = AwsDevice("arn:aws:braket:::device/quantum-simulator/amazon/sv1")

  bell = Circuit().h(0).cnot(0, 1)
  task = device.run(bell, shots=100)
  print(task.result().measurement_counts)
  ```

  The code sample imports the Amazon Braket framework, then defines the device to use (the SV1 AWS simulator). It then creates a Bell Pair circuit, executes the circuit on the simulator and prints the results of the hybrid job. This example can be found in `../examples/bell.py`.



  Many quantum algorithms need to run multiple independent circuits, and submitting the circuits in parallel can be faster than submitting them one at a time. In particular, parallel quantum task processing provides a significant speed up when using simulator devices. The following example shows how to run a batch of quantum tasks on SV1:

  ```python
  circuits = [bell for _ in range(5)]
  batch = device.run_batch(circuits, shots=100)

  print(batch.results()[0].measurement_counts)
  ```



  ```python
  from braket.aws import AwsQuantumJob

  job = AwsQuantumJob.create(
      device="arn:aws:braket:::device/quantum-simulator/amazon/sv1",
      source_module="job.py",
      entry_point="job:run_job",
      wait_until_complete=True,
  )
  print(job.result())
  ```
  where `run_job` is a function in the file `job.py`.


  The code sample imports the Amazon Braket framework, then creates a hybrid job with the entry point being the `run_job` function. The hybrid job creates quantum tasks against the SV1 AWS Simulator. The hybrid job runs synchronously, and prints logs until it completes. The complete example can be found in `../examples/job.py`.


  Amazon Braket provides access to two types of simulators: fully managed simulators, available through the Amazon Braket service, and the local simulators that are part of the Amazon Braket SDK.

  - Fully managed simulators offer high-performance circuit simulations. These simulators can handle circuits larger than circuits that run on quantum hardware. For example, the SV1 state vector simulator shown in the previous examples requires approximately 1 or 2 hours to complete a 34-qubit, dense, and square circuit (circuit depth = 34), depending on the type of gates used and other factors.
  - The Amazon Braket Python SDK includes an implementation of quantum simulators that can run circuits on your local, classic hardware. For example the braket_sv local simulator is well suited for rapid prototyping on small circuits up to 25 qubits, depending on the hardware specifications of your Braket notebook instance or your local environment. An example of how to execute the quantum task locally is included in the repository  `../examples/local_bell.py`.

  For a list of available simulators and their features, consult the [Amazon Braket Developer Guide](https://docs.aws.amazon.com/braket/latest/developerguide/braket-devices.html).



  Quantum tasks sent to QPUs don't always run right away. To view quantum task status, you can enable debugging logs. An example of how to enable these logs is included in repo: `../examples/debug_bell.py`. This example enables quantum task logging so that status updates are continuously printed to the terminal after a quantum task is executed. The logs can also be configured to save to a file or output to another stream. You can use the debugging example to get information on the quantum tasks you submit, such as the current status, so that you know when your quantum task completes.


  With Amazon Braket, you can run your quantum circuit on a physical quantum computer.

  The following example executes the same Bell Pair example described to validate your configuration on a Rigetti quantum computer.

  ```python
  import boto3
  from braket.circuits import Circuit
  from braket.aws import AwsDevice

  device = AwsDevice("arn:aws:braket:::device/qpu/rigetti/Ankaa-2")

  bell = Circuit().h(0).cnot(0, 1)
  task = device.run(bell)
  print(task.result().measurement_counts)
  ```

  When you execute your task, Amazon Braket polls for a result. By default, Braket polls for 5 days; however, it is possible to change this by modifying the `poll_timeout_seconds` parameter in `AwsDevice.run`, as in the example below. Keep in mind that if your polling timeout is too short, results may not be returned within the polling time, such as when a QPU is unavailable, and a local timeout error is returned. You can always restart the polling by using `task.result()`.

  ```python
  task = device.run(bell, poll_timeout_seconds=86400)  # 1 day
  print(task.result().measurement_counts)
  ```

  To select a quantum hardware device, specify its ARN as the value of the `device_arn` argument. A list of available quantum devices and their features can be found in the [Amazon Braket Developer Guide](https://docs.aws.amazon.com/braket/latest/developerguide/braket-devices.html).

  **Important** Quantum tasks may not run immediately on the QPU. The QPUs only execute quantum tasks during execution windows. To find their execution windows, please refer to the [AWS console](https://console.aws.amazon.com/braket/home) in the "Devices" tab.


  Sample Jupyter notebooks can be found in the [amazon-braket-examples](https://github.com/amazon-braket/amazon-braket-examples/) repo.



  The API reference, can be found on [Read the Docs](https://amazon-braket-sdk-python.readthedocs.io/en/latest/).

  **To generate the API Reference HTML in your local environment**

  To generate the HTML, first change directories (`cd`) to position the cursor in the `amazon-braket-sdk-python` directory. Then, run the following command to generate the HTML documentation files:

  ```bash
  pip install tox
  tox -e docs
  ```

  To view the generated documentation, open the following file in a browser:
  `../amazon-braket-sdk-python/build/documentation/html/index.html`



  This repository has both unit and integration tests.

  To run the tests, make sure to install test dependencies first:

  ```bash
  pip install -e "amazon-braket-sdk-python[test]"
  ```



  To run the unit tests:

  ```bash
  tox -e unit-tests
  ```

  You can also pass in various pytest arguments to run selected tests:

  ```bash
  tox -e unit-tests -- your-arguments
  ```

  For more information, please see [pytest usage](https://docs.pytest.org/en/stable/usage.html).

  To run linters and doc generators and unit tests:

  ```bash
  tox
  ```

  or if your machine can handle multithreaded workloads, run them in parallel with:

  ```bash
  tox -p auto
  ```



  First, configure a profile to use your account to interact with AWS. To learn more, see [Configure AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html).

  After you create a profile, use the following command to set the `AWS_PROFILE` so that all future commands can access your AWS account and resources.

  ```bash
  export AWS_PROFILE=YOUR_PROFILE_NAME
  ```
  To run the integration tests for local hybrid jobs, you need to have Docker installed and running. To install Docker follow these instructions: [Install Docker](https://docs.docker.com/get-docker/)

  Run the tests:

  ```bash
  tox -e integ-tests
  ```

  As with unit tests, you can also pass in various pytest arguments:

  ```bash
  tox -e integ-tests -- your-arguments
  ```





  If you encounter bugs or face issues while using the SDK, please let us know by posting
  the issue on our [Github issue tracker](https://github.com/amazon-braket/amazon-braket-sdk-python/issues/).
  For other issues or general questions, please ask on the [Quantum Computing Stack Exchange](https://quantumcomputing.stackexchange.com/questions/ask?Tags=amazon-braket).



  If you have feedback or features that you would like to see on Amazon Braket, we would love to hear from you!
  [Github issues](https://github.com/amazon-braket/amazon-braket-sdk-python/issues/) is our preferred mechanism for collecting feedback and feature requests, allowing other users
  to engage in the conversation, and +1 issues to help drive priority.



  [![Contributors](https://contrib.rocks/image?repo=amazon-braket/amazon-braket-sdk-python)](https://github.com/amazon-braket/amazon-braket-sdk-python/graphs/contributors)


  This project is licensed under the Apache-2.0 License.


pkgId: d70258e8ebecc7686242e69adb90f07046dfa915215241e3be502a4142176c6f
name: python-amazon-buddy
arch: src
version: 2.0.29
epoch: 0
release: 1
summary: python wrapper for the amazon_buddy npm package
url: https://github.com/kkristof200/py_amazon_buddy
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amazon-buddy-2.0.29-1.src.rpm
checksum_type: sha256
description:
  ![python_version](https://img.shields.io/static/v1?label=Python&message=3.5%20|%203.6%20|%203.7&color=blue) [![PyPI downloads/month](https://img.shields.io/pypi/dm/amazon_buddy?logo=pypi&logoColor=white)](https://pypi.python.org/pypi/amazon_buddy)



  Amazon scraper.



  ~~~~bash
  pip install amazon_buddy

  pip3 install amazon_buddy
  ~~~~



  ~~~~python
  from amazon_buddy import Product, AmazonBuddy, Category, SortType

  ab = AmazonBuddy(debug=True, user_agent='ADD_USER_AGENT')









  asin = 'B07RZV9LB7'




  ab.get_product_details(asin).save('{}.json'.format(asin))



  ~~~~


pkgId: e70a7d83743f54e93e284fb5eeb01566451662d566a712f54624f78ff6f5b894
name: python-amazon-denseclus
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Dense Clustering for Mixed Data Types
url: https://github.com/awslabs/amazon-denseclus
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amazon-denseclus-0.2.2-1.src.rpm
checksum_type: sha256
description:
  <p align="left">
  <a href="https://github.com/awslabs/amazon-denseclus/actions/workflows/tests.yml"><img alt="build" src="https://github.com/awslabs/amazon-denseclus/actions/workflows/cd.yml/badge.svg"></a>
  <a><img alt="total download" src="https://static.pepy.tech/personalized-badge/amazon-denseclus?period=total&units=international_system&left_color=black&right_color=green&left_text=Total Downloads"></a>
  <a><img alt="month download" src="https://static.pepy.tech/personalized-badge/amazon-denseclus?period=month&units=international_system&left_color=black&right_color=green&left_text=Monthly Downloads"></a>
  <a><img alt="weekly download" src="https://static.pepy.tech/personalized-badge/amazon-denseclus?period=week&units=international_system&left_color=black&right_color=green&left_text=Weekly Downloads"></a>
  <a href="https://badge.fury.io/py/Amazon-DenseClus"><img alt="PyPI version" src="https://badge.fury.io/py/Amazon-DenseClus.svg"></a>
  <a><img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/Amazon-DenseClus"></a>
  <a><img alt="PyPI - Wheel" src="https://img.shields.io/pypi/wheel/Amazon-DenseClus"></a>
  <a><img alt="PyPI - License" src="https://img.shields.io/pypi/l/Amazon-DenseClus"></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>
  <a href="https://github.com/marketplace/actions/super-linter"><img alt="Github Super-Linter" src="https://github.com/awslabs/amazon-denseclus/workflows/Lint%20Code%20Base/badge.svg"></a>
  </p>



  DenseClus is a Python module for clustering mixed type data using [UMAP](https://github.com/lmcinnes/umap) and [HDBSCAN](https://github.com/scikit-learn-contrib/hdbscan). Allowing for both categorical and numerical data, DenseClus makes it possible to incorporate all features in clustering.



  ```bash
  python3 -m pip install amazon-denseclus
  ```



  DenseClus requires a Panda's dataframe as input with both numerical and categorical columns.
  All preprocessing and extraction are done under the hood, just call fit and then retrieve the clusters!

  ```python
  from denseclus import DenseClus
  from denseclus.utils import make_dataframe


  df = make_dataframe()
  clf = DenseClus(df)
  clf.fit(df)

  scores = clf.evaluate()
  print(scores[0:10])
  ```






  DenseClus uses a `predict` method when `umap_combine_method` is set to `ensemble`.
  Results are return in 2d array with the first part being the labels and the second part the probabilities.

  ```python
  from denseclus import DenseClus
  from denseclus.utils import make_dataframe

  RANDOM_STATE = 10

  df = make_dataframe(random_state=RANDOM_STATE)
  train = df.sample(frac=0.8, random_state=RANDOM_STATE)
  test = df.drop(train.index)
  clf = DenseClus(random_state=RANDOM_STATE, umap_combine_method='ensemble')
  clf.fit(train)

  predictions = clf.predict(test)
  print(predictions) # labels, probabilities
  ```




  For a slower but more **stable** results select `intersection_union_mapper` to combine embedding layers via a third UMAP, which will provide equal weight to both numerics and categoriel columns. By default, you are setting the random seed which eliminates the ability for UMAP to run in parallel but will help circumevent some of [the randomness](https://umap-learn.readthedocs.io/en/latest/reproducibility.html) of the algorithm.

  ```python
  clf = DenseClus(
      umap_combine_method="intersection_union_mapper",
  )
  ```



  To use with gpu first have [rapids installed](https://docs.rapids.ai/install#selector).
  You can do this as setup by providing cuda verision.
  `pip install denseclus[gpu-cu12]`

  Then to run:

  ```python
  clf = DenseClus(
      umap_combine_method="ensemble",
      use_gpu=True
  )
  ```




  For advanced users, it's possible to select more fine-grained control of the underlying algorithms by passing
  dictionaries into `DenseClus` class for either UMAP or HDBSCAN.

  For example:
  ```python
  from denseclus import DenseClus
  from denseclus.utils import make_dataframe

  umap_params = {
      "categorical": {"n_neighbors": 15, "min_dist": 0.1},
      "numerical": {"n_neighbors": 20, "min_dist": 0.1},
  }
  hdbscan_params = {"min_cluster_size": 10}

  df = make_dataframe()

  clf = DenseClus(umap_combine_method="union"
               , umap_params=umap_params
               , hdbscan_params=hdbscan_params
               , random_state=None) # this will run in parallel

  clf.fit(df)
  ```






  A hands-on example with an overview of how to use is currently available in the form of a [Example Jupyter Notebook](/notebooks/01_DenseClusExampleNB.ipynb).

  Should you need to tune HDBSCAN, here is an optional approach: [Tuning with HDBSCAN Notebook](/notebooks/02_TuningwithHDBSCAN.ipynb)

  Should you need to validate UMAP emeddings, there is an approach to do so in the [Validation for UMAP Notebook](/notebooks/03_ValidationForUMAP.ipynb)




  [AWS Blog: Introducing DenseClus, an open source clustering package for mixed-type data](https://aws.amazon.com/blogs/opensource/introducing-denseclus-an-open-source-clustering-package-for-mixed-type-data/)

  [TDS Blog: How To Tune HDBSCAN](https://towardsdatascience.com/tuning-with-hdbscan-149865ac2970)

  [TDS Blog: On the Validation of UMAP](https://towardsdatascience.com/on-the-validating-umap-embeddings-2c8907588175)





  ```bibtex
  @article{mcinnes2018umap-software,
    title={UMAP: Uniform Manifold Approximation and Projection},
    author={McInnes, Leland and Healy, John and Saul, Nathaniel and Grossberger, Lukas},
    journal={The Journal of Open Source Software},
    volume={3},
    number={29},
    pages={861},
    year={2018}
  }
  ```

  ```bibtex
  @article{mcinnes2017hdbscan,
    title={hdbscan: Hierarchical density based clustering},
    author={McInnes, Leland and Healy, John and Astels, Steve},
    journal={The Journal of Open Source Software},
    volume={2},
    number={11},
    pages={205},
    year={2017}
  }
  ```


pkgId: cd2e5284d43e98c9c82b4fb6ef03f9620644c1de2c76f8f6a94a44c29140049a
name: python-amazon-ec2-best-instance
arch: src
version: 3.0.3
epoch: 0
release: 1
url: https://github.com/kankou-aliaksei/amazon-ec2-best-instance
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amazon-ec2-best-instance-3.0.3-1.src.rpm
checksum_type: sha256
summary:
  Amazon EC2 Best Instance (amazon-ec2-best-instance) allows you to choose the most optimal and cheap EC2 instance type for on-demand and spot and with a less reclaimed rate for a spot instance.

description:
  Amazon EC2 Best Instance (amazon-ec2-best-instance) allows you to choose the most optimal and cheap EC2 instance type for on-demand and spot and with a less reclaimed rate for a spot instance.



  > **Important**: This package is deprecated and should no longer be used. Please switch to the 'best-ec2' package by running:
  >
  > ```bash
  > pip install best-ec2
  > ```
  > https://pypi.org/project/best-ec2/


  * python3
  * pip3
  * boto3
  * AWS Account
  * AWS Credentials


  pip install amazon-ec2-best-instance



  * **vcpu** Required. Float. Describes the vCPU configurations for the instance type.
  * **memory_gb** Required. Float. Describes the memory for the instance type in GiB.
  * **usage_class** Optional. String. Indicates whether the instance type is offered for spot or On-Demand. Default: 'on-demand'. Values: 'spot'|'on-demand'.
  * **burstable** Optional. Boolean. Indicates whether the instance type is a burstable performance instance type.
  * **architecture** Optional. String. The architectures supported by the instance type. Default: 'x86_64'. Values: 'i386'|'x86_64'|'arm64'|'x86_64_mac'
  * **product_descriptions** Optional. List<String>. The operating system that you will use on the virtual machine. Default: ['Linux/UNIX']. Values: Linux/UNIX | Red Hat Enterprise Linux | SUSE Linux | Windows | Linux/UNIX (Amazon VPC) | Red Hat Enterprise Linux (Amazon VPC) | SUSE Linux (Amazon VPC) | Windows (Amazon VPC)
  * **is_current_generation** Optional. Boolean. Use the latest generation or not.
  * **has_gpu** Optional. Boolean. Indicating whether the instance is equipped with a GPU. Default: None
  * **gpu_memory** Optional. Integer. Amount of GPU Memory in Gigabytes (GiB). Only activated when 'has_gpu' is set to True. Default: None
  * **is_instance_storage_supported** Optional. Boolean. Use instance types with instance store support
  * **max_interruption_frequency** Optional. Integer (%). Max spot instance frequency interruption in percent. Note: If you specify >=21, then the '>20%' rate is applied. It is used only if 'usage_class' == 'spot' and 'is_best_price' == True
  * **availability_zones** Optional. List<String>. Availability zones. E.g. ['us-east-1a', 'us-east-1b']
  * **final_spot_price_determination_strategy** Optional. String. Default: "min". Valid values: "min"|"max"|"average"





  ```
  from amazon_ec2_best_instance import Ec2BestInstance

  ec2_best_instance = Ec2BestInstance()


  response = ec2_best_instance.get_best_instance_types({
      'vcpu': 1,
      'memory_gb': 2
  })

  print(response)

  '''
  [{'instance_type': 'c5n.2xlarge'}, ... , {'instance_type': 'x2iedn.8xlarge'}]
  '''
  ```



  ```
  import boto3
  from botocore.config import Config
  import logging
  from amazon_ec2_best_instance import Ec2BestInstance

  ec2_client_config = Config(
      retries={
          'max_attempts': 20,
          'mode': 'adaptive'
      }
  )

  pricing_client_config = Config(
      retries={
          'max_attempts': 10,
          'mode': 'standard'
      }
  )

  ec2_client = boto3.Session().client('ec2', config=ec2_client_config)
  pricing_client = boto3.Session().client('pricing', config=pricing_client_config)


  options = {
      
      'region': 'us-east-1',
      
      'describe_spot_price_history_concurrency': 20,
      
      'describe_on_demand_price_concurrency': 20,
      'clients': {
          'ec2': ec2_client,
          'pricing': pricing_client
      },
      
      'cache_ttl_in_minutes': 60
  }

  logging.basicConfig(level=logging.INFO, format='s: s: s')

  logger = logging.getLogger()

  ec2_best_instance = Ec2BestInstance(options, logger)

  response = ec2_best_instance.get_best_instance_types({
      
      'vcpu': 1,
      
      'memory_gb': 2,
      
      'usage_class': 'spot',
      
      'burstable': False,
      
      'architecture': 'x86_64',
      
      
          
      'product_descriptions': ['Linux/UNIX'],
      
      'is_current_generation': True,
      
      'is_best_price': True,
      
      'is_instance_storage_supported': True,
      
      'max_interruption_frequency': 10,
      
      'availability_zones': ['us-east-1a', 'us-east-1b']
  })

  print(response)
  '''
  [{'instance_type': 'c5d.large', 'price': '0.032700', 'interruption_frequency': {'min': 0, 'max': 5, 'rate': '<5%'}}, ...]
  '''

  ```



  If you need to get a spot instance with minimal price and minimal frequency of interruption you can use 'is_best_price' and/or 'max_interruption_frequency' input parameter

  ```
  from amazon_ec2_best_instance import Ec2BestInstance

  ec2_best_instance = Ec2BestInstance()

  response = ec2_best_instance.get_best_instance_types({
      
      'vcpu': 31.2,
      
      'memory_gb': 100.5,
      
      'usage_class': 'spot',
      
      
      'is_best_price': True,
      
      
      
      'max_interruption_frequency': 10
  })

  print(response)
  '''
  [{'instance_type': 'm6id.8xlarge', 'price': '0.642600', 'interruption_frequency': {'min': 6, 'max': 10, 'rate': '5-10%'}}, ...]
  '''
  ```

  ```
  from amazon_ec2_best_instance import Ec2BestInstance

  ec2_best_instance = Ec2BestInstance()

  response = ec2_best_instance.get_best_instance_types({
      
      'vcpu': 31.2,
      
      'memory_gb': 100.5,
      
      'usage_class': 'spot',
      
      
      'is_best_price': True
  })

  print(response)
  '''
  [{'instance_type': 'r5a.8xlarge', 'price': '0.578100'}, ...]
  '''
  ```


pkgId: b10a713a4481f64da7a71c478b3f802cd2d1deaadc6b8bc798e5fed21abab978
name: python-amazon-omics-tools
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Tools for working with the AWS HealthOmics Service
url: https://github.com/awslabs/amazon-omics-tools
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amazon-omics-tools-0.8.0-1.src.rpm
checksum_type: sha256
description:
  SDK and CLI Tools for working with the AWS HealthOmics Service.

  - [AWS HealthOmics Tools](#aws-healthomics-tools)
    - [Installation](#installation)
    - [SDK Tools](#sdk-tools)
      - [Omics Transfer Manager](#omics-transfer-manager)
        - [Basic Usage](#basic-usage)
        - [Download specific files](#download-specific-files)
        - [Upload specific files](#upload-specific-files)
        - [Subscribe to events](#subscribe-to-events)
        - [Threads](#threads)
      - [Omics URI Parser](#omics-uri-parser)
        - [Readset file URI:](#readset-file-uri)
        - [Reference file URI:](#reference-file-uri)
    - [CLI Tools](#cli-tools)
      - [Omics Rerun](#omics-rerun)
        - [List runs from manifest](#list-runs-from-manifest)
        - [Rerun a previously-executed run](#rerun-a-previously-executed-run)
      - [Omics Run Analyzer](#omics-run-analyzer)
        - [List completed runs](#list-completed-runs)
        - [Analyze a specific workflow run](#analyze-a-specific-workflow-run)
        - [Output workflow run manifest in JSON format](#output-workflow-run-manifest-in-json-format)
    - [Security](#security)
    - [License](#license)


  AWS HealthOmics Tools is available through pypi. To install, type:

  ```bash
  pip install amazon-omics-tools
  ```



  Installing from source requires that your machine has the following prerequisites installed:
  - `python3.10` or above
  - `poetry` package manager
  - `make` build tool

  ```
  git clone https://github.com/awslabs/amazon-omics-tools.git
  cd ./amazon-omics-tools
  make install
  ```






  The `TransferManager` class makes it easy to download files from a AWS HealthOmics reference or read set.  By default the files are saved to the current directory, or you can specify a custom location with the `directory` parameter.

  ```python
  import boto3
  from omics.common.omics_file_types import ReadSetFileName, ReferenceFileName, ReadSetFileType
  from omics.transfer.manager import TransferManager
  from omics.transfer.config import TransferConfig

  REFERENCE_STORE_ID = "<my-reference-store-id>"
  SEQUENCE_STORE_ID = "<my-sequence-store-id>"

  client = boto3.client("omics")
  manager = TransferManager(client)


  manager.download_reference(REFERENCE_STORE_ID, "<my-reference-id>")


  manager.download_read_set(SEQUENCE_STORE_ID, "<my-read-set-id>", "my-sequence-data")
  ```


  Specific files can be downloaded via the `download_reference_file` and `download_read_set_file` methods.
  The `client_fileobj` parameter can be either the name of a local file to create for storing the data, or a `TextIO` or `BinaryIO` object that supports write methods.

  ```python

  manager.download_reference_file(
      REFERENCE_STORE_ID,
      "<my-reference-id>",
      ReferenceFileName.INDEX
  )


  manager.download_read_set_file(
      SEQUENCE_STORE_ID,
      "<my-read-set-id>",
      ReadSetFileName.INDEX,
      "my-sequence-data/read-set-index"
  )
  ```


  Specific files can be uploaded via the `upload_read_set` method.
  The `fileobjs` parameter can be either the name of a local file, or a `TextIO` or `BinaryIO` object that supports read methods.
  For paired end reads, you can define `fileobjs` as a list of files.

  ```python

  read_set_id = manager.upload_read_set(
      "my-sequence-data/read-set-file.bam",
      SEQUENCE_STORE_ID,
      "BAM",
      "name",
      "subject-id",
      "sample-id",
      "<my-reference-arn>",
  )


  read_set_id = manager.upload_read_set(
      ["my-sequence-data/read-set-file_1.fastq.gz", "my-sequence-data/read-set-file_2.fastq.gz"],
      SEQUENCE_STORE_ID,
      "FASTQ",
      "name",
      "subject-id",
      "sample-id",
      "<my-reference-arn>",
  )
  ```


  Transfer events: `on_queued`, `on_progress`, and `on_done` can be observed by defining a subclass of `OmicsTransferSubscriber` and passing in an object which can receive events.

  ```python
  class ProgressReporter(OmicsTransferSubscriber):
      def on_queued(self, **kwargs):
          future: OmicsTransferFuture = kwargs["future"]
          print(f"Download queued: {future.meta.call_args.fileobj}")

      def on_done(self, **kwargs):
          print("Download complete")

  manager.download_read_set(SEQUENCE_STORE_ID, "<my-read-set-id>", subscribers=[ProgressReporter()])
  ```


  Transfer operations use threads to implement concurrency. Thread use can be disabled by setting the `use_threads` attribute to False.

  If thread use is disabled, transfer concurrency does not occur. Accordingly, the value of the `max_request_concurrency` attribute is ignored.

  ```python

  config = TransferConfig(use_threads=False)
  manager = TransferManager(client, config)
  manager.download_read_set(SEQUENCE_STORE_ID, "<my-read-set-id>")
  ```



  The `OmicsUriParser` class makes it easy to parse AWS HealthOmics readset and reference URIs to extract fields relevant for calling
  AWS HealthOmics APIs.



  Readset file URIs come in the following format:

  ```text
  omics://<AWS_ACCOUNT_ID>.storage.<AWS_REGION>.amazonaws.com/<SEQUENCE_STORE_ID>/readSet/<READSET_ID>/<SOURCE1/SOURCE2>
  ```

  For example:
  ```text
  omics://123412341234.storage.us-east-1.amazonaws.com/5432154321/readSet/5346184667/source1
  omics://123412341234.storage.us-east-1.amazonaws.com/5432154321/readSet/5346184667/source2
  ```


  Reference file URIs come in the following format:
  ```text
  omics://<AWS_ACCOUNT_ID>.storage.<AWS_REGION>.amazonaws.com/<REFERENCE_STORE_ID>/reference/<REFERENCE_ID>/source
  ```
  For example:
  ```text
  omics://123412341234.storage.us-east-1.amazonaws.com/5432154321/reference/5346184667/source
  ```

  To handle both HealthOmics URI types, you would use code like the following:

  ```python
  import boto3
  from omics.uriparse.uri_parse import OmicsUriParser, OmicsUri

  READSET_URI_STRING = "omics://123412341234.storage.us-east-1.amazonaws.com/5432154321/readSet/5346184667/source1"
  REFERENCE_URI_STRING = "omics://123412341234.storage.us-east-1.amazonaws.com/5432154321/reference/5346184667/source"

  client = boto3.client("omics")

  readset = OmicsUriParser(READSET_URI_STRING).parse()
  reference = OmicsUriParser(REFERENCE_URI_STRING).parse()



  manager = TransferManager(client)


  manager.download_reference(reference.store_id, reference.resource_id)


  manager.download_read_set(readset.store_id, readset.resource_id, readset.file_name)


  manager.download_read_set_file(
      readset.store_id,
      readset.resource_id,
      readset.file_name,
      "my-sequence-data/read-set-index"
  )
  ```


  CLI tools are modules in this package that can be invoked from the command line with:

  ```bash
  python -m omics.cli.<TOOL-NAME>
  ```



  The `omics-rerun` tool makes it easy to start a new run execution from a CloudWatch Logs manifest.

  For an overview of what it does and available options run:

  ```bash
  python -m omics.cli.rerun -h
  ```


  The following example lists all workflow run ids which were completed on July 1st (UTC time):
  ```bash
  python -m omics.cli.rerun -s 2023-07-01T00:00:00 -e 2023-07-02T00:00:00
  ```

  this returns something like:

  ```text
  1234567 (2023-07-01T12:00:00.000)
  2345678 (2023-07-01T13:00:00.000)
  ```


  To rerun a previously-executed run, specify the run id you would like to rerun:

  ```bash
  python -m omics.cli.rerun 1234567
  ```

  this returns something like:

  ```text
  StartRun request:
  {
    "workflowId": "4974161",
    "workflowType": "READY2RUN",
    "roleArn": "arn:aws:iam::123412341234:role/MyRole",
    "parameters": {
      "inputFASTQ_2": "s3://omics-us-west-2/sample-inputs/4974161/HG002-NA24385-pFDA_S2_L002_R2_001-5x.fastq.gz",
      "inputFASTQ_1": "s3://omics-us-west-2/sample-inputs/4974161/HG002-NA24385-pFDA_S2_L002_R1_001-5x.fastq.gz"
    },
    "outputUri": "s3://my-bucket/my-path"
  }
  StartRun response:
  {
    "arn": "arn:aws:omics:us-west-2:123412341234:run/3456789",
    "id": "3456789",
    "status": "PENDING",
    "tags": {}
  }
  ```

  It is possible to override a request parameter from the original run. The following example tags the new run, which is particularly useful as tags are not propagated from the original run.

  ```bash
  python -m omics.cli.rerun 1234567 --tag=myKey=myValue

  ```

  this returns something like:
  ```text
  StartRun request:
  {
    "workflowId": "4974161",
    "workflowType": "READY2RUN",
    "roleArn": "arn:aws:iam::123412341234:role/MyRole",
    "parameters": {
      "inputFASTQ_2": "s3://omics-us-west-2/sample-inputs/4974161/HG002-NA24385-pFDA_S2_L002_R2_001-5x.fastq.gz",
      "inputFASTQ_1": "s3://omics-us-west-2/sample-inputs/4974161/HG002-NA24385-pFDA_S2_L002_R1_001-5x.fastq.gz"
    },
    "outputUri": "s3://my-bucket/my-path",
    "tags": {
      "myKey": "myValue"
    }
  }
  StartRun response:
  {
    "arn": "arn:aws:omics:us-west-2:123412341234:run/4567890",
    "id": "4567890",
    "status": "PENDING",
    "tags": {
      "myKey": "myValue"
    }
  }
  ```

  Before submitting a rerun request, it is possible to dry-run to view the new StartRun request:
  ```bash
  python -m omics.cli.rerun -d 1234567
  ```

  this returns something like:
  ```text
  StartRun request:
  {
    "workflowId": "4974161",
    "workflowType": "READY2RUN",
    "roleArn": "arn:aws:iam::123412341234:role/MyRole",
    "parameters": {
      "inputFASTQ_2": "s3://omics-us-west-2/sample-inputs/4974161/HG002-NA24385-pFDA_S2_L002_R2_001-5x.fastq.gz",
      "inputFASTQ_1": "s3://omics-us-west-2/sample-inputs/4974161/HG002-NA24385-pFDA_S2_L002_R1_001-5x.fastq.gz"
    },
    "outputUri": "s3://my-bucket/my-path"
  }
  ```


  The `omics-run-analyzer` tool retrieves a workflow run manifest from CloudWatchLogs and generates statistics for the run, including CPU and memory utilization for each workflow task.

  For an overview of what it does and available options run:

  ```bash
  python -m omics.cli.run_analyzer -h
  ```


  The following example lists all workflow runs completed in the past 5 days:
  ```bash
  python -m omics.cli.run_analyzer -t5d
  ```

  this returns something like:

  ```text
  Workflow run IDs (<completionTime> <UUID>):
  1234567 (2024-02-01T12:00:00 12345678-1234-5678-9abc-123456789012)
  2345678 (2024-02-03T13:00:00 12345678-1234-5678-9abc-123456789012)
  ```


  ```bash
  python -m omics.cli.run_analyzer 1234567 -o run-1234567.csv
  ```

  this returns something like:

  ```text
  omics-run-analyzer: wrote run-1234567.csv
  ```

  The CSV output by the command above includes the following columns:

  * __arn__ : Unique workflow run or task identifier
  * __type__ : Resource type (_run_ or _task_)
  * __name__ : Workflow run or task name
  * __startTime__ : Start timestamp for the workflow run or task (UTC time)
  * __stopTime__ : Stop timestamp for the workflow run or task (UTC time)
  * __runningSeconds__ : Approximate workflow run or task runtime (in seconds)
  * __cpusRequested__ : The number of vCPU requested by the workflow task
  * __gpusRequested__ : The number of GPUs requested by the workflow task
  * __memoryRequestedGiB__ : Gibibytes of memory requested by the workflow task
  * __omicsInstanceTypeReserved__ : Requested HealthOmics instance type for each task
  * __omicsInstanceTypeMinimum__ : Minimum HealthOmics instance type that could run each task.
  * __recommendedCpus__: The number of CPUs recommended for this task (corresponding to the number of CPUs in the omicsInstanceTypeMinimum)
  * __recommendedMemoryGiB__: The amount of GiB of memory recommended for this task (corresponding to the number of CPUs in the omicsInstanceTypeMinimum)
  * __estimatedUSD__ : Estimated HealthOmics charges (USD) for the workflow based on _sizeReserved_ and _runningSeconds_
  * __minimumUSD__ : Estimated HealthOmics charges (USD) for the workflow based on the recommended _omicsInstanceTypeMinimum_ and _runningSeconds_
  * __cpuUtilizationRatio__ : CPU utilization (_cpusMaximum_ / _cpusReserved_) for workflow task(s)
  * __memoryUtilizationRatio__ : Memory utilization (_memoryMaximumGiB_ / _memoryReservedGiB_) for the workflow task(s)
  * __storageUtilizationRatio__ : Storage utilization (_storageMaximumGiB_ / _storageReservedGiB_) for the workflow run
  * __cpusReserved__ : vCPUs reserved for workflow task(s)
  * __cpusMaximum__ : Maximum vCPUs used during a single 1-minute interval
  * __cpusAverage__ : Average vCPUs used by workflow task(s)
  * __gpusReserved__ : GPUs reserved for workflow task(s)
  * __memoryReservedGiB__ : Gibibytes of memory reserved for workflow task(s)
  * __memoryMaximumGiB__ : Maximum gibibytes of memory used during a single 1-minute interval
  * __memoryAverageGiB__ : Average gibibytes of memory used by workflow task(s)
  * __storageReservedGiB__ : Gibibytes of storage reserved for the workflow run
  * __storageMaximumGiB__ : Maximum gibibytes of storage used during a single 1-minute interval
  * __storageAverageGiB__ : Average gibibytes of storage used by the workflow run

  For rows that are a _task_ type, the maximums, averages and reserved columns refer to the maximum, average or reserved amounts of the respective resource used by that task. These values can be used to guide the resources that should be requested for that task. For rows that are a _run_ type the maximums, averages and reserved columns refer to the maximum, average or reserved amounts of the respective resource used __concurrently__ by that run. These values can be used to determine if the accounts HealthOmics active CPUs/memory limits are being reached which might indicate the run is constrained by these limits.

  > [!WARNING]
  > At this time AWS HealthOmics does not report the average or maximum storage used by runs that use "DYNAMIC" storage that run for under two hours. Because of this limitation the `storageMaximumGiB` and `storageAverageGiB` are set to zero and will not be included in the estimate run cost.



  Based on the metrics observed and calculated for a run, the application will recommend the smallest instance type that could be used for each task in the run. The type is reported in the `omicsInstanceTypeMinimum` column. To obtain this type for a task you can set the task CPU and memory requested for the task to the values of `recommendedCpus` and  `recommendedMemoryGiB` in you workflow definition. Based on this change each task would be estimated to
  reduce the cost of the run by `estimatedUSD` minus `minimumUSD`. The total potential cost reduction for the entire run can be estimated by subtracting the `minimumUSD` value from the `estimatedUSD` value in the row where the `type` is "`run`".

  > [!WARNING]
  > Cost estimates are based on the AWS list price at the time the run analysis is performed. In the event prices have changed these may not reflect the price you were charged at the time of the run. Further, the run analyzer does not account for any discounts, credits or price agreements you may have. Price estimates for recommended instance sizes (`minimumUSD`) assume that the runtime of the task will remain the same on the recommended instance. Actual costs will be determined based on the actual runtime.



  Sometimes you will see variance in the amount of memory and CPU used in a run task, especially if you expect to run workflows with larger input files than were used in the analyzed run. For this reason you might want to allow add some headroom to the recommendations produced by the the run analyzer.

  The `-H` or `--headroom` flag can be use to add an additional `0.0` to `1.0` times the max CPU or memory used by a task to the calculation used to determine
  the `omicsInstanceTypeMinimum` recommendation. For example if a task used a max of 3.6 GiB of memory and the headroom value is 0.5 then 6 GiB of memory - `math.ceil(3.6 * (1 + 0.5))` - will be used to determine the minimum instance type that should be used.

  If your analyzed run is already close to optimal then adding headroom might result in the recommended minimum instance being larger than the instance used in the run which will also cause the "`minimumUSD`" to be larger than the "`estimatedUSD`".



  The RunAnalyzer tool can produce an interative timeline plot of a workflow. The plots allow you to visualize how individual tasks ran over the course of the run.

  ```bash
  python -m omics.cli.run_analyzer -P plots/ 7113639
  ```

  ![Example time line image showing stacked horizontal bars indicating the time taken by each task](./assets/timeline.png)



  ```bash
  python -m omics.cli.run_analyzer 1234567 -s -o run-1234567.json
  ```

  this returns something like:
  ```text
  omics-run-analyzer: wrote run-1234567.json
  ```


  > [!WARNING]
  > Currently this feature only supports Nextflow workflows.

  The `--write-config` option will write a new configuration file with the `recommendedCpus` and `recommendedMemoryGiB` as the resource requirements. This will take the maximum values if the task is run multiple times with different inputs.

  ```bash
  python -m omics.cli.run_analyzer 123456 --write-config=optimized.config
  ```



  > [!NOTE]
  > This feature is currently experimental and the output may change in future versions. We encourage feedback on which aggregations are useful and which are not.

  The `--batch` option can be used with a single run to aggregate all scattered tasks into one summarized task report. Non scattered tasks are also aggregated but will have a count of 1.

  ```bash
  python -m omics.cli.run_analyzer 1234567 --batch
  ```

  The option may also be used with multiple runs to aggregate all tasks including scattered tasks.

  ```bash
  python -m omics.cli.run_analyzer 1234567 2345678 3456789 --batch
  ```

  These statics are reported in CSV format:

  - __"type"__: The type of row (currently always task),
  - __"name"__: The base name of the task with any scatter suffix removed
  - __"count"__: The number of times the named task has been observed in the runs
  - __"meanRunningSeconds"__: The average runtime in seconds for the named tasks
  - __"maximumRunningSeconds"__: The longest runtime in seconds for the named task
  - __"stdDevRunningSeconds"__: The standard deviation of runtimes for the named task
  - __"maximumCpuUtilizationRatio"__: The highest CPU utilization ratio seen for any of the named tasks
  - __"meanCpuUtilizationRation"__: The average CPU utilization ratio for the named task
  - __"maximumMemoryUtilizationRatio"__: The highest memory utilization ratio seen for any of the named tasks
  - __"meanMemoryUtilizationRation"__: The average memory utilization ratio for the named task
  - __"maximumGpusReserved"__: The largest number of GPUs reserved for the named tasks
  - __"meanGpusReserved"__: The average number of GPUs reserved for the named task
  - __"recommendedCpus"__: The recommended number of Cpus that would accommodate all observed instances of a task (including any headroom factor)
  - __"recommendedMemoryGiB"__: The recommended GiBs of memory that would accommodate all observed instances of a task (including and headroom factor)
  - __"recommendOmicsInstanceType"__: The recommended omics instance type that would accomodate all observed instances of a task
  - __"maximumEstimatedUSD"__: The largest estimated cost observed for the named task.
  - __"meanEstimatedUSD"__: The average estimated cost observed for the named task.



  See [CONTRIBUTING](https://github.com/awslabs/amazon-omics-tools/blob/main/CONTRIBUTING.md#security-issue-notifications) for more information.



  This project is licensed under the Apache-2.0 License.


